c# automapper 使用

最新推荐文章于 2024-08-14 15:03:50 发布
最新推荐文章于 2024-08-14 15:03:50 发布
阅读量137 收藏 1
点赞数
原文链接：http://www.cnblogs.com/vaevvaev/p/7080423.html
版权

一、最简单的用法

有两个类User和UserDto

复制代码 
 1     public class User
 2     {
 3         public int Id { get; set; }
 4         public string Name { get; set; }
 5         public int Age { get; set; }
 6     }
 7 
 8     public class UserDto
 9     {
10         public string Name { get; set; }
11         public int Age { get; set; }
12     }
复制代码

将User转换成UserDto也和简单

复制代码 
1     Mapper.Initialize(x => x.CreateMap<User, UserDto>());
2     User user = new User()
3     {
4         Id = 1,
5         Name = "caoyc",
6         Age = 20
7     };
8     var dto = Mapper.Map<UserDto>(user);
复制代码

 这是一种最简单的使用，AutoMapper会更加字段名称去自动对于，忽略大小写。

 

二、如果属性名称不同

将UserDto的Name属性改成Name2

复制代码 
 1     Mapper.Initialize(x => 
 2         x.CreateMap<User, UserDto>()
 3          .ForMember(d =>d.Name2, opt => {
 4             opt.MapFrom(s => s.Name);
 5             })
 6         );
 7 
 8     User user = new User()
 9     {
10         Id = 1,
11         Name = "caoyc",
12         Age = 20
13     };
14 
15     var dto = Mapper.Map<UserDto>(user);
复制代码

 

三、使用Profile配置

自定义一个UserProfile类继承Profile，并重写Configure方法

复制代码 
 1     public class UserProfile : Profile
 2     {
 3         protected override void Configure()
 4         {
 5             CreateMap<User, UserDto>()
 6                 .ForMember(d => d.Name2, opt =>
 7                 {
 8                     opt.MapFrom(s => s.Name);
 9                 });
10         }
11     }
复制代码

使用时就这样

复制代码 
 1     Mapper.Initialize(x => x.AddProfile<UserProfile>());
 2 
 3     User user = new User()
 4     {
 5         Id = 1,
 6         Name = "caoyc",
 7         Age = 20
 8     };
 9 
10     var dto = Mapper.Map<UserDto>(user);
复制代码

 

四、空值替换NullSubstitute

空值替换允许我们将Source对象中的空值在转换为Destination的值的时候，使用指定的值来替换空值。

复制代码 
 1     public class UserProfile : Profile
 2     {
 3         protected override void Configure()
 4         {
 5             CreateMap<User, UserDto>()
 6                 .ForMember(d => d.Name2, opt => opt.MapFrom(s => s.Name))
 7                 .ForMember(d => d.Name2, opt => opt.NullSubstitute("值为空"));
 8                 
 9         }
10     }
复制代码
复制代码 
1     Mapper.Initialize(x => x.AddProfile<UserProfile>());
2 
3     User user = new User()
4     {
5         Id = 1,
6         Age = 20
7     };
8 
9     var dto = Mapper.Map<UserDto>(user);
复制代码

结果为：

 

五、忽略属性Ignore

复制代码 
 1     public class User
 2     {
 3         public int Id { get; set; }
 4         public string Name { get; set; }
 5         public int Age { get; set; }
 6     }
 7 
 8     public class UserDto
 9     {
10         public string Name { get; set; }
11         public int Age { get; set; }
12 
13     }
14 
15     public class UserProfile : Profile
16     {
17         protected override void Configure()
18         {
19             CreateMap<User, UserDto>().ForMember("Name", opt => opt.Ignore());
20         }
21     }
复制代码

使用

复制代码 
 1     Mapper.Initialize(x => x.AddProfile<UserProfile>());
 2 
 3     User user = new User()
 4     {
 5         Id = 1,
 6         Name="caoyc",
 7         Age = 20
 8     };
 9 
10     var dto = Mapper.Map<UserDto>(user);
复制代码

结果：

 

六、预设值

如果目标属性多于源属性，可以进行预设值

