namespace WDBuyNET.DMSFrame.Utils.Helpers
{
public static class ReflectionHelper
{
public class TypeLoadConfig
{
private bool copyToMemory;
private bool loadAbstractType;
private string targetFilePostfix;
public bool CopyToMemory
{
get
{
return this.copyToMemory;
}
set
{
this.copyToMemory = value;
}
}
public bool LoadAbstractType
{
get
{
return this.loadAbstractType;
}
set
{
this.loadAbstractType = value;
}
}
public string TargetFilePostfix
{
get
{
return this.targetFilePostfix;
}
set
{
this.targetFilePostfix = value;
}
}
public TypeLoadConfig()
{
this.copyToMemory = false;
this.loadAbstractType = false;
this.targetFilePostfix = ".dll";
}
public TypeLoadConfig(bool copyToMem, bool loadAbstract, string postfix)
{
this.copyToMemory = false;
this.loadAbstractType = false;
this.targetFilePostfix = ".dll";
this.copyToMemory = copyToMem;
this.loadAbstractType = loadAbstract;
this.targetFilePostfix = postfix;
}
}
public static void CopyProperty(object source, object target)
{
ReflectionHelper.CopyProperty(source, target, null);
}
public static void CopyProperty(object source, object target, IList<MapItem> propertyMapItemList)
{
Type type = source.GetType();
Type type2 = target.GetType();
PropertyInfo[] properties = type.GetProperties();
if (propertyMapItemList != null)
{
foreach (MapItem current in propertyMapItemList)
{
object property = ReflectionHelper.GetProperty(source, current.Source);
ReflectionHelper.SetProperty(target, current.Target, property);
}
}
else
{
PropertyInfo[] array = properties;
for (int i = 0; i < array.Length; i++)
{
PropertyInfo propertyInfo = array[i];
if (propertyInfo.CanRead)
{
object property2 = ReflectionHelper.GetProperty(source, propertyInfo.Name);
ReflectionHelper.SetProperty(target, propertyInfo.Name, property2);
}
}
}
}
private static void DistillMethods(Type interfaceType, ref IList<MethodInfo> methodList)
{
MethodInfo[] methods = interfaceType.GetMethods();
for (int i = 0; i < methods.Length; i++)
{
MethodInfo methodInfo = methods[i];
bool flag = false;
foreach (MethodInfo current in methodList)
{
if (current.Name == methodInfo.Name && current.ReturnType == methodInfo.ReturnType)
{
ParameterInfo[] parameters = current.GetParameters();
ParameterInfo[] parameters2 = methodInfo.GetParameters();
if (parameters.Length == parameters2.Length)
{
bool flag2 = true;
for (int j = 0; j < parameters.Length; j++)
{
if (parameters[j].ParameterType != parameters2[j].ParameterType)
{
flag2 = false;
}
}
if (flag2)
{
flag = true;
break;
}
}
}
}
if (!flag)
{
methodList.Add(methodInfo);
}
}
Type[] interfaces = interfaceType.GetInterfaces();
i = 0;
while (i < interfaces.Length)
{
Type interfaceType2 = interfaces[i];
ReflectionHelper.DistillMethods(interfaceType2, ref methodList);
i++;
}
}
public static IList<MethodInfo> GetAllMethods(params Type[] interfaceTypes)
{
for (int i = 0; i < interfaceTypes.Length; i++)
{
Type type = interfaceTypes[i];
if (!type.IsInterface)
{
throw new Exception("Target Type must be interface!");
}
}
IList<MethodInfo> result = new List<MethodInfo>();
i = 0;
while (i < interfaceTypes.Length)
{
Type interfaceType = interfaceTypes[i];
ReflectionHelper.DistillMethods(interfaceType, ref result);
i++;
}
return result;
}
public static object GetFieldValue(object obj, string fieldName)
{
Type type = obj.GetType();
FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField);
if (field == null)
{
throw new Exception(string.Format("The field named '{0}' not found in '{1}'.", fieldName, type));
}
return field.GetValue(obj);
}
public static string GetMethodFullName(MethodInfo method)
{
return string.Format("{0}.{1}()", method.DeclaringType, method.Name);
}
public static object GetProperty(object obj, string propertyName)
{
return obj.GetType().InvokeMember(propertyName, BindingFlags.GetProperty, null, obj, null);
}
public static Type GetType(string typeAndAssName)
{
string[] array = typeAndAssName.Split(new char[]
{
','
});
return (array.Length >= 2) ? ReflectionHelper.GetType(array[0].Trim(), array[1].Trim()) : Type.GetType(typeAndAssName);
}
public static Type GetType(string typeFullName, string assemblyName)
{
Type result;
if (assemblyName == null)
{
result = Type.GetType(typeFullName);
}
else
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
Assembly[] array = assemblies;
for (int i = 0; i < array.Length; i++)
{
Assembly assembly = array[i];
if (assembly.FullName.Split(new char[]
{
','
})[0].Trim() == assemblyName.Trim())
{
result = assembly.GetType(typeFullName);
return result;
}
}
Assembly assembly2 = Assembly.Load(assemblyName);
result = ((!(assembly2 != null)) ? null : assembly2.GetType(typeFullName));
}
return result;
}
public static string GetTypeFullName(Type t)
{
return t.FullName + "," + t.Assembly.FullName.Split(new char[]
{
','
})[0];
}
public static IList<TBase> LoadDerivedInstance<TBase>(Assembly asm)
{
IList<TBase> list = new List<TBase>();
Type typeFromHandle = typeof(TBase);
Type[] types = asm.GetTypes();
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
bool arg_41_0;
if (typeFromHandle.IsAssignableFrom(type) && !type.IsAbstract)
{
arg_41_0 = type.IsInterface;
}
else
{
arg_41_0 = true;
}
if (!arg_41_0)
{
TBase item = (TBase)Activator.CreateInstance(type);
list.Add(item);
}
}
return list;
}
public static IList<Type> LoadDerivedType(Type baseType, string directorySearched, bool searchChildFolder, ReflectionHelper.TypeLoadConfig config)
{
if (config == null)
{
config = new ReflectionHelper.TypeLoadConfig();
}
IList<Type> list = new List<Type>();
IList<Type> result;
if (searchChildFolder)
{
ReflectionHelper.LoadDerivedTypeInAllFolder(baseType, list, directorySearched, config);
result = list;
}
else
{
ReflectionHelper.LoadDerivedTypeInOneFolder(baseType, list, directorySearched, config);
result = list;
}
return result;
}
private static void LoadDerivedTypeInAllFolder(Type baseType, IList<Type> derivedTypeList, string folderPath, ReflectionHelper.TypeLoadConfig config)
{
ReflectionHelper.LoadDerivedTypeInOneFolder(baseType, derivedTypeList, folderPath, config);
string[] directories = Directory.GetDirectories(folderPath);
if (directories != null)
{
string[] array = directories;
for (int i = 0; i < array.Length; i++)
{
string folderPath2 = array[i];
ReflectionHelper.LoadDerivedTypeInAllFolder(baseType, derivedTypeList, folderPath2, config);
}
}
}
private static void LoadDerivedTypeInOneFolder(Type baseType, IList<Type> derivedTypeList, string folderPath, ReflectionHelper.TypeLoadConfig config)
{
string[] files = Directory.GetFiles(folderPath);
string[] array = files;
for (int i = 0; i < array.Length; i++)
{
string text = array[i];
if (config.TargetFilePostfix == null || text.EndsWith(config.TargetFilePostfix))
{
Assembly assembly = null;
try
{
assembly = ((!config.CopyToMemory) ? Assembly.LoadFrom(text) : Assembly.Load(FileHelper.ReadFileReturnBytes(text)));
}
catch (Exception )
{
}
if (assembly != null)
{
Type[] types = assembly.GetTypes();
Type[] array2 = types;
for (int j = 0; j < array2.Length; j++)
{
Type type = array2[j];
bool arg_C5_0;
if (type.IsSubclassOf(baseType) || baseType.IsAssignableFrom(type))
{
arg_C5_0 = (!config.LoadAbstractType && type.IsAbstract);
}
else
{
arg_C5_0 = true;
}
if (!arg_C5_0)
{
derivedTypeList.Add(type);
}
}
}
}
}
}
public static MethodInfo SearchGenericMethodInType(Type originType, string methodName, Type[] argTypes)
{
MethodInfo[] methods = originType.GetMethods();
MethodInfo result;
for (int i = 0; i < methods.Length; i++)
{
MethodInfo methodInfo = methods[i];
if (methodInfo.ContainsGenericParameters && methodInfo.Name == methodName)
{
bool flag = true;
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length == argTypes.Length)
{
for (int j = 0; j < parameters.Length; j++)
{
if (!parameters[j].ParameterType.IsGenericParameter)
{
if (parameters[j].ParameterType.IsGenericType)
{
if (parameters[j].ParameterType.GetGenericTypeDefinition() != argTypes[j].GetGenericTypeDefinition())
{
flag = false;
break;
}
}
else
{
if (parameters[j].ParameterType != argTypes[j])
{
flag = false;
break;
}
}
}
}
if (flag)
{
result = methodInfo;
return result;
}
}
}
}
result = null;
return result;
}
public static MethodInfo SearchMethod(Type originType, string methodName, Type[] argTypes)
{
MethodInfo method = originType.GetMethod(methodName, argTypes);
MethodInfo result;
if (method != null)
{
result = method;
}
else
{
MethodInfo methodInfo = ReflectionHelper.SearchGenericMethodInType(originType, methodName, argTypes);
if (methodInfo != null)
{
result = methodInfo;
}
else
{
Type baseType = originType.BaseType;
if (baseType != null)
{
while (baseType != typeof(object))
{
MethodInfo method2 = baseType.GetMethod(methodName, argTypes);
if (method2 != null)
{
result = method2;
return result;
}
MethodInfo methodInfo2 = ReflectionHelper.SearchGenericMethodInType(baseType, methodName, argTypes);
if (methodInfo2 != null)
{
result = methodInfo2;
return result;
}
baseType = baseType.BaseType;
}
}
if (originType.GetInterfaces() != null)
{
IList<MethodInfo> allMethods = ReflectionHelper.GetAllMethods(originType.GetInterfaces());
foreach (MethodInfo current in allMethods)
{
if (!(current.Name != methodName))
{
ParameterInfo[] parameters = current.GetParameters();
if (parameters.Length == argTypes.Length)
{
bool flag = true;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType != argTypes[i])
{
flag = false;
break;
}
}
if (flag)
{
result = current;
return result;
}
}
}
}
}
result = null;
}
}
return result;
}
public static void SetFieldValue(object obj, string fieldName, object val)
{
Type type = obj.GetType();
FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField);
if (field == null)
{
throw new Exception(string.Format("The field named '{0}' not found in '{1}'.", fieldName, type));
}
field.SetValue(obj, val);
}
public static void SetProperty(IList<object> objs, string propertyName, object proValue)
{
object[] array = new object[]
{
proValue
};
foreach (object current in objs)
{
ReflectionHelper.SetProperty(current, propertyName, proValue);
}
}
public static void SetProperty(object obj, string propertyName, object proValue)
{
ReflectionHelper.SetProperty(obj, propertyName, proValue, true);
}
public static void SetProperty(object obj, string propertyName, object proValue, bool ignoreError)
{
Type type = obj.GetType();
PropertyInfo property = type.GetProperty(propertyName);
if (!(property != null) || !property.CanWrite)
{
if (!ignoreError)
{
throw new Exception(string.Format("The setter of property named '{0}' not found in '{1}'.", propertyName, type));
}
}
else
{
try
{
proValue = TypeHelper.ChangeType(property.PropertyType, proValue);
}
catch (object )
{
}
object[] args = new object[]
{
proValue
};
type.InvokeMember(propertyName, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty, null, obj, args);
}
}
public static object DllInvoke(string DllFileName, string NameSpace, string ClassName, string MethodName, params object[] ObjArrayParams)
{
object result;
try
{
Assembly assembly = Assembly.LoadFrom(DllFileName);
Type[] types = assembly.GetTypes();
Type[] array = types;
for (int i = 0; i < array.Length; i++)
{
Type type = array[i];
if (type.Namespace == NameSpace && type.Name == ClassName)
{
MethodInfo method = type.GetMethod(MethodName);
if (method != null)
{
object obj = Activator.CreateInstance(type);
result = method.Invoke(obj, ObjArrayParams);
return result;
}
}
}
}
catch (Exception )
{
}
result = 0;
return result;
}
}
}
