Add project files.

Diligent.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29102.190
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Diligent", "Diligent\Diligent.csproj", "{59BF46E0-F78D-44B4-A8FF-0F58B896EC51}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{59BF46E0-F78D-44B4-A8FF-0F58B896EC51}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{59BF46E0-F78D-44B4-A8FF-0F58B896EC51}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{59BF46E0-F78D-44B4-A8FF-0F58B896EC51}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{59BF46E0-F78D-44B4-A8FF-0F58B896EC51}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {FADD0868-3EDB-4F9A-8017-3034FBE1C592}
+	EndGlobalSection
+EndGlobal

Diligent/Data/EntityFrameworkCore/IEFCoreContext.cs

+using Microsoft.EntityFrameworkCore;
+
+namespace Diligent.Data
+{
+	public interface IEFCoreContext : IDbContext
+	{
+		DbContext EFCoreContext { get; }
+	}
+}

Diligent/Data/IDbContext.cs

+using System;
+
+namespace Diligent.Data
+{
+	public interface IDbContext : IUnitOfWork
+	{
+
+	}
+}

Diligent/Data/IUnitOfWork.cs

+using System.Threading.Tasks;
+
+namespace Diligent.Data
+{
+	public interface IUnitOfWork
+	{
+		void SaveChanges();
+		Task SaveChangesAsync();
+	}
+}

Diligent/Data/Mongo/IMongoContext.cs

+using MongoDB.Driver;
+
+namespace Diligent.Data
+{
+	public interface IMongoContext : IDbContext
+	{
+		IMongoDatabase MongoDatabase { get; }
+	}
+}

Diligent/Diligent.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.2" />
+    <PackageReference Include="MongoDB.Driver" Version="2.10.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Log\" />
+    <Folder Include="Mail\" />
+    <Folder Include="Security\" />
+    <Folder Include="Validation\" />
+  </ItemGroup>
+
+</Project>

Diligent/Persistence/EntityFrameworkCore/Repository.cs

+using Diligent.Data;
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Diligent.Persistence.EntityFrameworkCore
+{
+	public abstract class Repository<TEntity> : IRepository<TEntity> 
+		where TEntity : class
+	{
+		private readonly DbContext _context;
+
+		public Repository(IEFCoreContext context)
+		{
+			_context = context.EFCoreContext;
+		}
+
+		public virtual TEntity Get(object id)
+		{
+			return _context.Set<TEntity>().Find(id);
+		}
+		public virtual IEnumerable<TEntity> GetAll()
+		{
+			return _context.Set<TEntity>().ToList();
+		}
+		public virtual void Add(TEntity entity)
+		{
+			_context.Set<TEntity>().Add(entity);
+		}
+		public virtual void Add(IEnumerable<TEntity> entities)
+		{
+			_context.Set<TEntity>().AddRange(entities);
+		}
+		public virtual void Update(TEntity entity)
+		{
+			_context.Set<TEntity>().Update(entity);
+		}
+		public virtual void Update(IEnumerable<TEntity> entities)
+		{
+			_context.Set<TEntity>().UpdateRange(entities);
+		}
+		public virtual void Remove(TEntity entity)
+		{
+			_context.Set<TEntity>().Remove(entity);
+		}
+		public virtual void Remove(IEnumerable<TEntity> entities)
+		{
+			_context.Set<TEntity>().RemoveRange(entities);
+		}
+
+		public virtual void SaveChanges()
+		{
+			_context.SaveChanges();
+		}
+
+		public virtual async Task<TEntity> GetAsync(object id)
+		{
+			return await _context.Set<TEntity>().FindAsync(id);
+		}
+		public virtual async Task<IEnumerable<TEntity>> GetAllAsync()
+		{
+			return await _context.Set<TEntity>().ToListAsync();
+		}
+		public virtual async Task AddAsync(TEntity entity)
+		{
+			await _context.Set<TEntity>().AddAsync(entity);
+		}
+		public virtual async Task AddAsync(IEnumerable<TEntity> entities)
+		{
+			await _context.Set<TEntity>().AddRangeAsync(entities);
+		}
+		public virtual async Task UpdateAsync(TEntity entity)
+		{
+			_context.Set<TEntity>().Update(entity);
+			await Task.CompletedTask;
+		}
+		public virtual async Task UpdateAsync(IEnumerable<TEntity> entities)
+		{
+			_context.Set<TEntity>().UpdateRange(entities);
+			await Task.CompletedTask;
+		}
+		public virtual async Task RemoveAsync(TEntity entity)
+		{
+			_context.Set<TEntity>().Remove(entity);
+			await Task.CompletedTask;
+		}
+		public virtual async Task RemoveAsync(IEnumerable<TEntity> entities)
+		{
+			_context.Set<TEntity>().RemoveRange(entities);
+			await Task.CompletedTask;
+		}
+
+		public virtual async Task SaveChangesAsync()
+		{
+			await _context.SaveChangesAsync();
+		}
+	}
+}

Diligent/Persistence/IRepository.cs

