跟我学MVC系列（Repository模式、LINQ、EF、IOC框架Castle、JQuery、AJAX）（四）Models（ORM、Repository模式、分页）...

跟我学MVC系列（Repository模式、LINQ、EF、IOC框架Castle、JQuery、AJAX）（三）Models（ORM、Repository模式、分页） (9-3 23:00)
跟我学MVC系列（Repository模式、LINQ、EF、IOC框架Castle、JQuery、AJAX）（二）Models（ORM） (9-3 10:43)
跟我学MVC系列（Repository模式、LINQ、EF、IOC框架Castle、JQuery、AJAX）（一）数据库建模 (9-1 00:04)

今天，我们接上篇。我们在 Repository 文件夹下创建一个类BaseRepositoryBase.cs,这个类是要继承 IRepository 接口，实现里面的方法，这样，就把增删查改方法给抽象出来，以后的类只要继承BaseRepositoryBase.cs,就不用自己去实现啦。
代码如下：

Code
using System;
using System.Collections.Generic;
using System.Data.Objects;
using System.Linq;
using PBAccount.Models;

namespace PBAccount.Repository
{
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="T">实体接口</typeparam>
    /// <typeparam name="TEntity">EF数据类</typeparam>
    public abstract class BaseRepositoryBase<T, TEntity> : IRepository<T> where TEntity : class
    {
        protected PBAccountEntities1 dataContext;
        public BaseRepositoryBase(PBAccountEntities1 dataContext)
        {
            this.dataContext = dataContext;
        }

        #region IRepository<T> 成员

        public virtual void Add(T entity)
        {
            dataContext.AddObject(EntitySetName, ToEntity(entity));
        }

        private string EntitySetName
        {
            get { return typeof(TEntity).Name; }
        }

        public virtual void Del(T entity)
        {
            dataContext.DeleteObject(ToEntity(entity));
        }

        public virtual void Update(T entity)
        {

        }

        protected ObjectQuery<TEntity> EntitySet
        {
            get { return dataContext.CreateQuery<TEntity>("[" + EntitySetName + "]"); }
        }

        public IList<T> Find(ICriteria criteria)
        {
            if (criteria == null)
                throw new ArgumentNullException("criteria");
            var query = EntitySet.Where(criteria.Expression, criteria.Parameters.Select(p => new ObjectParameter(p.Name, p.Value)).ToArray());

            return ToList(query);
        }


        public IList<T> FindAll()
        {
            return ToList(EntitySet);
        }

        public IList<T> Find(ICriteria criteria, int page, int pageSize, Order orderExpr)
        {
            if (criteria == null || orderExpr == null)
                throw new ArgumentNullException("criteria");
            var query = EntitySet.Where(criteria.Expression, criteria.Parameters.Select(p => new ObjectParameter(p.Name, p.Value)).ToArray());


            return ToList(orderExpr.OrderFrom<TEntity>(query).Skip((page - 1) * pageSize).Take(pageSize));
        }

        public int Count(ICriteria criteria)
        {
            if (criteria == null)
                throw new ArgumentNullException("criteria");
            return EntitySet.Where(criteria.Expression, criteria.Parameters.Select(p => new ObjectParameter(p.Name, p.Value)).ToArray()).Count();
        }

        public void SaveChanges()
        {
            dataContext.SaveChanges();
        }

        public virtual T Find(Guid entityId)
        {
            return Find(new EqualParameterCriteria(EntitySetName + "Id", entityId)).FirstOrDefault();
        }

        protected virtual IList<T> ToList(IQueryable<TEntity> query)
        {
            return query.AsEnumerable().Select(x => CreateSqlEntity(x)).Cast<T>().ToList();
        }

        #endregion

        protected abstract T CreateSqlEntity(TEntity x);
        protected abstract TEntity ToEntity(T t);

        #region IRepository<T> 成员


        public int GetAccounts(ICriteria criteria, int page, int pageSize, Order orderExpr)
        {
            if (criteria == null || orderExpr == null)
                throw new ArgumentNullException("criteria");
            var query = EntitySet.Where(criteria.Expression, criteria.Parameters.Select(p => new ObjectParameter(p.Name, p.Value)).ToArray());


            return ToList(orderExpr.OrderFrom<TEntity>(query).Skip((page - 1) * pageSize).Take(pageSize)).Count;
        }

        #endregion
    }
}

以上就是BaseRepositoryBase.cs。现在提醒你一下啊，我们在Models下面定义了三个实体类接口（IAccount.cs IAccountType.cs IUser.cs ）呢，下面我们用EF来对它们实现，你就会发现EF的魅力啦，代码如下啊：      

Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using PBAccount.Models;
using PBAccount.Repository.Helper;

namespace PBAccount.Repository
{
    public class SQLAccount:IAccount
    {
        internal Accounts account;

        public SQLAccount()
        {
            this.account = new Accounts
            {
                AccountID = Guid.NewGuid()
            };
        }

        #region IAccount 成员

        public Guid AccountID
        {
            get
            {
                return account.AccountID;
            }
            set
            {
                account.AccountID = value;
            }
        }

