架构，改善程序复用性的设计~第三讲 实现一种功能的代码只能出现在一处（续）

在写完架构，改善程序复用性的设计~第三讲 实现一种功能的代码只能出现在一处 ， 这篇文章后，得到了园友的反馈，说这种简单的业务逻辑还可以，但业务比较复杂时，根据就没法用这种方法。

针对这个问题，我觉得有必要再写一个续集了，呵呵！

上回说的主要核心内容是将公用的部分从一个方法中提取出来，生成一个新的方法，这个重构中叫做“提取到方法”
，另外一个核心内容就是方法的”单一职责“，即一个方法干一件事，将出现复杂事件时，将多个方法进行组合调用即可

这回主要说一个重构中的提取，其实不仅方法可以被提取，类，及整个项目也可以被提取，只要他们有被提取的必要！
一个例子：对于一个数据实体操作的基类，它包括了其它所有实体类共有的属性（DB）和方法（SubmitChanges），这可以理解了”提取到类“，当然这也是类的继承及面向对象的一个例子。

     /// <summary>
    /// ＬＩＮＱ数据库操作基类
    /// </summary>
    public abstract class RepositoryBase
    {
        public RepositoryBase(DataContext db)
        {
            DB = db;
        }
       protected System.Data.Linq.DataContext DB { get; private set; }

        #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 ex)
                {
                    foreach (System.Data.Linq.ObjectChangeConflict occ in DB.ChangeConflicts)
                    {
                        // 使用当前数据库中的值，覆盖Linq缓存中实体对象的值  
                        occ.Resolve(System.Data.Linq.RefreshMode.OverwriteCurrentValues);
                        // 使用Linq缓存中实体对象的值，覆盖当前数据库中的值  
                        occ.Resolve(System.Data.Linq.RefreshMode.KeepCurrentValues);
                        // 只更新实体对象中改变的字段的值，其他的保留不变  
                        occ.Resolve(System.Data.Linq.RefreshMode.KeepChanges);
                    }
                    DB.SubmitChanges();
                }
            }
        }

        #endregion
     }

还有一种更大程序上的提取，即”提取到项目“，就是说，它的整个项目都是其它项目公用的部分，所有把整个项目抽象出来

Entity.Commons这个项目是对所有解决方案的所有实体层进行的抽象，它里面有对实体的分页，实体参数组织，实体消息返回及实体统一验证等功能，都在Entity.Commons里实现

