Vous amène à maîtriser les exemples d'utilisation du framework OOM AutoMapper

Cet article présente principalement les connaissances pertinentes du framework OOMAutoMapper. Les cinq exemples de cet article peuvent vous aider à résoudre des problèmes de base courants. Il a une certaine valeur de référence. Jetons-y un coup d'œil avec l'éditeur ci-dessous

est écrit devant

Comme son nom l'indique, Object. -Object-Mapping Conversion mutuelle entre entités, AutoMapper est aussi un cliché. Son importance est de vous aider à convertir des relations simples et gênantes entre entités sans conversion manuelle, comme la conversion entre ViewModel et entité, et la conversion entre SearchModel et. Entité. L'importance de mon partage est que la plupart des partages sur Internet ont eu lieu il y a quelques années et que de nombreuses méthodes ont été abandonnées. Le compilateur vous dira que la méthode est obsolète, abandonnée et non recommandée, comme Mapper. .CreateMap et d'autres méthodes Bien sûr, la plupart des pilotes expérimentés sont simplement allés sur github pour lire la documentation, ou je l'ai simplement recherché sur Google et découvert, mais les informations chinoises n'expliquaient rien sur la méthode abandonnée. Les cinq exemples de cet article peuvent vous aider à résoudre des problèmes de base courants.

Préparation

Nous préparons d'abord du ViewModel et du TModel. ViewModel est l'entité avec laquelle vous interagissez avec l'utilisateur. TModel est l'entité que vous utilisez pour gérer la base de données.

Les entités sont affichées comme suit :

TModel a les trois entités simples suivantes. Elles ont des entités indépendantes et des entités un-à-plusieurs.

public class TAddress
{
 public string Country { get; set; }
 public string City { get; set; }
 public string Street { get; set; }
 public string PostCode { get; set; }
 public string CreateTime { get; set; }
 public int CreateUserId { get; set; }
}

public class TAuthor
 {
  public string Name { get; set; }
  public string Description { get; set; }
  public List<TContactInfo> ContactInfo { get; set; }
 }
 public class TContactInfo
 {
 public int Id { get; set; }
 public string Email { get; set; }
 public string Blog { get; set; }
 public string Twitter { get; set; }
 }

ViewModel est le suivant :

public class VM_Address
 {
 public string Country { get; set; }
 public string City { get; set; }
 public string City2 { get; set; }
 }
 public class VM_Author
 {
 public string Name { get; set; }
 public string Description { get; set; }
 public List<VM_ContactInfo> ContactInfo { get; set; }
 }
 public class VM_ContactInfo
 {
 public int Id { get; set; }
 public string Email { get; set; }
 public string Blog { get; set; }
 public string Twitter { get; set; }
 }

Conversion d'une seule entité

Lors de la conversion d'une seule entité, lorsque les attributsnoms des champs correspondent exactement, il vous suffit de préciser la conversion entre les deux entités. spécifiez l'entité source et l'entité de destination. Ensuite vous devez vous référer aux exemples suivants :

VM_Address dto = new VM_Address
  {
  Country = "China",
  City = "Beijing"
  };
  Mapper.Initialize(m => m.CreateMap<VM_Address, TAddress>());
  TAddress address = Mapper.Map<VM_Address, TAddress>(dto);

Veuillez noter que dans AutoMapper5.x, Initialize est préférable pour initialiser vos règles.

Après avoir spécifié les règles de conversion, veuillez utiliser la méthode Map pour convertir et afficher vos entités cibles. Le premier paramètre représente SourceModel et le deuxième paramètre est DestinationModel.

Conversion d'attributs avec des noms différents pour une seule entité

Lorsque vous devez convertir des champs avec des noms différents Lors du mappage, faites attention à l'utilisation de la méthode ForMember. Le premier paramètre vous oblige à spécifier le champ cible qui nécessite une configuration spéciale. Le deuxième paramètre vous oblige à spécifier le fonctionnement des attributs de champ. le sens est de dire à AutoMapper que je dois spécifier la source City de l'entité cible comme valeur d'attribut City2 de l'entité source.

