Onion Architecture- Entity Framework Code First Models DataAnnotations

Question

I am developing a ASP.NET MVC Project following the Onion Architecture. I have added the Models inside my Core Project and these Models will be referred as the POCO classes for the Entity Framework Models in the Infrastructure Project.

My question is how can I add Data Annotations Which depends on the Entity Framework?

Can I make the Core Models as Interfaces and inherit it in the Infrastructure Projects and do real Implementation?

Answer 1

You don't need to create Core Models as Interfaces if you switch from Data Annotations the Fluent API.

Here's an example.

The Entity1 object is a core layer domain object:

namespace MyApp.Core.Model
{
  public class Entity1
  {
    public short Id { get; set; }
    public string ExternalCode { get; set; }
    public byte Status { get; set; }
  }
}

In the infrastructure layer, create an Entity1Mapping class where you'll do what you'd have done using Data Annotation, but this time, with the Fluent API instead:

using System.Data.Entity.ModelConfiguration;

namespace MyApp.Infrasrtucture.Data.Configuration
{
  internal class Entity1Mapping : EntityTypeConfiguration<Core.Model.Entity1>
  {
     internal Entity1Mapping()
     {
       HasKey(g => g.Id);
       Property(g => g.Id).IsRequired();

       Property(g => g.ExternalCode)
           .IsRequired()
           .HasMaxLength(100)
           .IsVariableLength()
           .IsUnicode(false);

       Property(g => g.Status).HasColumnName("EntityStatus").IsRequired();
     }
  }
}

Last thing you have to do, is adding the mapping in the modelBuilder of your context:

using System.Data.Entity;

namespace MyApp.Infrastructure.Data
{
  public class MyContext : DbContext, IDbContext
  {
    public MyContext() : base("ConnectionStringMyContext")
    { }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
      Database.SetInitializer<MyContext>(null);
      modelBuilder.Configurations.Add(new Configuration.Entity1Mapping());
    }
  }
}

This is the IDBContext just in case:

public interface IDbContext
{
  DbSet<T> Set<T>() where T : class;
  DbEntityEntry<T> Entry<T>(T entity) where T : class;
  int SaveChanges();
  void Dispose();
}

Answer 2

Using FluentAPI is a good a solution in my opinion.

It is worth noting though that System.Component.DataAnnotations does not rely on EntityFramework - so you can use DataAnnotations in your core project and still be agnostic on your particular persistance mechanism.