So richten Sie Automapper in ASP.NET Core ein

Ich bin relativ neu bei .NET und habe mich für .NET Core entschieden, anstatt die "alten Methoden" zu lernen. Ich habe hier einen ausführlichen Artikel zum Einrichten von AutoMapper für .NET Core gefunden. Gibt es jedoch eine einfachere Anleitung für Neulinge ?

Ich habe es herausgefunden! Hier sind die Details:

1. Fügen Sie Ihrer Lösung das Haupt-AutoMapper-Paket über NuGet hinzu .

2. Fügen Sie Ihrer Lösung das AutoMapper Dependency Injection Package über NuGet hinzu .

3. Erstellen Sie eine neue Klasse für ein Zuordnungsprofil. (Ich habe eine Klasse im Hauptlösungsverzeichnis namens erstellt MappingProfile.csund den folgenden Code hinzugefügt.) Ich verwende ein Userund UserDto-Objekt als Beispiel.

   public class MappingProfile : Profile {
       public MappingProfile() {
           // Add as many of these lines as you need to map your objects
           CreateMap<User, UserDto>();
           CreateMap<UserDto, User>();
       }
   }

4. Fügen Sie dann die AutoMapperConfiguration Startup.cswie folgt hinzu :

   public void ConfigureServices(IServiceCollection services) {
       // .... Ignore code before this
   
      // Auto Mapper Configurations
       var mappingConfig = new MapperConfiguration(mc =>
       {
           mc.AddProfile(new MappingProfile());
       });
   
       IMapper mapper = mappingConfig.CreateMapper();
       services.AddSingleton(mapper);
   
       services.AddMvc();
   
   }

5. Gehen Sie wie folgt vor, um das zugeordnete Objekt im Code aufzurufen:

   public class UserController : Controller {
   
       // Create a field to store the mapper object
       private readonly IMapper _mapper;
   
       // Assign the object in the constructor for dependency injection
       public UserController(IMapper mapper) {
           _mapper = mapper;
       }
   
       public async Task<IActionResult> Edit(string id) {
   
           // Instantiate source object
           // (Get it from the database or whatever your code calls for)
           var user = await _context.Users
               .SingleOrDefaultAsync(u => u.Id == id);
   
           // Instantiate the mapped data transfer object
           // using the mapper you stored in the private field.
           // The type of the source object is the first type argument
           // and the type of the destination is the second.
           // Pass the source object you just instantiated above
           // as the argument to the _mapper.Map<>() method.
           var model = _mapper.Map<UserDto>(user);
   
           // .... Do whatever you want after that!
       }
   }

Ich hoffe, dies hilft jemandem, neu mit ASP.NET Core zu beginnen! Ich freue mich über Feedback oder Kritik, da ich noch neu in der .NET-Welt bin!

Schritt So verwenden Sie AutoMapper mit ASP.NET Core.

Schritt 1. Installieren von AutoMapper.Extensions.Microsoft.DependencyInjection aus dem NuGet-Paket.

Schritt 2. Erstellen Sie einen Ordner in Lösung, um Zuordnungen mit dem Namen "Zuordnungen" beizubehalten.

Schritt 3. Nach dem Hinzufügen des Mapping-Ordners haben wir eine Klasse mit dem Namen " MappingProfile " hinzugefügt. Dieser Name kann alles Einzigartige und Gute verstehen.

In dieser Klasse werden wir alle Zuordnungen pflegen.

Schritt 4. Initialisierung von Mapper beim Start "ConfigureServices"

In der Startklasse müssen wir das von uns erstellte Profil initialisieren und den AutoMapper-Dienst registrieren.

  Mapper.Initialize(cfg => cfg.AddProfile<MappingProfile>());

  services.AddAutoMapper();

Code-Snippet, um die ConfigureServices-Methode anzuzeigen, bei der AutoMapper initialisiert und registriert werden muss.

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }


    public void ConfigureServices(IServiceCollection services)
    {
        services.Configure<CookiePolicyOptions>(options =>
        {
            // This lambda determines whether user consent for non-essential cookies is needed for a given request.
            options.CheckConsentNeeded = context => true;
            options.MinimumSameSitePolicy = SameSiteMode.None;
        });


        // Start Registering and Initializing AutoMapper

        Mapper.Initialize(cfg => cfg.AddProfile<MappingProfile>());
        services.AddAutoMapper();

        // End Registering and Initializing AutoMapper

        services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);

    }}

