AutoMaper

最新推荐文章于 2024-06-07 07:00:00 发布
最新推荐文章于 2024-06-07 07:00:00 发布
阅读量921 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxzhq2002/article/details/12406301
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Reflection;
using System.Data;
using System.Data.SqlClient;

namespace ConsoleApplication4
{
    public class AutoMapper
    {
        public delegate string FormatColumnName(string columnName);

        /// <summary>
        /// 从缓存中取出对象的公共属性，用来解决反射的性能问题
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static PropertyInfo[] GetProperties<T>() where T : class
        {
            Type t = typeof(T);
            string key = string.Format("GetProperties_{0}", t.FullName);
            System.Runtime.Caching.MemoryCache cache = System.Runtime.Caching.MemoryCache.Default;
            if (cache[key] == null)
            {
                PropertyInfo[] properties = t.GetProperties();
                cache.Add(key, properties, new DateTimeOffset(DateTime.Now.AddMinutes(20)));
                return properties;
            }
            return cache[key] as PropertyInfo[];
        }
        public static List<string> GetColumnNames(IDataReader dr)
        {
            return GetColumnNames(dr, null);
        }
        public static List<string> GetColumnNames(IDataReader dr, FormatColumnName method)
        {
            List<string> list = new List<string>();
            for (int i = 0; i < dr.FieldCount; i++)
            {
                var fileName = dr.GetName(i);
                if (method != null)
                {
                    fileName = method(fileName);
                }
                list.Add(fileName);
            }
            return list;
        }
        /// <summary>
        /// 将数据库中的字段名用Pascel命名法则转换成类型的属性名，若有"_"则在"_"处将数据库字段名切割成N个片段，每个片段的首字母大写其余字母小写，将这些片段连接起来组成某个类的属性名
        /// </summary>
        /// <param name="columnName">columnName名</param>
        /// <returns></returns>
        private static string ConvertToPascal(string columnName)
        {
            string[] strArr = columnName.Split('_');
            StringBuilder result = new StringBuilder();
            foreach (string item in strArr)
            {
                if (item.Length > 0)
                {
                    result.Append(item.Substring(0, 1).ToUpper());
                    if (item.Length > 1)
                    {
                        result.Append(item.Substring(1).ToLower());
                    }
                }
            }
            return result.ToString();
        }
        /// <summary>
        /// 将数据库中的字段名用Pascel命名法则转换成类型的属性名，若有"_"则在"_"处将数据库字段名切割成N个片段，每个片段的首字母大写其余字母小写，将这些片段连接起来组成某个类的属性名
        /// </summary>
        public static readonly FormatColumnName ConvertToPascal2
            = columnName =>
            {
                string[] sArr = columnName.Split('_');
                StringBuilder result = new StringBuilder();
                foreach (string item in sArr)
                {
                    if (item.Length > 0)
                    {
                        result.Append(item.Substring(0, 1).ToUpper());
                        if (item.Length > 1)
                        {
                            result.Append(item.Substring(1).ToLower());
                        }
                    }
                }
                return result.ToString();
            };

        /// <summary>
        /// 将DataReader转换为实体集合
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="dr">数据读取流</param>
        /// <param name="method">DataReader的字段名与类型T的属性名之间的转换函数</param>
        /// <returns></returns>
        public static List<T> DataReaderToModelList<T>(IDataReader dr, FormatColumnName method) where T : class, new()
        {
            List<T> list = null;
            var fieldNames = GetColumnNames(dr, method);
            var properties = GetProperties<T>();

            while (dr.Read())
            {
                if (list == null)
                {
                    list = new List<T>();
                }

                T o = new T();
                foreach (var p in properties)
                {
                    var columnName = p.Name;
                    if (fieldNames.Contains(columnName))
                    {
                        if (!Convert.IsDBNull(dr[columnName]))
                        {
                            object value = dr[columnName];
                            if (value.GetType() != p.PropertyType)
                            {
                                //如果dr中字段的类型与实体T的属性类型不匹配，则以T的属性类型为准
                                value = Convert.ChangeType(value, p.PropertyType);
                            }
                            p.SetValue(o, value, null);
                        }
                    }
                }
                list.Add(o);
            }
            return list;
        }

