关于DataTalbe和对象类的转换

[Nobel0429]

public class DictClass
{
#region 域

private string item_Code;
private string item_name;
#endregion

#region 属性


[Column ]
public string Item_Code
{
get { return item_Code; }
set { item_Code = value; }
}
[Column]
public string Item_name
{
get { return item_name; }
set { item_name = value; }
}
#endregion

#region 构造方法
public DictClass()
{
}

public DictClass(DataTable dt)//传入一个datatable 返回一个对象
{
DataTransfer.TransObject(dt,this);
}
#endregion

现在的问题是如果我的属性是datetime类型 那么我转换成类的时候就会报错，
誰有用泛型转换的实例給我参考下 分不夠再加

[bychgh]

帮顶

[antiking]

参考下
public static List<T> DataTableToObject<T>(List<T> xtraList, DataTable xtraDataTable) where T : new()
{
xtraList = new List<T>();
foreach (DataRow dr in xtraDataTable.Rows)
{
T _t = new T();
Type _type = _t.GetType();
foreach (DataColumn dc in xtraDataTable.Columns)
{
PropertyInfo info = _type.GetProperty(dc.ColumnName);
info.SetValue(_t, dr[dc.ColumnName], null);
}
xtraList.Add(_t);
}
return xtraList;
}

[Nobel0429]