Schritt 5. Ausgabe abrufen.

Um das zugeordnete Ergebnis zu erhalten, müssen wir AutoMapper.Mapper.Map aufrufen und das richtige Ziel und die richtige Quelle übergeben.

AutoMapper.Mapper.Map<Destination>(source);

Code-Auszug

    [HttpPost]
    public void Post([FromBody] SchemeMasterViewModel schemeMaster)
    {
        if (ModelState.IsValid)
        {
            var mappedresult = AutoMapper.Mapper.Map<SchemeMaster>(schemeMaster);
        }
    }

Ich möchte die Antworten von @ theutz erweitern - nämlich diese Zeile:

// services.AddAutoMapper(typeof(Startup));  // <-- newer automapper version uses this signature.

Es gibt ( wahrscheinlich ) einen Fehler in AutoMapper.Extensions.Microsoft.DependencyInjection Version 3.2.0. (Ich verwende .NET Core 2.0)

Dies wird in dieser GitHub-Ausgabe behandelt. Wenn Ihre Klassen, die die Profilklasse von AutoMapper erben, außerhalb der Assembly existieren, in der sich Ihre Startup-Klasse befindet, werden sie wahrscheinlich nicht registriert, wenn Ihre AutoMapper-Injektion folgendermaßen aussieht:

services.AddAutoMapper();

es sei denn, Sie geben explizit an, nach welchen Assemblys AutoMapper-Profile durchsucht werden sollen.

Dies kann in Ihrem Startup.ConfigureServices folgendermaßen erfolgen:

services.AddAutoMapper(<assembies> or <type_in_assemblies>);

Dabei verweisen "Assemblys" und "type_in_assemblies" auf die Assembly, in der Profilklassen in Ihrer Anwendung angegeben sind. Z.B:

services.AddAutoMapper(typeof(ProfileInOtherAssembly), typeof(ProfileInYetAnotherAssembly));

Ich nehme an (und ich betone dieses Wort), dass aufgrund der folgenden Implementierung einer parameterlosen Überladung (Quellcode von GitHub ):

public static IServiceCollection AddAutoMapper(this IServiceCollection services)
{
     return services.AddAutoMapper(null, AppDomain.CurrentDomain.GetAssemblies());
}

Wir verlassen uns darauf, dass CLR bereits eine JIT-Assembly hat, die AutoMapper-Profile enthält, die möglicherweise zutreffen oder nicht, da sie nur bei Bedarf angepasst werden (weitere Details in dieser StackOverflow-Frage).

Die Antwort von theutz hier ist sehr gut, ich möchte nur Folgendes hinzufügen:

Wenn Sie Ihr Mapping-Profil von MapperConfigurationExpressionanstatt erben lassen Profile, können Sie ganz einfach einen Test hinzufügen, um Ihr Mapping-Setup zu überprüfen. Dies ist immer praktisch:

[Fact]
public void MappingProfile_VerifyMappings()
{
    var mappingProfile = new MappingProfile();

    var config = new MapperConfiguration(mappingProfile);
    var mapper = new Mapper(config);

    (mapper as IMapper).ConfigurationProvider.AssertConfigurationIsValid();
}

Ich habe es auf diese Weise gelöst (ähnlich wie oben, aber ich denke, es ist eine sauberere Lösung) für .NET Core 2.2 / Automapper 8.1.1 mit Extensions.DI 6.1.1.

Erstellen Sie die MappingProfile.cs-Klasse und füllen Sie den Konstruktor mit Maps (ich plane, eine einzelne Klasse zu verwenden, um alle meine Zuordnungen zu speichern).

    public class MappingProfile : Profile
    {
        public MappingProfile()
        {
            CreateMap<Source, Dest>().ReverseMap();
        }
    }

Fügen Sie in Startup.cs unten hinzu, um DI hinzuzufügen (das Assembly-Argument bezieht sich auf die Klasse, die Ihre Mapping-Konfigurationen enthält, in meinem Fall auf die MappingProfile-Klasse).

//add automapper DI
services.AddAutoMapper(typeof(MappingProfile));

Verwenden Sie es in Controller wie jedes andere DI-Objekt

    [Route("api/[controller]")]
    [ApiController]
    public class AnyController : ControllerBase
    {
        private readonly IMapper _mapper;

        public AnyController(IMapper mapper)
        {
            _mapper = mapper;
        }

        public IActionResult Get(int id)
        {
            var entity = repository.Get(id);
            var dto = _mapper.Map<Dest>(entity);

            return Ok(dto);
        }
    }

