.NET中利用反射来实现自动映射两个对象中的数据成员

Posted 2020-09-02 墨尔本

　　在以前的项目开发之中，经常会遇到这样一个问题：比如在外面项目的架构设计之中，我们采用MVC和EntityFramework来构建一个Web应用程序。比如我们采用常用的多层架构，例如有Presentation层、BusinessLogic层、DataAccess层等，各层之间是相对独立并且职责分明的。比如我们在Presentation层中会定义ViewModel，在DataAccess层中的DbContext部分又会由EntityFramework来自动生成StorageModel，或者叫做DataModel。然后我们从DataAccess层从数据库抓取到数据之后需要将这些数据传递给viewModel，并最终呈现给前段用户，当然两种Model之间定义的字段（属性）可能会有所区别，这个我们将会在稍后讨论。

　　我们先来看看如何解决这一类问题。首先最朴素笨拙的办法就是，逐个属性的为对象赋值，例如这样：

var viewModels = new List<EmployeeViewModel>();
            List<EmployeeStorageModel> storageModels = new List<EmployeeStorageModel>();
            if (storageModels.Count > 0)
            {
                EmployeeViewModel viewModel = null;
                foreach (var storageModel in storageModels)
                {
                    viewModel.Number = storageModel.Name;
                    viewModel.Name = storageModel.Name;
                    viewModel.HireDate = storageModel.HireDate;
                    viewModel.Job = storageModel.Job;
                    viewModel.Department = storageModel.Department;
                    viewModel.Salary = storageModel.Salary;
                    //....
                }
            }

如果对象的属性比较多，那么我们就不得不写一长串的赋值语句，这显示不是一个聪明的办法。说了这么多目的是为了抛出一个问题。那么解决方案呢？对于这个问题有许多的解决方案，比如使用AutoMapper等，之前我记得我们一个同事写了一个扩展方法是使用JSON的序列化和反序列化来实现对象数据成员之间的映射，不过我今天要拿出来说的是使用映射来解决这个问题。

　　我想要实现的功能如下，或者说我要解决的问题吧：

1. 实现两个不同对象数据成员的映射，数据成员包括属性和公共可写字段；

2. 将具有相同名称和数据类型的数据成员映射到另外另外一个对象；

在这里我先给出核心代码，后面将会对业务逻辑和一些注意问题进行详细的说明：

第一、定义一个Attribute，这个特性主要用来标示类的数据成员的别名，后面我将介绍为什么要怎么做

//数据成员的别名
    [AttributeUsage(AttributeTargets.Property| AttributeTargets.Field,
        AllowMultiple=false, Inherited=true)]
    public class DataMemberAliasAttribute : System.Attribute
    {
        private readonly string _alias;

        public DataMemberAliasAttribute(string alias)
        {
            _alias = alias;
        }

        public string Alias
        {
            get
            {
                return _alias;
            }
        }
    }

 

 

第二、定义一个类，这个类包含一个公共的静态方法Mapping，这个方法是一个扩展方法，后面将会详细介绍为什么要这么定义

private static T Mapping<T>(this object source) where T : class
        {
            Type t = typeof(T);

            if (source == null)
            {
                return default(T);
            }

            T target = (T)t.Assembly.CreateInstance(t.FullName);

            #region Mapping Properties
            PropertyInfo[] targetProps = t.GetProperties();
            if (targetProps != null && targetProps.Length > 0)
            {
                string targetPropName;  //目标属性名称
                PropertyInfo sourceProp;
                object sourcePropValue;
                foreach (PropertyInfo targetProp in targetProps)
                {
                    //优先使用数据成员的别名，如果没有别名则使用属性名
                    object[] targetPropAliasAttrs = targetProp.GetCustomAttributes(typeof(DataMemberAliasAttribute), true);
                    if (targetPropAliasAttrs != null && targetPropAliasAttrs.Length > 0)
                        targetPropName = ((DataMemberAliasAttribute)targetPropAliasAttrs[0]).Alias;
                    else
                        targetPropName = targetProp.Name;

                    //检索源属性
                    sourceProp = source.GetType().GetProperty(targetPropName);
                    if (sourceProp != null && sourceProp.CanRead && targetProp.CanRead)
                    {
                        sourcePropValue = sourceProp.GetValue(source, null);
                        //属性类型一致时，直接填充属性值
                        if (targetProp.PropertyType == sourceProp.PropertyType)
                            targetProp.SetValue(target, sourcePropValue, null);
                    }
                }
            }
            #endregion

            #region Mapping Fields
            FieldInfo[] targetFields = t.GetFields();
            if (targetFields!=null&&targetFields.Length>0)
            {
                string targetFieldName;
                FieldInfo sourceField;
                foreach (FieldInfo targetField in targetFields)
                {
                    if (!targetField.IsInitOnly && !targetField.IsLiteral)
                    {//字段可以被赋值
                        object[] targetFieldAttrs = targetField.GetCustomAttributes(typeof(DataMemberAliasAttribute), true);
                        if (targetFieldAttrs != null && targetFieldAttrs.Length > 0)
                            targetFieldName = ((DataMemberAliasAttribute)targetFieldAttrs[0]).Alias;
                        else
                            targetFieldName = targetField.Name;

                        sourceField = source.GetType().GetField(targetFieldName);
                        if (sourceField!=null)
                        {
                            //数据类型相同时映射值
                            if (targetField.FieldType == sourceField.FieldType)
                                targetField.SetValue(target, sourceField.GetValue(source));
                        }
                    }
                }
            }
            #endregion

            return target;
        }

        public static TOut Mapping<TOut,TIn>(this TIn source) 
            where TIn :class
            where TOut :class
        {
            return source.Mapping<TOut>();
        }
    }

 