        /// <summary>
        /// 将DataReader转换成类型T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dr">DataReader</param>
        /// <param name="method">DataReader的字段名与类型T的属性名之间的转换方法,FieldToPropertyMethods类中有几个预定义的静态方法可供使用</param>
        /// <returns></returns>
        public static T DataReaderToModel<T>(IDataReader dr) where T : class,new()
        {
            T objectInstance = new T();
            PropertyInfo[] properties = GetProperties<T>();
            var filedNames = GetColumnNames(dr);

            foreach (var p in properties)
            {
                var columnName = p.Name;
                if (filedNames.Contains(columnName))
                {
                    if (!Convert.IsDBNull(dr[columnName]))
                    {
                        object value = dr[columnName];
                        if (value.GetType() != p.PropertyType)
                        {
                            //如果dr中字段的类型与实体T的属性类型不匹配，则以T的属性类型为准
                            value = Convert.ChangeType(value, p.PropertyType);
                        }
                        p.SetValue(objectInstance, value, null);
                    }
                }
                
            }
            return objectInstance;
        }

        public static DbType GetDbType(object o)
        {
            string typeName = o.GetType().Name.ToLower();
            DbType dbType;
            switch (typeName)
            {
                case "guid":
                    dbType = DbType.Guid;
                    break;
                case "short":
                    dbType = DbType.Int16;
                    break;
                case "byte":
                    dbType = DbType.Byte;
                    break;
                case "int":
                    dbType = DbType.Int32;
                    break;
                case "long":
                    dbType = DbType.Int64;
                    break;
                case "dateTime":
                    dbType = DbType.DateTime;
                    break;
                case "double":
                    dbType = DbType.Double;
                    break;
                case "decimal":
                    dbType = DbType.Decimal;
                    break;
                case "float":
                    dbType = DbType.Decimal;
                    break;
                case "bool":
                    dbType = DbType.Boolean;
                    break;
                default:
                    dbType = DbType.String;
                    break;
            }
            return dbType;
        }

        public static DbType GetDbType2(Type type)
        {
            TypeCode typeCode = Type.GetTypeCode(type);
            DbType dt;
            switch (typeCode)
            {
                case TypeCode.Boolean:
                    dt = DbType.Boolean;
                    break;
                case TypeCode.Byte:
                    dt = DbType.Byte;
                    break;
                case TypeCode.Char:
                    dt = DbType.UInt16;
                    break;
                case TypeCode.DateTime:
                    dt = DbType.DateTime;
                    break;
                case TypeCode.Decimal:
                    dt = DbType.Decimal;
                    break;
                case TypeCode.Double:
                    dt = DbType.Double;
                    break;
                case TypeCode.Int16:
                    dt = DbType.Int16;
                    break;
                case TypeCode.Int32:
                    dt = DbType.Int32;
                    break;
                case TypeCode.Int64:
                    dt = DbType.Int64;
                    break;
                //case TypeCode.Object:
                //    dt = DbType.Object;
                //    break;
                case TypeCode.SByte:
                    dt = DbType.SByte;
                    break;
                case TypeCode.Single:
                    dt = DbType.Single;
                    break;
                case TypeCode.String:
                    dt = DbType.String;
                    break;
                case TypeCode.UInt16:
                    dt = DbType.UInt16;
                    break;
                case TypeCode.UInt32:
                    dt = DbType.UInt32;
                    break;
                case TypeCode.UInt64:
                    dt = DbType.UInt64;
                    break;
                default:
                    dt = DbType.Int32;
                    break;
            }
            return dt;
        }