复制代码 
 1     public class User
 2     {
 3         public int Id { get; set; }
 4         public string Name { get; set; }
 5         public int Age { get; set; }
 6     }
 7 
 8     public class UserDto
 9     {
10         public string Name { get; set; }
11         public int Age { get; set; }
12         public string Gender { get; set; }
13 
14     }
15 
16     public class UserProfile : Profile
17     {
18         protected override void Configure()
19         {
20             CreateMap<User, UserDto>();
21         }
22     }
复制代码

使用

复制代码 
 1     Mapper.Initialize(x => x.AddProfile<UserProfile>());
 2 
 3     User user = new User()
 4     {
 5         Id = 1,
 6         Name="caoyc",
 7         Age = 20
 8     };
 9 
10     UserDto dto = new UserDto() {Gender = "男"};
11     Mapper.Map(user, dto);
复制代码

 七、类型转换ITypeConverter

如果数据中Gender存储的int类型，而DTO中Gender是String类型

复制代码 
1     public class User
2     {
3         public int Gender { get; set; }
4     }
5 
6     public class UserDto
7     {
8         public string Gender { get; set; }
9     }
复制代码

类型转换类，需要实现接口ITypeConverter

复制代码 
 1     public class GenderTypeConvertert : ITypeConverter<int, string>
 2     {
 3         public string Convert(int source, string destination, ResolutionContext context)
 4         {
 5             switch (source)
 6             {
 7                 case 0:
 8                     destination = "男";
 9                     break;
10                 case 1:
11                     destination = "女";
12                     break;
13                 default:
14                     destination = "未知";
15                     break;
16             }
17             return destination;
18         }
19     }
复制代码

配置规则

复制代码 
 1     public class UserProfile : Profile
 2     {
 3         protected override void Configure()
 4         {
 5             CreateMap<User, UserDto>();
 6 
 7             CreateMap<int, string>().ConvertUsing<GenderTypeConvertert>();
 8             //也可以写这样
 9             //CreateMap<int, string>().ConvertUsing(new GenderTypeConvertert());
10         }
11     }
复制代码

使用

复制代码 
 1     Mapper.Initialize(x => x.AddProfile<UserProfile>());
 2 
 3     User user0 = new User() { Gender = 0 };
 4     User user1 = new User() { Gender = 1 };
 5     User user2 = new User() { Gender = 2 };
 6     var dto0= Mapper.Map<UserDto>(user0);
 7     var dto1 = Mapper.Map<UserDto>(user1);
 8     var dto2 = Mapper.Map<UserDto>(user2);
 9 
10     Console.WriteLine("dto0:{0}", dto0.Gender);
11     Console.WriteLine("dto1:{0}", dto1.Gender);
12     Console.WriteLine("dto2:{0}", dto2.Gender);
复制代码

结果

 

八、条件约束Condition

当满足条件时才进行映射字段，例如人类年龄，假设我们现在人类年龄范围为0-200岁（这只是假设），只有满足在这个条件才进行映射

DTO和Entity

复制代码 
1     public class User
2     {
3         public int Age { get; set; }
4     }
5 
6     public class UserDto
7     {
8         public int Age { get; set; }
9     }
复制代码

Profile

复制代码 
1     public class UserProfile : Profile
2     {
3         protected override void Configure()
4         {
5             CreateMap<User, UserDto>().ForMember(dest=>dest.Age,opt=>opt.Condition(src=>src.Age>=0 && src.Age<=200));
6         }
7     }
复制代码

使用代码

复制代码 
 1     Mapper.Initialize(x => x.AddProfile<UserProfile>());
 2 
 3     User user0 = new User() { Age = 1 };
 4     User user1 = new User() { Age = 150 };
 5     User user2 = new User() { Age = 201 };
 6     var dto0= Mapper.Map<UserDto>(user0);
 7     var dto1 = Mapper.Map<UserDto>(user1);
 8     var dto2 = Mapper.Map<UserDto>(user2);
 9 
10     Console.WriteLine("dto0:{0}", dto0.Age);
11     Console.WriteLine("dto1:{0}", dto1.Age);
12     Console.WriteLine("dto2:{0}", dto2.Age);
复制代码

