其一时半刻候利用Dto的好处就体现出来了,那样在后台往前台传递数据时得以省略不须求的音讯公海赌船网址

是因为安全思量,在后台与前台举行数量传输时,往往不会一直传输实人体模型型,而是选取Dto(Data
transfer object
数据传输对象),那样在后台往前台传递数据时方可省略不须求的新闻,只保留须要的新闻,大大加强数据安全性。

由于安全思量,在后台与前台进行数据传输时,往往不会直接传输实人体模型型,而是采用Dto(Data
transfer object
数据传输对象),那样在后台往前台传递数据时方可大约不必要的新闻,只保留须求的消息,大大增强数据安全性。

由于安全思索,在后台与前台举办数据传输时,往往不会直接传输实人体模型型,而是采取Dto(Data
transfer object
数据传输对象),那样在后台往前台传递数据时方可不难不须求的新闻,只保留须要的音信,大大增强数据安全性。

上边给出五个互相照应的涉嫌模型User、UserDto

下边给出四个相互照应的涉嫌模型User、UserDto

上面给出七个相互照应的关系模型User、UserDto

public class User
{
    private const int NameMaxLength = 20;

    private const int PassWordMaxLength = 16;

    [Key]
    public long Id { get; }


    [MaxLength(NameMaxLength)]
    public string Name { get; set; }

    [MaxLength(PassWordMaxLength)]
    [DataType(DataType.Password)]
    public string PassWord { get; set; }
}

public class UserDto
{
    private const int NameMaxLength = 20;

    private const int PassWordMaxLength = 16;

    [MaxLength(NameMaxLength)]
    public string Name { get; set; }

    [MaxLength(PassWordMaxLength)]
    public string PassWord { get; set; }
}
public class User
{
    private const int NameMaxLength = 20;

    private const int PassWordMaxLength = 16;

    [Key]
    public long Id { get; }


    [MaxLength(NameMaxLength)]
    public string Name { get; set; }

    [MaxLength(PassWordMaxLength)]
    [DataType(DataType.Password)]
    public string PassWord { get; set; }
}

public class UserDto
{
    private const int NameMaxLength = 20;

    private const int PassWordMaxLength = 16;

    [MaxLength(NameMaxLength)]
    public string Name { get; set; }

    [MaxLength(PassWordMaxLength)]
    public string PassWord { get; set; }
}
public class User{    private const int NameMaxLength = 20;    private const int PassWordMaxLength = 16;    [Key]    public long Id { get; }    [MaxLength(NameMaxLength)]    public string Name { get; set; }    [MaxLength(PassWordMaxLength)]    [DataType(DataType.Password)]    public string PassWord { get; set; }}public class UserDto{    private const int NameMaxLength = 20;    private const int PassWordMaxLength = 16;    [MaxLength(NameMaxLength)]    public string Name { get; set; }    [MaxLength(PassWordMaxLength)]    public string PassWord { get; set; }}

这里将 Id 定义为自增加主键,在注册页面,那个 Id
应不可知,这一年使用Dto的利益就反映出来了,那个时候,在存入数据库时会涉及到
UserDtoUser
的类型转换,遵照事先的阅历,肯定能够依据上边那样来写:

这里将 Id 定义为自拉长主键,在注册页面,这么些 Id
应不可知,这一年利用Dto的益处就反映出来了,这年,在存入数据库时会涉及到
UserDtoUser
的类型转换,依据事先的经历,肯定可以依照下边那样来写:

这里将 Id 定义为自增进主键,在登记页面,那么些 Id
应不可知,那年利用Dto的功利就展示出来了,那一年,在存入数据库时会涉及到
UserDtoUser
的类型转换,依据事先的经历,肯定能够依照上边这样来写:

user.Name=userDto.Name;
user.PassWord=UserDto.PassWord;
user.Name=userDto.Name;
user.PassWord=UserDto.PassWord;
user.Name=userDto.Name;user.PassWord=UserDto.PassWord;

诸如此类的转换即便能够,然则只要二个 User
对象丰富复杂,有贰十个甚至2十七个脾气,这一年那种写法就会议及展览示13分傻乎乎。

那般的转换即便能够,然而如果一个 User
对象丰富复杂,有十8个甚至贰四个属性,今年那种写法就会显示非凡傻乎乎。

诸如此类的更换就算能够,不过即使二个 User
对象丰富复杂,有1玖个甚至二17个属性,这一年那种写法就会呈现十二分傻乎乎。

本条时候大家就足以借助AutoMapper来帮衬我们成功 UserDtoUser
的转换了。

