CODEWITHSUNDEEP
c#architecture
Bruno V
Bruno V

Reputation: 1731

Mixed architecural approach between layered or shared entities

We are developing an application with the following layers:

We are looking for a way to share the entities of the physical data layer to the DL and the BL.

These points are important in deciding the best architecure:

I've come across architectures that share entities for all layers (+ fast implementation, - extensibility) or architectures with an entity (DTO) per layer (+ extensibility, - fast implementation/reusability). This blogpost describes these two architectures.

Is there an approach that combines these architectures and takes our requirements into account?

For now we've come up with the following classes and interfaces:

Interfaces:

// Contains properties shared for all entities
public interface I_DL
{
    bool Active { get; set; }
}

// Contains properties specific for a customer
public interface I_DL_Customer : I_DL
{
    string Name { get; set; }
}

PDL

// Generated by EF or mocking object
public partial class Customer
{
    public bool Active { get; set; }
    public string Name { get; set; }
}

DL

// Extend the generated entity with custom behaviour
public partial class Customer : I_DL_Customer
{

}

BL

// Store a reference to the DL entity and define the properties shared for all entities
public abstract class BL_Entity<T> where T : I_DL
{
    private T _entity;

    public BL_Entity(T entity)
    {
        _entity = entity;
    }

    protected T entity
    {
        get { return _entity; }
        set { _entity = value; }
    }

    public bool Active
    {
        get
        {
            return entity.Active;
        }
        set
        {
            entity.Active = value;
        }
    }

}

// The BL customer maps directly to the DL customer
public class BL_Customer : BL_Entity<I_DL_Customer>
{
    public BL_Customer (I_DL_Customer o) : base(o) { }

    public string Name
    {
        get
        {
            return entity.Name;
        }
        set
        {
            entity.Name = value;
        }
    }
}

Upvotes: 1

Views: 144

Answers (1)

jnovo
jnovo

Reputation: 5789

The DTO-per-layer design is the most flexible and modular. Hence, it is also the most reusable: don't confuse the convenience of reusing the same entities with the reusability of the different modules which is the main concern at the architectural level. However, as you pointed out, this approach is neither the fastest to develop nor the most agile if your entities change often.

If you want to share entities among the layers I wouldn't go through the hassle of specifying a hierarchy through the different layers; I'd either let all layers use the EF entities directly, or define those entities in a different assembly shared by all the layers -- the physical data layer included, which may directly persist those entities through EF code-first, or translate to/from those shared entities to the EF ones.

Upvotes: 2

Related Questions