EntityBase.cs代码如下：

    /// <summary>
    /// 实体基类，与linq to sql数据映射对应
    /// </summary>
    [Serializable]
    public abstract class EntityBase /*: INotifyPropertyChanging, INotifyPropertyChanged*/
    {

        public EntityBase()
        {
            this.IsRealDeleted = true;
        }
        #region 实体相关
        /// <summary>
        /// 实体主键
        /// 在子类中对它赋值，在其它类中可以访问到这个主键属性
        /// </summary>
        public abstract object[] PrimaryKey { get; }
        /// <summary>
        /// 是否执行真删除,默认为true,如果设为false，则更新实体的status字段
        /// </summary>
        public virtual bool IsRealDeleted { get; protected set; }
        /// <summary>
        /// 记录修改的列信息
        /// 子类可以根据需要，去复写记录数据的方式
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected virtual void PropertyChangedEvent(object sender, PropertyChangedEventArgs e)
        {
            #region 添加修改字段记录
            // VLog.IVLog log = new VLog.SqlVLog();
            // log.Write(string.Format("被修改的字段{0}", e.PropertyName));
            #endregion
            #region 记录修改的字段和修改成的值
            Type t = this.GetType();
            PropertyInfo pi = t.GetProperty(e.PropertyName);
            object value = pi.GetValue(this, null);
            this.OnPropertyChanged(e.PropertyName, value);
            #endregion

        }
        #endregion

        #region 实体验证

        /// <summary>
        /// 验证的字段名集合，为NULL表示验证所有字段
        /// </summary>
        public string[] ValidFields { get; set; }

        /// <summary>
        /// 数据验证(是否成功)
        /// 虚属性，子类可以根据自己的逻辑去复写
        /// </summary>
        public virtual bool IsValid { get { return this.GetRuleViolations().Count() == 0; } }
        /// <summary>
        /// 获取验证失败的信息枚举,默认提供了非空验证
        /// 它使用了简单的迭代器,如果GetRuleViolations有错误则返回迭代列表
        /// </summary> 
        /// <returns></returns>
        public virtual IEnumerable<RuleViolation> GetRuleViolations()
        {
            PropertyInfo[] propertyInfo = this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
            if (ValidFields != null) propertyInfo = propertyInfo.Where(i => ValidFields.Contains(i.Name)).ToArray();
            foreach (var i in propertyInfo)
            {
                if (i.GetCustomAttributes(typeof(System.Data.Linq.Mapping.ColumnAttribute), false) != null
                    && i.GetCustomAttributes(typeof(System.Data.Linq.Mapping.ColumnAttribute), false).Count() > 0
                    && !((System.Data.Linq.Mapping.ColumnAttribute)i.GetCustomAttributes(typeof(System.Data.Linq.Mapping.ColumnAttribute), false)[0]).CanBeNull
                    && !((System.Data.Linq.Mapping.ColumnAttribute)i.GetCustomAttributes(typeof(System.Data.Linq.Mapping.ColumnAttribute), false)[0]).IsPrimaryKey)
                    if (i.GetValue(this, null) == null || string.IsNullOrEmpty(i.GetValue(this, null).ToString()))
                        yield return new RuleViolation("*", i.Name);
            }
        }
        #endregion

        #region 重写linq to sql的一些东西

        #region INotifyPropertyChanged and INotifyPropertyChanging Members

        public event PropertyChangedEventHandler BasePropertyChanged;
        public event PropertyChangingEventHandler BasePropertyChanging;
        protected virtual void OnPropertyChanging(String propertyName)
        {
            if ((this.BasePropertyChanging != null))
            {
                this.BasePropertyChanging(this, new PropertyChangingEventArgs(propertyName));
            }
        }
        protected virtual void OnPropertyChanged(String propertyName, object newValue)
        {
            if ((this.BasePropertyChanged != null))
            {
                this.BasePropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }

            if (_changeList == null)
                return;

            if (_changeList.ContainsKey(propertyName))
            {
                _changeList.Remove(propertyName);
            }
            _changeList.Add(propertyName, newValue);
        }
        protected bool IsPropertyChanged(string name)
        {
            return _changeList != null && _changeList.ContainsKey(name);
        }
        #endregion

        #region Change tracking

        private Dictionary<string, object> _changeList;

        public Dictionary<string, object> GetChanges()
        {
            return _changeList;
        }

        private void StartTrackChanges()
        {
            if (_changeList != null)
            {
                throw new InvalidOperationException("This object is already tracking changes");
            }
            _changeList = new Dictionary<string, object>();
        }

        private bool _IsAlreadySaved = false;

        public bool IsAlreadySaved()
        {
            return _IsAlreadySaved;
        }
        /// <summary>
        /// 保存实体
        /// </summary>
        public void MarkEntitySaved()
        {
            _IsAlreadySaved = true;
        }
        /// <summary>
        /// 实体初始化，开始跟踪实体的变化　
        /// </summary>
        public virtual void Initialization()
        {
            this.StartTrackChanges();
        }

        #endregion

        #endregion
    }
    #region 子类更新需要实现它的分部方法，内容如下
    //partial void OnCreated()
    //  {
    //      base.IsRealDeleted = false;//假删除
    //      base.Initialization();//基类的某些属性初始化
    //      this.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(base.PropertyChangedEvent);//初始实体时，先订阅列修改的事件
    //  }
    #endregion

通过这篇文章，我们知道了，对于代码重构，不仅仅只对于方法而言，对于重构，也不仅仅只对一个项目而言，它可能是项目与项目之间的重构。