输出结果

 

 

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
using AutoMapper;  
using System.Data;  
  
namespace ConsoleApplication2  
{  
    class Program  
    {  
  
        static void Main(string[] args)  
        {  
            //1.普通转换  
            Name name1 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .BeforeMap((name, nameDto) => Console.WriteLine("hello world before"))  
            .AfterMap((name, nameDto) => Console.WriteLine("hello world after"));  
            NameDto nameDto1 = Mapper.Map<Name, NameDto>(name1);  
            Console.WriteLine("1");  
            Console.WriteLine(nameDto1.FirstName + nameDto1.LastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //整体设置  
            //2.整体即时转换  
            Mapper.Reset();  
            Name name2 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ConstructUsing(name => new NameDto() { AllName = name.FirstName + name.LastName });  
            NameDto nameDto2 = Mapper.Map<Name, NameDto>(name2);  
            Console.WriteLine("2");  
            Console.WriteLine(nameDto2.AllName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //3.整体通过TypeConverter类型转换  
            Mapper.Reset();  
            Name name3 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ConvertUsing<NameConverter>();  
            NameDto nameDto3 = Mapper.Map<Name, NameDto>(name3);  
            Console.WriteLine("3");  
            Console.WriteLine(nameDto3.AllName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //单属性设置  
            //4.属性条件转换  
            Mapper.Reset();  
            Name name4 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.FirstName, opt => opt.Condition(name => !name.FirstName.Equals("l", StringComparison.OrdinalIgnoreCase)));  
            NameDto nameDto4 = Mapper.Map<Name, NameDto>(name4);  
            Console.WriteLine("4");  
            Console.WriteLine(string.IsNullOrEmpty(nameDto4.FirstName));  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //5.属性忽略  
            Mapper.Reset();  
            Name name5 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.FirstName, opt => opt.Ignore());  
            NameDto nameDto5 = Mapper.Map<Name, NameDto>(name5);  
            Console.WriteLine("5");  
            Console.WriteLine(string.IsNullOrEmpty(nameDto5.FirstName));  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //6.属性转换  
            Mapper.Reset();  
            Name name6 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.AllName, opt => opt.MapFrom(name => name.FirstName + name.LastName))  
            .ForMember(name => name.FirstName, opt => opt.MapFrom(name=>name.FirstName));  
            NameDto nameDto6 = Mapper.Map<Name, NameDto>(name6);  
            Console.WriteLine("6");  
            Console.WriteLine(nameDto6.AllName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //7.属性通过ValueResolver转换  
            Mapper.Reset();  
            Name name7 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, StoreDto>()  
            .ForMember(storeDto => storeDto.Name, opt => opt.ResolveUsing<NameResolver>());  
            StoreDto store1 = Mapper.Map<Name, StoreDto>(name7);  
            Console.WriteLine("7");  
            Console.WriteLine(store1.Name.FirstName + store1.Name.LastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //8.属性填充固定值  
            Mapper.Reset();  
            Name name8 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.AllName, opt => opt.UseValue<string>("ljzforever"));  
            NameDto nameDto8 = Mapper.Map<Name, NameDto>(name8);  
            Console.WriteLine("8");  
            Console.WriteLine(nameDto8.AllName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //9.属性格式化  
            Mapper.Reset();  
            Name name9 = new Name() { FirstName = "L", LastName = "jz" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.FirstName, opt => opt.AddFormatter<StringFormatter>());  
            NameDto nameDto9 = Mapper.Map<Name, NameDto>(name9);  
            Console.WriteLine("9");  
            Console.WriteLine(nameDto9.FirstName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //10.属性null时的默认值  
            Mapper.Reset();  
            Name name10 = new Name() { FirstName = "L" };  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.LastName, opt => opt.NullSubstitute("jz"));  
            NameDto nameDto10 = Mapper.Map<Name, NameDto>(name10);  
            Console.WriteLine("10");  
            Console.WriteLine(nameDto10.LastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //其它设置与特性  
            //11.转换匿名对象  
            Mapper.Reset();  
            object name11 = new { FirstName = "L", LastName = "jz" };  
            NameDto nameDto11 = Mapper.DynamicMap<NameDto>(name11);  
            Console.WriteLine("11");  
            Console.WriteLine(nameDto11.FirstName + nameDto11.LastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //12.转换DataTable  
            Mapper.Reset();  
            DataTable dt = new DataTable();  
            dt.Columns.Add("FirstName", typeof(string));  
            dt.Columns.Add("LastName", typeof(string));  
            dt.Rows.Add("L", "jz");  
            List<NameDto> nameDto12 = Mapper.DynamicMap<IDataReader, List<NameDto>>(dt.CreateDataReader());  
            Console.WriteLine("12");  
            Console.WriteLine(nameDto12[0].FirstName + nameDto12[0].LastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
            //emitMapper error  
            //List<NameDto> nameDto20 = EmitMapper.ObjectMapperManager.DefaultInstance.GetMapper<IDataReader, List<NameDto>>().Map(dt.CreateDataReader());  
  
  
            //13.转化存在的对象  
            Mapper.Reset();  
            Mapper.CreateMap<Name, NameDto>()  
            .ForMember(name => name.LastName, opt => opt.Ignore());  
            Name name13 = new Name() { FirstName = "L" };  
            NameDto nameDto13 = new NameDto() { LastName = "jz" };  
            Mapper.Map<Name, NameDto>(name13, nameDto13);  
            //nameDto13 = Mapper.Map<Name, NameDto>(name13);//注意,必需使用上面的写法,不然nameDto13对象的LastName属性会被覆盖  
            Console.WriteLine("13");  
            Console.WriteLine(nameDto13.FirstName + nameDto13.LastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //14.Flatten特性 Store.Name.FirtName=FlattenName.NameFirstname  
            Mapper.Reset();  
            Mapper.CreateMap<Store, FlattenName>();  
            Store store2 = new Store() { Name = new Name() { FirstName = "L", LastName = "jz" } };  
            FlattenName nameDto14 = Mapper.Map<Store, FlattenName>(store2);  
            Console.WriteLine("14");  
            Console.WriteLine(nameDto14.NameFirstname + nameDto14.NameLastName);  
            Console.WriteLine();  
            //Console.ReadKey();  
  
            //15.将Dictionary转化为对象,现在还不支持  
            Mapper.Reset();  
            Mapper.CreateMap<Dictionary<string, object>, Name>();  
            Dictionary<string, object> dict = new Dictionary<string, object>();  
            dict.Add("FirstName", "L");  
            //Name name15 = Mapper.DynamicMap<Dictionary<string, object>, Name>(dict);  
            Name name15 = Mapper.Map<Dictionary<string, object>, Name>(dict);  
            Console.WriteLine("15");  
            Console.WriteLine(name15.FirstName);  
            Console.WriteLine();  
            Console.ReadKey();  
        }  
    }  
  
  
    public class Store  
    {  
        public Name Name { get; set; }  
        public int Age { get; set; }  
    }  
  
    public class Name  
    {  
        public string FirstName { get; set; }  
        public string LastName { get; set; }  
    }  
  
    public class StoreDto  
    {  
        public NameDto Name { get; set; }  
        public int Age { get; set; }  
    }  
  
    public class NameDto  
    {  
        public string FirstName { get; set; }  
        public string LastName { get; set; }  
        public string AllName { get; set; }  
    }  
  
    public class FlattenName  
    {  
        public string NameFirstname { get; set; }  
        public string NameLastName { get; set; }  
    }  
  
    public class NameConverter : TypeConverter<Name, NameDto>  
    {  
        protected override NameDto ConvertCore(Name source)  
        {  
            return new NameDto() { AllName = source.FirstName + source.LastName };  
        }  
    }  
  
    public class NameResolver : ValueResolver<Name, NameDto>  
    {  
        protected override NameDto ResolveCore(Name source)  
        {  
            return new NameDto() { FirstName = source.FirstName, LastName = source.LastName,AllName=source.FirstName+source.LastName };  
        }  
    }  
  
    public class NameFormatter : ValueFormatter<NameDto>  
    {  
        protected override string FormatValueCore(NameDto name)  
        {  
            return name.FirstName + name.LastName;  
        }  
    }  
  
    public class StringFormatter : ValueFormatter<string>  
    {  
        protected override string FormatValueCore(string name)  
        {  
            return name + "-";  
        }  
    }  
}

 

转载于:https://www.cnblogs.com/vaevvaev/p/7080423.html

weixin_30954265
关注
C# 的 AutoMapper 库入门：刨根问底的深度解析
java专栏
08-19 1109
Automapper 允许我们定义自定义映射逻辑。set;set;set;set;set;set;set;// 初始化 AutoMapperget;set;get;set;get;set;get;set;get;set;get;set;get;set;// 初始化 AutoMapper var config = new MapperConfiguration(cfg => {});// 创建 Person 对象 var person = new Person {
如何在C＃中使用AutoMapper
NoerrorCode的博客
08-20 394
在这个示例中，我们首先创建一个MapperConfiguration对象，并使用AddProfile方法将我们之前定义的映射配置添加到配置中。然后，我们创建一个Mapper对象，并传入配置。在这个例子中，我们将Person对象的FirstName和LastName属性映射到PersonDTO对象的FullName属性上。AutoMapper是一个强大的对象映射库，可帮助简化C＃中的对象之间的转换过程。接下来，在我们需要进行对象映射的地方，我们需要创建一个Mapper对象并使用Map方法执行映射。
C# AutoMapper 使用方法总结
08-19
主要介绍了C# AutoMapper 使用方法，文中讲解非常细致，代码帮助大家更好的理解学习，感兴趣的朋友可以了解下
【C#】使用AutoMapper-看这篇就够了
热门推荐
catshitone的专栏
11-20 3万+
1.基本配置 Profile配置 public class OrganizationProfile : Profile { public OrganizationProfile() { CreateMap<Foo, FooDto>(); } } 使用： var configuration = new MapperConfiguration(cfg => { //cfg.CreateMap<Foo, Bar>(); cfg.AddProfile<
在 C# 中使用 AutoMapper 进行对象映射
最新发布
Hellc007的博客
08-14 1646
C# 中使用 AutoMapper 进行对象映射。AutoMapper 是一个非常强大的工具，它可以减少手动编写映射代码的工作量
C# AutoMapper初使用
fhqiwmc的博客
03-14 722
AutoMapper 提供简单的类型配置，以及映射的简单测试。真正的问题可能是“为什么要使用对象-对象映射？映射可以发生在应用程序中的许多位置，但主要发生在层之间的边界中，例如 UI/域层或服务/域层之间。一层的关注点通常与另一层的关注点冲突，因此对象-对象映射会导致隔离模型，其中每一层的关注点只能影响该层中的类型。对象-对象映射的工作原理是将一种类型的输入对象转换为不同类型的输出对象。AutoMapper 的有趣之处在于，它提供了一些有趣的约定，可以省去如何将类型 A 映射到类型 B 的繁琐工作。
C# AutoMapper
标准都是留给不爱的人，爱的本质是自由意志的沉沦
07-14 1102
} }} } }} } }} } }在上面的示例中，我们创建了一个类，并在其中定义了到的映射规则。} } }} } }} } }} } }在上面的示例中，我们使用了方法来为所有成员应用相同的映射策略。方法使用了反射来动态获取对象的属性值。
详解c# AutoMapper 使用方式
08-28
本篇文章主要介绍了详解c# AutoMapper 使用方式 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C#中使用AutoMapper
你不认识的22的博客
11-21 3326
通常使用方法 public static class Extension { //自定义转换方法,这个不用指定具体继承哪个类 public static TDestination MapTo&lt;TSource, TDestination&gt;(this TSource source) where TDestination : class where T...
c# Automapper使用方法
05-27
使用AutoMapper可以简化对象映射的过程，提高开发效率。下面是使用AutoMapper的基本步骤： 1. 在项目中安装AutoMapper NuGet包。 2. 创建一个映射配置类，用于定义源对象和目标对象之间的映射关系。例如： ``` ...
C# 中AutoMapper的使用方法
chinaherolts2008的博客
04-04 1357
译文链接： https://www.infoworld.com/art… AutoMapper 是一个非常流行的 object-to-object 映射库，它的目的就是帮助你实现不同类型对象之间的映射，举一个例子，在 DDD 开发模式中，你可能需要实现将 DTO object 映射为 Model object，在过去，你需要人肉的将这两个类型下的属性字段进行一一映射，现在 AutoMapper 就可以帮你节省 这种冗余的模板式代码 匹配所耗费的时间。 开始玩 AutoMapper 之前，你需要在 Visua
C# 使用AutoMapper实现类映射
rjcql的专栏
01-25 886
AutoMapper是一个用于.NET中简化类之间的映射的扩展库；可以在执行对象映射的过程，省去的繁琐转换代码，实现了对DTO的快速装配，有效的减少了代码量。通过NuGet安装，AutoMapper， 由于本例用到了DI,所以需要顺便安装一下 AutoMapper.Extensions.Microsoft.DependencyInjection。
【C#】AutoMapper 使用手册
guliang21的专栏
06-12 1350
文章目录1 入门例子2 注册2.1 Profile3 配置3.1 命名约定3.2 配置可见性3.3 全局属性/字段过滤3.4 识别前缀和后缀3.5 替换字符4 调用构造函数5 数组和列表映射5.1 处理空集合5.2 集合中的多态6 方法到属性映射7 自定义映射8 扁平化映射8.1 IncludeMembers9 嵌套映射 本文基于 AutoMapper 9.0.0 AutoMapper 是一个对象-对象映射器，可以将一个对象映射到另一个对象。 官网地址：http://automapper.org/ 官方
C# AutoMapper的使用
qq_35193189的博客
06-25 6853
AutoMapper介绍 为什么要使用AutoMapper？ 我们在实现两个实体之间的转换，首先想到的就是新的一个对象，这个实体的字段等于另一个实体的字段，这样确实能够实现两个实体之间的转换，但这种方式的扩展性，灵活性非常差，维护起来相当麻烦;实体之前转换的工具有很多，不过我还是决定使用AutoMapper，因为它足够轻量级，而且也非常流行，国外的大牛们都使用它使用AutoMapper可以很方...
使用AutoMapper将Null转为空字符或0等默认值
qq_35219163的博客
04-24 2161
AutoMapper的一些配置 使用的Core3.0 和frame4.5可能会有一些区别 记录自己写的Mapper的配置 有不好的地方欢迎指正 可以对为Null的属性进行一些默认值的配置 转换方法在MapFactory 中的ValueTransformers int? -> 0 datetime? ->datetime.now bool? ->false string-&gt...
AutoMapper 学习笔记
wem520的专栏
05-16 3759
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using AutoMapper; using System.Data; namespace ConsoleApplication2 { class Prog
.NET对象映射库AutoMapper
qq_40796482的博客
05-10 2513
在此示例中，“CreateMap”方法创建了一个新的映射关系，该映射关系将Employee对象映射到EmployeeDTO对象。AutoMapper是一个.NET对象映射库，它可以自动将一个对象的属性值映射到另一个对象中。注意，为了使AutoMapper能够映射对象，两个对象必须具有相同的属性名称和类型。另外，AutoMapper提供了许多自定义选项，例如条件映射、后期操作等，您可以根据您的需要轻松地使用它们。此外，AutoMapper还支持批量对象的映射，以及其他高级映射功能，例如条件映射、后期操作等。
Automapper
weixin_30467087的博客
04-04 175
一、AutoMapper 说明:Automapper是一个object-object mapping（对象映射）工具，一般主要用于两个对象之间数据映射和交换。 二、安装程序集包 1、程序包管理控制台方式 Install-Package AutoMapper 2、Nuget方式 三、实体映射 1、两个实体之间的映射 using AutoMapper; using S...
ObjectMapper忽略字段大小写
诚的博客
02-22 2390
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);//忽略未知字段 objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);// 忽略字段大小写 HazardousAreaBean hazardousAreaBean=objectMapper.readValue(JSON.toJSONStrin.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值