Meine Repositorys behandeln und bieten Persistenz für ein reichhaltiges Domänenmodell. Ich möchte die anämische Entity Framework-Datenentität nicht für meine Geschäftsebenen verfügbar machen, daher benötige ich eine Art der Zuordnung zwischen ihnen.

In den meisten Fällen erfordert das Erstellen einer Domänenmodellinstanz aus einer Datenentität die Verwendung parametrisierter Konstruktoren und Methoden (da diese reichhaltig sind). Es ist nicht so einfach wie eine Eigenschafts- / Feldübereinstimmung. AutoMapper kann für die umgekehrte Situation verwendet werden (Zuordnung zu Datenentitäten), jedoch nicht beim Erstellen von Domänenmodellen.

Unten ist der Kern meines Repository-Musters.

DasEntityFrameworkRepository Klasse arbeitet mit zwei generischen Typen:

TDomainModel: Das Rich Domain-ModellTEntityModel: Die Entity Framework-Datenentität

Zwei abstrakte Methoden sind definiert:

ToDataEntity(TDomainModel): In Dateneinheiten konvertieren (zAdd() undUpdate() Methoden)ToDomainModel(TEntityModel): Domänenmodelle erstellen (für dieFind() Methode).

Konkrete Implementierungen dieser Methoden würden das für das betreffende Repository erforderliche Mapping definieren.

public interface IRepository<T> where T : DomainModel
{
    T Find(int id);
    void Add(T item);
    void Update(T item);
}

public abstract class EntityFrameworkRepository<TDomainModel, TEntityModel> : IRepository<TDomainModel>
    where TDomainModel : DomainModel
    where TEntityModel : EntityModel
{
    public EntityFrameworkRepository(IUnitOfWork unitOfWork)
    {
        // ...
    }

    public virtual TDomainModel Find(int id)
    {
        var entity = context.Set<TEntityModel>().Find(id);

        return ToDomainModel(entity);
    }

    public virtual void Add(TDomainModel item)
    {
        context.Set<TEntityModel>().Add(ToDataEntity(item));
    }

    public virtual void Update(TDomainModel item)
    {
        var entity = ToDataEntity(item);

        DbEntityEntry dbEntityEntry = context.Entry<TEntityModel>(entity);

        if (dbEntityEntry.State == EntityState.Detached)
        {
            context.Set<TEntityModel>().Attach(entity);

            dbEntityEntry.State = EntityState.Modified;
        }
    }

    protected abstract TEntityModel ToDataEntity(TDomainModel domainModel);
    protected abstract TDomainModel ToDomainModel(TEntityModel dataEntity);
}

Hier ist ein grundlegendes Beispiel für eine Repository-Implementierung:

public interface ICompanyRepository : IRepository<Company>
{
    // Any specific methods could be included here
}

public class CompanyRepository : EntityFrameworkRepository<Company, CompanyTableEntity>, ICompanyRepository
{
    protected CompanyTableEntity ToDataEntity(Company domainModel)
    {
        return new CompanyTable()
        {
            Name = domainModel.Name,
            City = domainModel.City
            IsActive = domainModel.IsActive
        };
    }

    protected Company ToDomainModel(CompanyTableEntity dataEntity) 
    {
        return new Company(dataEntity.Name, dataEntity.IsActive)
        {
            City = dataEntity.City
        }
    }
}

Problem:

A Company könnte aus vielen zusammengesetzt seinDepartments. Wenn ich diese eifrig aus dem Internet laden möchteCompanyRepository beim Abholen einesCompany Wo würde ich dann das Mapping zwischen aDepartment und einDepartmentDataEntity?

Ich könnte mehr Abbildungsmethoden im Internet anbietenCompanyRepository, aber das wird bald chaotisch. Bald würde es systemweit doppelte Zuordnungsmethoden geben.

Was ist ein besserer Ansatz für das oben genannte Problem?