Présentation de l'utilisation d'AutoMapper dans le MOO

Cet article présente principalement les connaissances pertinentes du framework OOM AutoMapper. 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 un oeil avec l'éditeur ci-dessous

est écrit devant

MOO, comme son nom l'indique, entités Object-Object-Mapping sont convertis les uns aux autres, AutoMapper C'est aussi un cliché. Sa signification est de vous aider à convertir des relations simples et gênantes entre les entités sans travail manuel, comme la conversion entre ViewModel et Entity, et la conversion entre SearchModel et Entity. Mon partage est que la plupart des partages sur Internet datent d'il y a quelques années et que de nombreuses méthodes ont été abandonnées. Lorsque vous l'obtiendrez, le compilateur vous dira que la méthode est obsolète, abandonnée et son utilisation n'est pas recommandée. telles que Mapper.CreateMap et d'autres méthodes. Bien sûr, les pilotes les plus expérimentés accèdent directement à github pour lire la documentation ou vous pouvez simplement la rechercher sur Google pour le savoir, mais les informations chinoises n'ont aucune explication sur la méthode après son apparition. abandonné. 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é, en AttributSi les noms de champs correspondent exactement, il vous suffit de préciser les règles de conversion entre les deux entités, de préciser 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, veuillez faire 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 du champ que je choisis. La méthode MapFrom qu'elle fournit consiste à indiquer à 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);

Définir la conversion

Lors de la conversion entre collections, vous n'avez pas besoin de configurer la correspondance entre la liste cible et la liste sourceobjet 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 (en ignorant les attributs)

Lorsque l'entité contient différents types d'attributs, par exemple, TModel1 contient une liste< ;TModel> 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 des désignations spéciales. Et lorsque les types sont différents, 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);

[Recommandations associées]

1 Tutoriel vidéo gratuit ASP

2. Tutoriel ASP

3 Tutoriel vidéo de base de Li Yanhui

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!