Sådan arbejder du med AutoMapper i C #

AutoMapper er et populært objekt-til-objekt kortlægningsbibliotek, der kan bruges til at kortlægge objekter, der tilhører forskellige typer. Som et eksempel skal du muligvis kortlægge DTO'erne (Data Transfer Objects) i din applikation til modelobjekterne. AutoMapper sparer dig for den kedelige indsats at skulle manuelt kortlægge en eller flere egenskaber af sådanne inkompatible typer.

For at begynde at arbejde med AutoMapper skal du oprette et projekt i Visual Studio og derefter installere AutoMapper. Du kan installere AutoMapper fra NuGet ved hjælp af følgende kommando i NuGet Package Manager-konsolvinduet:

PM> Installer-pakke AutoMapper

Opret tilknytninger ved hjælp af AutoMapper

En objekt-til-objekt-kortlægger, såsom AutoMapper, konverterer et inputobjekt af en type til et outputobjekt af en anden type. Overvej følgende to klasser.

 offentlig klasse AuthorModel
    {
  offentlig int Id
        {
  få; sæt;
        }
  offentlig streng Fornavn
        {
  få; sæt;
        }
  offentlig streng Efternavn
        {
  få; sæt;
        }
  public string Adresse
        {
  få; sæt;
        }
    }
 offentlig klasse AuthorDTO
    {
  offentlig int Id
        {
  få; sæt;
        }
  offentlig streng Fornavn
        {
  få; sæt;
        }
  offentlig streng Efternavn
        {
  få; sæt;
        }
  public string Adresse
        {
  få; sæt;
        }
    }

Følgende kodestykke viser, hvordan du kan oprette et kort mellem disse to typer, AuthorModel og AuthorDTO.

var config = ny MapperConfiguration (cfg => {
  cfg.CreateMap ();
            });

Derefter er det så simpelt at udføre kortlægningen mellem typerne som det følgende stykke kode viser.

IMapper iMapper = config.CreateMapper ();
var kilde = ny AuthorModel ();
var destination = iMapper.Map (kilde);

Et eksempel på AutoMapper

Lad os nu arbejde med nogle data. Henvis til det følgende stykke kode, der gemmer nogle data i kildeobjektet og derefter viser egenskabsværdierne i destinationsobjektet, når kortlægningen er udført.

var config = ny MapperConfiguration (cfg => {
  cfg.CreateMap ();
            });
IMapper iMapper = config.CreateMapper ();
var kilde = ny AuthorModel ();
source.Id = 1;
source.FirstName = "Joydip";
source.LastName = "Kanjilal";
source.Address = "Indien";
var destination = iMapper.Map (kilde);
Console.WriteLine ("Forfatternavn:" + destination.Førstnavn + "" + destination.LastName);

Når du udfører ovenstående stykke kode, vises forfatternavnet, der er gemt inde i destinationsobjektet. Værdierne for egenskaberne destination FirstName og destination LastName vil være de samme som kildeobjektet, fordi du har kortlagt objekterne med succes ved hjælp af AutoMapper!

Bemærk, at AutoMapper kan kortlægge ethvert sæt klasser. AutoMapper følger dog visse konventioner, hvoraf den ene er, at de ejendomsnavne, der kortlægges, skal have identiske navne. Hvis ejendomsnavne ikke er identiske, skal du lade AutoMapper vide, hvordan egenskaberne skal kortlægges. Forudsat at vi vil kortlægge de to egenskaber Contact og ContactDetails, illustrerer følgende eksempel, hvordan dette kan opnås.

var config = ny MapperConfiguration (cfg => {
  cfg.CreateMap ()
  .ForMember (destination => destination.ContactDetails,
  opts => opts.MapFrom (source => source.Contact));
            });

Bemærk følgende udsagn, der bruges til at oprette destinationsobjektet.

var destination = iMapper.Map (kilde);

Hvis destinationsobjektet allerede findes, kan du i stedet bruge udsagnet nedenfor.

iMapper.Map (sourceObject, destinationObject);

I det væsentlige kan ovenstående kodestykke bruges til at kortlægge to objekter, der allerede findes.

Brug af fremskrivninger i AutoMapper

AutoMapper giver fremragende understøttelse af fremskrivninger. Fremskrivninger bruges til at kortlægge kildeværdier til en destination, der ikke matcher kildens struktur. (I modsætning hertil var den kortlægning, vi diskuterede ovenfor, en en-til-en-kortlægning.)

Lad os nu se på en projektion. Overvej f.eks. Følgende klasse.

 offentlig klasse Adresse
    {
  offentlig streng By {get; sæt; }
  public string State {get; sæt; }
  public string Country {get; sæt; }
    }

Lad os få vores AuthorModel-klasse til at bruge adresseklassen til at gemme adresseoplysninger om forfatterne. Her er, hvordan den opdaterede AuthorModel-klasse vil se ud.

 offentlig klasse AuthorModel
    {
  offentlig int Id
        {
  få; sæt;
        }
  offentlig streng Fornavn
        {
  få; sæt;
        }
  offentlig streng Efternavn
        {
  få; sæt;
        }
  offentlig adresse
        {
  få; sæt;
        }
    }

Og her er den opdaterede AuthorDTO-klasse.

offentlig klasse AuthorDTO
    {
  offentlig int Id
        {
  få; sæt;
        }
  offentlig streng Fornavn
        {
  få; sæt;
        }
  offentlig streng Efternavn
        {
  få; sæt;
        }
  offentlig streng By {get; sæt; }
  public string State {get; sæt; }
  public string Country {get; sæt; }
    }

Antag nu, at vi skal kortlægge AuthorDTO- og AuthorModel-klasser. Følgende kodestykke illustrerer, hvordan dette kan opnås.

var config = ny MapperConfiguration (cfg => {
  cfg.CreateMap ()
  .ForMember (destination => destination. Adresse,
  map => map.MapFrom (
  kilde => ny adresse
                  {
  By = kilde. By,
  Stat = kilde. Stat,
  Land = kilde. Land
                  }));

Jeg vil diskutere de mere avancerede funktioner i AutoMapper i et fremtidigt indlæg her. Indtil da kan du lære mere om AutoMapper på dette link.