zoukankan      html  css  js  c++  java
  • EF4+Repository+UnitOfWork 代码摘录

    IContextFactory.cs

    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    //IDbContextFactory.cs
    namespace EFCodeFirstTest.Data
    {
        public interface IDbContextFactory<TContext> where TContext:DbContext,new()
        {
            TContext GetDbContext();
        }
    }

    DbContextFactory.cs

    using System;
    using System.Collections.Generic;
    using System.Configuration;
    using System.Data.Entity;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        //DbContextFactory.cs
        public class DbContextFactory<TContext>:IDbContextFactory<TContext>,IDisposable
            where TContext:DbContext,new()
        {
            private string _connectionString;
            private TContext _context;
    
            public DbContextFactory()
            {
                _connectionString = ConfigurationManager.ConnectionStrings["dbContext"].ConnectionString;
                _context.Database.Connection.ConnectionString = _connectionString;
                _context = Activator.CreateInstance<TContext>();
            }
    
            public DbContextFactory(string connectionString) : this()
            {
                _connectionString = connectionString;
            }
    
            public TContext GetDbContext()
            {
                return _context == null ? Activator.CreateInstance<TContext>() : _context;
            }
    
            public void Dispose()
            {
                if (_context != null)
                    _context.Dispose();
    
                GC.SuppressFinalize(this);
            }
        }
    }

    IGenericRepository.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        public interface IGenericRepository<TEntity>:IDisposable
            where TEntity:class
        {
            /// <summary>
            /// Gets all objects from database
            /// </summary>
            IQueryable<TEntity> GetAll();
    
            /// <summary>
            /// Gets objects from database by filter.
            /// </summary>
            /// <param name="predicate">Specified a filter</param>
            IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate);
    
            /// <summary>
            /// Gets objects from database with filting and paging.
            /// </summary>
            /// <typeparam name="Key"></typeparam>
            /// <param name="filter">Specified a filter</param>
            /// <param name="total">Returns the total records count of the filter.</param>
            /// <param name="index">Specified the page index.</param>
            /// <param name="size">Specified the page size</param>
            IQueryable<TEntity> Filter<Key>(Expression<Func<TEntity, bool>> filter,
                out int total, int index = 0, int size = 50);
    
            /// <summary>
            /// Gets objects from database with filter and orderby and include fields
            /// </summary>
            /// <param name="filter">can be null</param>
            /// <param name="orderBy">default is null</param>
            /// <param name="includeProperties">string split by ','</param>
            /// <returns></returns>
            IQueryable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>,
                IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "");
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="total"></param>
            /// <param name="filter"></param>
            /// <param name="orderBy"></param>
            /// <param name="includeProperties"></param>
            /// <param name="index"></param>
            /// <param name="size"></param>
            /// <returns></returns>
            IQueryable<TEntity> GetPaged(out int total, Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>,
                IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "", int index = 0, int size = 50);
    
            /// <summary>
            /// Gets the object(s) is exists in database by specified filter.
            /// </summary>
            /// <param name="predicate">Specified the filter expression</param>
            bool Contains(Expression<Func<TEntity, bool>> predicate);
    
            /// <summary>
            /// Find object by keys.
            /// </summary>
            /// <param name="keys">Specified the search keys.</param>
            TEntity Find(params object[] keys);
    
            /// <summary>
            /// Find object by specified expression.
            /// </summary>
            /// <param name="predicate"></param>
            TEntity Find(Expression<Func<TEntity, bool>> predicate);
    
            /// <summary>
            /// Create a new object to database.
            /// </summary>
            /// <param name="t">Specified a new object to create.</param>
            void Create(TEntity t);
    
            /// <summary>
            /// Delete the object from database.
            /// </summary>
            /// <param name="t">Specified a existing object to delete.</param>        
            void Delete(TEntity t);
    
            /// <summary>
            /// Delete objects from database by specified filter expression.
            /// </summary>
            /// <param name="predicate"></param>
            void Delete(Expression<Func<TEntity, bool>> predicate);
    
            /// <summary>
            /// Update object changes and save to database.
            /// </summary>
            /// <param name="t">Specified the object to save.</param>
            void Update(TEntity t);
    
            /// <summary>
            /// To Save all the changes 
            /// </summary>
            /// <returns></returns>
            int Save();
    
            /// <summary>
            /// Get the total objects count.
            /// </summary>
            int Count { get; }
    
            /// <summary>
            /// Get the object by execute the raw sql statements.
            /// </summary>
            /// <param name="query"></param>
            /// <param name="parameters"></param>
            /// <returns></returns>
            IQueryable<TEntity> GetWithRawSql(string query, params object[] parameters);
        }
    }

    GenericRepository.cs

    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Data.Entity;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        public abstract class GenericRepository<TContext, TEntity> : IGenericRepository<TEntity>
            where TContext : DbContext, new()
            where TEntity : class
        {
            protected TContext _context;
            protected IDbContextFactory<TContext> _dbContextFactory;
            protected readonly IDbSet<TEntity> _set;
    
            protected GenericRepository(IDbContextFactory<TContext> dbContextFactory)
            {
                _dbContextFactory = dbContextFactory;
                _context = _dbContextFactory.GetDbContext();
                _set = _context.Set<TEntity>();
            }
    
            protected TContext Context
            {
                get
                {
                    return _context;
                }
            }
    
            protected IDbSet<TEntity> DbSet
            {
                get
                {
                    return _set == null ? _context.Set<TEntity>() : _set;
                }
            }
    
            public IQueryable<TEntity> GetAll()
            {
                return DbSet.AsQueryable();
            }
    
            public IQueryable<TEntity> GetPaged(out int total, Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>,
                IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "", int index = 0, int size = 50)
            {
                int skipCount = index * size;
                var _reset = Get(filter, orderBy, includeProperties);
                _reset = skipCount == 0 ? _reset.Take(size) : _reset.Skip(skipCount).Take(size);
                total = _reset.Count();
                return _reset.AsQueryable();
            }
    
            public IQueryable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>,
                IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "")
            {
                IQueryable<TEntity> query = DbSet;
    
                if (filter != null)
                {
                    query = query.Where(filter);
                }
    
                foreach (var includeProperty in includeProperties.Split
                    (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    query = query.Include(includeProperty);
                }
    
                if (orderBy != null)
                {
                    return orderBy(query).AsQueryable();
                }
                else
                {
                    return query.AsQueryable();
                }
            }
    
    
            public IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate)
            {
                return DbSet.Where(predicate).AsQueryable<TEntity>();
            }
    
            public IQueryable<TEntity> Filter<Key>(Expression<Func<TEntity, bool>> filter, out int total, int index = 0, int size = 50)
            {
                int skipCount = index * size;
                var _resetSet = filter != null ? DbSet.Where(filter).AsQueryable() : DbSet.AsQueryable();
                _resetSet = skipCount == 0 ? _resetSet.Take(size) : _resetSet.Skip(skipCount).Take(size);
                total = _resetSet.Count();
                return _resetSet.AsQueryable();
            }
    
            public bool Contains(Expression<Func<TEntity, bool>> predicate)
            {
                return DbSet.Count(predicate) > 0; ;
            }
    
            public virtual TEntity Find(params object[] keys)
            {
                return DbSet.Find(keys);
            }
    
            public virtual TEntity Find(Expression<Func<TEntity, bool>> predicate)
            {
                return DbSet.FirstOrDefault(predicate);
            }
    
            public virtual void Create(TEntity t)
            {
                DbSet.Add(t);
            }
    
            public virtual void Delete(TEntity t)
            {
                if (Context.Entry(t).State == EntityState.Detached)
                {
                    DbSet.Attach(t);
                }
                DbSet.Remove(t);
            }
    
            public virtual void Delete(Expression<Func<TEntity, bool>> predicate)
            {
                var toDelete = Filter(predicate);
                foreach (var obj in toDelete)
                {
                    DbSet.Remove(obj);
                }
            }
    
            public void Update(TEntity t)
            {
                var entry = Context.Entry(t);
                DbSet.Attach(t);
                entry.State = EntityState.Modified;
            }
    
            public int Save()
            {
                return Context.SaveChanges();
            }
    
            public int Count
            {
                get { return DbSet.Count(); }
            }
    
            public IQueryable<TEntity> GetWithRawSql(string query, params object[] parameters)
            {
                return Context.Database.SqlQuery<TEntity>(query, parameters).AsQueryable();
            }
    
            public void Dispose()
            {
                if (Context != null)
                    Context.Dispose();
                GC.SuppressFinalize(this);
            }
        }
    }

    IUnitOfWork.cs

    using System;
    
    namespace EFCodeFirstTest.Data
    {
        public interface IUnitOfWork
        {
            void Commit();
        }
    }

    UnitOfWork.cs

    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        public class UnitOfWork<TContext>:IUnitOfWork
            where TContext : DbContext,new()
        {
            private IDbContextFactory<TContext> _dbContextFactory;
            private TContext _context;
    
            public UnitOfWork(IDbContextFactory<TContext> dbContextFactory)
            {
                _dbContextFactory = dbContextFactory;
                _context = _dbContextFactory.GetDbContext();
            }
    
            public TContext Context
            {
                get
                {
                    return _context ?? (_context = _dbContextFactory.GetDbContext());
                }
            }
    
            public void Commit()
            {
                Context.SaveChanges();
            }
        }
    }

    IProductContext.cs

    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        public interface IProductContext
        {
            IDbSet<Product> Products { get; }
            IDbSet<Category> Categories { get; }
        }
    }

    ProductContext.cs

    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        public class ProductContext:DbContext,IProductContext
        {
            public ProductContext(string connectionString)
                : base(connectionString)
            {
                this.Database.Connection.ConnectionString = connectionString;
                
            }
           
            //public DbSet<Product> Products { get; set; }
            private IDbSet<Category> _categories = null;
            public IDbSet<Category> Categories
            {
                get
                {
                    return _categories == null ? Set<Category>() : _categories;
                }
            }
    
            private IDbSet<Product> _products = null;
            public IDbSet<Product> Products
            {
                get
                {
                    return _products == null ? this.Set<Product>() : _products;
                }
            }
    
            protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                
                modelBuilder.Entity<Product>().HasKey(b=>b.ProductId);
            }
        }
    }

    Entities.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace EFCodeFirstTest.Data
    {
        public class Product
        {
            public int ProductId { get; set; }
            public string Name { get; set; }
            public Category Category { get; set; }
        }
        public class Category
        {
            public string CategoryId { get; set; }
            public string Name { get; set; }
            public ICollection<Product> Products { get; set; }
        }
    }
  • 相关阅读:
    547. Friend Circles
    399. Evaluate Division
    684. Redundant Connection
    327. Count of Range Sum
    LeetCode 130 被围绕的区域
    LeetCode 696 计数二进制子串
    LeetCode 116 填充每个节点的下一个右侧节点
    LeetCode 101 对称二叉树
    LeetCode 111 二叉树最小深度
    LeetCode 59 螺旋矩阵II
  • 原文地址:https://www.cnblogs.com/Seekr/p/2661632.html
Copyright © 2011-2022 走看看