+using Diligent.Data;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Diligent.Persistence
+{
+	public interface IRepository<TEntity> : IUnitOfWork
+		where TEntity : class
+	{
+		TEntity Get(object id);
+		IEnumerable<TEntity> GetAll();
+		void Add(TEntity entity);
+		void Add(IEnumerable<TEntity> entities);
+		void Update(TEntity entity);
+		void Update(IEnumerable<TEntity> entities);
+		void Remove(TEntity entity);
+		void Remove(IEnumerable<TEntity> entities);
+
+		Task<TEntity> GetAsync(object id);
+		Task<IEnumerable<TEntity>> GetAllAsync();
+		Task AddAsync(TEntity entity);
+		Task AddAsync(IEnumerable<TEntity> entities);
+		Task UpdateAsync(TEntity entity);
+		Task UpdateAsync(IEnumerable<TEntity> entities);
+		Task RemoveAsync(TEntity entity);
+		Task RemoveAsync(IEnumerable<TEntity> entities);
+	}
+}

Diligent/Persistence/Mongo/IEntity.cs

+namespace Diligent.Persistence.Mongo
+{
+	public interface IEntity<TKey>
+	{
+		TKey Id { get; set; }
+	}
+}

Diligent/Persistence/Mongo/MongoRepository.cs

+using Diligent.Data;
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Diligent.Persistence.Mongo
+{
+	public abstract class Repository<TEntity> : IRepository<TEntity>
+		where TEntity : class, IEntity<object>
+	{
+		public virtual string CollectionName => GetType().Name.Replace(nameof(Repository<TEntity>), "");
+
+		private readonly IMongoContext _context;
+		private readonly IMongoCollection<TEntity> _collection;
+
+		protected Repository(IMongoContext context)
+		{
+			_context = context;
+			_collection = context.MongoDatabase.GetCollection<TEntity>(CollectionName);
+		}
+
+		public virtual TEntity Get(object id)
+		{
+			var filter = Builders<TEntity>.Filter.Eq(e => e.Id, id);
+			return _collection.Find(filter).FirstOrDefault();
+		}
+		public virtual IEnumerable<TEntity> GetAll()
+		{
+			return _collection.Find(_ => true).ToList();
+		}
+		public virtual void Add(TEntity entity)
+		{
+			_collection.InsertOne(entity);
+		}
+		public virtual void Add(IEnumerable<TEntity> entities)
+		{
+			_collection.InsertMany(entities);
+		}
+		public virtual void Update(TEntity entity)
+		{
+			var filter = Builders<TEntity>.Filter.Eq(en => en.Id, entity.Id);
+			_collection.ReplaceOne(filter, entity);
+		}
+		public virtual void Update(IEnumerable<TEntity> entities)
+		{
+			foreach (var entity in entities)
+				Update(entity);
+		}
+		public virtual void Remove(TEntity entity)
+		{
+			var filter = Builders<TEntity>.Filter.Eq(en => en.Id, entity.Id);
+			_collection.DeleteOne(filter);
+		}
+		public virtual void Remove(IEnumerable<TEntity> entities)
+		{
+			var filter = Builders<TEntity>.Filter.Where(en => entities.Contains(en));
+			_collection.DeleteMany(filter);
+		}
+
+		public virtual void SaveChanges()
+		{
+			_context.SaveChanges();
+		}
+
+		public virtual async Task<TEntity> GetAsync(object id)
+		{
+			var filter = Builders<TEntity>.Filter.Eq(e => e.Id, id);
+			return await _collection.FindAsync(filter).Result.FirstOrDefaultAsync();
+		}
+		public virtual async Task<IEnumerable<TEntity>> GetAllAsync()
+		{
+			return await _collection.FindAsync(_ => true).Result.ToListAsync();
+		}
+		public virtual async Task AddAsync(TEntity entity)
+		{
+			await _collection.InsertOneAsync(entity);
+		}
+		public virtual async Task AddAsync(IEnumerable<TEntity> entities)
+		{
+			await _collection.InsertManyAsync(entities);
+		}
+		public virtual async Task UpdateAsync(TEntity entity)
+		{
+			var filter = Builders<TEntity>.Filter.Eq(en => en.Id, entity.Id);
+			await _collection.ReplaceOneAsync(filter, entity);
+		}
+		public virtual async Task UpdateAsync(IEnumerable<TEntity> entities)
+		{
+			foreach (var entity in entities)
+				await UpdateAsync(entity);
+		}
+		public virtual async Task RemoveAsync(TEntity entity)
+		{
+			var filter = Builders<TEntity>.Filter.Eq(en => en.Id, entity.Id);
+			await _collection.DeleteOneAsync(filter);
+		}
+		public virtual async Task RemoveAsync(IEnumerable<TEntity> entities)
+		{
+			var filter = Builders<TEntity>.Filter.Where(en => entities.Contains(en));
+			await _collection.DeleteManyAsync(filter);
+		}
+
+		public virtual async Task SaveChangesAsync()
+		{
+			await _context.SaveChangesAsync();
+		}
+	}
+}