  //Fields
        internal const BindingFlags ColumnBindingFlags = (BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

        //Methods
        public static void TransEntityPropertyToWebFormData(object entity, object form)
        {
            if ((form != null) && (entity != null))
            {
                Type formType = form.GetType();
                Type entityType = entity.GetType();
                IFieldMemberInfo[] columns = FieldMemberInfo.GetFieldMembers(formType, BindingFlags.GetProperty | BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, true);
                for (int i = 0; i < columns.Length; i++)
                {
                    if (columns[i].CanWrite)
                    {
                        object value = null;
                        if (entity is DataRow)
                        {
                            DataRow dr = (DataRow) entity;
                            value = dr[columns[i].Name];
                        }
                        else
                        {
                            PropertyInfo property = entityType.GetProperty(columns[i].Name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
                            if ((property != null) && property.CanRead)
                            {
                                value = property.GetValue(entity, null);
                            }
                        }
                        if (value != null)
                        {
                            object fieldObject = columns[i].GetValue(form);
                            string stringValue = (string) Convert.ChangeType(value, typeof(string));
                            if (fieldObject is TextBox)
                            {
                                (fieldObject as TextBox).Text = stringValue;
                            }
                            else if (fieldObject is DropDownList)
                            {
                                DropDownList ddl = fieldObject as DropDownList;
                                ddl.ClearSelection();
                                WebHelper.SafelySetDropDownListValue(ddl, stringValue);
                            }
                            else if (fieldObject is Label)
                            {
                                (fieldObject as Label).Text = stringValue;
                            }
                            else if (fieldObject is HyperLink)
                            {
                                (fieldObject as HyperLink).Text = stringValue;
                            }
                        }
                    }
                }
            }
        }

        public static void TransObject(object[] objs, DataTable dt)
        {
            TransObject(objs, dt, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
        }

        public static void TransObject(DataTable dt, object[] objs)
        {
            TransObject(dt, objs, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
        }

        public static void TransObject(DataTable dt, object obj)
        {
            TransObject(dt, new object[] { obj });
        }

        public static void TransObject(object obj, DataTable dt)
        {
            TransObject(new object[] { obj }, dt);
        }

        public static void TransObject(DataRow[] drs, object[] objs, BindingFlags columnBindingFlags)
        {
            if ((((objs != null) && (objs.Length != 0)) && (drs != null)) && (drs.Length != 0))
            {
                int num = drs.Length;
                if (objs.Length < num)
                {
                    num = objs.Length;
                }
                Type type = objs[0].GetType();
                IFieldMemberInfo[] columns = FieldMemberInfo.GetFieldMembers(type, columnBindingFlags);
                for (int i = 0; i < num; i++)
                {
                    if (objs[i].GetType() == type)
                    {
                        DataRow dr = drs[i];
                        for (int k = 0; k < columns.Length; k++)
                        {
                            if (columns[k].CanWrite)
                            {
                                columns[k].SetValue(objs[i], dr[columns[k].Name]);
                            }
                        }
                    }
                }
            }
        }

        public static void TransObject(DataTable dt, object[] objs, BindingFlags columnBindingFlags)
        {
            if ((((objs != null) && (objs.Length != 0)) && (dt != null)) && (dt.Rows.Count != 0))
            {
                TransObject(dt.Select(), objs, columnBindingFlags);
            }
        }

        public static Array TransObject(DataTable dt, Type type, params object[] parameters)
        {
            return TransObject(dt, type, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, parameters);
        }

        public static void TransObject(object[] objs, DataTable dt, BindingFlags columnBindingFlags)
        {
            if (((objs != null) && (objs.Length != 0)) && (dt != null))
            {
                Type type = objs[0].GetType();
                IFieldMemberInfo[] columns = FieldMemberInfo.GetFieldMembers(type, columnBindingFlags);
                for (int i = 0; i < objs.Length; i++)
                {
                    if (objs[i].GetType() == type)
                    {
                        DataRow dr = dt.NewRow();
                        for (int k = 0; k < columns.Length; k++)
                        {
                            if (columns[k].CanRead)
                            {
                                dr[columns[k].Name] = columns[k].GetValue(objs[i]);
                            }
                        }
                        dt.Rows.Add(dr);
                    }
                }
            }
        }

        public static Array TransObject(DataRow[] drs, Type type, BindingFlags columnBindingFlags, params object[] parameters)
        {
            if ((drs == null) || (drs.Length == 0))
            {
                return null;
            }
            int num = drs.Length;
            Array objs = Array.CreateInstance(type, num);
            for (int i = 0; i < num; i++)
            {
                objs.SetValue(TypeHelper.CreateObject(type, null, true, parameters), i);
            }
            TransObject(drs, (object[]) objs, columnBindingFlags);
            return objs;
        }

        public static Array TransObject(DataTable dt, Type type, BindingFlags columnBindingFlags, params object[] parameters)
        {
            if ((dt == null) || (dt.Rows.Count == 0))
            {
                return null;
            }
            int num = dt.Rows.Count;
            Array objs = Array.CreateInstance(type, num);
            for (int i = 0; i < num; i++)
            {
                objs.SetValue(TypeHelper.CreateObject(type, null, true, parameters), i);
            }
            TransObject(dt, (object[]) objs, columnBindingFlags);
            return objs;
        }

贴上部分代码 因为这个类库完善了好久，也用了好久 如果要改成泛型的话确实不知道从哪部分下手 望高手給个链接或者简单点的实现案例

[ViewStates]

泛型貌似不能完全满足你的要求吧。
你应该在COLUMN ATTRIBUTE上加注DBTYPE吧？

DataTransfer.TransObject这个方法是什么？

[Nobel0429]

DataTransfer.TransObject
是我封装的一个DLL 里面是一些数据的转换

[tzs2304]

关注

[liaoyukun111]

JF

[ViewStates]

DataTransfer.TransObject(dt,this);
你的这个是不是应该加个REF关键字？不然你DICCLASS怎么传的出来？
你的意思是想通过DATATABLE配合泛型还原一个对应的实体对象么？

[Nobel0429]

我是用[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple=false)]和PropertyInfo 转换到类的 不用ref

 public void SetValue(object obj,object  value) 
    {
        Type type;
        if (this.property != null)
        {
            type = this.property.PropertyType;
        }
        else
        {
            type = this.field.FieldType;
        }
        if (Convert.IsDBNull(value))
        {
            if (this.columnAttribute.DefaultValue != null)
            {
                value = this.columnAttribute.DefaultValue;
            }
            else if (!type.IsValueType)
            {
                value = null;
            }
            else
            {
                return;
            }
        }
        if (this.property != null)
        {
            try
            {
                this.property.SetValue(obj, IsValidata(value), null);
            }
            catch
            {
                this.property.SetValue(obj, value, null);
            }
           
        }
        else
        {
            this.field.SetValue(obj, value);
        }
    }

因为现在传进去datetime类型 我用this.gettype得到的是string类型 现在用比较笨的方法暂时解决了可以传datetime的问题 但是我想趁现在不忙改个泛型的出来

[Nobel0429]

[Quote=引用 8 楼 viewstates 的回复:]
DataTransfer.TransObject(dt,this);
你的这个是不是应该加个REF关键字？不然你DICCLASS怎么传的出来？
你的意思是想通过DATATABLE配合泛型还原一个对应的实体对象么？
[/Quote]

对的 是通过datatable 配合泛型 还原一个实体对象

[ViewStates]

这种东西网上很多的，都是配合泛型和数据集来做实体的转换
大体的方法就是用反射去找和数据集字段一样的实体字段，然后SETVALUE，数据集中字段的类型用CONVERT.CHANGETYPE将类型转为PROPERTYINFO.PROPERTYTYPE。然后生成一个实体，对于ILIST型的依次类推，只需要循环数据集的每一行即可。
同样你也可以使用在PROPERTY上加注CUSTOMERATTRIBUTE的方式来进行进一步的定义