In meiner Startup.cs (Core 2.2, Automapper 8.1.1)

services.AddAutoMapper(new Type[] { typeof(DAL.MapperProfile) });            

In meinem Datenzugriffsprojekt

namespace DAL
{
    public class MapperProfile : Profile
    {
        // place holder for AddAutoMapper (to bring in the DAL assembly)
    }
}

In meiner Modelldefinition

namespace DAL.Models
{
    public class PositionProfile : Profile
    {
        public PositionProfile()
        {
            CreateMap<Position, PositionDto_v1>();
        }
    }

    public class Position
    {
        ...
    }

Ich mag viele Antworten, besonders die von @saineshwar. Ich verwende .net Core 3.0 mit AutoMapper 9.0, daher ist es an der Zeit, die Antwort zu aktualisieren.

Was für mich funktioniert hat, war in Startup.ConfigureServices (...), das den Dienst folgendermaßen registriert:

    services.AddAutoMapper(cfg => cfg.AddProfile<MappingProfile>(), 
                               AppDomain.CurrentDomain.GetAssemblies());

Ich denke, dass der Rest der @ Saineshwar-Antwort perfekt bleibt. Aber wenn jemand interessiert ist, ist mein Controller-Code:

[HttpGet("{id}")]
public async Task<ActionResult> GetIic(int id)
{
    // _context is a DB provider
    var Iic = await _context.Find(id).ConfigureAwait(false);

    if (Iic == null)
    {
        return NotFound();
    }

    var map = _mapper.Map<IicVM>(Iic);

    return Ok(map);
}

Und meine Mapping-Klasse:

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Iic, IicVM>()
            .ForMember(dest => dest.DepartmentName, o => o.MapFrom(src => src.Department.Name))
            .ForMember(dest => dest.PortfolioTypeName, o => o.MapFrom(src => src.PortfolioType.Name));
            //.ReverseMap();
    }
}

----- BEARBEITEN -----

Nachdem ich die Dokumente gelesen habe, die in den Kommentaren von Lucian Bargaoanu verlinkt sind, denke ich, dass es besser ist, diese Antwort ein wenig zu ändern.

Die parameterlos services.AddAutoMapper() (mit der Antwort @saineshwar) funktioniert nicht mehr (zumindest für mich). Wenn Sie jedoch die NuGet-Assembly AutoMapper.Extensions.Microsoft.DependencyInjection verwenden, kann das Framework alle Klassen überprüfen, die AutoMapper.Profile erweitern (wie meine, MappingProfile).

In meinem Fall, in dem die Klasse zu derselben ausführenden Assembly gehört, kann die Dienstregistrierung auf verkürzt werden services.AddAutoMapper(System.Reflection.Assembly.GetExecutingAssembly());
(Ein eleganterer Ansatz könnte eine parameterlose Erweiterung mit dieser Codierung sein).

Danke, Lucian!

Ich verwende AutoMapper 6.1.1 und asp.net Core 1.1.2.

Definieren Sie zunächst Profilklassen, die von der Profilklasse von Automapper geerbt wurden. Ich habe eine leere IProfile-Schnittstelle erstellt. Der Zweck besteht nur darin, die Klassen dieses Typs zu finden.

 public class UserProfile : Profile, IProfile
    {
        public UserProfile()
        {
            CreateMap<User, UserModel>();
            CreateMap<UserModel, User>();
        }
    }

Erstellen Sie nun eine separate Klasse, z. B. Zuordnungen

 public class Mappings
    {
     public static void RegisterMappings()
     {            
       var all =
       Assembly
          .GetEntryAssembly()
          .GetReferencedAssemblies()
          .Select(Assembly.Load)
          .SelectMany(x => x.DefinedTypes)
          .Where(type => typeof(IProfile).GetTypeInfo().IsAssignableFrom(type.AsType()));

            foreach (var ti in all)
            {
                var t = ti.AsType();
                if (t.Equals(typeof(IProfile)))
                {
                    Mapper.Initialize(cfg =>
                    {
                        cfg.AddProfiles(t); // Initialise each Profile classe
                    });
                }
            }         
        }

    }