        public IUser user
        {
            get
            {
                if (null == user && null != account)
                {
                    if (!account.UsersReference.IsLoaded && account.IsInObjectContext())
                    {
                        account.UsersReference.Load();
                    }
                    if ( null != account.Users)
                    {
                        user = new SQLUser(account.Users);
                    }

                }
                return user;
            }
            set
            {
                user = value;
                account.Users = user == null ? null : ((SQLUser)user).user;
            }
        }

        public bool InOrOut
        {
            get
            {
                return (bool)account.InOrOut;
            }
            set
            {
                account.InOrOut = value;
            }
        }

        public float Amount
        {
            get
            {
                return (float)account.Amount;
            }
            set
            {
                account.Amount = value;
            }
        }

        public IAccountType AccountType
        {
            get
            {
                if (null == AccountType && null != account)
                {
                    if (!account.AccountTypesReference.IsLoaded && account.IsInObjectContext())
                    {
                        account.AccountTypesReference.Load();
                    }
                    if (null != account.AccountTypes)
                    {
                        AccountType = new SQLAccountType(account.AccountTypes);
                    }

                }
                return AccountType;
            }
            set
            {
                AccountType = value;
                account.AccountTypes = AccountType == null ? null : ((SQLAccountType)AccountType).accounttype;
            }
        }

        public DateTime Time
        {
            get
            {
                return (DateTime)account.Time;
            }
            set
            {
                account.Time = value;
            }
        }

        public AccountStatus Status
        {
            get
            {
                return (AccountStatus)account.Status;
            }
            set
            {
                account.Status = (int)value;
            }
        }

        public string Detail
        {
            get { return account.Detail == null ? null : Encoding.Default.GetString(account.Detail); }
            set { account.Detail = value == null ? null : Encoding.Default.GetBytes(value); }
        }

        #endregion
    }
}



using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using PBAccount.Models;

namespace PBAccount.Repository
{
    public class SQLUser:IUser
    {
        internal Users user;
        public SQLUser(Users user)
        {
            this.user=user;
        }
        public SQLUser()
        {
            this.user = new Users() {
                UserID=Guid.NewGuid()
            };

        }


        #region IUser 成员

        public Guid UserID
        {
            get
            {
                return user.UserID;
            }
            set
            {
                user.UserID = value;
            }
        }

        public string LoginName
        {
            get
            {
                return user.LoginName;
            }
            set
            {
                user.LoginName = value;
            }
        }

        public string Name
        {
            get
            {
                return user.Name;
            }
            set
            {
                user.Name = value;
            }
        }

        public bool Sex
        {
            get
            {
                return  (bool)user.Sex;
            }
            set
            {
                user.Sex = value;
            }
        }

        public DateTime BirthDay
        {
            get
            {
                return (DateTime)user.BirthDay;
            }
            set
            {
                user.BirthDay = value;
            }
        }

        public string Profession
        {
            get
            {
                return user.Profession;
            }
            set
            {
                user.Profession = value;
            }
        }

        public int Role
        {
            get
            {
                return (int)user.Role;
            }
            set
            {
                user.Role = value;
            }
        }

        #endregion
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using PBAccount.Models;

namespace PBAccount.Repository.Helper
{
    public class SQLAccountType:IAccountType
    {
        internal AccountTypes accounttype;
        public SQLAccountType()
        {
            this.accounttype=new AccountTypes(){
            AccountTypeID=Guid.NewGuid()
            };
        }

        public SQLAccountType(AccountTypes accouttype)
        {
            this.accounttype = accouttype;
        }

        #region IAccountType 成员

        public Guid AccountTypeID
        {
            get
            {
                return accounttype.AccountTypeID;
            }
            set
            {
                accounttype.AccountTypeID = value;
            }
        }

        public string AccountTypeName
        {
            get
            {
                return accounttype.AccountTypeName;
            }
            set
            {
                accounttype.AccountTypeName = value;
            }
        }

        #endregion
    }
}

上面的代码你可是要仔细分析哦，你是否注意到上面代码中出现了一个 IsInObjectContext（）方法， 这个方法又涉及到一个新概念啦，那就是“扩展方法”，详情参阅：http://msdn.microsoft.com/zh-cn/library/bb383977.aspx ，具体我就不说了，你看这个方法名称就基本上知道它的意思啦，主要起到验证的作用。这个扩展方法是如何实现的呢？我们在Repository文件夹下新建了一个Helper文件夹，在Helper文件夹下建立一个ObjectEntityHelper.cs 类，代码如下：

Code
using System.Data;
using System.Data.Objects.DataClasses;

namespace PBAccount.Repository.Helper
{
        static public class ObjectEntityHelper
        {
            /// <summary>
            /// 扩展方法 验证所传入的参数类 
            /// </summary>
            /// <param name="entity"></param>
            /// <returns></returns>
            public static bool IsInObjectContext(this EntityObject entity)
            {
                return entity.EntityState == EntityState.Unchanged || entity.EntityState == EntityState.Modified;
            }
        }
}

OK，现在，我们看看解决方案的截图吧：

看到了这个图，你就会明白现在的项目架构了吧。
这篇就到这儿啦。下篇继续，共同努力啊。

转载于:https://www.cnblogs.com/poorboy/archive/2009/09/05/1560661.html