具有通用存储库和工作单元的实体框架

我在我的一个应用程序中使用实体框架和通用存储库。我需要对功单位积分。我有点困惑，在不影响应用程序性能的情况下，使用通用存储库模式添加工作单元的最佳方法是什么。谁能帮我做这件事?

我已经添加了我的通用存储库代码和其他存储库代码如下。

通用存储库:

using System;
using System.Data.Entity;
using System.Data.Entity.Validation;
using System.Linq;
using System.Threading.Tasks;
using EntityFrameworkDemo.Entity;
using EntityFrameworkDemo.Models;
using EntityFrameworkDemo.Repository.UnitOfWork;
namespace EntityFrameworkDemo.Repository
{
    public class BaseRepository<T> : IDisposable where T : BaseModel
    {
      internal EFContext db;
    public BaseRepository()
    {
        db = new EFContext();
    }
    /// <summary>
    /// Initializes a new instance of the <see cref="BaseRepository"/> class.
    /// </summary>
    /// <param name="context">The context.</param>
    public BaseRepository(EFContext context)
    {
        db = context;
    }
    /// <summary>
    /// Gets this instance.
    /// </summary>
    /// <returns></returns>
    public IQueryable<T> GetAll()
    {
        return db.Set<T>().Where(t => !t.DeletedOn.HasValue);
    }

    /// <summary>
    /// Gets the specified identifier.
    /// </summary>
    /// <param name="id">The identifier.</param>
    /// <returns></returns>
    public T Get(long? id)
    {
        return db.Set<T>().Find(id); ;
    }
    /// <summary>
    /// Gets the specified identifier.
    /// </summary>
    /// <param name="id">The identifier.</param>
    /// <returns></returns>
    public Task<T> GetASync(long? id)
    {
        return db.Set<T>().FindAsync(id);
    }
    /// <summary>
    /// Inserts the specified current.
    /// </summary>
    /// <param name="current">The current.</param>
    /// <returns></returns>
    public async Task<T> Insert(T current)
    {
        db.Set<T>().Add(current);
        try
        {
            await db.SaveChangesAsync();
        }
        catch (DbEntityValidationException e)
        {
            foreach (var eve in e.EntityValidationErrors)
            {
                Console.WriteLine("Entity of type '"{0}'" in state '"{1}'" has the following validation errors:",
                    eve.Entry.Entity.GetType().Name, eve.Entry.State);
                foreach (var ve in eve.ValidationErrors)
                {
                    Console.WriteLine("- Property: '"{0}'", Error: '"{1}'"",
                        ve.PropertyName, ve.ErrorMessage);
                }
            }
            throw;
        }
        return await db.Set<T>().FirstAsync();
    }
    /// <summary>
    /// Inserts the specified current.
    /// </summary>
    /// <param name="current">The current.</param>
    /// <returns></returns>
    public async Task Update(T current)
    {
        db.Entry<T>(current).State = System.Data.Entity.EntityState.Modified;
        try
        {
            await db.SaveChangesAsync();
        }
        catch (DbEntityValidationException e)
        {
            foreach (var eve in e.EntityValidationErrors)
            {
                Console.WriteLine("Entity of type '"{0}'" in state '"{1}'" has the f  ollowing validation errors:",
                    eve.Entry.Entity.GetType().Name, eve.Entry.State);
                foreach (var ve in eve.ValidationErrors)
                {
                    Console.WriteLine("- Property: '"{0}'", Error: '"{1}'"",
                        ve.PropertyName, ve.ErrorMessage);
                }
            }
            throw;
        }
    }
    /// <summary>
    /// Deletes the specified identifier.
    /// </summary>
    /// <param name="id">The identifier.</param>
    /// <returns></returns>
    public async Task Delete(long? id)
    {
        var current = await this.GetASync(id);
        if (current != null)
        {
            current.DeletedOn = DateTime.Now;
            db.Entry<T>(current).State = System.Data.Entity.EntityState.Modified;
            await db.SaveChangesAsync();
        }
    }
    /// <summary>
    /// Deletes the specified identifier permanently.
    /// </summary>
    /// <param name="id">The identifier.</param>
    /// <returns></returns>
    public async Task DeletePermanently(long? id)
    {
        var current = await this.GetASync(id);
        if (current != null)
        {
            db.Set<T>().Remove(current);
            await db.SaveChangesAsync();
        }
    }
    /// <summary>
    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    /// <summary>
    /// Finalizes an instance of the <see cref="BaseRepository"/> class.
    /// </summary>
    ~BaseRepository()
    {
        Dispose(false);
    }
    /// <summary>
    /// Releases unmanaged and - optionally - managed resources.
    /// </summary>
    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (db != null)
            {
                db.Dispose();
                db = null;
            }
        }
    }
}

}

Student Repository:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using EntityFrameworkDemo.Models;
namespace EntityFrameworkDemo.Repository
{
    public class StudentRepository : BaseRepository<Student>
    {
    public StudentRepository()
        : base()
    { }
    }
}

控制器:

 public class HomeController : Controller
{
    private StudentRepository studentRepo = new StudentRepository();
    public async Task<ActionResult> Index()
    {
        var test = studentRepo.GetAll();
        return View();
    }
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            studentRepo.Dispose();
        }
        base.Dispose(disposing);
    }
}