        public SqlParameter[] SqlParameter<T>(T entity) where T:class, new()
        {
            IList<SqlParameter> sqlParameterList = new List<SqlParameter>();
            PropertyInfo[] properties = GetProperties<T>();
            foreach (var p in properties)
            {
                SqlParameter sqlParameter = new SqlParameter();
                sqlParameter.ParameterName = string.Format("@{0}", p.Name);
                sqlParameter.Value = p.GetValue(entity, null);
                sqlParameter.DbType = GetDbType(p.PropertyType);
                sqlParameterList.Add(sqlParameter);
            }
            return sqlParameterList.ToArray();
        }

        /// <summary>
        /// 将DataReader转换为泛型集合
        /// </summary>
        /// <typeparam naame="T">泛型</typeparam>
        /// <param name="dr">DataReader</param>
        /// <returns></returns>
        private List<T> DataReaderToEntityList<T>(IDataReader dr) where T : class
        {
            List<T> list = new List<T>();
            Type t = typeof(T);
            PropertyInfo[] properties = t.GetProperties();
            while (dr.Read())
            {
                T o = Activator.CreateInstance(t) as T;
                foreach (PropertyInfo p in properties)
                {
                    if (!Convert.IsDBNull(dr[p.Name]))
                    {
                        p.SetValue(o, dr[p.Name], null);
                    }
                }
                T e = o as T;
                list.Add(e);
            }
            return list;
        }
        private List<T> DataReaderToEntityList2<T>(IDataReader dr) where T : class, new()
        {
            List<T> result = new List<T>();
            PropertyInfo[] properties = GetProperties<T>();
            List<string> fieldNames = GetColumnNames(dr);
            while (dr.Read())
            {
                T objectInstance = new T();
                foreach (var p in properties)
                {
                    var exists = fieldNames.Exists(item => item.Equals(p.Name, StringComparison.OrdinalIgnoreCase));
                    if (exists)
                    {
                        p.SetValue(objectInstance, dr[p.Name], null);
                    }
                }
                result.Add(objectInstance);
            }
            return result;

        }
        private T DataReaderToEntity<T>(IDataReader dr) where T : class, new()
        {
            T objectInstance = new T();
            PropertyInfo[] properties = GetProperties<T>();
            for (int i = 0; i < dr.FieldCount; i++)
            {
                foreach (var p in properties)
                {
                    if (p.Name == dr.GetName(i))
                    {
                        p.SetValue(objectInstance, dr[i], null);
                    }
                }
            }
            return objectInstance;
        }
        /// <summary>
        /// 映射
        /// </summary>
        /// <typeparam name="FormT">源类型</typeparam>
        /// <typeparam name="ToT">目标类型</typeparam>
        /// <param name="formObject">源对象</param>
        /// <returns>目标对象</returns>
        public static ToT Mapping<FormT, ToT>(FormT formObject)
            where FormT : class, new()
            where ToT : class, new()
        {
            //http://blog.csdn.net/cxzhq2002/article/details/8753495
            //集合到集合暂没有实现
            ToT t = new ToT();
            PropertyInfo[] formProperties = GetProperties<FormT>();
            PropertyInfo[] toProperties = GetProperties<ToT>();
            foreach (var p in toProperties)
            {
                var exists = formProperties.Where(item => item.Name.Equals(p.Name, StringComparison.OrdinalIgnoreCase));
                if (exists.Count() > 0)
                {
                    var value = exists.First().GetValue(formObject, null);
                    p.SetValue(t, value, null);
                }
            }
            return t;
        }

