第一回 要想知道为什么抽象出基类，应该先对基类有一个比较明确的认识

      基类，即基础类型，也称为父类，祖宗类等，它一般会以抽象类（abstract class）的形式体现出来，它会包括一些具有共性的，一般性的信息（属性和方法等），它在描述一类对象时，经常会被抽象出来，如一个小猫，一只小狗，很容易会让你抽象出一个animal来，这是正常的，是符合面向对象人生观的，呵呵。

      而在实际项目开发中，这种例子也不少，可以说到处都可以看到基类的身影，有人说，请不要使用继承，因为它为使你的程序很糟糕，依赖太多不好，但我要说的是，如果你的程序是一个关系复杂，面向对象的，那你的程序在某些地方必须要去继承（抽象出基类），有时，我们会说，那什么时候去使用基类，我们应该如何去衡量呢？事实上这种衡量是没有意义的，是应试的，就像我国的教育，我是很不喜欢，永远都是应付考试，对于基类这东西，你需要它时，就使用它，不要管什么原则，当你需要解耦时，就使用对象的组合，还有，如果对基类还是有所偏见，那可以去看看微软的System.Collections和System.Web.Mvc下的实现，看看人家是如何设计的。

    以下是一个完整的，简单的数据操作基类，它将子类公用的属性数据库上下文（DataContext）抽象出来，将增删改查的Curd操作也抽象出来，结果，这个基类就变成了这样：

    /// <summary>
    /// 标准数据操作基类
    /// </summary>
    public abstract class DataBase : IRepository
    {
        /// <summary>
        /// 数据访问对象（只对子类可见）
        /// </summary>
        protected DataContext DB;

        #region Constructors
        public DataBase()
            : this(new LINQ.DataClasses1DataContext(System.Configuration.ConfigurationManager.ConnectionStrings["XXB"].ToString()))
        { }
        public DataBase(DataContext db)
            : this(() => { return db; })
        { }
        public DataBase(Func<DataContext> func)
        {
            this.DB = func();
        }
        #endregion

        #region DBContext SubmitChanges
        /// <summary>
        /// XXB默认提交【重写时候可能需要写入自定义的类似约束的逻辑】
        /// </summary>
        protected virtual void SubmitChanges()
        {
            ChangeSet cSet = DB.GetChangeSet();
            if (cSet.Inserts.Count > 0
                || cSet.Updates.Count > 0
                || cSet.Deletes.Count > 0)
            {
                try
                {
                    DB.SubmitChanges(System.Data.Linq.ConflictMode.ContinueOnConflict);
                }
                catch (System.Data.Linq.ChangeConflictException)
                {
                    foreach (System.Data.Linq.ObjectChangeConflict occ in DB.ChangeConflicts)
                    {
                        occ.Resolve(System.Data.Linq.RefreshMode.OverwriteCurrentValues);
                        occ.Resolve(System.Data.Linq.RefreshMode.KeepCurrentValues);
                        occ.Resolve(System.Data.Linq.RefreshMode.KeepChanges);
                    }
                    DB.SubmitChanges();
                }
            }
        }

        #endregion

        #region IRepository 成员

        public virtual void Update<TEntity>(TEntity entity) where TEntity : class
        {
            this.SubmitChanges();
            
        }

        public virtual void Update<TEntity>(IEnumerable<TEntity> list) where TEntity : class
        {
            list.ToList().ForEach(entity =>
            {
                this.Update<TEntity>(entity);
            });
        }

        public virtual void Insert<TEntity>(TEntity entity) where TEntity : class
        {
            DB.GetTable<TEntity>().InsertOnSubmit(entity);
            this.SubmitChanges();
        }

        public virtual void Insert<TEntity>(IEnumerable<TEntity> list) where TEntity : class
        {
            DB.GetTable<TEntity>().InsertAllOnSubmit<TEntity>(list);
            this.SubmitChanges();
        }

        public virtual TEntity InsertGetIDENTITY<TEntity>(TEntity entity) where TEntity : class
        {
            this.Insert<TEntity>(entity);
            return GetModel<TEntity>(i => i == entity).FirstOrDefault();
        }

        public virtual void Delete<TEntity>(TEntity entity) where TEntity : class
        {
            DB.GetTable<TEntity>().DeleteOnSubmit(entity);
            this.SubmitChanges();
        }

        public virtual void Delete<TEntity>(IEnumerable<TEntity> list) where TEntity : class
        {
            DB.GetTable<TEntity>().DeleteAllOnSubmit<TEntity>(list);
            this.SubmitChanges();
        }

        public virtual IQueryable<TEntity> GetModel<TEntity>() where TEntity : class
        {
            return this.DB.GetTable<TEntity>();
        }

        public virtual IQueryable<TEntity> GetModel<TEntity>(System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate) where TEntity : class
        {
            return GetModel<TEntity>().Where(predicate);
        }

        public virtual TEntity Find<TEntity>(params object[] keyValues) where TEntity : class
        {
            var mapping = DB.Mapping.GetTable(typeof(TEntity));
            var keys = mapping.RowType.IdentityMembers.Select((m, i) => m.Name + " = @" + i).ToArray();
            TEntity entityTEntity = DB.GetTable<TEntity>().Where(String.Join(" && ", keys), keyValues).FirstOrDefault();
            if (entityTEntity != null)
                DB.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, entityTEntity);
            return entityTEntity;
        }

        #endregion
    }

对于一个数据操作具体类来说，直接继承它就可以了，然后再去实现自己的业务逻辑，很清晰。