类的智能化设计_后期添加任意功能

当一个类设计好后.它的属性.字段,方法等都会固定下来.如果要在后期添加新功能.有多种办法

1,直接修改.  用于类比较小,修改的地方也少.就这样直接修改

2,继承一个接口,然后实现接口. 这是常用的.体现了继承的优点. 也有缺点.当类比较多时候.要全部都修改.

3,适配器模式.新建一个类,传入原对象.并继承接口.体现了低耦合,高内聚.如:

  internal interface I新功能
    {
        void 飞();
    }

    internal class 新对象 : I新功能
    {
        private 对象 _对象;

        public 新对象(对象 对象1)
        {
            _对象 = 对象1;
        }

        #region I新功能 Members

        public void 飞()
        {
        }

        #endregion
    }

 

下面要介绍的是让类拥有学习功能.在后期如果再要添加功能就可以学习后再使用.

先让类继承于 智能化接口. 再建立针对于这个类的学校. 当对象需要新功能的时候.就让对象去学校学习.

然后就可以调用对象的新功能了.

 

  internal interface I智能化
    {
        /// <summary>
        /// int 为技能的哈希码. obj为技能.
        /// </summary>
        /// <value>The 技能.</value>
        Dictionary<int, object> 技能 { get; set; }

        /// <summary>
        /// T 为学会的技能
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        T 使用<T>();
    }

    internal interface I学校
    {
        /// <summary>
        /// T 为要学习的技能
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="智能对象">The 智能对象.</param>
        void 教学<T>(I智能化 智能对象);
    }

    internal class 学校 : I学校
    {
        #region I学校 Members

        public void 教学<T>(I智能化 智能对象) //可以有限制,或者其他限制
        {
            var h = typeof (T).GetHashCode();
            if (智能对象.技能.ContainsKey(h))
            {
                return; //存在技能就返回.
            }
            T 新技能 = default (T); //此处可以对技能做更多操作初始化.
            智能对象.技能.Add(h, 新技能);
        }

        #endregion
    }

    internal class 飞
    {
        public void 飞翔()
        {
            //...
        }

        public void 降落()
        {
        }
    }

 

上面建立了通用的智能化接口. 学校接口.和一个新技能飞翔.

下面是对象的建立.

internal class 对象 : I智能化
    {
        public 对象()
        {
            技能 = new Dictionary<int, object>();
        }

        #region I智能化 Members

        public T 使用<T>()
        {
            int h = typeof (T).GetHashCode();
            if (技能.ContainsKey(h))
            {
                return (T) 技能[h];
            }
            return default(T);
        }

        public Dictionary<int, object> 技能 { get; set; }

        #endregion
    }

 对象拥有技能列表.我还没找到怎么用泛型代替.先用万能对象.

客户端调用如下:

 internal class 客户
    {
        private  对象 对象1;

        public 客户()
        {
            对象1 = new 对象();
            演示();
        }

        private void 演示()
        {
            I学校 学校1 = new 学校();
            学校1.教学<飞>(对象1);
            对象1.使用<飞>().飞翔();
        }
    }

 

学校可以对不同的类教学不同的技能, 可以泛型化.

具体表现有更多可以优化的地方.先记录下来,抛砖引玉.