Rufen Sie jetzt im MVC Core-Webprojekt in der Datei Startup.cs im Konstruktor die Mapping-Klasse auf, die alle Zuordnungen zum Zeitpunkt des Ladens der Anwendung initialisiert.

Mappings.RegisterMappings();

Wenn Sie für ASP.NET Core (getestet mit 2.0+ und 3.0) lieber die Quelldokumentation lesen möchten: https://github.com/AutoMapper/AutoMapper.Extensions.Microsoft.DependencyInjection/blob/master/README.md

Andernfalls funktionieren die folgenden 4 Schritte:

1. Installieren Sie AutoMapper.Extensions.Microsoft.DependancyInjection von Nuget.

2. Fügen Sie einfach einige Profilklassen hinzu.

3. Fügen Sie dann unten Ihre Startup.cs-Klasse hinzu. services.AddAutoMapper(OneOfYourProfileClassNamesHere)

4. Dann injizieren Sie einfach IMapper in Ihre Controller oder wo immer Sie ihn brauchen:

public class EmployeesController {

    private readonly IMapper _mapper;

    public EmployeesController(IMapper mapper){

        _mapper = mapper;
    }

Und wenn Sie ProjectTo jetzt verwenden möchten, ist es einfach:

var customers = await dbContext.Customers.ProjectTo<CustomerDto>(_mapper.ConfigurationProvider).ToListAsync()

Für AutoMapper 9.0.0:

public static IEnumerable<Type> GetAutoMapperProfilesFromAllAssemblies()
    {
        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            foreach (var aType in assembly.GetTypes())
            {
                if (aType.IsClass && !aType.IsAbstract && aType.IsSubclassOf(typeof(Profile)))
                    yield return aType;
            }
        }
    }

MapperProfile:

public class OrganizationProfile : Profile
{
  public OrganizationProfile()
  {
    CreateMap<Foo, FooDto>();
    // Use CreateMap... Etc.. here (Profile methods are the same as configuration methods)
  }
}

In Ihrem Startup:

services.AddAutoMapper(GetAutoMapperProfilesFromAllAssemblies()
            .ToArray());

In Controller oder Service: Inject Mapper:

private readonly IMapper _mapper;

Verwendung:

var obj = _mapper.Map<TDest>(sourceObject);

In den neuesten Versionen von asp.net core sollten Sie die folgende Initialisierung verwenden:

services.AddAutoMapper(typeof(YourMappingProfileClass));

Asp.Net Core 2.2 mit AutoMapper.Extensions.Microsoft.DependencyInjection.

public class MappingProfile : Profile
{
  public MappingProfile()
  {
      CreateMap<Domain, DomainDto>();
  }
}

In Startup.cs

services.AddAutoMapper(typeof(List.Handler));

Hinzufügen zu dem, was Arve Systad zum Testen erwähnt hat. Wenn Sie aus irgendeinem Grund wie ich sind und die in der Zutz-Lösung bereitgestellte Vererbungsstruktur beibehalten möchten, können Sie die MapperConfiguration folgendermaßen einrichten:

var mappingProfile = new MappingProfile();
var config = new MapperConfiguration(cfg =>
{
    cfg.AddProfile(mappingProfile);
});
var mapper = new Mapper(config);

Ich habe das in NUnit gemacht.

services.AddAutoMapper (); hat bei mir nicht funktioniert. (Ich verwende Asp.Net Core 2.0)

Nach der Konfiguration wie unten

   var config = new AutoMapper.MapperConfiguration(cfg =>
   {                 
       cfg.CreateMap<ClientCustomer, Models.Customer>();
   });

Mapper initialisieren IMapper mapper = config.CreateMapper ();

und fügen Sie das Mapper-Objekt als Singleton-Dienste zu Diensten hinzu.AddSingleton (Mapper);

Auf diese Weise kann ich dem Controller einen DI hinzufügen

  private IMapper autoMapper = null;

  public VerifyController(IMapper mapper)
  {              
   autoMapper = mapper;  
  }

und ich habe wie folgt in meinen Aktionsmethoden verwendet

  ClientCustomer customerObj = autoMapper.Map<ClientCustomer>(customer);

Über die Antwort von theutz muss der IMapper-Mapper- Parrameter nicht im Controller-Konstruktor angegeben werden.

Sie können den Mapper verwenden, da er an jeder Stelle des Codes ein statisches Element ist.

public class UserController : Controller {
   public someMethod()
   {
      Mapper.Map<User, UserDto>(user);
   }
}