Hvordan jobbe med AutoMapper i C #

AutoMapper er et populært kart-til-objekt kartleggingsbibliotek som kan brukes til å kartlegge objekter som tilhører forskjellige typer. Som et eksempel kan det hende du må kartlegge DTO-ene (Data Transfer Objects) i applikasjonen din til modellobjektene. AutoMapper sparer deg for den kjedelige innsatsen å måtte kartlegge en eller flere egenskaper manuelt av slike inkompatible typer.

For å begynne å jobbe med AutoMapper, bør du opprette et prosjekt i Visual Studio og deretter installere AutoMapper. Du kan installere AutoMapper fra NuGet ved å bruke følgende kommando i vinduet NuGet Package Manager:

PM> Installer-pakke AutoMapper

Lag kartlegginger ved hjelp av AutoMapper

En objekt-til-objekt-kartlegger som AutoMapper konverterer et inngangsobjekt av en type til et utgangsobjekt av en annen type. Tenk på følgende to klasser.

 offentlig klasse AuthorModel
    {
  offentlig int Id
        {
  få; sett;
        }
  offentlig streng Fornavn
        {
  klar;
        }
  offentlig streng Etternavn
        {
  få; sett;
        }
  offentlig streng Adresse
        {
  få; sett;
        }
    }
 offentlig klasse AuthorDTO
    {
  offentlig int Id
        {
  få; sett;
        }
  offentlig streng Fornavn
        {
  få; sett;
        }
  offentlig streng Etternavn
        {
  få; sett;
        }
  offentlig streng Adresse
        {
  få; sett;
        }
    }

Følgende kodebit viser hvordan du kan lage et kart mellom disse to typene, AuthorModel og AuthorDTO.

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

For å utføre kartleggingen mellom typene er så enkelt som følgende kode viser.

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

Et eksempel på AutoMapper

La oss nå jobbe med noen data. Henvis til følgende kode som lagrer noen data i kildeobjektet og deretter viser eiendomsverdiene i destinasjonsobjektet etter at kartleggingen er gjort.

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

Når du utfører kodestykket ovenfor, vises forfatternavnet som er lagret i destinasjonsobjektet. Verdiene til destinasjonen FirstName og destinations LastName-egenskapene vil imidlertid være de samme som kildeobjektet fordi du har kartlagt objektene med hell ved hjelp av AutoMapper!

Merk at AutoMapper kan kartlegge ethvert sett med klasser. Imidlertid følger AutoMapper visse konvensjoner, hvorav den ene er at eiendomsnavnene som blir kartlagt skal ha identiske navn. Hvis eiendomsnavnene ikke er identiske, må du fortelle AutoMapper hvordan egenskapene skal kartlegges. Forutsatt at vi ønsker å kartlegge de to egenskapene Contact og ContactDetails, illustrerer følgende eksempel hvordan dette kan oppnås.

var config = new MapperConfiguration (cfg => {
  cfg.CreateMap ()
  .ForMember (destinasjon => destinasjon. Kontaktdetaljer,
  opts => opts.MapFrom (source => source.Contact));
            });

Legg merke til følgende utsagn som brukes til å opprette målobjektet.

var destinasjon = iMapper.Map (kilde);

Hvis destinasjonsobjektet allerede eksisterer, kan du bruke utsagnet nedenfor i stedet.

iMapper.Map (sourceObject, destinationObject);

I hovedsak kan kodebiten ovenfor brukes til å kartlegge to objekter som allerede eksisterer.

Bruke projeksjoner i AutoMapper

AutoMapper gir utmerket støtte for projeksjoner. Projeksjoner brukes til å kartlegge kildeverdier til et mål som ikke samsvarer med kildestrukturen. (Derimot var kartleggingen vi diskuterte ovenfor en en-til-en-kartlegging.)

La oss nå se på en projeksjon. Tenk for eksempel på følgende klasse.

 offentlig klasse Adresse
    {
  offentlig streng By {get; sett; }
  public string State {get; sett; }
  offentlig streng Land {get; sett; }
    }

La oss få AuthorModel-klassen vår til å bruke adresseklassen til å lagre adresseinformasjonen til forfatterne. Slik ser den oppdaterte AuthorModel-klassen ut.

 offentlig klasse AuthorModel
    {
  offentlig int Id
        {
  få; sett;
        }
  offentlig streng Fornavn
        {
  klar;
        }
  offentlig streng Etternavn
        {
  få; sett;
        }
  offentlig adresse
        {
  få; sett;
        }
    }

Og her er den oppdaterte AuthorDTO-klassen.

offentlig klasse AuthorDTO
    {
  offentlig int Id
        {
  få; sett;
        }
  offentlig streng Fornavn
        {
  få; sett;
        }
  offentlig streng Etternavn
        {
  få; sett;
        }
  offentlig streng By {get; sett; }
  public string State {get; sett; }
  offentlig streng Land {get; sett; }
    }

Anta at vi må kartlegge klasser for AuthorDTO og AuthorModel. Følgende kodebit illustrerer hvordan dette kan oppnås.

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

Jeg vil diskutere de mer avanserte funksjonene til AutoMapper i et fremtidig innlegg her. Inntil da kan du lære mer om AutoMapper på denne lenken.