        public static IList<V> Mapping<U, V>(IList<U> formList)
            where U : class, new()
            where V : class, new()
        {
            //http://blog.csdn.net/cxzhq2002/article/details/8753495
            //集合到集合暂没有实现

             //轻量的映射工具，不可与ORM做比较。它不参与到DB。一般用来配合SqlHelper/企业库来使用
            //作用：1.参数;2.dataReader转为Entity或List,3.对象对象，集合到集合，不支持深嵌套对象。

            PropertyInfo[] formProperties = GetProperties<U>();
            PropertyInfo[] toProperties = GetProperties<V>();

            IList<V> toList = new List<V>();
            foreach (var item in formList)
            {
                V to = new V();
                foreach (var p in toProperties)
                {
                    var exists = formProperties.Where(k => k.Name.Equals(p.Name, StringComparison.OrdinalIgnoreCase));
                    if (exists.Count() > 0)
                    {
                        var value = exists.First().GetValue(item, null);
                        p.SetValue(to, value, null);
                    }
                }
                toList.Add(to);                
            }
            return toList;
        }
        /// <summary>
        /// 映射
        /// </summary>
        /// <typeparam name="FormT">源类型</typeparam>
        /// <typeparam name="ToT">目标类型</typeparam>
        /// <param name="formObject">源对象</param>
        /// <returns>目标对象</returns>
        public static void Mapping<FormT, ToT>(FormT formObject, ToT toObject)
            where FormT : class, new()
            where ToT : class, new()
        {
            PropertyInfo[] formProperties = GetProperties<FormT>();
            PropertyInfo[] toProperties = GetProperties<ToT>();
            foreach (var p in toProperties)
            {
                var index = formProperties.ToList().FindIndex(item => item.Name.Equals(p.Name, StringComparison.OrdinalIgnoreCase));
                if (index >= 0)
                {
                    var value = formProperties[index].GetValue(formObject, null);
                    p.SetValue(toObject, value, null);
                }
            }
        }
    }
}





//轻量的映射工具，不可与ORM做比较。它不参与到DB。一般用来配合SqlHelper/企业库来使用
//作用：1.参数;2.dataReader转为Entity或List,3.对象对象，集合到集合，不支持深嵌套对象。

数据库部分参数可借助dynamic来实现必须要的参数（暂时没办法添加值类型） 

            dynamic student = new { Name = "张三", Gender = true, Age = 25, Birthday = DateTime.Now };
            Console.Write(student.GetType());

 增加Attibute来实现特殊对映

