通用存储库模式 [英] Generic repository pattern

问题描述

如何在asp.net中创建通用存储库模式mvc



我尝试过：



我正在尝试创建存储库模式但不能创建

解决方案

如果要先创建代码然后按照以下代码创建通用存储库模式
 
< pre> [表（类别）] 
公共类别
 {
 [DatabaseGeneratedAttribute（DatabaseGeneratedOption） .Identity），Key（）] 
 public int Id {get;组; } 
 
 [必需] 
公共字符串名称{get;组; } 
 
 public virtual ICollection< BlogPost> BlogPosts {get;组; } 
} 
 
 [表（BlogPosts）] 
公共类BlogPost 
 {
 [DatabaseGeneratedAttribute（DatabaseGeneratedOption.Identity），Key（）] 
 public int Id {get;组; } 
 public string Title {get;组; } 
 public string Content {get;组; } 
 public DateTime PublishDate {get;组; } 
 
 [ForeignKey（Category）] 
 public int CategoryId {get;组; } 
 
公共虚拟类别类别{get;组; } 
} 

公共密封类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;组; } 
 public DbSet< Category>类别{get;组; } 
 public DbSet< StudentModel>学生模特{get;组; } 
} 

您需要为UnitOfWork和Repository创建接口，如下所示

{
IRepository< T>存储库< T>（）其中T：class;
void SaveChanges（）;
void BeginTransaction（）;
void RollBackTransaction（）;
void CommitTransaction（）;
}

公共接口IRepository< T>
{
IEnumerable< T> GetAll（Func< T，bool> predicate = null）;
T Get（Func< T，bool>谓词）;
void Add（T entity）;
void Attach（T entity）;
void删除（T实体）;
}

你需要实现这两个界面

公共类UnitOfWork：IUnitOfWork 
 {
 private readonly BlogContext entities = null; 
 
 private DbContextTransaction ObjectSetTransaction {get;组; } 
 
 public UnitOfWork（）
 {
 entities = new BlogContext（）; 
} 
 
 //私人词典<类型，对象> repositories = new Dictionary< Type，object>（）; 
 
 // [依赖] 
 public IRepository< T>存储库< T>（）其中T：class 
 {
返回新的存储库< T>（实体）; 
 //返回新的存储库< T>（entities.Set< T>（））; 
 
 // if（repositories.Keys.Contains（typeof（T））== true）
 // {
 // return（IRepository< T>）repositories [typeof （T）]; 
 //} 
 
 // IRepository< T> repository = new Repositories< T>（实体）; 
 //rereories.Add（typeof（T），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 dispos = 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）; 
} 
} 
 
 
 
公共类存储库< T> ：IRepository< T>其中T：class 
 {
 // private readonly BlogContext entities = null; 
 private readonly IDbSet< T> objectSet = null; 
 
公共存储库（BlogContext实体）
 {
 //this.entities = entities; 
 this.objectSet = entities.Set< T>（）; 
} 
 
公共存储库（IDbSet< T> objectSet）
 {
 this.objectSet = objectSet; 
} 
 
 public IEnumerable< T> GetAll（Func< T，bool> predicate = null）
 {
 if（predicate！= null）
 {
 return objectSet.Where（predicate）; 
} 
 
返回objectSet.AsEnumerable（）; 
} 
 
 public T Get（Func< T，bool>谓词）
 {
 return objectSet.FirstOrDefault（predicate）; 
} 
 
 public void Add（T entity）
 {
 objectSet.Add（entity）; 
} 
 
 public void Attach（T entity）
 {
 objectSet.Attach（entity）; 
} 
 
 public void删除（T实体）
 {
 objectSet.Remove（entity）; 
} 
} 

现在，您可以使用创建对象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 =Ahmedab​​ad，PublishDate = DateTime.UtcNow，Title =City}）; 
 unitOfWork.SaveChanges（）; 
 
 unitOfWork.CommitTransaction（）; 
} 
 catch 
 {
 unitOfWork.RollBackTransaction（）; 
} 
返回RedirectToAction（List，Home）; 
} 
 
 return View（model）; 
} 
 
 
 [必需] 
 public HttpPostedFileBase file {get;组; } 
 
< div class =modal-dialog> 
<！ - 模态内容 - > 
< div class =modal-content> 
< div class =modal-header> 
< button type =buttonclass =closedata-dismiss =modal>& times;< / button> 
< h4 class =modal-title> @ Model.VideoName< / h4> 
< / div> 
< div class =modal-body> 
< video width =100％控制autoplay =autoplay> 
 @ *< source id =videosrc ='@ Url.Content（〜/ Video /+ Model.VideoPath）'type =video / mp4> * @ 
< ; source id =videosrc =@ Model.VideoPath> 
 @ *< source id =videosrc =@ Url.Action（GetVideo，Video，new {VideoId = Model.VideoId}）> * @ 
< /视频> 
< / div> 
< / div> 
< / div> 
 
< div id =myModalclass =modal faderole =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（）; 
 
函数PlayVideo（VideoId）{

.ajax（{
url：'/ Video / PlayVideo'，
datatype：html ，
类型：获取，
数据：{'VideoId'：VideoId}，
contenttype：'application / json; charset = utf-8'，
成功： function（data）{

（＃myModal）。html（data）;

How to create generic repository pattern in asp.net mvc

What I have tried:

I am trying to create repository patterns but not able to create

解决方案

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

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

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

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


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

这篇关于通用存储库模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！