VM_Address dto = new VM_Address
  {
  Country = "China",
  City2 = "Beijing"
  };
  Mapper.Initialize(m => m.CreateMap<VM_Address, TAddress>().ForMember(x => x.City, opt => opt.MapFrom(o => o.City2)));
  TAddress address = Mapper.Map<VM_Address, TAddress>(dto);

Conversion de collection

Lors de la conversion entre collections, vous n'avez pas besoin de configurer la liste cible et la liste source Correspondance dans l'objet , et il vous suffit de configurer la relation de correspondance de mappage de votre objet générique.

  TAddress address = new TAddress { Country = "China", City = "Beijing" };
  TAddress address2 = new TAddress() { Country = "USA", City = "New York" };
  List<TAddress> addressList = new List<TAddress>() { address2, address };
  Mapper.Initialize(m => m.CreateMap<TAddress, VM_Address>());//这里仅需配置实体间的转换，而不是实体集合的转换
  List<VM_Address> res = Mapper.Map<List<TAddress>, List<VM_Address>>(addressList);

L'entité contient différents types de conversion d'attributs (ignorer les attributs)

Lorsque l'entité contient différents types d'attributs, tel que TModel1 contient un List et votre ViewModel1 contient un List. À ce stade, vous pouvez choisir d'ignorer cet attribut

 var contacts = new List<TContactInfo>() { new TContactInfo() 
　　　　　　　　　　{ Blog = "myblog", Email = "ws@qq.com" }, new TContactInfo() { Blog = "myblog", Email = "ll@qq.com" } };
  TAuthor author = new TAuthor() { Description = "描述", Name = "吴双", ContactInfo = contacts };
  Mapper.Initialize(m => { m.CreateMap<TAuthor, VM_Author>().ForMember(x => x.ContactInfo, opt => opt.Ignore()); });
　　　　　　　VM_Author dto = Mapper.Map<TAuthor, VM_Author>(author);
//这里的Ignore代表配置ContractInfo该属性的操作 为 忽略Ignore,映射时将忽略该属性 由于List<TContactInfo>()和List<VM_ContactInfo>() 是不同类型，所以需要配置忽略或者是特殊映射，特殊映射例子看下方

<.>L'entité contient différents types de conversion d'attribut (attribut spécifié Mapfrom)

Bien sûr, lorsque vous avez besoin de cet attribut, vous ne pouvez pas l'ignorer, mais utilisez MapFrom pour faire une spécification spéciale, et lorsque le type n'est pas Lorsqu'ils sont identiques, vous devez spécifier la relation de mappage entre vos deux types. Comme dans les exemples ci-dessous

m.CreateMap(); et

m.CreateMap().ForMember(x => x.ContactInfo, opt => ; opt.MapFrom(o => o.ContactInfo));

var contacts = new List<TContactInfo>()
  {
  new TContactInfo() { Blog = "myblog", Email = "ws@qq.com" },
  new TContactInfo() { Blog = "myblog", Email = "ll@qq.com" }
  };
  TAuthor author = new TAuthor() { Description = "描述", Name = "吴双", ContactInfo = contacts };
  Mapper.Initialize(m =>
  {
  m.CreateMap<TContactInfo, VM_ContactInfo>();//注意 内部不同类型实体转换时必要的
  m.CreateMap<TAuthor, VM_Author>().ForMember(x => x.ContactInfo, opt => opt.MapFrom(o => o.ContactInfo));//注意 制定MapFrom是必要的
  });
  VM_Author dto = Mapper.Map<TAuthor, VM_Author>(author);

Écrivez à la fin

Dans la conversion d'entités, vous avez clairement vu la nécessité et le caractère pratique d'AutoMapper.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!