这年大家就能够借助AutoMapper来增派大家实现 UserDtoUser
的转移了。

其近来候我们就足以借助AutoMapper来支持大家做到 UserDtoUser
的更换了。

率先安装Nuget包

先是安装Nuget包

首先安装Nuget包

在 Tools – Nuget Package Manage – Package Manage Console 输入

在 Tools – Nuget Package Manage – Package Manage Console 输入

在 Tools – Nuget Package Manage – Package Manage Console 输入

Install-Package AutoMapper 
Install-Package AutoMapper 
Install-Package AutoMapper 

安装相应的Nuget包。

安装相应的Nuget包。

安装相应的Nuget包。

根据
Github
上付出的帮扶文书档案来看,有三种办法能够创制映射,壹种是静态的 Initalize
1种是动态创制。

根据
Github
上提交的帮忙文档来看,有二种艺术能够创设映射,一种是静态的 Initalize
一种是动态创制。

据他们说 Github 上付出的拉扯文书档案来看,有三种方法能够创立映射,1种是静态的
Initalize 一种是动态成立。

下边接纳二种区别的章程来实行单元测试

下边选用二种分化的艺术来展开单元测试

上面采纳三种分裂的方法来进展单元测试

    public void Using_Initlalize_Test()
    {
        UserDto dto = new UserDto
        {
            Name = "Niko",
            PassWord = "1234",
        };
        Mapper.Initialize(ctx => ctx.CreateMap<UserDto, User>());
        User user = Mapper.Map<UserDto, User>(dto);
        user.Name.ShouldBe("Niko");
        user.PassWord.ShouldBe("1234");
        user.Id.ToString().ShouldBe("0");
    }

    public  void Using_MapperConfiguration_Test()
    {
        var config = new MapperConfiguration(ctx => ctx.CreateMap<UserDto, User>());
        var mapper = config.CreateMapper();
       // var mapper = new Mapper(config);
        UserDto dto = new UserDto
        {
            Name = "Niko",
            PassWord = "1234",
        };
        User user = mapper.Map<User>(dto);
        //User user = Mapper.Map<User>(dto);
        user.Name.ShouldBe("Niko");
        user.PassWord.ShouldBe("1234");
        user.Id.ToString().ShouldBe("0");
    }
    public void Using_Initlalize_Test()
    {
        UserDto dto = new UserDto
        {
            Name = "Niko",
            PassWord = "1234",
        };
        Mapper.Initialize(ctx => ctx.CreateMap<UserDto, User>());
        User user = Mapper.Map<UserDto, User>(dto);
        user.Name.ShouldBe("Niko");
        user.PassWord.ShouldBe("1234");
        user.Id.ToString().ShouldBe("0");
    }

    public  void Using_MapperConfiguration_Test()
    {
        var config = new MapperConfiguration(ctx => ctx.CreateMap<UserDto, User>());
        var mapper = config.CreateMapper();
       // var mapper = new Mapper(config);
        UserDto dto = new UserDto
        {
            Name = "Niko",
            PassWord = "1234",
        };
        User user = mapper.Map<User>(dto);
        //User user = Mapper.Map<User>(dto);
        user.Name.ShouldBe("Niko");
        user.PassWord.ShouldBe("1234");
        user.Id.ToString().ShouldBe("0");
    }
    public void Using_Initlalize_Test()    {        UserDto dto = new UserDto        {            Name = "Niko",            PassWord = "1234",        };        Mapper.Initialize(ctx => ctx.CreateMap<UserDto, User>;        User user = Mapper.Map<UserDto, User>;        user.Name.ShouldBe;        user.PassWord.ShouldBe;        user.Id.ToString().ShouldBe;    }    public  void Using_MapperConfiguration_Test()    {        var config = new MapperConfiguration(ctx => ctx.CreateMap<UserDto, User>;        var mapper = config.CreateMapper();       // var mapper = new Mapper;        UserDto dto = new UserDto        {            Name = "Niko",            PassWord = "1234",        };        User user = mapper.Map<User>;        //User user = Mapper.Map<User>;        user.Name.ShouldBe;        user.PassWord.ShouldBe;        user.Id.ToString().ShouldBe;    }

此地运用到 Shouldly
断言框架
,具体用法参考官方文书档案。

此间运用到 Shouldly
断言框架
,具体用法参考官方文书档案。

此处运用到 Shouldly 断言框架,具体用法参考官方文书档案。

写完规则之后 日常会调用 AssertConfigurationIsValid
方法,检查规则是还是不是完全

写完规则之后 平日会调用 AssertConfigurationIsValid
方法,检查规则是不是完好

写完规则之后 平日会调用 AssertConfigurationIsValid
方法,检查规则是还是不是完全

        Mapper.AssertConfigurationIsValid();
        Mapper.AssertConfigurationIsValid();
        Mapper.AssertConfigurationIsValid();

二种方式,单元测试均通过。那样的话,借助 Automapper
处理复杂的靶子映射,将大大简化大家的代码量。

二种方法,单元测试均经过。那样的话,借助 Automapper
处理千丝万缕的指标映射,将大大简化大家的代码量。

三种艺术,单元测试均通过。那样的话,借助 Automapper
处理千丝万缕的对象映射,将大大简化咱们的代码量。

为了进一步便捷地选用 AutoMappper ,对AutoMapper进行扩大

为了特别便利地接纳 AutoMappper ,对AutoMapper实行扩展

为了尤其简便易行地动用 AutoMappper ,对AutoMapper举办扩大

 public static class AutoMapperExtension
{
    /// <summary>
    /// 对象到对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>

    public static T MapTo<T>(this object obj)
    {
        if (obj == null) return default(T);
        Mapper.Initialize(ctx=>ctx.CreateMap(obj.GetType(),typeof(T)));
        return Mapper.Map<T>(obj);
    }

    /// <summary>
    /// 集合到集合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>

    public static List<T> MapTo<T>(this IEnumerable obj )
    {
        if (obj == null) throw new ArgumentNullException();
        Mapper.Initialize(ctx => ctx.CreateMap ( obj.GetType(), typeof(T))) ;
        return Mapper.Map<List<T>>(obj);
    }
}
 public static class AutoMapperExtension
{
    /// <summary>
    /// 对象到对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>

    public static T MapTo<T>(this object obj)
    {
        if (obj == null) return default(T);
        Mapper.Initialize(ctx=>ctx.CreateMap(obj.GetType(),typeof(T)));
        return Mapper.Map<T>(obj);
    }

    /// <summary>
    /// 集合到集合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>

    public static List<T> MapTo<T>(this IEnumerable obj )
    {
        if (obj == null) throw new ArgumentNullException();
        Mapper.Initialize(ctx => ctx.CreateMap ( obj.GetType(), typeof(T))) ;
        return Mapper.Map<List<T>>(obj);
    }
}
 public static class AutoMapperExtension{    /// <summary>    /// 对象到对象    /// </summary>    /// <typeparam name="T"></typeparam>    /// <param name="obj"></param>    /// <returns></returns>    public static T MapTo<T>(this object obj)    {        if (obj == null) return default;        Mapper.Initialize(ctx=>ctx.CreateMap(obj.GetType(),typeof;        return Mapper.Map<T>;    }    /// <summary>    /// 集合到集合    /// </summary>    /// <typeparam name="T"></typeparam>    /// <param name="obj"></param>    /// <returns></returns>    public static List<T> MapTo<T>(this IEnumerable obj )    {        if (obj == null) throw new ArgumentNullException();        Mapper.Initialize(ctx => ctx.CreateMap ( obj.GetType(), typeof ;        return Mapper.Map<List<T>>;    }}

应用方面包车型客车办法开始展览单元测试:

采纳方面包车型地铁诀窍举行单元测试:

动用方面包车型地铁措施实行单元测试:

    public void testme()
    {
        UserDto dto = new UserDto
        {
            Name = "Niko",
            PassWord = "1234",
        };
        User user=dto.MapTo<User>();
        user.Name.ShouldBe("Niko");
        user.PassWord.ShouldBe("1234");
        user.Id.ToString().ShouldBe("0");
    }
    public void testme()
    {
        UserDto dto = new UserDto
        {
            Name = "Niko",
            PassWord = "1234",
        };
        User user=dto.MapTo<User>();
        user.Name.ShouldBe("Niko");
        user.PassWord.ShouldBe("1234");
        user.Id.ToString().ShouldBe("0");
    }
    public void testme()    {        UserDto dto = new UserDto        {            Name = "Niko",            PassWord = "1234",        };        User user=dto.MapTo<User>();        user.Name.ShouldBe;        user.PassWord.ShouldBe;        user.Id.ToString().ShouldBe;    }

测试通过,相比较以上封装前后的格局,发现包裹后代码量特别从简,使用起来更为便于。

测试通过,相比以上封装前后的主意,发现包裹后代码量尤其简明,使用起来更加惠及。

测试通过,相比较以上封装前后的不二法门,发现包裹后代码量特别简洁,使用起来更为便于。

相关文章