Mit DTO zur übertragung von Daten zwischen service layer und UI-Schicht

Ihren Dienst erhalten sollten, DTOs, Zuordnung zu Geschäftseinheiten und senden Sie diese an das repository. Es sollte auch das abrufen von business-Entitäten aus dem repository anzeigen Sie DTOs und die Rückgabe der DTOs als reponses. So Ihr business-Entitäten, die nie aus der business-Schicht, nur die DTOs tun.

Dann Ihre UI\Weblayer sollte bewusst sein, das Unternehmen. Die web-Schicht sollte nur wissen über die DTOs. Zur Durchsetzung dieser Regel ist sehr wichtig, dass auf der UI-Ebene nicht verwendet die service-Implementierung Klassen (privat), nur die Schnittstellen. Und die service-Schnittstellen sollte nicht davon abhängen, die business-Einrichtungen, nur die DTOs.

Also müssen Sie service-Schnittstellen basiert auf DTOs, und Ihre Basis-service-Klasse muss ein weiteres generisches argument für die DTO. Ich mag, um eine Basis-Klasse für die Personen und die DTOs, so dass Sie können deklariert werden als:

//Your UI\presentation layer will work with the interfaces (The inheriting ones) 
//so it is very important that there is no dependency
//on the business entities in the interface, just on the DTOs!
protected interface IRepoService<TDto> 
    where TDto: DTOBase
{
    //I'm just adding a couple of methods  but you get the idea
    TDto GetByID(object id);
    void Update(TDto entityToUpdateDto)
}

//This is the interface that will be used by your UI layer
public IImageService: IRepoService<ImageDTO>
{
}

//This class and the ones inheriting should never be used by your 
//presentation\UI layer because they depend on the business entities!
//(And it is a best practice to depend on interfaces, anyway)
protected abstract class RepoService<TEntity, TDto> : IRepoService<TDto> 
    where TEntity : EntityBase
    where TDto: DTOBase
{
    ... 
}

//This class should never be used by your service layer. 
//Your UI layer should always use IImageService
//You could have a different namespace like Service.Implementation and make sure
//it is not included by your UI layer
public class ImageService : RepoService<ImageModel, ImageDto>, IImageService
{
    ...
}

Müssen Sie dann einen Weg der addition der Zuordnung zwischen Entitäten und DTO an, dass Basis-service ohne tatsächlich die Implementierung der Zuordnung (wie es hängt von jeder konkreten Person und DTO-Klassen). Sie könnte erklären, abstrakten Methoden, die die Zuordnung durchzuführen und müssen implementiert werden, die auf jeden spezifischen Dienst (wie ImageService). Die Durchführung des Basis-RepoService würde wie folgt Aussehen:

public TDto GetByID(object id)
{
    //I'm writing it this way so its clear what the method is doing
    var entity = repo.GetByID(id);
    var dto = this.EntityToDto(entity);
    return dto;
}

public void Update(TDto entityToUpdateDto)
{
    var entity = this.DtoToEntity(entityToUpdateDto)
    repo.Update(entity);
}

//These methods will need to be implemented by every service like ImageService
protected abstract TEntity DtoToEntity(TDto dto);
protected abstract TDto EntityToDto(TEntity entity);

Oder Sie könnten erklären, mapping services, das hinzufügen einer Abhängigkeit mit einem appropiated mapping-Dienst bereitgestellt werden sollten, von Ihren IOC (Das macht mehr Sinn, wenn Sie brauchen die gleiche Zuordnung auf verschiedene Dienste). Die Umsetzung der RepoService würde wie folgt Aussehen:

private IRepository<TEntity> _repo;
private IDtoMappingService<TEntity, TDto> _mappingService;

public RepoService(IUnitOfWork repo, IDtoMappingService<TEntity, TDto> mapping)
{
    _repo = repo.GetRepository<TEntity>();
    _mappingService = mapping;
}

public TDto GetByID(object id)
{
    //I'm writing it this way so its clear what the method is doing
    var entity = repo.GetByID(id);
    var dto = _mappingService.EntityToDto(entity);
    return dto;
}

public void Update(TDto entityToUpdateDto)
{
    var entity = _mappingService.DtoToEntity(entityToUpdateDto)
    repo.Update(entity);
}

//You will need to create implementations of this interface for each 
//TEntity-TDto combination
//Then include them in your dependency injection configuration
public interface IDtoMappingService<TEntity, TDto>
    where TEntity : EntityBase
    where TDto: DTOBase
{
    public TEntity DtoToEntity(TDto dto);
    public TDto EntityToDto(TEntity entity);
}

In beiden Fällen (abstract-Methoden oder-mapping-services) implementieren Sie die Zuordnung zwischen den Entitäten und DTOs manuell oder mit einem tool wie Automapper. Aber Sie sollten sehr vorsichtig sein bei der Verwendung der AutoMapper und entity framework, aber das ist ein anderes Thema! (Google ein bisschen über, und sammeln Sie einige Informationen zum Thema. Als erste Rat, achten Sie auf die Abfragen werden auf der Datenbank ausgeführt, wenn das laden von Daten, so dass Sie nicht laden Sie es mehr als notwendig, oder senden viele Anfragen. Beim speichern von Daten darauf achten, Ihre Sammlungen und Beziehungen)

Lange post vielleicht, aber ich hoffe, es hilft!

InformationsquelleAutor Daniel J.G.