在使用 MVC 开发项目的过程中遇到了个问题，就是模型和数据实体之间的如何快捷的转换？是不是可以像 Entity Framework 的那样 EntityTypeConfiguration，或者只需要少量的代码就可以把数据实体对象转换成一个 Model 对象（当时还不知道有 AutoMapper 这种东西），所以自己尝试写了一个简单的实现。

1、初步尝试

EntityTypeConverter 类主要用把数据实体转换成 Model

    /// <summary>

    /// 提供一组实体对象模型转换的方法。

    /// </summary>

    /// <typeparam name="TEntityInfo">指定的实体信息对象类型。</typeparam>

    public static class EntityTypeConverter<TEntityInfo>

    {

        /// <summary>

        /// 将指定的实体对象转换成 <see cref="BaseModel"/> 类型的对象模型。

        /// </summary>

        /// <typeparam name="BaseModel">指定类型的模型对象。</typeparam>

        /// <param name="tEntityInfo">指定的实体信息。</param>

        /// <returns><see cref="BaseModel"/> 类型的对象模型。</returns>

        public static BaseModel ConverterToModel<BaseModel>(TEntityInfo tEntityInfo) where BaseModel : new()

        {

            if (tEntityInfo == null)

                throw new ArgumentNullException("tEntityInfo");

            BaseModeltEntity = new BaseModel();

            foreach (var prop in typeof(BaseModel).GetProperties())

            {

                if (!prop.CanRead || !prop.CanWrite)

                    continue;

                if (!CommonHelper.GetCustomTypeConverter(prop.PropertyType).CanConvertFrom(typeof(string)))

                    continue;

                string fieldName = String.Empty;
　　　　　　　　　// 验证是否有别名

                var customAttribute = prop.CustomAttributes.Where(att => att.AttributeType == typeof(ModelFieldAliasAttribute)).FirstOrDefault();

                if (customAttribute != null)

                {

                    var constructorArgument = customAttribute.ConstructorArguments[0];

                    fieldName = constructorArgument.Value.ToString();

                }

                else

                {

                    fieldName = prop.Name;

                }

                PropertyInfo property = typeof(TEntityInfo).GetProperty(fieldName);

                if (property != null)

                {

                    dynamic value = property.GetValue(tEntityInfo, null);

                    prop.SetValue(tEntity, value, null);

                }

            }

            return tEntity;

        }

        /// <summary>

        /// 将指定的实体对象转换成 <see cref="BaseModel"/> 类型的对象模型列表。

        /// </summary>

        /// <typeparam name="BaseModel">指定类型的模型对象。</typeparam>

        /// <param name="tEntityList">指定的实体信息列表。</param>

        /// <returns><see cref="BaseModel"/> 类型的对象模型列表。</returns>

        public static List<BaseModel> ConverterToList<BaseModel>(IList<TEntityInfo> tEntityList) where BaseModel: new()

        {

            List<BaseModel> modelList = new List<BaseModel>();

            if (tEntityList != null && tEntityList.Count > 0)

            {

                foreach (var item in tEntityList)

                {

                    modelList.Add(ConverterToModel<BaseModel>(item));

                }

            }

            return modelList;

        }

    }

辅助类基于 TypeConverter 实现的方法，用于泛型字段的转换

    public class GenericListTypeConverter<T> : TypeConverter

    {

        protected readonly TypeConverter typeConverter;

        public GenericListTypeConverter()

        {

            typeConverter = TypeDescriptor.GetConverter(typeof(T));

            if (typeConverter == null)

                throw new InvalidOperationException("No type converter exists for type " + typeof(T).FullName);

        }

        protected virtual string[] GetStringArray(string input)

        {

            if (!String.IsNullOrEmpty(input))

            {

                string[] result = input.Split(',');

                Array.ForEach(result, s => s.Trim());

                return result;

            }

            else

                return new string[0];

        }

        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)

        {

            if (sourceType == typeof(string))

            {

                string[] items = GetStringArray(sourceType.ToString());

                return items.Any();

            }

            return base.CanConvertFrom(context, sourceType);

        }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)

        {

            if (value is string)

            {

                string[] items = GetStringArray((string)value);

                var result = new List<T>();

                Array.ForEach(items, s =>

                {

                    object item = typeConverter.ConvertFromInvariantString(s);

                    if (item != null)

                    {

                        result.Add((T)item);

                    }

                });

                return result;

            }

            return base.ConvertFrom(context, culture, value);

        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)

        {

            if (destinationType == typeof(string))

            {

                string result = string.Empty;

                if (((IList<T>)value) != null)

                {

                    //we don't use string.Join() because it doesn't support invariant culture

                    for (int i = 0; i < ((IList<T>)value).Count; i++)

                    {

                        var str1 = Convert.ToString(((IList<T>)value)[i], CultureInfo.InvariantCulture);

                        result += str1;

                        //don't add comma after the last element

                        if (i != ((IList<T>)value).Count - 1)

                            result += ",";

                    }

                }

                return result;

            }

            return base.ConvertTo(context, culture, value, destinationType);

        }

    }

