Generic repository pattern

If you want to create code first approach then follow below code to create generic repository pattern
 
<pre>[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; }
    }

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);
  }

public class UnitOfWork : IUnitOfWork
    {
        private readonly BlogContext entities = null;

        private DbContextTransaction ObjectSetTransaction { get; set; }

        public UnitOfWork()
        {
            entities = new BlogContext();
        }

        //private Dictionary<Type, object> repositories = new Dictionary<Type, object>();

        //[Dependency]
        public IRepository<T> Repository<T>() where T : class
        {
            return new Repositories<T>(entities);
            //return new Repositories<T>(entities.Set<T>());

            //if (repositories.Keys.Contains(typeof(T)) == true)
            //{
            //    return (IRepository<T>)repositories[typeof(T)];
            //}

            //IRepository<T> repository = new Repositories<T>(entities);
            //repositories.Add(typeof(T), repository);
            //return repository;
        }

        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 BlogContext entities = null;
        private readonly IDbSet<T> objectSet = null;

        public Repositories(BlogContext entities)
        {
            //this.entities = 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);
        }
    }

  [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);
        }


        [Required]
        public HttpPostedFileBase file { get; set; }

<div class="modal-dialog">
    <!-- Modal content-->
    <div class="modal-content">
        <div class="modal-header">
            <button type="button" class="close" data-dismiss="modal">&times;</button>
            <h4 class="modal-title">@Model.VideoName</h4>
        </div>
        <div class="modal-body">
            <video width="100%" controls autoplay="autoplay">
                @*<source id="video" src='@Url.Content("~/Video/" + Model.VideoPath)' type="video/mp4">*@
                <source id="video" src="@Model.VideoPath" >
                @*<source id="video" src="@Url.Action("GetVideo", "Video", new { VideoId = Model.VideoId } )">*@
            </video>
        </div>
    </div>
</div>

<div id="myModal" class="modal fade" role="dialog">

var uploadFilesDir = Server.MapPath("~/Video");
                    var fileSavePath = Path.Combine(uploadFilesDir, model.file.FileName);

                    int length = model.file.ContentLength;
                    byte[] video = new byte[length];

                    model.file.InputStream.Read(video, 0, length);
                    model.file.SaveAs(fileSavePath);

                    Video.DataModel.Video obj = new Video.DataModel.Video();
                    obj.VideoName = model.VideoName;
                    obj.VideoPath = model.file.FileName;
                    obj.Image = video;

                    VideoContext entity = new VideoContext();
                    entity.Videos.Add(obj);
                    entity.SaveChanges();

 function PlayVideo(VideoId) {
        $.ajax({
            url: '/Video/PlayVideo',
            datatype: "html",
            type: "Get",
            data: { 'VideoId': VideoId },
            contenttype: 'application/json; charset=utf-8',
            success: function (data) {
                $("#myModal").html(data);
                $("#myModal").modal("show");
            },
            error: function (xhr) {
                alert('error');
            }
        });
    }

<pre>  <security>
      <requestFiltering>
        <requestLimits maxAllowedContentLength="1073741824" />
      </requestFiltering>
    </security>

<httpRuntime maxRequestLength="1048576" executionTimeout="3600" targetFramework="4.5" />