第三、然后我就可以使用下面这种语法来进行两个对象之间数据成员的映射：

EmployeeViewModel viewmodel = storageModel.Mapping<EmployeeViewModel, EmployeeStorageModel>();

 

好的，代码已经全部贴出来了。那么我先来介绍一下第一个问题：为什么要定义DataMemberAliasAttribute这个特性类。人们在做一件事情的时候通常都是为了解决某一类问题的，同样，之所以这么做，是为了适应两个对象（类）包含的数据成员的名字可能不相同。就拿上面的例子来说，在上面的EmployeeStorageModel中可能或包含一个Property，叫做hire_date，表示员工的雇用日期，但是在EmployeeViewModel类中可能会有一个叫做HireDate的属性与之对应。如果我们仅仅使用属性本身的名字来进行映射的话这是不够的，而且这种情况经常会发生，因为我们的StorageModel通常可能是有EntityFramework自动生成的，他么的名称通常与数据库表中的字段的名称相同，而这完全取决于数据库表设计人员的设计习惯，但是ViewModel很有可能是某一个.NET程序员设计的，他很有可能会按照微软建议的属性命名方法来进行属性的命名，例如每个单词的首字母都为大写。所以我在这里定义了这个特性类，用来表示某个数据成员的“别名”，使用方法如下：

public class EmployeeViewModel
    {
        public const string phoneNumber = "";
        public readonly string emailAddress;

        [DataMemberAlias("id")]
        public int Id { get; set; }

        [DataMemberAlias("employee_number")]
        public string EmployeeNumber { get; set; }

        [DataMemberAlias("employee_name")]
        public string EmployeeName { get; set; }

        [DataMemberAlias("hire_date")]
        public DateTime HireDate { get; set; }

        [DataMemberAlias("salary")]
        public double Salary { get; set; }

        [DataMemberAlias("job")]
        public string Job { get; set; }

        [DataMemberAlias("department")]
        public Department Department
        {
            get;
            set;
        }

        public int Status { get; set; }

    }

这样就可以解决上面提出的问题。注意如果在对象类中为数据成员设置了别名，那么在进行映射时，会优先匹配别名；如果没有为数据成员按设置别名，那么就会匹配数据成员本身的名称。同时需要注意以下细节：

1、对象B的属性需要可写，对象A的属性需要可读，否则将会忽略此数据成员；

2、对象B的字段需要可以被赋值，即不能带readonly或者const修饰符，因为这样的话，无法为字段进行赋值，只能忽略它们；

3、只映射公共的属性和字段（通常属性都为public，而带有public修饰符的字段也具有属性的一些特征）

4、对象A和对象B相同数据成员的数据类型必须相同；

5、如果对象A和对象B中的数据成员的数据类型相同且都为引用类型，那么传递是是引用，在使用中需要注意这一点，请见Department属性的示例代码

 　　

 

[DataMemberAlias("department")]
        public Department Department
        {
            get;
            set;
        }

public class Department
    {
        public int DepartmentCode { get; set; }

        public string DepartmentName { get; set; }

        public string DepartmentLeader { get; set; }

    }

 

现在我们来看一下Mapping这个扩展方法，首先这个方法是一个番型方法，它包含两个类型参数TIn和TOut，TOut为方法返回值的数据类型，及对象B的数据类型，TIn为参数的数据类型，即为对象A的数据类型。同时限定这两个类型参数在实例化的时候必须指定为类类型，这一点是出于对应用场景的设计。因为这是一个扩展方法，所以可以使用下面的语法来进行方法的调用：

EmployeeViewModel viewmodel = storageModel.Mapping<EmployeeViewModel, EmployeeStorageModel>();

 本来想讲一下Mapping方法的业务逻辑的，但是因为时间的关系，在这里就不再细说了，代码里面都有注释。大家如果有兴趣可以加我微信：Happy_Chopper

 

------------------------------------------------------------------------------------------------------------------------------------End