自定义属性 ModelFieldAlias 类用于标识字段别名。

    /// <summary>

    /// 表示一个模型转换对象字段类型的特性。

    /// </summary>

    [AttributeUsage(ValidTargets, AllowMultiple = false, Inherited = false)]

    public class ModelFieldAliasAttribute : Attribute

    {

        /// <summary>

        /// 指定此属性可以应用特性的应用程序元素。

        /// </summary>

        internal const AttributeTargets ValidTargets = AttributeTargets.Field | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Parameter;

        /// <summary>

        /// 模型的字段别名。

        /// </summary>

        private string _fieldAlias;

        /// <summary>

        /// 初始化 <see cref="ModelFieldAliasAttribute"/> 类的新实例。

        /// </summary>

        public ModelFieldAliasAttribute()

        {

        }

        /// <summary>

        /// 使用指定的筛选类型初始化 <see cref="ModelFieldAliasAttribute"/> 类的新实例。

        /// </summary>

        /// <param name="fieldAlias">指定模型的字段别名。</param>

        public ModelFieldAliasAttribute(string fieldAlias)

        {

            _fieldAlias = fieldAlias;

        }

        /// <summary>

        /// 获取或设置模型的字段别名。

        /// </summary>

        public string FieldAlias

        {

            get { return _fieldAlias; }

            set { _fieldAlias = value; }

        }

    }

使用方法：

        // 集合对象

        List<ChannelNavigationInfo> channelNavigationList = new List<ChannelNavigationInfo>();

        List<ChannelNavigationModel> channelNavigationModelList = new List<ChannelNavigationModel>();

        channelNavigationModelList = EntityTypeConverter<ChannelNavigationInfo>.ConverterToList<ChannelNavigationModel>(channelNavigationList);

        // 单独对象

        ChannelNavigationInfo channelNavigation = new ChannelNavigationInfo();

        ChannelNavigationModel channelNavigationModel = new ChannelNavigationModel();

        channelNavigationModel = EntityTypeConverter<ChannelNavigationInfo>.ConverterToModel<ChannelNavigationModel>(channelNavigation);

由于系统中大多数情况下都是对数据查询的业务，很少有插入和更新，所以没有发现这种实现的弊端，后来开发管理系统的时候，需要大量的数据插入和更新操作，发现这种方法没法做反向映射和转换。

2、AutoMapper

AutoMapper 是用来解决对象之间映射转换的类库。对于我们开发人员来说，写对象之间互相转换的代码是一件极其浪费生命的事情，AutoMapper 能够帮助我们节省不少时间。

知道这个类库是在研究 nopCommerce 这个项目的时候看到的，使用 AutoMapper 创建映射非常简单。

Mapper.CreateMap<Order, OrderDto>();//创建映射关系Order –> OrderDto

OrderDto dto = Mapper.Map<OrderDto>(order);//使用Map方法，直接将order对象装换成OrderDto对象

AutoMapper能够自动识别和匹配大部分对象属性:

如果源类和目标类的属性名称相同，直接匹配，目标类型的 CustomerName 可以匹配源类型的 Customer.Name，目标类型的 TotalRecords 可以匹配源类型的 GetTotalRecords() 方法。

AutoMapper 还支持自定义匹配规则：

Mapper.CreateMap<CalendarEvent, CalendarEventForm>()

    // 属性匹配，匹配源类中 WorkEvent.Date 到 EventDate

    .ForMember(dest => dest.EventDate, opt => opt.MapFrom(src => src.WorkEvent.Date))

    .ForMember(dest => dest.SomeValue, opt => opt.Ignore())//忽略目标类中的属性

    .ForMember(dest => dest.TotalAmount, opt => opt.MapFrom(src => src.TotalAmount ?? 0))//复杂的匹配

    .ForMember(dest => dest.OrderDate, opt => opt.UserValue<DateTime>(DateTime.Now)); //固定值匹配

为了方便使用，可以把扩展方法统一在一个类中实现。

    /// <summary>

    /// 提供一组对象映射相关的扩展方法。

    /// </summary>

    public static class MappingExtensions

    {

        #region City...

        /// <summary>

        /// 执行从 <see cref="City"/> 对象到 <see cref="CityModel"/> 对象的映射。

        /// </summary>

        /// <param name="entity">指定的 <see cref="City"/> 对象。</param>

        /// <returns><see cref="CityModel"/> 对象。</returns>

        public static CityModel ToModel(this City entity)

        {

            return Mapper.Map<City, CityModel>(entity);

        }

        /// <summary>

        /// 执行从 <see cref="CityModel"/> 对象到 <see cref="City"/> 对象的映射。

        /// </summary>

        /// <param name="model">指定的 <see cref="CityModel"/> 对象。</param>

        /// <returns><see cref="City"/> 对象。</returns>

        public static City ToEntity(this CityModel model)

        {

            return Mapper.Map<CityModel, City>(model);

        }

        /// <summary>

        /// 执行从 <see cref="CityModel"/> 对象到 <see cref="City"/> 对象的映射。

        /// </summary>

        /// <param name="model">指定的 <see cref="CityModel"/> 模型对象。</param>

        /// <param name="destination">指定的 <see cref="City"/> 实体对象。</param>

        /// <returns><see cref="City"/> 对象。</returns>

        public static City ToEntity(this CityModel model, City destination)

        {

            return Mapper.Map(model, destination);

        }

        #endregion

    }

最后，在 Global.cs 文件中程序启动前，调用该方法。

AutoMapperConfiguration.Configuration();

巴特西

ASP.NET MVC 模型和数据对象映射实践

1、初步尝试

2、AutoMapper

最新文章

热门文章