C#用反射实现两个类的对象之间的值的复制

在进行实体转换操作的时候如果需要在对两个实体之间两个属性字段差不多相同的类要进行一个互相的转换，我们要把a对象的所有字段的值都复制给b对象，我们只能用b.属性=a.属性来写，如果属性字段太多的话，就要写很多行复制语句，麻烦还容易漏掉一些，这个时候可以利用c#的反射来实现复制。我们可以写这样一个利用泛型的映射函数。

1.适用于创建实体的时候从一个实体作为数据源赋值

        /// <summary>
        /// 反射实现两个类的对象之间相同属性的值的复制
        /// 适用于初始化新实体
        /// </summary>
        /// <typeparam name="D">返回的实体</typeparam>
        /// <typeparam name="S">数据源实体</typeparam>
        /// <param name="s">数据源实体</param>
        /// <returns>返回的新实体</returns>
        public static D Mapper<D, S>(S s)
        {
            D d = Activator.CreateInstance<D>(); //构造新实例
            try
            {
                var Types = s.GetType();//获得类型  
                var Typed = typeof(D);
                foreach (PropertyInfo sp in Types.GetProperties())//获得类型的属性字段  
                {
                    foreach (PropertyInfo dp in Typed.GetProperties())
                    {
                        if (dp.Name == sp.Name && dp.PropertyType == sp.PropertyType && dp.Name!= "Error" && dp.Name != "Item")//判断属性名是否相同  
                        {
                            dp.SetValue(d, sp.GetValue(s, null), null);//获得s对象属性的值复制给d对象的属性  
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return d;
        }

2.适用于没有创建实体，两个实体之间数据的转换

        /// <summary>
        /// 反射实现两个类的对象之间相同属性的值的复制
        /// 适用于没有新建实体之间
        /// </summary>
        /// <typeparam name="D">返回的实体</typeparam>
        /// <typeparam name="S">数据源实体</typeparam>
        /// <param name="d">返回的实体</param>
        /// <param name="s">数据源实体</param>
        /// <returns></returns>
        public static D MapperToModel<D, S>(D d,S s)
        {
            try
            {
                var Types = s.GetType();//获得类型  
                var Typed = typeof(D);
                foreach (PropertyInfo sp in Types.GetProperties())//获得类型的属性字段  
                {
                    foreach (PropertyInfo dp in Typed.GetProperties())
                    {
                        if (dp.Name == sp.Name && dp.PropertyType == sp.PropertyType && dp.Name != "Error" && dp.Name != "Item")//判断属性名是否相同  
                        {
                            dp.SetValue(d, sp.GetValue(s, null), null);//获得s对象属性的值复制给d对象的属性  
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return d;
        }

3.获取实体类字段自动生成表格或绑定数据

/// <summary>
        /// 返回实体字段
        /// </summary>
        /// <returns>
        /// </returns>
        public static string GetModel<T>(T t) where T : class
        {
            string json = "{";
            PropertyInfo[] myPropertyInfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
            for (int i = 0; i < t.GetType().GetProperties().Count(); i++)
            {
                PropertyInfo pi = myPropertyInfo[i];
                if (i == t.GetType().GetProperties().Count() - 1)
                    json += "\"" + pi.Name + "\":" + "\"" + pi.Name + "\"";
                else
                    json += "\"" + pi.Name + "\":" + "\"" + pi.Name + "\",";
            }
            json += "}";
            return json;
        }

4.两个类之间不同属性字段转换以及忽略更新目标字段

private TDestination Mapper<TSource,TDestination>(TSource source,TDestination destination,List<string> ignoreFields=null)
        {
            try
            {
                var typeSource = source.GetType();  
                var typeDestination = typeof(TDestination);
                foreach (PropertyInfo sp in typeSource.GetProperties())  
                {
                    foreach (PropertyInfo dp in typeDestination.GetProperties())
                    {
                        if (ignoreFields != null && ignoreFields.Contains(dp.Name))
                        {
                            continue;
                        }
                        var value = sp.GetValue(source, null);
                        if (value!=null && dp.Name == sp.Name && dp.Name!= "Error" && dp.Name != "Item")
                        {
                            if (dp.PropertyType == sp.PropertyType)
                            {
                                dp.SetValue(destination, value);  
                            }
                            else
                            {
                                if (value.ToString() == "True")
                                {
                                    value = 1;
                                }
                                else if(value.ToString() == "False")
                                {
                                    value = 0;
                                }

                                if (sp.PropertyType == typeof(System.DateTime?) || sp.PropertyType == typeof(System.DateTime))
                                {
                                    value = Convert.ToDateTime(value).ToString("yyyy-MM-dd HH:mm:ss");
                                }
                                
                                if (dp.PropertyType == typeof(System.DateTime?)||dp.PropertyType == typeof(System.DateTime))
                                {
                                    dp.SetValue(destination, Convert.ToDateTime(value));
                                }
                                else
                                {
                                    dp.SetValue(destination, Convert.ChangeType(value, dp.PropertyType));
                                }
                            }
                        }
                    }
                }
                return destination;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                throw;
            }
        }