public static class ClassExtender
{
private static Dictionary<Enum, double> unitDictionary;
public static Dictionary<Enum, double> UnitDictionary
{
get
{
if (unitDictionary==null)
{
unitDictionary = new Dictionary<Enum,double>();
unitDictionary.Add(ContentUnit.per, 100);
unitDictionary.Add(ContentUnit.permillage, 1000);
unitDictionary.Add(ContentUnit.ppm,1000000);
unitDictionary.Add(ThicknessUnit.um, 1);
unitDictionary.Add(ThicknessUnit.ur, 1 * 0.0254);
}
return unitDictionary;
}
private set { unitDictionary = value; }
}
/// <summary>
/// 感兴趣元素转换为历史记录元素
/// </summary>
/// <param name="curveElement">感兴趣元素本身</param>
/// <param name="ignoreUnit">是否保留原单位,False保留原各自单位数据需换算,True单位一起交换数据不变</param>
/// <returns></returns>
public static HistoryElement ToHistroyElement(this CurveElement curveElement)
{
if (curveElement == null) return null;
string sFormat = string.Empty;//"f" + WorkCurveHelper.SoftWareContentBit.ToString();
HistoryElement historyElement = HistoryElement.New;
//SwapCurveHistroyElement(curveElement, historyElement, false);
historyElement.elementName = curveElement.Caption.ConvertToType(historyElement.elementName);
historyElement.unitValue = curveElement.ContentUnit.ConvertToType(historyElement.unitValue);
if (!(curveElement.Content > double.Epsilon && curveElement.Content < double.PositiveInfinity))
curveElement.Content = 0d;
historyElement.contextelementValue = curveElement.Content.ConvertToType(historyElement.contextelementValue);
historyElement.Error = curveElement.Error.ConvertToType(historyElement.Error);
historyElement.thickunitValue = curveElement.ThicknessUnit.ConvertToType(historyElement.thickunitValue);
historyElement.thickelementValue = curveElement.Thickness.ConvertToType(historyElement.thickelementValue);
historyElement.CaculateIntensity = curveElement.Intensity.ConvertToType(historyElement.CaculateIntensity);
return historyElement;
}
/// <summary>
/// 历史记录转换为感兴趣元素
/// </summary>
/// <param name="historyElement">历史记录本身</param>
/// <param name="ignoreUnit">是否保留原单位,False数据换算后交换单位不交换,True单位交换数据不换算直接交换</param>
/// <returns></returns>
public static CurveElement ToCurveElement(this HistoryElement historyElement)
{
if (historyElement == null) return null;
var curEle = historyElement.MatchCurveElement();
CurveElement curveElement = curEle ?? CurveElement.New;
//SwapCurveHistroyElement(curveElement, historyElement,false);
curveElement.Caption = historyElement.elementName.ConvertToType(historyElement.elementName);
curveElement.ContentUnit = historyElement.unitValue.ConvertToType(curveElement.ContentUnit);
curveElement.ThicknessUnit = historyElement.thickunitValue.ConvertToType(curveElement.ThicknessUnit);
curveElement.Content = historyElement.contextelementValue.ConvertToType(curveElement.Content);
if (!(curveElement.Content > double.Epsilon && curveElement.Content < double.PositiveInfinity))
curveElement.Content = 0d;
curveElement.Error = historyElement.Error.ConvertToType(curveElement.Error);
curveElement.Intensity = historyElement.CaculateIntensity.ConvertToType(curveElement.Intensity);
curveElement.Thickness = historyElement.thickelementValue.ConvertToType(curveElement.Thickness);
return curveElement;
}
/// <summary>
/// 从现有单位转换为指定单位的换算率
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t1"></param>
/// <param name="t2">转换到的单位</param>
/// <returns></returns>
public static double UnitExChangeTo<T>(this T t1,T t2) where T: struct
{
double back = 1.0;
if (typeof(T).IsEnum)
{
Enum t1Value = t1.ConvertToType<Enum>();
Enum t2Value = t2.ConvertToType<Enum>();
if (UnitDictionary.Keys.Contains(t1Value) && UnitDictionary.Keys.Contains(t2Value))
back = UnitDictionary[t2Value] * 1.0 / (UnitDictionary[t1Value] == 0 ? UnitDictionary[t2Value] : UnitDictionary[t1Value]);
}
return back;
}
/// <summary>
/// 将数据按单位转换成换算后该类型数据
/// </summary>
/// <typeparam name="T">数据源类型也是返回的类型</typeparam>
/// <typeparam name="T1">数据源单位类型</typeparam>
/// <typeparam name="T2">目标数据源单位类型</typeparam>
/// <typeparam name="T3">源单位和目标单位的标准单位</typeparam>
/// <param name="TSourceResult">数据源</param>
/// <param name="TSourceUnit">数据源单位</param>
/// <param name="TDestinationUnit">转换到的目标单位</param>
/// <param name="TStandard">标准单位类型的任意取值</param>
/// <returns></returns>
public static T ValueExChangeByUnit<T, T1, T2,T3>(this T TSourceResult, T1 TSourceUnit, T2 TDestinationUnit,T3 TStandard)where T3:struct
where T:IComparable
{
try
{
T3 tempSource = TSourceUnit.ConvertToType<T3>();
T3 tempDestination = TDestinationUnit.ConvertToType<T3>();
double dSource = TSourceResult.ConvertToType<double>();
double dExChange = tempSource.UnitExChangeTo(tempDestination);
return (dSource * dExChange).ConvertToType<T>();
}
catch { }
return TSourceResult;
}
/// <summary>
/// 感兴趣元素与历史记录元素互换
/// </summary>
/// <param name="curveElement">感兴趣元素</param>
/// <param name="historyElement">历史记录元素</param>
/// <param name="ignoreUnit">是否保留原单位,False保留原各自单位数据需换算,True单位一起交换数据不变</param>
/// <returns></returns>
public static void SwapCurveHistroyElement(CurveElement curveElement, HistoryElement historyElement, bool ignoreUnit)
{
if (curveElement == null || historyElement == null)
return;
object value = curveElement.Caption;
curveElement.Caption = historyElement.elementName;
historyElement.elementName = value.ConvertToType<string>();
if (ignoreUnit)//不将值进行单位换算，直接将单位互换值不变
{
value = curveElement.ContentUnit;
curveElement.ContentUnit = historyElement.unitValue.ConvertToType(curveElement.ContentUnit);
historyElement.unitValue = value.ConvertToType(historyElement.unitValue);
value = curveElement.ThicknessUnit;
curveElement.ThicknessUnit = historyElement.thickunitValue.ConvertToType(curveElement.ThicknessUnit);
historyElement.thickunitValue = value.ConvertToType(historyElement.thickunitValue);
}
value = curveElement.Content;
curveElement.Content = historyElement.contextelementValue.ConvertToType<double>();
historyElement.contextelementValue = value.ConvertToType<string>();
value = curveElement.Intensity;
curveElement.Intensity = historyElement.ElementIntensity.ConvertToType(curveElement.Intensity);
historyElement.ElementIntensity = value.ConvertToType(historyElement.ElementIntensity);
value = curveElement.Error;
curveElement.Error = historyElement.Error.ConvertToType(curveElement.Error);
historyElement.Error = value.ConvertToType(historyElement.Error);
value = curveElement.Thickness;
curveElement.Thickness = historyElement.thickelementValue.ConvertToType(curveElement.Thickness);
historyElement.thickunitValue = value.ConvertToType(historyElement.thickunitValue);
if (!ignoreUnit)//不置换单位即需要单位换算
{
curveElement.Content = curveElement.Content.ValueExChangeByUnit(historyElement.unitValue, curveElement.ContentUnit, ContentUnit.per);//历史记录单位转换为感兴趣元素单位
curveElement.Error = curveElement.Error.ValueExChangeByUnit(historyElement.unitValue, curveElement.ContentUnit, ContentUnit.per);
curveElement.Thickness = curveElement.Thickness.ValueExChangeByUnit(historyElement.thickunitValue, curveElement.ThicknessUnit, ThicknessUnit.ur);
historyElement.contextelementValue = historyElement.contextelementValue.ValueExChangeByUnit(curveElement.ContentUnit, historyElement.unitValue, ContentUnit.per);
historyElement.Error = historyElement.Error.ValueExChangeByUnit(curveElement.ContentUnit, historyElement.unitValue, ContentUnit.per);
historyElement.thickelementValue = historyElement.thickelementValue.ValueExChangeByUnit(curveElement.ThicknessUnit, historyElement.thickunitValue, ThicknessUnit.ur);
}
}
public static void Swap<T>(ref T t1,ref T t2)
{
T temp = default(T);
temp = t1;
t1 = t2;
t2 = temp;
}
public static void SwapDiff<T1, T2>(ref T1 t1, ref T2 t2)
{
T1 temp = default(T1);
temp = t2.ConvertToType(t1);
Swap(ref t1,ref temp);
t2 = temp.ConvertToType(t2);
}
/// <summary>
public delegate TResult FuncEx<T1, TOut, TResult>(T1 str, out TOut outValue);
/// <summary>
/// 通用类型转换扩展 针对系统自带简单类型和实现了强制转换 和 TryParse的类型
/// </summary>
/// <typeparam name="T">目标类型</typeparam>
/// <param name="objSource">需要进行类型转换的源数据</param>
/// <param name="TTarget">需要转换成的类型，申明为可变参数目的适应无参调用及可能的匿名类型</param>
/// <returns>返回目标类型数据，转换失败返回目标类型的默认值</returns>
public static T ConvertToType<T>(this object objSource, params T[] TTarget)
{
T back = default(T);
if (object.Equals(objSource, null)) return back;//防止未实现操作符重写==
try
{
return (T)objSource;//强制转换 针对实现了强制转换的类型 或者实现强制转换后调用此转换
}
catch (InvalidCastException ex) { }
Type type = typeof(T);
if (type.IsGenericType)//获取目标类型，如果为泛型类型取其中的类型
type = type.GetGenericArguments().FirstOrDefault();
if (type == typeof(string))//如果为string类型ToString并递归调用
return objSource.ToString().ConvertToType<T>();
var TryParse = //反射获取Tryparse方法
type.GetMethod("TryParse", BindingFlags.Public | BindingFlags.Static, Type.DefaultBinder,
new Type[] { typeof(string), type.MakeByRefType() },
new ParameterModifier[] { new ParameterModifier(2) });
var parameters = new object[] { objSource.ToString(), Activator.CreateInstance(type) };//必须先声明数组否则无法返回
bool success = false;
try
{
Delegate TryParseFunc = Delegate.CreateDelegate(typeof(FuncEx<string, T, bool>), null, TryParse);//尝试创建委托执行 可能比反射效率更高
success = TryParseFunc == null ? false : TryParseFunc.DynamicInvoke(parameters).ConvertToType(success);//获取尝试转换结果
}
catch
{
success = TryParse == null ? false : TryParse.Invoke(null, parameters).ConvertToType(success);//获取尝试转换结果
}
if (success)//如果成功转换为T类型
return parameters.LastOrDefault().ConvertToType<T>();
return back;//如果之前都无返回值此处返回默认T类型的值
}
/// <summary>
/// 利用Lambda进行转换 针对简单类型转换及实现了强制转换的转换
/// </summary>
/// <typeparam name="TSource">源类型</typeparam>
/// <typeparam name="TTarget">目标类型</typeparam>
/// <param name="objSource">源数据</param>
/// <param name="target">可变类型适用于无参类型及可能的匿名类型</param>
/// <returns>返回目标类型数据，如果无法转换将抛出异常</returns>
public static TTarget LambdaConvertToType<TSource, TTarget>(this TSource objSource,params TTarget[] target)
{
if (object.Equals(objSource, null)) return default(TTarget);
Type typeSource = objSource.GetType();
Type typeTarget = typeof(TTarget);
ParameterExpression source = Expression.Parameter(typeSource, "source");//转换表达式参数
Expression instanceCast = Expression.Convert(source, typeTarget);//转换表达式
var lambda = Expression.Lambda<Func<TSource, TTarget>>(instanceCast, source);//转换成的委托类型
return (TTarget)lambda.Compile().DynamicInvoke(objSource);//转换结果
}
/// <summary>
/// 通用类型转换扩展
/// </summary>
/// <typeparam name="TSource">源数据类型</typeparam>
/// <typeparam name="TTarget">目标数据类型</typeparam>
/// <param name="source">需要进行类型转换的源数据</param>
/// <param name="target">需要转换成的类型，申明为可变类型适应无参调用</param>
/// <returns>返回目标类型数据，转换失败返回目标类型的默认值</returns>
public static TTarget ConvertToType<TSource, TTarget>(this TSource source,params TTarget[] target)
{
TTarget back = default(TTarget);
if (object.Equals(source, null)) return back;//防止未实现操作符重写==
try
{
return source.LambdaConvertToType<TSource, TTarget>();//调用Lambda转换
}
catch (InvalidOperationException) { }
catch (Exception) { }
return source.ConvertToType<TTarget>();//调用通用转换
}
/// <summary>
/// 历史记录匹配感兴趣元素
/// </summary>
/// <param name="historyElement"></param>
/// <returns></returns>
public static CurveElement MatchCurveElement(this HistoryElement historyElement)
{
var _HistoryRecord = historyElement.HistoryRecord;
if (_HistoryRecord == null) return null;
var _WorkcCurve = WorkCurve.FindById(_HistoryRecord.WorkCurveId);
if (_WorkcCurve == null) return null;
var _ElementList = _WorkcCurve.ElementList;
if (_ElementList == null) return null;
var _Items = _ElementList.Items;
if (_Items == null || _Items.Count == 0) return null;
return _Items.FirstOrDefault(w=>w.Caption==historyElement.elementName);
}
/// <summary>
/// 字典增加相同类型的字典
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="dicBase"></param>
/// <param name="dicParts"></param>
/// <returns></returns>
public static Dictionary<TKey, TValue> AddRangs<TKey, TValue>(this Dictionary<TKey, TValue> dicBase, params Dictionary<TKey, TValue>[] dicParts)
{
foreach(var dic in dicParts.SkipWhile(w=>w==null))
{
foreach (var key in dic.Keys)
{
if(!dicBase.Keys.Contains(key))
dicBase.Add(key, dic[key]);
}
}
return dicBase;
}
/// <summary>
/// 根据其他集合排序现有集合
/// </summary>
/// <typeparam name="T1">类型1</typeparam>
/// <typeparam name="T2">类型2</typeparam>
/// <param name="enumer1">基础集合</param>
/// <param name="enumer2">排序集合</param>
/// <param name="func">排序方式</param>
/// <returns>返回原集合</returns>
public static IEnumerable<T1> OrderBy<T1, T2>(this IEnumerable<T1> enumer1, IEnumerable<T2> enumer2, Func<T2, T1> func)
{
if (func == null||enumer2==null)
foreach (var enu in enumer1)
yield return enu;
foreach (var enu in enumer2)
yield return func(enu);
}
/// <summary>
/// 根据其他集合排序生成集合型object
/// </summary>
/// <typeparam name="T1">本身集合类型</typeparam>
/// <typeparam name="T2">对象集合类型</typeparam>
/// <param name="enumer1">本身集合</param>
/// <param name="enumer2">排序集合</param>
/// <param name="func">排序方法</param>
/// <returns></returns>
public static object ObjectOrderBy<T1, T2>(this IEnumerable<T1> enumer1, IEnumerable<T2> enumer2, Func<T2, T1> func)
{
if (func == null||enumer1==null||enumer2==null)
return enumer1;
Type type = enumer1.GetType();
object obj = Activator.CreateInstance(type);
MethodInfo method = type.GetMethod("Add");
foreach (var enu in enumer2.SkipWhile(w => w == null))
{
T1 o = func(enu);
method.Invoke(obj, new object[] { o });
}
return obj;
}
/// <summary>
/// 集合根据其他集合排序返回本身类型集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <param name="t"></param>
/// <param name="enumer2"></param>
/// <param name="func"></param>
/// <returns></returns>
public static T OrderBy<T,T1,T2>(this T t,IEnumerable<T2> enumer2,Func<T2,T1> func) where T :IEnumerable<T1>
{
IEnumerable<T1> enumer = t as IEnumerable<T1>;
if (enumer == null) return t;
object o = enumer.ObjectOrderBy(enumer2, func);
return (T)o;
}
/// <summary>
/// 自身排序返回自身类型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <param name="t"></param>
/// <param name="func"></param>
/// <returns></returns>
public static T OrderBySelf<T, T1, T2>(this T t, Func<T1, T2> func) where T:IEnumerable<T1>
{
IEnumerable<T1> enumer = t as IEnumerable<T1>;
if (t == null || enumer == null) return t;
object obj = CreateInstance(t);
MethodInfo method = t.GetType().GetMethod("Add");
foreach (var value in enumer.OrderBy(func).SkipWhile(w => w == null))
{
method.Invoke(obj, new object[] { value });
}
return (T)obj;
}
/// <summary>
/// 按构造函数类型创建默认对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public static T CreateInstance<T>(this T t)
{
Type type = typeof(T);
object obj = type.CreateInstanceLoop();
return (T)obj;
}
/// <summary>
/// 根据Type创建实例
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static object CreateInstanceLoop(this Type type)
{
ConstructorInfo[] cis = type.GetConstructors();
List<object> objs = new List<object>();
if (cis == null||cis.Count()==0)
return Activator.CreateInstance(type,objs.ToArray());//无构造函数直接返回
var ci = cis.OrderBy(w => w.GetParameters().Count()).FirstOrDefault();
ParameterInfo[] pis = ci.GetParameters();
foreach (var p in pis)
{
object o=null;
if (p.ParameterType.IsClass && p.ParameterType != typeof(string))//类获取构造函数构造
o = p.ParameterType.CreateInstanceLoop();//递归获取参数类型的参数
else if (p.ParameterType == typeof(string))//string赋值空
o = string.Empty;
else
o = Activator.CreateInstance(p.ParameterType);
objs.Add(o);
}
return Activator.CreateInstance(type, objs.ToArray());//根据构造函数参数构造对象
}
public static double Round(this double dSource, int decimals)
{
return Math.Round(dSource, decimals);
}
public static double Round(this double dSource, int decimals, double ndValue)
{
double dBack = dSource.Round(decimals);
return dBack <= ndValue ? double.NaN : dBack;
}
}
