If you want to create code first approach then follow below code to create generic repository pattern
[Table("Categories")]
public class Category
{
[DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity), Key()]
public int Id { get; set; }
[Required]
public string Name { get; set; }
public virtual ICollection<BlogPost> BlogPosts { get; set; }
}
[Table("BlogPosts")]
public class BlogPost
{
[DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity), Key()]
public int Id { get; set; }
public string Title { get; set; }
public string Content { get; set; }
public DateTime PublishDate { get; set; }
[ForeignKey("Category")]
public int CategoryId { get; set; }
public virtual Category Category { get; set; }
}
public sealed class BlogContext : DbContext
{
static BlogContext()
{
Database.SetInitializer<BlogContext>(null);
}
public BlogContext()
: base("name=TABFusionRMSContext")
{
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
}
public DbSet<BlogPost> BlogPosts { get; set; }
public DbSet<Category> Categories { get; set; }
public DbSet<StudentModel> StudentModels { get; set; }
}
You need to create Interface for UnitOfWork And Repository like below
public interface IUnitOfWork : IDisposable
{
IRepository<T> Repository<T>() where T : class;
void SaveChanges();
void BeginTransaction();
void RollBackTransaction();
void CommitTransaction();
}
public interface IRepository<T>
{
IEnumerable<T> GetAll(Func<T, bool> predicate = null);
T Get(Func<T, bool> predicate);
void Add(T entity);
void Attach(T entity);
void Delete(T entity);
}
You need to implement this two interface
public class UnitOfWork : IUnitOfWork
{
private readonly BlogContext entities = null;
private DbContextTransaction ObjectSetTransaction { get; set; }
public UnitOfWork()
{
entities = new BlogContext();
}
public IRepository<T> Repository<T>() where T : class
{
return new Repositories<T>(entities);
}
public void SaveChanges()
{
entities.SaveChanges();
}
public void BeginTransaction()
{
ObjectSetTransaction = entities.Database.BeginTransaction();
}
public void RollBackTransaction()
{
ObjectSetTransaction.Rollback();
ObjectSetTransaction.Dispose();
}
public void CommitTransaction()
{
ObjectSetTransaction.Commit();
ObjectSetTransaction.Dispose();
}
private bool disposed = false;
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
entities.Dispose();
}
}
this.disposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
public class Repositories<T> : IRepository<T> where T : class
{
private readonly IDbSet<T> objectSet = null;
public Repositories(BlogContext entities)
{
this.objectSet = entities.Set<T>();
}
public Repositories(IDbSet<T> objectSet)
{
this.objectSet = objectSet;
}
public IEnumerable<T> GetAll(Func<T, bool> predicate = null)
{
if (predicate != null)
{
return objectSet.Where(predicate);
}
return objectSet.AsEnumerable();
}
public T Get(Func<T, bool> predicate)
{
return objectSet.FirstOrDefault(predicate);
}
public void Add(T entity)
{
objectSet.Add(entity);
}
public void Attach(T entity)
{
objectSet.Attach(entity);
}
public void Delete(T entity)
{
objectSet.Remove(entity);
}
}
Now you can use this classes in your controller using creating object unitofwork
[HttpPost]
public ActionResult Create(Category model)
{
if (ModelState.IsValid)
{
try
{
UnitOfWork unitOfWork = New UnitOfWork();
unitOfWork.BeginTransaction();
unitOfWork.Repository<Category>().Add(model);
unitOfWork.SaveChanges();
unitOfWork.Repository<BlogPost>().Add(new BlogPost { CategoryId = model.Id, Content = "Ahmedabad", PublishDate = DateTime.UtcNow, Title = "City" });
unitOfWork.SaveChanges();
unitOfWork.CommitTransaction();
}
catch
{
unitOfWork.RollBackTransaction();
}
return RedirectToAction("List", "Home");
}
return View(model);
}