Repository pattern infrastructure (with FrameLog auditing).

ApplicationContext.cs

namespace Demo.Repository.Infrastructure
{
    public class ApplicationContext : DbContext
    {
        public readonly FrameLogModule<ChangeSet, Person> Logger;

        public ApplicationContext() : base("name=Demo")
        {
            Configuration.ProxyCreationEnabled = false;
            Database.Initialize(true);
            this.Logger = new FrameLogModule<ChangeSet, Person>(new ChangeSetFactory(), this.FrameLogContext);
        }

        public IDbSet<Country> Countries { get; set; }

        public IDbSet<Issue> Issues { get; set; }

        #region logging

        public DbSet<ChangeSet> ChangeSets { get; set; }

        public IFrameLogContext<ChangeSet, Person> FrameLogContext
        {
            get { return new FrameLogContextAdapter(this); }
        }

        public HistoryExplorer<ChangeSet, Person> HistoryExplorer
        {
            get { return new HistoryExplorer<ChangeSet, Person>(this.FrameLogContext); }
        }

        public DbSet<ObjectChange> ObjectChanges { get; set; }

        public DbSet<PropertyChange> PropertyChanges { get; set; }

        public int Save(Person author)
        {
            return this.Logger.SaveChanges(author, SaveOptions.AcceptAllChangesAfterSave);
        }

        #endregion

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<Issue>()
                .HasMany(x => x.AdditionalCountries)
                .WithMany(x => x.Issues)
                .Map(x =>
                    {
                        x.ToTable("CountriesIssues");
                        x.MapLeftKey("Issue_Id");
                        x.MapRightKey("Country_Code");
                    });

            modelBuilder.Entity<Issue>()
                        .Property(p => p.LogDate)
                        .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Computed);
        }
    }
}

ContextFactory.cs

namespace Demo.Repository.Infrastructure
{
    public class ContextFactory : IContextFactory
    {
        private ApplicationContext context;

        public ApplicationContext Get()
        {
            return this.context ?? (this.context = new ApplicationContext());
        }

        public void Dispose()
        {
            if (this.context != null)
            {
                this.context.Dispose();
            }
        }
    }
}

FrameLogContextAdapter.cs

namespace Demo.Repository.Infrastructure
{
    public class FrameLogContextAdapter : DbContextAdapter<ChangeSet, Person>
    {
        private readonly ApplicationContext context;

        public FrameLogContextAdapter(ApplicationContext context) : base(context)
        {
            this.context = context;
        }

        public override IQueryable<IChangeSet<Person>> ChangeSets
        {
            get { return this.context.ChangeSets; }
        }

        public override IQueryable<IObjectChange<Person>> ObjectChanges
        {
            get { return this.context.ObjectChanges; }
        }

        public override IQueryable<IPropertyChange<Person>> PropertyChanges
        {
            get { return this.context.PropertyChanges; }
        }

        public override Type UnderlyingContextType
        {
            get { return typeof(ApplicationContext); }
        }

        public override void AddChangeSet(ChangeSet changeSet)
        {
            this.context.ChangeSets.Add(changeSet);
        }
    }
}

GenericRepository.cs

namespace Demo.Repository.Infrastructure
{
    public class GenericRepository<T> : RepositoryBase where T : class
    {
        private readonly ApplicationContext context;

        public GenericRepository(IUnitOfWork unitOfWork) : base(unitOfWork)
        {
            this.context = this.UnitOfWork.ApplicationContext;
            this.DataSet = this.context.Set<T>();
        }

        protected IDbSet<T> DataSet { get; private set; }

        public void Add(T entity)
        {
            this.DataSet.Attach(entity);
            this.context.Entry(entity).State = EntityState.Added;
        }

        public void Update(T entity)
        {
            this.DataSet.Attach(entity);
            this.context.Entry(entity).State = EntityState.Modified;
        }
    }
}

RepositoryBase.cs

namespace Demo.Repository.Infrastructure
{
    public class RepositoryBase
    {
        public RepositoryBase(IUnitOfWork unitOfWork)
        {
            if (unitOfWork == null)
            {
                throw new ArgumentNullException("unitOfWork");
            }

            this.UnitOfWork = unitOfWork;
        }

        protected IUnitOfWork UnitOfWork { get; private set; }
    }
}

UnitOfWork.cs

namespace Demo.Repository.Infrastructure
{
    public class UnitOfWork : IUnitOfWork
    {
        private ApplicationContext applicationContext;

        public UnitOfWork(IContextFactory contextFactory)
        {
            this.ContextFactory = contextFactory;
        }

        public ApplicationContext ApplicationContext
        {
            get { return this.applicationContext ?? (this.applicationContext = this.ContextFactory.Get()); }
        }

        private IContextFactory ContextFactory { get; set; }

        public int Commit()
        {
            return this.ApplicationContext.SaveChanges();
        }
        
        /// <summary>
        /// Audit the change.
        /// </summary>
        /// <param name="user">The author of the change.</param>
        /// <returns>Result of SaveChanges().</returns>
        public int Commit(Person user)
        {
            return this.ApplicationContext.Save(user);
        }

        public void Rollback()
        {
            this.ApplicationContext.Dispose();
        }
    }
}