private Proxy ProxyData(string json)
{
var argumentTable = new Dictionary <string, string>();
var args = json.Split(',');
foreach (var item in args)
{
AddArgument(ref argumentTable, item);
}
var proxy = new Proxy();
foreach (var p in proxy.GetType().GetProperties())
{
string value;
if (argumentTable.TryGetValue(p.Name, out value))
{
var type = p.PropertyType;
if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
var nullableConverter = new System.ComponentModel.NullableConverter(type);
type = nullableConverter.UnderlyingType;
}
p.SetValue(proxy, Convert.ChangeType(value, type));
}
}
return(proxy);
}
/// <summary>
/// 转换DataTable为实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="table"></param>
/// <returns></returns>
public static IList <T> GetEntities <T>(DataTable table) where T : new()
{
IList <T> entities = new List <T>();
foreach (DataRow row in table.Rows)
{
T entity = new T();
foreach (PropertyInfo propertyInfo in typeof(T).GetProperties())
{
if (row.Table.Columns.Contains(propertyInfo.Name))
{
if (DBNull.Value != row[propertyInfo.Name])
{
Type type = propertyInfo.PropertyType;
//判断type类型是否为泛型，因为nullable是泛型类,
if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))//判断convertsionType是否为nullable泛型类
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(type);
//将type转换为nullable对的基础基元类型
type = nullableConverter.UnderlyingType;
}
propertyInfo.SetValue(entity, Convert.ChangeType(row[propertyInfo.Name], type), null);
}
}
}
entities.Add(entity);
}
return(entities);
}
/// <summary>
/// 用户信息的字段
/// </summary>
/// <param name="id"></param>
/// <param name="fieldName"></param>
/// <param name="value"></param>
/// <returns></returns>
public ActionResult EditField(string userId, string fieldName, string value)
{
User user = UserService.Instance.Get(userId);
var prop = typeof(User).GetProperty(fieldName);
var type = prop.PropertyType;
//判断convertsionType是否为nullable泛型类
if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(type);
//将type转换为nullable对的基础基元类型
type = nullableConverter.UnderlyingType;
if (string.IsNullOrEmpty(value))
{
prop.SetValue(user, null);
}
else
{
prop.SetValue(user, Convert.ChangeType(value, type), null);
}
}
else
{
var val = Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
prop.SetValue(user, val);
}
UserService.Instance.Edit(user);
return(Json(new { status = 0 }));
}
/// <summary>
/// 类型转换（包含Nullable<>和非Nullable<>转换）
/// </summary>
/// <param name="value"></param>
/// <param name="conversionType"></param>
/// <returns></returns>
private static object ChangeType(object value, Type conversionType)
{
// Note: This if block was taken from Convert.ChangeType as is, and is needed here since we're
// checking properties on conversionType below.
if (conversionType == null)
{
throw new ArgumentNullException("conversionType");
} // end if
// If it's not a nullable type, just pass through the parameters to Convert.ChangeType
if (conversionType.IsGenericType &&
conversionType.IsNullable())
{
if (value == null)
{
return(null);
} // end if
// It's a nullable type, and not null, so that means it can be converted to its underlying type,
// so overwrite the passed-in conversion type with this underlying type
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
} // end if
// Now that we've guaranteed conversionType is something Convert.ChangeType can handle (i.e. not a
// nullable type), pass the call on to Convert.ChangeType
return(Convert.ChangeType(value, conversionType));
}
/// <summary>
/// DataTable转实体
/// </summary>
/// <typeparam name="T">实体</typeparam>
/// <param name="table">DataTable实例</param>
/// <returns></returns>
public static T ToEntity <T>(this DataTable table) where T : new()
{
var entity = new T();
foreach (DataRow row in table.Rows)
{
foreach (var item in entity.GetType().GetProperties())
{
if (!row.Table.Columns.Contains(item.Name))
{
continue;
}
if (DBNull.Value == row[item.Name])
{
continue;
}
var newType = item.PropertyType;
//判断type类型是否为泛型，因为nullable是泛型类,
if (newType.IsGenericType && newType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
var nullableConverter = new System.ComponentModel.NullableConverter(newType);
//将type转换为nullable对的基础基元类型
newType = nullableConverter.UnderlyingType;
}
item.SetValue(entity, Convert.ChangeType(row[item.Name], newType), null);
}
}
return(entity);
}
/// <summary>
/// DataTable to Entity
/// </summary>
/// <typeparam name="T">>Generic Type</typeparam>
/// <param name="table">DataTable</param>
/// <returns></returns>
public static T ToEntity <T>(this DataTable table) where T : new()
{
T entity = new T();
foreach (DataRow row in table.Rows)
{
foreach (var item in entity.GetType().GetProperties())
{
if (row.Table.Columns.Contains(item.Name))
{
if (DBNull.Value != row[item.Name])
{
Type newType = item.PropertyType;
//(newType.IsGenericType) Determine if the type is generic because nullable is a generic class.
//(newType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)) Judge whether convertsionType is nullable generic class
if (newType.IsGenericType && newType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
// If the type is a nullable class, declare a NullableConverter class that provides the conversion from the Nullable class to the underlying primitive type
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(newType);
// The primitive primitive type that converts type to a nullable pair
newType = nullableConverter.UnderlyingType;
}
item.SetValue(entity, Convert.ChangeType(row[item.Name], newType), null);
}
}
}
}
return(entity);
}
/// <summary>
/// 数据行对应到实体类对象
/// </summary>
/// <param name="row">数据行</param>
/// <returns>实体对象</returns>
public static T ToEntity(DataRow row)
{
Type type = typeof(T);
T model = System.Activator.CreateInstance <T>();
foreach (PropertyInfo pi in type.GetProperties())
{
if (!row.Table.Columns.Contains(pi.Name) || row[pi.Name] == null || row[pi.Name].ToString() == "")
{
continue;
}
try
{
//判断字段类型是否可以为空类型
if (pi.PropertyType.IsGenericType && pi.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
if (row[pi.Name] != null)
{
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(pi.PropertyType);
pi.SetValue(model, Convert.ChangeType(row[pi.Name], nullableConverter.UnderlyingType), null);
}
}
else
{
pi.SetValue(model, Convert.ChangeType(row[pi.Name], pi.PropertyType), null);
}
}
catch
{ }
}
return(model);
}
/// <summary>
/// 获取可空类型的实际类型
/// </summary>
public static Type GetUnNullableType(this Type InputType)
{
try
{
string Key = InputType.Name + "-GetUnNullableType";
if (CacheManage.Get(Key) != null)
{
InputType = (Type)(CacheManage.Get(Key));
}
else
{
if (InputType.IsGenericType && InputType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
var nullableConverter = new System.ComponentModel.NullableConverter(InputType);
InputType = nullableConverter.UnderlyingType;
}
CacheManage.Insert(Key, InputType);
}
return(InputType);
}
catch (Exception ex)
{
ex.Data.Add("Running Process", "Super.Framework.TypeHelper.GetUnNullableType");
ex.Data.Add("Working Parameter Type", InputType.Name);
throw ex;
}
}
public static List <T> ToEntities <T>(this DataTable table) where T : new()
{
List <T> entities = new List <T>();
if (table == null)
{
return(null);
}
foreach (DataRow row in table.Rows)
{
T entity = new T();
foreach (var item in entity.GetType().GetProperties())
{
if (table.Columns.Contains(item.Name))
{
if (DBNull.Value != row[item.Name])
{
Type newType = item.PropertyType;
//判断type类型是否为泛型，因为nullable是泛型类,
if (newType.IsGenericType &&
newType.GetGenericTypeDefinition().Equals(typeof(Nullable <>))) //判断convertsionType是否为nullable泛型类
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(newType);
//将type转换为nullable对的基础基元类型
newType = nullableConverter.UnderlyingType;
}
item.SetValue(entity, Convert.ChangeType(row[item.Name], newType), null);
}
}
}
entities.Add(entity);
}
return(entities);
}
public static Type GetUnderlyingTypeForNullable(Type nullableType)
{
return(_nullableTypeCache.GetOrAdd(nullableType, (nt) =>
{
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(nt);
return nullableConverter.UnderlyingType;
}));
}
public ActionResult Exec(ExecModel mr)
{
#region 动态创建类实例
string Typename = "Model." + mr.Type;
dynamic obj = System.Reflection.Assembly.Load("Model").CreateInstance(Typename, false);
#endregion
#region 动态解析Json
dynamic v = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(mr.value);//{Name:张三,Age:21}
#endregion
#region 将类实例赋值
System.Reflection.PropertyInfo[] fields = obj.GetType().GetProperties();//获取指定对象的所有公共属性
foreach (System.Reflection.PropertyInfo t in fields)
{
Type type = t.PropertyType;
if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))//判断convertsionType是否为nullable泛型类
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(type);
//将type转换为nullable对的基础基元类型
type = nullableConverter.UnderlyingType;
}
foreach (var r in v) //对json进行循环
{
if (r.Name == t.Name) //判断当前属性是否在json中
{
t.SetValue(obj, Convert.ChangeType(v[t.Name].Value, type), null); //给对象赋值
}
}
}
#endregion
bool issuccess = false;
if (mr.ExecType == "Update")
{
issuccess = BLL.CommonBLL.Update(obj);
}
else if (mr.ExecType == "Insert")
{
issuccess = BLL.CommonBLL.add(obj);
}
else if (mr.ExecType == "Delete")
{
issuccess = BLL.CommonBLL.Delete(obj);
}
else if (mr.ExecType == "Proc")
{
issuccess = BLL.CommonBLL.ExecByProc(obj);
}
var ret = new
{
messagecode = issuccess ? 1 : 0,
};
return(Json(ret, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Get a real type of a Nullable type
/// </summary>
/// <param name="conversionType"></param>
/// <returns></returns>
public static Type GetUnNullableType(Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
var nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return(conversionType);
}
private static T ConvertirTipo <T>(Object valor)
{
Type objTipoConversion = typeof(T);
if (objTipoConversion.IsGenericType)
{
objTipoConversion = new System.ComponentModel.NullableConverter(objTipoConversion).UnderlyingType;
}
return((T)Convert.ChangeType(valor, objTipoConversion));
}
/// <summary>
/// 新增博客
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <CommonResultDto <string> > Post(BlogAddDto dto)
{
using (await _context.Database.BeginTransactionAsync())
{
System.ComponentModel.NullableConverter nullableDateTime = new System.ComponentModel.NullableConverter(typeof(DateTime?));
string blogContentId = Guid.NewGuid().ToString();
string blogId = Guid.NewGuid().ToString();
tbl_blog_content tbl_content = new tbl_blog_content
{
Id = blogContentId,
Content = dto.Content
};
tbl_blog tbl_blog = new tbl_blog
{
Id = blogId,
Title = dto.Title,
ContentId = blogContentId,
Remark = dto.Remark,
CategoryId = dto.CategoryId,
PicUrl = dto.PicUrl,
ViewTimes = 0,
LikeTimes = 0,
State = dto.State == "1" ? '1' : '2', //状态（枚举类型 1未发布 2已发布）
CreateAt = DateTime.Now,
PublishAt = dto.State == "2" ? DateTime.Now : (DateTime?)nullableDateTime.ConvertFromString(null),
DeleteAt = null
};
List <tbl_blog_tag_relation> relationList = new List <tbl_blog_tag_relation>();
foreach (var item in dto.TagIdList)
{
relationList.Add(new tbl_blog_tag_relation
{
Id = Guid.NewGuid().ToString(),
BlogId = blogId,
TagId = item
});
}
await _context.tbl_blog.AddAsync(tbl_blog);
await _context.tbl_blog_content.AddAsync(tbl_content);
await _context.tbl_blog_tag_relation.AddRangeAsync(relationList);
await _context.SaveChangesAsync();
_context.Database.CommitTransaction();
return(new CommonResultDto <string> {
Msg = "新增成功", Success = true
});
}
}
/// <summary>
/// ��ȡ�ɿ����͵�ʵ������
/// </summary>
/// <param name="conversionType"></param>
/// <returns></returns>
public static Type GetUnNullableType(Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
//����Ƿ��ͷ������ҷ�������ΪNullable<>����Ϊ�ɿ�����
//��ʹ��NullableConverterת��������ת��
var nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return conversionType;
}
/// <summary>
/// 修改类型
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <returns></returns>
static private Object ChangeType(object value, Type targetType)
{
Type convertType = targetType;
if (targetType.IsGenericType && targetType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(targetType);
convertType = nullableConverter.UnderlyingType;
}
return(Convert.ChangeType(value, convertType));
}
/// <summary>
/// 获取可空类型的实际类型
/// </summary>
/// <param name="conversionType"></param>
/// <returns></returns>
public static Type GetUnNullableType(Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
//如果是泛型方法，且泛型类型为Nullable<>则视为可空类型
//并使用NullableConverter转换器进行转换
var nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return(conversionType);
}
public static Type GetUnderlyingType(this Type type)
{
bool nullableType = type.IsGenericType &&
type.GetGenericTypeDefinition().Equals(typeof(Nullable <>));
if (nullableType)
{
type = new System.ComponentModel.NullableConverter(type).UnderlyingType;
}
return(type);
}
/// <summary>
/// 对可空类型进行判断转换(*要不然会报错)
/// </summary>
/// <param name="value">DataReader字段的值</param>
/// <param name="conversionType">该字段的类型</param>
/// <returns></returns>
private static object CheckType(object value, Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
if (value == null)
{
return(null);
}
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return(Convert.ChangeType(value, conversionType));
}
public static object ChangeType2(object value, Type conversionType)
{
if (value is DBNull || value == null||string.IsNullOrWhiteSpace(value.ToString()))
return null;
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
System.ComponentModel.NullableConverter nullableConverter
= new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return Convert.ChangeType(value, conversionType);
}
/// <summary>
/// Asigna un valor a una propiedad de un objeto
/// </summary>
/// <typeparam name="T">Tipo de dato</typeparam>
/// <param name="objeto">Objeto al cual se le asignara el valor a su propiedad</param>
/// <param name="valorPropiedad">Valor de la propiedad</param>
/// <param name="propiedad">Propiedad del objeto</param>
/// <creador>Jonathan Contreras</creador>
/// <fecha_creacion>23-04-2010</fecha_creacion>
public static void AsignarValorPropiedad <T>(T objeto, Object valorPropiedad, System.Reflection.PropertyInfo propiedad)
{
if (propiedad != null && valorPropiedad != null && valorPropiedad.GetType() != typeof(System.DBNull))
{
Type objTipoConversion = propiedad.PropertyType;
if (objTipoConversion.IsGenericType)
{
objTipoConversion = new System.ComponentModel.NullableConverter(objTipoConversion).UnderlyingType;
}
valorPropiedad = Convert.ChangeType(valorPropiedad, objTipoConversion);
propiedad.SetValue(objeto, valorPropiedad, System.Reflection.BindingFlags.Default, null, null, null);
}
}
public object ChangeType(object value, Type conversionType)
{
if ( conversionType.IsGenericType &&
conversionType.GetGenericTypeDefinition( ).Equals( typeof( Nullable<> ) ) ) {
System.ComponentModel.NullableConverter nullableConverter
= new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return Convert.ChangeType(value, conversionType);
}
/// <summary>
/// Metodo que permite copiar los valores de las propiedades del mismo nombre entre un DTO y otro
/// </summary>
/// <typeparam name="T">Tipo de dato DTO origen</typeparam>
/// <typeparam name="X">Tipo de dato DTO destino</typeparam>
/// <param name="datoOriginal">DTO origen</param>
/// <param name="datoCopia">DTO destino</param>
/// <creador>Jonathan Contreras</creador>
/// <fecha_creacion>27-09-2010</fecha_creacion>
public static void MapearDatos <T, X>(T datoOriginal, X datoCopia, String[] listaPropiedades)
{
if (datoOriginal == null || datoCopia == null)
{
return;
}
System.Reflection.PropertyInfo objPropiedadX = null, objPropiedadT = null;
Type objTipoX = typeof(X), objTipoT = typeof(T), objTipoConversion = null;
Object objValorOriginal = null;
System.ComponentModel.NullableConverter objConversor = null;
for (int intIndice = 0; intIndice < listaPropiedades.Length; intIndice++)
{
objPropiedadT = objTipoT.GetProperty(listaPropiedades[intIndice]);
if (objPropiedadT != null)
{
objPropiedadX = objTipoX.GetProperty(listaPropiedades[intIndice]);
if (objPropiedadX == null)
{
objPropiedadX = objTipoX.GetProperty(Texto.SepararTextoPorMayusculas(listaPropiedades[intIndice]).Replace(" ", "_").ToUpper());
}
if (objPropiedadX == null)
{
objPropiedadX = objTipoX.GetProperty(Texto.ConvertirAMinusculaPrimeraEnMayuscula(listaPropiedades[intIndice].ToLower().Replace("_", " ")).Replace(" ", ""));
}
if (objPropiedadX != null && objPropiedadX.CanWrite)
{
objTipoConversion = objPropiedadX.PropertyType;
if (objTipoConversion.IsGenericType)
{
objConversor = new System.ComponentModel.NullableConverter(objTipoConversion);
objTipoConversion = objConversor.UnderlyingType;
}
if ((objValorOriginal = objPropiedadT.GetValue(datoOriginal, null)) != null)
{
objValorOriginal = Convert.ChangeType(objValorOriginal, objTipoConversion);
if (objValorOriginal != null)
{
objPropiedadX.SetValue(datoCopia, objValorOriginal, System.Reflection.BindingFlags.Default, null, null, null);
}
}
}
}
}
ValidarDatosFecha <X>(ref datoCopia);
}
public static T CustomChangeType <T>(object value, Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (value == null)
{
return(default(T));
}
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return((T)Convert.ChangeType(value, conversionType));
}
private static Type GetNullAbleProperty(Type propertyType)
{
var type = propertyType;
//判断type类型是否为泛型，因为nullable是泛型类,
if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))//判断convertsionType是否为nullable泛型类
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(propertyType);
//将type转换为nullable对的基础基元类型
type = nullableConverter.UnderlyingType;
}
return(type);
}
/// <summary>
/// 可为空类型扩展类，转换为基础类型
/// </summary>
/// <param name="value"></param>
/// <param name="convertsionType"></param>
/// <returns></returns>
public static object ChanageType(this object value, Type convertsionType)
{
if (convertsionType.IsGenericType &&
convertsionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
if (value == null || value.ToString().Length == 0)
{
return(null);
}
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(convertsionType);
convertsionType = nullableConverter.UnderlyingType;
}
return(Convert.ChangeType(value, convertsionType));
}
public static object ChangeType2(object value, Type conversionType)
{
if (value is DBNull || value == null || string.IsNullOrEmpty(value.ToString()))
{
return(null);
}
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return(Convert.ChangeType(value, conversionType));
}
/// <summary>
/// DataTable转List
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dt"></param>
/// <returns></returns>
public static IList <T> ConvertTo <T>(DataTable dt) where T : new()
{
// 定义集合
IList <T> ts = new List <T>();
foreach (DataRow dr in dt.Rows)
{
T t = new T();
// 获得此模型的公共属性
PropertyInfo[] propertys = t.GetType().GetProperties();
foreach (PropertyInfo pi in propertys)
{
Type type = pi.PropertyType;
//if判断就是解决办法
if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))//判断convertsionType是否为nullable泛型类
{
//如果type为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(type);
//将type转换为nullable对的基础基元类型
type = nullableConverter.UnderlyingType;
}
if (dr.Table.Columns.Contains(pi.Name.ToUpper()))
{
object value = dr[pi.Name.ToUpper()];
if (value != DBNull.Value)
{
pi.SetValue(t, Convert.ChangeType(value, type), null);
}
}
//prop.SetValue(obj, value, null);
//tempName = pi.Name; // 检查DataTable是否包含此列
//if (dt.Columns.Contains(tempName))
//{
// // 判断此属性是否有Setter
// if (!pi.CanWrite) continue;
// object value = dr[tempName];
// if (value != DBNull.Value)
// pi.SetValue(t, value, null);
//}
}
ts.Add(t);
}
return(ts);
}
private static object ChangeType(object value, Type type, bool SqlKeyWordsFilter)
{
string tempValue = SqlKeyWordsFilter == true?
Wf_RegexHelper.ParseHtmlBQ(Wf_RegexHelper.SqlKeyWordsFilter(Wf_ConvertHelper.ToString(value))) : Wf_ConvertHelper.ToString(value);
if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(type);
return(Convert.ChangeType(tempValue, nullableConverter.UnderlyingType));
}
else
{
return(Convert.ChangeType(tempValue, type));
}
}
/// <summary>
/// 对可空类型进行判断转换
/// </summary>
/// <param name="value">DataReader字段的值</param>
/// <param name="conversionType">该字段的类型</param>
/// <returns></returns>
public static object ConvertToSpecifyType(this object value, Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (value == null)
{
return(null);
}
System.ComponentModel.NullableConverter nullableConverter =
new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return(Convert.ChangeType(value, conversionType));
}
public T ValueAs <T>()
{
if (this.Value is T)
{
return((T)this.Value);
}
else
{
var destinationType = typeof(T);
if (destinationType.IsNullable())
{
destinationType = new System.ComponentModel.NullableConverter(destinationType).UnderlyingType;
}
return((T)System.Convert.ChangeType(this.Value, destinationType));
}
}
//这个类对可空类型进行判断转换，要不然会报错
private static object HackType(object value, Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (value == null)
{
return(null);
}
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
//if (value is System.DateTime)
//{
// value = Convert.ToDateTime(value).ToString("yyyyMMddHHmmss");
//}
return(Convert.ChangeType(value, conversionType));
}
public static object ChangeType(this object value, Type destinationType)
{
if (destinationType.IsGenericType && destinationType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
if (value == null)
return null;
var nullableConverter = new System.ComponentModel.NullableConverter(destinationType);
if (nullableConverter.CanConvertFrom(value.GetType()))
{
return nullableConverter.ConvertFrom(value);
}
destinationType = nullableConverter.UnderlyingType;
}
return Convert.ChangeType(value, destinationType);
}
private static object HackType <T>(object value, T conversionType) where T : Type
{
// return value == null ? new T() : (T)value;
value = IsNullOrDBNull(value) ? default(T) : (T)value;
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
if (value == null)
{
return(null);
}
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = (nullableConverter.UnderlyingType as T);
}
return(Convert.ChangeType(value, conversionType));
}
/// <summary>
/// Returns an Object with the specified Type and whose value is equivalent to the specified object.
/// Swiped from http://aspalliance.com/852_CodeSnip_ConvertChangeType_Wrapper_that_Handles_Nullable_Types
/// </summary>
/// <param name="value">An Object that implements the IConvertible interface.</param>
/// <param name="conversionType">The Type to which value is to be converted.</param>
/// <returns>An object whose Type is conversionType (or conversionType's underlying type if conversionType
/// is Nullable<>) and whose value is equivalent to value. -or- a null reference, if value is a null
/// reference and conversionType is not a value type.</returns>
/// <remarks>
/// This method exists as a workaround to System.Convert.ChangeType(Object, Type) which does not handle
/// nullables as of version 2.0 (2.0.50727.42) of the .NET Framework. The idea is that this method will
/// be deleted once Convert.ChangeType is updated in a future version of the .NET Framework to handle
/// nullable types, so we want this to behave as closely to Convert.ChangeType as possible.
/// This method was written by Peter Johnson at:
/// http://aspalliance.com/author.aspx?uId=1026.
/// </remarks>
public static object ChangeType(object value, Type conversionType)
{
// Note: This if block was taken from Convert.ChangeType as is, and is needed here since we're
// checking properties on conversionType below.
if (conversionType == null)
{
throw new ArgumentNullException("conversionType");
} // end if
// If it's not a nullable type, just pass through the parameters to Convert.ChangeType
if (conversionType.IsGenericType &&
conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
// It's a nullable type, so instead of calling Convert.ChangeType directly which would throw a
// InvalidCastException (per http://weblogs.asp.net/pjohnson/archive/2006/02/07/437631.aspx),
// determine what the underlying type is
// If it's null, it won't convert to the underlying type, but that's fine since nulls don't really
// have a type--so just return null
// Note: We only do this check if we're converting to a nullable type, since doing it outside
// would diverge from Convert.ChangeType's behavior, which throws an InvalidCastException if
// value is null and conversionType is a value type.
if (value == null)
{
return null;
} // end if
// It's a nullable type, and not null, so that means it can be converted to its underlying type,
// so overwrite the passed-in conversion type with this underlying type
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
} // end if
if (conversionType == typeof(System.Guid))
{
return new Guid(value.ToString());
}
// Now that we've guaranteed conversionType is something Convert.ChangeType can handle (i.e. not a
// nullable type), pass the call on to Convert.ChangeType
return Convert.ChangeType(value, conversionType);
}
private void InitializeDeserializer()
{
if (typeof(IPathSerializable).IsAssignableFrom(BindingTargetType))
{
MethodInfo m = BindingTargetType.GetMethod("TryDeserializePath", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(IPathStack), BindingTargetType }, null);
if (m == null) throw new BindingException(String.Format("{0} is missing the static TryDeserializePath method.", BindingTargetType.FullName));
_deserializer = delegate(IPathStack path, out object obj) {
object[] args = new object[] { path, null };
bool r = (bool) m.Invoke(null, args);
obj = args[1];
return r;
};
}
else if (BindingTargetType.IsGenericType && BindingTargetType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
System.ComponentModel.NullableConverter converter = new System.ComponentModel.NullableConverter(BindingTargetType);
BindingTargetType = converter.UnderlyingType;
}
}
public static object ChangeType(object value, Type conversionType)
{
if (value == null)
return null;
if (conversionType.IsGenericType &&
conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
System.ComponentModel.NullableConverter nullableConverter
= new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
if (conversionType.IsEnum && value is string)
{
value = Enum.Parse(conversionType, value.ToString(), true);
}
return Convert.ChangeType(value, conversionType);
}
private void ImportAttributes(IDataReader reader, string[] attributes, EntityMapping entityMapping, Entity entity, Hashtable columnAliasMapping)
{
if (attributes != null && _Model.GetInheritedAttributes(entity.Type).Count > 0)
{
ArrayList attrs = new ArrayList(attributes);
StringCollection names = new StringCollection();
AttributeMappingCollection attributeMappings = new AttributeMappingCollection();
attributeMappings.TypeName = entityMapping.Type;
// Retrieve attributes of the current entity type and all its sub classes attributes
foreach (AttributeMapping a in entityMapping.Attributes)
attributeMappings.Add(a);
IList children = _Model.GetTree(entityMapping.Type);
if (children != null && children.Count > 0)
{
foreach (Evaluant.Uss.Models.Entity e in children)
{
EntityMapping currentEM = _Mapping.Entities[e.Type];
if (currentEM == null)
throw new SqlMapperException(string.Concat("Cannot find the entity ", e.Type, " in your mapping file"));
foreach (Evaluant.Uss.Models.Attribute a in e.Attributes)
{
if (attributeMappings[a.Name] == null)
if (currentEM.Attributes[a.Name] != null)
attributeMappings.Add(currentEM.Attributes[a.Name]);
}
}
}
foreach (AttributeMapping am in attributeMappings)
{
string fullAttributeName = _Model.GetFullAttributeName(am.Name, am.ParentEntity.Type);
// load only specified attributes ?
if (((attrs.Count > 0) && !attrs.Contains(fullAttributeName)))
continue;
//Process generic Attributes
string name = string.Empty;
if (am.Discriminator != null && am.Discriminator != string.Empty)
if (reader[am.Discriminator] != DBNull.Value)
name = (string)reader[am.Discriminator];
if (columnAliasMapping != null && columnAliasMapping[fullAttributeName] == null)
continue;
object val = columnAliasMapping == null ? reader[fullAttributeName] : reader[columnAliasMapping[fullAttributeName].ToString()];
string type = (am.Discriminator != null) ? reader[am.Discriminator].ToString() : am.Name;
if (((type != string.Empty) && !names.Contains(type)) && (type == am.Name))
{
Type t = am.Type;
Evaluant.Uss.Models.Entity current = _Model.GetEntity(entity.Type);
if (t == null && name != null && name != string.Empty)
t = _Model.GetAttribute(entity.Type, name).Type;
string attributeName = am.Name;
if (t == null && entity != null && _Model.GetAttribute(entity.Type, attributeName) != null)
t = _Model.GetAttribute(entity.Type, attributeName).Type;
if (current != null && t == null)
{
while (_Model.GetParent(current) != null)
{
current = _Model.GetParent(current);
if (_Model.GetAttribute(current.Type, attributeName) != null)
t = _Model.GetAttribute(current.Type, attributeName).Type;
}
}
if (current != null && t == null)
{
foreach (Evaluant.Uss.Models.Entity child in _Model.GetTree(current.Type))
if (_Model.GetAttribute(child.Type, attributeName) != null)
t = _Model.GetAttribute(child.Type, attributeName).Type;
}
if (((t == null) || (!t.IsValueType && (t != typeof(string)))) && (am.Name == "*"))
{
object obj2 = Utils.UnSerialize((string)val);
t = obj2.GetType();
}
SerializableType serializable = am.GetSerializableType(am.DbType, t);
if (val != DBNull.Value)
{
object sValue = null;
switch (serializable)
{
case SerializableType.BinarySerialization:
sValue = Utils.UnSerialize((byte[])val);
break;
case SerializableType.StringSerialization:
sValue = Utils.UnSerialize((string)val);
t = val.GetType();
break;
case SerializableType.Standard:
#if !EUSS11
if ((t.IsGenericType && t.GetGenericTypeDefinition().Equals(typeof(Nullable<>))))
{
sValue = new System.ComponentModel.NullableConverter(t).ConvertTo(val, t.GetGenericArguments()[0]);
}
else
#endif
{
if (am.DbType == DbType.String)
val = ((string)val).Trim();
sValue = Convert.ChangeType(val, t, CultureInfo.InvariantCulture);
}
break;
case SerializableType.String:
if (val.GetType() == t)
sValue = val;
else
sValue = Utils.StringToObject((string)val, t);
break;
case SerializableType.Int:
val = Convert.ToInt32(val);
if (t.IsEnum)
sValue = Enum.ToObject(t, val);
else
sValue = Convert.ChangeType(val, t, CultureInfo.InvariantCulture);
break;
}
if (t == null)
t = typeof(object);
if (entity.FindEntry(type) == null)
entity.AddValue(type, sValue, t, State.UpToDate);
}
names.Add(type);
entity.State = State.UpToDate;
}
}
}
}
