/// <summary>
/// 获取属性列表
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public static List <PropertyInfo> GetPropertyList(Type t)
{
bool isAnonymousType = t.Name.Contains("f__AnonymousType"); //忽略匿名类型
string key = t.FullName; // t.GUID.ToString();由泛型 XX<T> 引起的如： Ge<A> 和 Ge<B> ,Guid名相同,所以用FullName
if (!isAnonymousType && propCache.ContainsKey(key))
{
return(propCache[key]);
}
else
{
bool isInheritOrm = t.BaseType.Name.StartsWith("OrmBase") || t.BaseType.Name.StartsWith("SimpleOrmBase");
PropertyInfo[] pInfo = isInheritOrm ? t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) : t.GetProperties();
List <PropertyInfo> list = new List <PropertyInfo>(pInfo.Length);
try
{
list.AddRange(pInfo);
if (!isAnonymousType)
{
propCache.Set(key, list);
}
}
catch (Exception err)
{
Log.Write(err, LogType.Error);
}
return(list);
}
}
/// <summary>
/// 获取Field列表
/// </summary>
public static List <FieldInfo> GetFieldList(Type t)
{
string key = t.GUID.ToString();
if (fieldCache.ContainsKey(key))
{
return(fieldCache[key]);
}
else
{
bool isInheritOrm = t.BaseType.Name == "OrmBase" || t.BaseType.Name == "SimpleOrmBase";
FieldInfo[] pInfo = isInheritOrm ? t.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) : t.GetFields();
List <FieldInfo> list = new List <FieldInfo>(pInfo.Length);
try
{
list.AddRange(pInfo);
fieldCache.Set(key, list);
}
catch (Exception err)
{
Log.Write(err, LogType.Error);
}
return(list);
}
}
/// <summary>
/// 获取属性列表
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
internal static List <PropertyInfo> GetPropertyInfo(Type t)
{
string key = t.GUID.ToString();
if (propCache.ContainsKey(key))
{
return(propCache[key]);
}
else
{
bool isInheritOrm = t.BaseType.Name == "OrmBase" || t.BaseType.Name == "SimpleOrmBase";
PropertyInfo[] pInfo = isInheritOrm ? t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) : t.GetProperties();
List <PropertyInfo> list = new List <PropertyInfo>(pInfo.Length);
try
{
list.AddRange(pInfo);
propCache.Set(key, list);
}
catch (Exception err)
{
Log.WriteLogToTxt(err);
}
return(list);
}
}
internal static string GetHashKey(string sourceString)
{
try
{
if (hashKeyCache.ContainsKey(sourceString))
{
return(hashKeyCache[sourceString]);
}
else
{
if (hashKeyCache.Count > 512)
{
hashKeyCache.Clear();
hashKeyCache = new MDictionary <string, string>(64);
}
string value = "K" + Math.Abs(sourceString.GetHashCode()) + sourceString.Length;
hashKeyCache.Add(sourceString, value);
return(value);
}
}
catch
{
return(sourceString);
}
}
/// <summary>
/// 获取特性列表
/// </summary>
private static object[] GetAttributes(Type t, Type searchType, PropertyInfo pi, FieldInfo fi)
{
string key = t.GUID.ToString();
if (searchType != null)
{
key += searchType.Name;
}
if (pi != null)
{
key += pi.Name;
}
else if (fi != null)
{
key += fi.Name;
}
//key = key.GetHashCode().ToString();
if (attrCache.ContainsKey(key))
{
return(attrCache[key]);
}
else
{
try
{
object[] items = null;
if (pi != null)
{
items = searchType == null?pi.GetCustomAttributes(false) : pi.GetCustomAttributes(searchType, true);
}
else if (fi != null)
{
items = searchType == null?fi.GetCustomAttributes(false) : fi.GetCustomAttributes(searchType, true);
}
else
{
items = searchType == null?t.GetCustomAttributes(false) : t.GetCustomAttributes(searchType, true);
}
attrCache.Add(key, items);
return(items);
}
catch (Exception err)
{
Log.Write(err, LogType.Error);
}
return(null);
}
}
/// <summary>
/// 判断是否存在指定的属性
/// </summary>
/// <param name="searchType"></param>
/// <param name="pi"></param>
/// <returns></returns>
internal static bool ExistsAttr(Type searchType, PropertyInfo pi, FieldInfo fi)
{
string key = (pi != null ? pi.DeclaringType.FullName + pi.Name : fi.DeclaringType.FullName + fi.Name) + searchType.Name;
int code = key.GetHashCode();
if (attrExistsCache.ContainsKey(code))
{
return(attrExistsCache[code]);
}
object[] items = pi != null?pi.GetCustomAttributes(searchType, true) : fi.GetCustomAttributes(searchType, true);
if (items != null && items.Length > 0)
{
attrExistsCache.Add(code, true);
return(true);
}
attrExistsCache.Add(code, false);
return(false);
}
/// <summary>
/// 获取属性列表
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
internal static PropertyInfo[] GetPropertyInfo(Type t)
{
if (propCache.ContainsKey(t.GUID))
{
return(propCache[t.GUID]);
}
else
{
bool isInheritOrm = t.BaseType.Name == "OrmBase" || t.BaseType.Name == "SimpleOrmBase";
PropertyInfo[] pInfo = isInheritOrm ? t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) : t.GetProperties();
try
{
propCache.Add(t.GUID, pInfo);
}
catch
{
}
return(pInfo);
}
}
/// <summary>
/// 获取泛型的参数长度，同时类型修改为普通类型（非泛型按默认方法计算）
/// </summary>
public static int GetArgumentLength(ref Type t, out Type[] argTypes)
{
string key = t.FullName;
if (argumentCache.ContainsKey(key))
{
argTypes = argumentCache[key];
}
else
{
int len = 0;
if (t.IsGenericType)
{
#region MyRegion
argTypes = t.GetGenericArguments();
len = argTypes.Length;
for (int i = 0; i < argTypes.Length; i++)
{
if (argTypes[i].IsGenericType && argTypes[i].Name.StartsWith("Nullable"))
{
argTypes[i] = Nullable.GetUnderlyingType(argTypes[i]);
}
}
#endregion
}
else
{
#region 非泛型
if (t.Name.EndsWith("[]") || t.Name == "MDataRowCollection" || t.Name == "MDataColumn")
{
len = 1;
}
else if (t.Name == "NameValueCollection" || (t.BaseType != null && t.BaseType.Name == "NameValueCollection"))
{
len = 2;
}
else if (t.BaseType != null && t.BaseType.Name == "DbParameterCollection")
{
len = 1;
}
else
{
System.Reflection.MethodInfo mi = t.GetMethod("Add");
if (mi != null)
{
len = mi.GetParameters().Length;
}
}
argTypes = new Type[len];
for (int i = 0; i < argTypes.Length; i++)
{
argTypes[i] = typeof(object);
}
#endregion
}
argumentCache.Set(key, argTypes);
}
if (t.IsGenericType)
{
if (t.Name.StartsWith("Nullable"))
{
t = Nullable.GetUnderlyingType(t);
}
else if (t.Name == "IList`1")
{
//List<int> a;typeof(List<int>);
t = typeof(List <>).MakeGenericType(argTypes[0]);
}
else if (t.Name == "IDictionary`2")
{
t = typeof(Dictionary <,>).MakeGenericType(argTypes[0], argTypes[1]);
}
}
return(argTypes.Length);
}