diligent-net-core/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();
		}
	}
}