cxzhq2002
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AutoMapper基本用法
CHIZHIDA
05-31 1万+
AutoMapper的基本用法AutoMapper的使用场景 AutoMapper的使用场景 AutoMapper是对象到对象的映射工具。在完成映射规则之后，AutoMapper可以将源对象转换为目标对象。 表现层于应用层之间是通过DTO来进行交互的，数据传输对象是没有行为的POCO对象，他的目的是为了对领域对象进行数据封装，实现层与层之间的数据传递。为何不直接将领域对象进行数据传递？因为领域对...
FaleMaisDDD:Telzir.TalkMore 关于 DDD + AutoMaper + Ninject + UnitOfWork 的项目
06-13
《深入探讨：FaleMaisDDD项目中的DDD、AutoMapper、Ninject与Unit Of Work实践》 在IT领域，尤其在软件开发中，DDD（Domain-Driven Design，领域驱动设计）、AutoMapper、Ninject以及Unit Of Work模式是四个非常...
EF AutoMaper
weixin_34025151的博客
07-18 68
Mapper.CreateMap<Source,Dest>(); 该方法已弃用，使用下面这个 Mapper.Initialize(x=>x.CreateMap<Source,Dest>()); 转载于:https://www.cnblogs.com/guxingy/p/9329704.html
.NET开发中合理使用对象映射库，简化和提高工作效率
最新发布
技术杂谈，聚焦优质文章、开源项目、实用工具和学习、工作、面试心得分享。博客园推荐博客、阿里云专家博主，擅长于C#、.NET、.NET Core、Golang、TypeScript、Vue、Uni App、Angular开发。
06-07 627
在日常开发中，我们常常需要将一个对象映射到另一个对象，这个过程中可能需要编写大量的重复性代码，如果每次都手动编写，不仅会影响开发效率，而且当项目越来越复杂，庞大的时候还容易出现错误。为了解决这个问题，对象映射库就随之而出了，这些库可以自动完成对象之间的映射，从而减少了开发工作量，提高了开发效率。AutoMapper是一个流行的.NET对象映射库，它可以自动进行对象之间的转换和映射，极大的简化了开发人员在处理对象映射时的工作量。
AutoMapper
哈哈的博客
08-27 505
AutoMapper用于两个对象间的映射，通常用于完成DTO(Data Transfer Object)和Model之间的转换。AutoMapper1.创建Mapper.Initialize(cfg => { cfg.CreateMap<Foo, FooDto>(); cfg.CreateMap<Bar, BarDto>(); });var fooDto = Mapper.Map<F
AutoMapper快速上手
weixin_33919950的博客
04-23 92
一.什么是AutoMapper AutoMapper是一个简单的对象映射框架(OOM),对象映射原理是把一种类型的输入对象转换为不同类型的输出对象,通俗讲就是通过一些约束讲一种类型中数据自动映射到另一数据类型中 二.AutoMapper的好处 以前的时候我们将DTO对象转换为Model对象或者将Model对象转换为DTO对象时,我们必须将每一个属性都...
.NET对象映射库AutoMapper
qq_40796482的博客
05-10 2435
在此示例中，“CreateMap”方法创建了一个新的映射关系，该映射关系将Employee对象映射到EmployeeDTO对象。AutoMapper是一个.NET对象映射库，它可以自动将一个对象的属性值映射到另一个对象中。注意，为了使AutoMapper能够映射对象，两个对象必须具有相同的属性名称和类型。另外，AutoMapper提供了许多自定义选项，例如条件映射、后期操作等，您可以根据您的需要轻松地使用它们。此外，AutoMapper还支持批量对象的映射，以及其他高级映射功能，例如条件映射、后期操作等。
jsAutomapper:AutoMapper 的 Javascript 实现
06-11
jsAutomapper John Kalberer 对 AutoMapper 的 Javascript 实现 用法： var atest = { same : 10 , bleh : 4 } ; var btest = { dumb : null , func : null , ...* call 'createMap' where "a" and "b" are the...
C#中设计、使用Fluent API
01-20
我们经常使用的一些框架例如：EF,Automaper,NHibernate等都提供了非常优秀的Fluent API, 这样的API充分利用了VS的智能提示，而且写出来的代码非常整洁。我们如何在代码中也写出这种Fluent的代码呢，我这里介绍3总...
CodeFrame.Web：基于.net core 2.0的代码框架，目标用于快速构建web项目
02-04
CodeFrame.Web基于.net core 2.0的代码框架，用于...细分，菜单，按钮权限参考整合以下开源项目asp.net核心 UnitOfWork github： : log4net 2.0.8 EntityFrameworkCore layui AutoMaper Redis项目已发布linux预览地址
worldnomads:数列计算器
07-12
世界Nomad民族 数列计算器 v1.0 安装：从 Visual Studio 2013 ... 注意：使用的其他资源包括 AutoMaper、AngularJS、Bootstrap.Less、LessJS。 去做： 验证负数和十进制数的数字输入。 实施 elmah 错误日志记录。
.Net Core中更高级的AutoMapper示例
cxu0262的博客
05-18 670
AutoMapper是基于约定的，面向对象的映射器。 面向对象的映射器是将输入对象转换为不同类型的输出对象的映射器。 AutoMapper也可以用于映射相似或不相似的对象（即，具有相同或不同的属性的对象）。 在上一篇文章中，我们检查了AutoMapper的基本功能。 在本文中，我们将探讨AutoMapper的一些高级功能。 [ 点击此处注册免费的三个小时的Kubernetes入门课程，...
AutoMapper详解
热门推荐
李宥的博客
06-10 1万+
简单来说，AutoMapper是以.NET(C#)语言开发的一个轻量的处理一个实体对象到另一个实体对象之间映射关系的组件库。开发人员需要做的是通过AutoMapper配置两个实体对象之间的一些映射关系。就可以直接实现映射关系的复用，提高开发效率，减少重复代码。为了降低现代开发框架的复杂度，往往需要做代码分层，分层之后，必然出现不同的数据承载对象VO、BO、Entity ，从设计的角度来说，VO、BO、Entity 的设计思路并不违反 DRY 原则，为了分层清晰、减少耦合，多维护几个类的成本也并不是不能接受的
AutoMapper入门教程
Small_nie
03-26 3011
AutoMapper入门教程及IDataReader转List说明NuGet安装使用示例功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导...
AutoMaper 来创建DTO （EF,WCF,DTO）
Gavin luo 我们共同努力
03-12 2228
在上一篇文章说 WCF 在序列化 Entity Framework 的实体对象中，会陷入死循环，求助很久没有得到答应，便想到了用DTO 来处理这个恶性的问题（自己再多写几个实体层，直接不用EF的实体返回到页面前端），这样做无非解决了眼前一个尴尬问题，也为后续的性能增加了不少色彩。 了解到AutoMapper可以帮我简化不少工作（自动映射复制），便准备在项目中尝试一把，后续如果有什么问题，会更新在
关于对象映射器-AutoMapper学习。
二等碗
12-20 551
我接触AutoMapper比较晚，目前已经是8.0了。那么以前都是自己写表达式，但是现在的话，会用到更多的功能，所以选择了AutoMapper，除了AutoMapper以外其实还有很多的，对象映射器，比如TinyMapper，不过现在的TinyMapper不支持dotnet core ，所以我就暂时用不到了。 我们可以看一下官方文档，了解如何简单使用AutoMapper。 后面的时间，我会努力更新...
AutoMapper 8.0的应用--动态配置
yan_ncwu的博客
02-17 2112
AutoMapper 8.0中，需要使用configure来配置mapper。为此，实现动态的类型配置如下 public static class AutoMapHelper { private static bool ConfigExist(Type srcType, Type destType) { return Mappe...
asp.net core webapi AutoMapper使用
qq_41942413的博客
12-26 933
AutoMapper是一个.NET库，用于简化对象之间的映射。它可以帮助开发人员在不同类型之间进行自动转换，从而减少重复的手动映射代码。使用AutoMapper，开发人员可以定义映射规则，然后该库会自动执行对象之间的映射。这使得在应用程序中对数据进行转换和映射变得更加简单和高效。下面是AutoMapper的一些常见功能：对象到对象的映射：简化了从一个对象类型到另一个对象类型的转换。集合的映射：可以自动映射集合中的对象，减少了手动迭代和映射的工作。
AutoMapper 配置实现深度拷贝的对象映射
技术广场
05-12 842
默认情况下，AutoMapper执行的是浅拷贝，只复制源对象的属性到目标对象的对应属性。无论是针对所有字段还是特定的属性，通过自定义转换器或自定义映射规则，你可以实现灵活的深度拷贝逻辑。但是，如果我们需要在对象映射过程中实现深度拷贝，包括嵌套对象的属性字段，我们可以通过一些配置来实现。总结起来，AutoMapper是一个强大的对象映射库，通过适当的配置，我们可以实现深度拷贝的对象映射。另外，如果你需要在多个映射中重复使用相同的深度拷贝逻辑，你可以将其封装为可重用的自定义转换器，然后在需要的地方进行调用。
AutoMapper 9.0的使用
DotNetFamily
09-30 4085
AutoMapper于2019.8.12升级9.0 从此不再支持静态的对象转换 自己琢磨了一下，写了一套扩展 官方链接如下 https://github.com/AutoMapper/AutoMapper/tree/v9.0.0 我做了一下方便使用的简单封装 public static class AutoMapperExtension { public static I...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值