public static IList Map(Type objectType, IDataReader dataReader, ObjectPropertyConvertType convertType)
{
if (!TypeHelper.IsValueType(objectType))
{
return(Map(objectType, dataReader));
}
Type[] typeArguments = { objectType };
var list = (IList)Activator.CreateInstance(ReflectorConsts.ListType.MakeGenericType(typeArguments));
while (dataReader.Read())
{
if (!dataReader.IsDBNull(0))
{
list.Add(dataReader.GetValue(0));
}
}
return(list);
}
public static IList Map(Type objectType, DataSet ds, ObjectPropertyConvertType convertType)
{
var list = (IList)Activator.CreateInstance(ReflectorConsts.ListObjectType);
var setters = ExpressionReflector.GetSetters(objectType);
var properties = ExpressionReflector.GetProperties(objectType);
var table1 = ds.Tables[0];
foreach (DataRow row in ds.Tables[0].Rows)
{
object obj2 = null;
if (objectType.IsSealed)
{
var list2 = new List <object>();
foreach (DataColumn column in ds.Tables[0].Columns)
{
var item = row[column];
if (item == DBNull.Value)
{
item = null;
}
list2.Add(item);
}
if (TypeHelper.IsValueType(objectType))
{
obj2 = list2[0];
}
else
{
obj2 = ExpressionReflector.CreateInstance(objectType, convertType, list2.ToArray());
}
}
else
{
obj2 = ExpressionReflector.CreateInstance(objectType, convertType);
foreach (DataColumn column2 in ds.Tables[0].Columns)
{
var obj4 = row[column2];
if (obj4 != DBNull.Value)
{
var info = properties[column2.ColumnName];
if (info != null)
{
var propertyType = info.PropertyType;
var underlyingType = Nullable.GetUnderlyingType(propertyType);
if (underlyingType == null)
{
underlyingType = propertyType;
}
if (underlyingType.IsEnum)
{
obj4 = Enum.Parse(underlyingType, Convert.ToString(obj4));
}
else
{
obj4 = Convert.ChangeType(obj4, underlyingType);
}
setters[column2.ColumnName](obj2, obj4);
}
}
}
}
list.Add(obj2);
}
return(list);
}
public static Func <object[], object> GetConstructor(Type type, ObjectPropertyConvertType convertType)
{
Func <object[], object> func = null;
if (!_objectConstructors.TryGetValue(type, out func))
{
var dictionary = _objectConstructors;
lock (dictionary)
{
Expression expression;
if (_objectConstructors.TryGetValue(type, out func))
{
return(func);
}
var array = Expression.Parameter(ReflectorConsts.ObjectArrayType);
if (TypeHelper.IsValueType(type))
{
expression = Expression.New(type);
}
else
{
var constructor = type.GetConstructors()[0];
var list = new List <Expression>();
var infoArray = constructor.GetParameters();
for (var i = 0; i < infoArray.Length; i++)
{
var info2 = infoArray[i];
var expression3 = Expression.ArrayIndex(array, Expression.Constant(i));
var flag2 = TypeHelper.IsNullableType(info2.ParameterType);
var parameterType = info2.ParameterType;
if (flag2)
{
parameterType = TypeHelper.GetUnderlyingType(parameterType);
}
Expression expression4 = null;
if (convertType != ObjectPropertyConvertType.ConvertTo)
{
if (convertType == ObjectPropertyConvertType.Cast)
{
expression4 = Expression.Convert(expression3, info2.ParameterType);
}
}
else
{
MethodInfo method = null;
if (parameterType == ReflectorConsts.DateTimeType)
{
method = ReflectorConsts.ConvertToDateTimeMethod;
Expression[] expressionArray1 = { expression3 };
expression4 = Expression.Call(null, ReflectorConsts.ConvertToDateTimeMethod,
expressionArray1);
}
else if (parameterType == ReflectorConsts.StringType)
{
method = ReflectorConsts.ConvertToStringMethod;
}
else if (parameterType == ReflectorConsts.Int32Type)
{
method = ReflectorConsts.ConvertToInt32Method;
}
else
{
if (parameterType != ReflectorConsts.BoolType)
{
throw new Exception("不支持：" + parameterType);
}
method = ReflectorConsts.ConvertToBoolMethod;
}
Expression[] arguments = { expression3 };
expression4 = Expression.Call(null, method, arguments);
if (flag2)
{
expression4 = Expression.Convert(expression4, info2.ParameterType);
}
}
list.Add(expression4);
}
expression = Expression.New(constructor, list.ToArray());
}
ParameterExpression[] parameters = { array };
func = Expression.Lambda <Func <object[], object> >(expression, parameters).Compile();
_objectConstructors.Add(type, func);
}
}
return(func);
}
public static object CreateInstance(Type type, ObjectPropertyConvertType convertType, params object[] parameters)
{
return(GetConstructor(type, convertType)(parameters));
}
