分析模式:随感——多重动态分类的模拟

  1 using  System;
  2
  3 namespace  MultiTypeTry
  4 {
  5    
  6    public class IObservationB
  7    {
  8        private Observation parent;
  9        public Observation Parent
 10        {
 11            set { parent = value;}
 12            get { return parent; }
 13        }
 14        virtual public void Confirm(){}
 15        
 16    }
 17
 18    public class Hypothesis : IObservationB
 19    {
 20        override public void Confirm()
 21            {
 22                Console.WriteLine("This is Hypothesis!");
 23            }
 24    }
 25
 26    public class Projection : IObservationB
 27    {
 28        override public void Confirm()
 29            {
 30                Console.WriteLine("This is Projection!");
 31            }
 32    }
 33
 34    public class ActiveObservation : IObservationB
 35    {
 36        override public void Confirm()
 37        {
 38            Console.WriteLine("This is ActiveObservation!");
 39        }
 40    }
 41
 42    public class IObservationA
 43    {
 44        private Observation parent;
 45        public Observation Parent
 46        {
 47            set { parent = value;}
 48            get { return parent; }
 49        }
 50        virtual public void Observe(){}
 51    }
 52
 53    public class Measurement : IObservationA
 54    {
 55        override public void Observe()
 56        {
 57            Console.WriteLine("This is Measurement!");
 58        }
 59    }
 60
 61    public class CategoryObservation : IObservationA
 62    {
 63        override public void Observe()
 64        {
 65             Console.WriteLine("This is CategoryObservation!");
 66        }
 67    }
 68
 69
 70    public class Observation 
 71    {
 72        public static IObservationA InstanceA;
 73        public static IObservationB InstanceB;
 74        public Observation(IObservationA iObservationA,IObservationB iObservationB)  
 75        {
 76            InstanceA = iObservationA;
 77            InstanceA.Parent = this;
 78            InstanceB = iObservationB;
 79            InstanceB.Parent = this;
 80        }
 81
 82        public static implicit operator IObservationA(Observation ob)
 83        {
 84            return InstanceA;
 85        }
 86
 87        public static implicit operator IObservationB(Observation ob)
 88        {
 89            return InstanceB;
 90        }
 91
 92    }
 93
 94    public class TestApp
 95    {
 96        [STAThread]
 97        public static void Main()
 98        {
 99            IObservationA a = new CategoryObservation();
100            IObservationB b = new Hypothesis();
101
102            Observation ob = new Observation(a,b);
103            
104            ((IObservationA)ob).Observe();
105            ((IObservationB)ob).Confirm();
106
107            //ob.Observe();
108
109            Console.ReadLine();
110
111        }
112    }
113}
114

        先把代码贴上来吧。自己觉得似乎就是一个多接口继承的变种，好象离真正的多重动态分类差的远了些。恩。思考中。