示例#1
0
        static void Invock6()
        {
            ConcretePrototype1 p1 = new ConcretePrototype1("abc");
            ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();

            Console.WriteLine($"Cloned:{c1.ID}");
        }
示例#2
0
        public void Main()
        {
            var s = new ConcretePrototype1("id");

            ((ProtoType)s).Idd();   //访问父类被隐藏的Idd方法
            s.Idd();                //默认访问新类的Idd方法
            var sClone = s.Clone();
        }
示例#3
0
        private static void DemonstratePrototype()
        {
            // First create the prototypes
            var p1 = new ConcretePrototype1("One");
            var p2 = new ConcretePrototype2("Two");

            // Then these can be cloned whenever you need a new object with the same data
            var c1 = p1.Clone();
            var c2 = p2.Clone();

            Console.WriteLine($"Clone of type: {c1.Id}"); // This will have Id "One"
            Console.WriteLine($"Clone of type: {c2.Id}"); // and this "Two"
        }
示例#4
0
        static void Main(string[] args)
        {
            ConcretePrototype1 prototype1 = new ConcretePrototype1(1);
            ConcretePrototype1 clone1     = (ConcretePrototype1)prototype1.Clone();

            Console.WriteLine($"Cloned concrete type with id {clone1.Id}");

            ConcretePrototype2 prototype2 = new ConcretePrototype2(2);
            ConcretePrototype2 clone2     = (ConcretePrototype2)prototype2.Clone();

            Console.WriteLine($"Cloned concrete type with id {0}", clone2.Id);

            Console.ReadKey();
        }
示例#5
0
        public static void Main()
        {
            //--------------------------- AbstractFactory
            Console.WriteLine("--------------------------- AbstractFactory");

            Client client = null;

            client = new Client(new CocaColaFactory());
            client.Run();

            client = null;
            client = new Client(new PepsiColaFactory());
            client.Run();

            /*
             *  AbstractFactory.Program + CocaColaBottle interacts with AbstractFactory.Program + CocaColaWater
             *  AbstractFactory.Program + CocaColaCover closes AbstractFactory.Program + CocaColaBottle
             *  AbstractFactory.Program + PepsiColaBottle interacts with AbstractFactory.Program + PepsiColaWater
             *  AbstractFactory.Program + PepsiColaCover closes AbstractFactory.Program + PepsiColaBottle
             */


            //--------------------------- Builder
            Console.WriteLine("--------------------------- Builder");

            Builder  stoneHouseBuilder = new ConcreteBuilder();
            Director director          = new Director(stoneHouseBuilder);

            director.Construct();

            House house = stoneHouseBuilder.GetResult();

            house.Show();

            /*
             *  Basement Created
             *  Floor Created
             *  Roof Created
             *  Element: DesignPatterns.Basement builded.
             *  Element: DesignPatterns.Floor builded.
             *  Element: DesignPatterns.Roof builded.
             */


            //--------------------------- FactoryMethod
            Console.WriteLine("--------------------------- FactoryMethod");

            Creator creator = new ConcreteCreator();
            Product product = null;

            product = creator.FactoryMethod();
            //creator.AnOperation();

            /* 46104728 */

            //--------------------------- Prototype
            Console.WriteLine("--------------------------- Prototype");

            Prototype prototype = new ConcretePrototype1(1);
            Prototype clone     = prototype.Clone();

            clone.AnOperation();

            Prototype prototype2 = new ConcretePrototype2(2);
            Prototype clone2     = prototype2.Clone();

            clone2.AnOperation();

            /*
             *  ID : 1
             *  Class : DesignPatterns.ConcretePrototype1
             *  ID : 2
             *  Class : DesignPatterns.ConcretePrototype2
             */


            //--------------------------- Singleton
            Console.WriteLine("--------------------------- Singleton");

            Singleton firstInstance  = Singleton.Instance();
            Singleton secondInstance = Singleton.Instance();

            // Singleton thirdinstance = new Singleton(); // error

            Console.WriteLine(firstInstance.GetHashCode());
            Console.WriteLine(secondInstance.GetHashCode());
            Console.WriteLine(ReferenceEquals(firstInstance, secondInstance));

            firstInstance.SampleOperation();
            Console.WriteLine(secondInstance.GetSampleData());

            /*
             *  12289376
             *  12289376
             *  True
             *  Singleton Sample Data
             */


            //Console.WriteLine("--------------------------- Adapter (Class)");
            //iTarget target = new Adapter();
            //target.Operation();

            Console.WriteLine("--------------------------- Adapter (Object)");
            Target target = new Adapter();

            target.Operation();

            /*
             *  SpecificOperation
             */


            //--------------------------- Bridge
            Console.WriteLine("--------------------------- Bridge");
            Abstract AnotherAbs11 = new RefinedAbstract1(new ConcreteImp1());

            Console.WriteLine(AnotherAbs11.DoSomething());

            Abstract AnotherAbs21 = new RefinedAbstract2(new ConcreteImp1());

            Console.WriteLine(AnotherAbs21.DoSomething());

            Abstract AnotherAbs12 = new RefinedAbstract1(new ConcreteImp2());

            Console.WriteLine(AnotherAbs12.DoSomething());

            Abstract AnotherAbs22 = new RefinedAbstract2(new ConcreteImp2());

            Console.WriteLine(AnotherAbs22.DoSomething());

            /*
             *  RefinedAbstract1 is doing smth. with Imp1
             *  RefinedAbstract2 is doing different things with Imp1
             *  RefinedAbstract1 is doing smth. with Imp2
             *  RefinedAbstract2 is doing different things with Imp2
             */

            //--------------------------- Composite
            Console.WriteLine("--------------------------- Composite");
            Component root    = new Composite("root");
            Component branch1 = new Composite(" - branch1");
            Component branch2 = new Composite(" - branch2");
            Component leaf1   = new Leaf(" - - leaf1");
            Component leaf2   = new Leaf(" - - leaf2");
            Component leaf3   = new Leaf(" - - leaf3");

            root.Add(branch1);
            root.Add(branch2);
            branch1.Add(leaf1);
            branch1.Add(leaf2);
            branch2.Add(leaf3);

            root.Operation();

            /*
             *  root
             *   - branch1
             *   - - leaf1
             *   - - leaf2
             *   - branch2
             *   - - leaf3
             */


            //--------------------------- Decorator
            Console.WriteLine("--------------------------- Decorator");
            AbstractComponent someComponenet = new ConcreteComponenet();
            Decorator         decoratorA     = new ConcreteDecoratorA();
            Decorator         decoratorB     = new ConcreteDecoratorB();

            decoratorA.component = someComponenet;
            decoratorB.component = decoratorA;
            decoratorB.Operation();


            /*
             *  Concrete Componenet Operation
             *  Some State
             *  Some Behavior
             */


            //--------------------------- Facade
            Console.WriteLine("--------------------------- Facade");
            Facade facade = new Facade();

            facade.OperationAB();
            facade.OperationCD();

            /*
             *  Operation A
             *  Operation B
             *  Operation C
             *  Operation D
             */


            //--------------------------- Flyweight
            Console.WriteLine("--------------------------- Flyweight");

            /*
             *  int externalState = 0;
             *
             *  Flyweight flyweight = null;
             *  FlyweightFactory factory = new FlyweightFactory();
             *
             *  flyweight = factory.GetFlyweight("1");
             *  flyweight.Operation(externalState);
             *
             *  flyweight = factory.GetFlyweight("10");
             *  flyweight.Operation(externalState);
             *
             *  flyweight = new UnsharedConcreteFlyweight();
             *  flyweight.Operation(externalState);
             */

            ActorMikeMyers mike = new ActorMikeMyers();

            RoleAustinPowers austin = new RoleAustinPowers(mike);

            austin.Greetings("Hello! I'm Austin Powers!");

            RoleDoctorEvil dr = new RoleDoctorEvil(mike);

            dr.Greetings("Hello! I'm Dr. Evil!");

            /*
             *  Hello! I'm Austin Powers!
             *  Hello! I'm Dr. Evil!
             */


            //--------------------------- Proxy
            Console.WriteLine("--------------------------- Proxy");
            //Subject original = new Original();
            //Subject proxy = new Proxy(original);
            //proxy.Operation();

            Subject anotherProxy = new Proxy();

            anotherProxy.Operation();

            /*
             *  Do Smth
             *  Do Smth
             */


            //--------------------------- ChainOfResponsibility
            Console.WriteLine("--------------------------- ChainOfResponsibility");
            Handler concreteHandler1 = new ConcreteHandler1();
            Handler concreteHandler2 = new ConcreteHandler2();

            concreteHandler1.successor = concreteHandler2;
            concreteHandler1.Operation(1);
            concreteHandler1.Operation(2);

            /*
             *  One
             *  Two
             */


            //--------------------------- Command
            Console.WriteLine("--------------------------- Command");
            Receiver povar = new Receiver();
            Command  zakaz = new ConcreteCommand(povar);
            //Invoker ofichiant = new Invoker(zakaz);
            Invoker ofichiant = new Invoker();

            ofichiant.StoreCommand(zakaz);
            ofichiant.Execute();

            /*
             *  Receiver!
             */


            //--------------------------- Interpreteur
            Console.WriteLine("--------------------------- Interpreteur");
            Context context = new Context
            {
                Vocabulary = 'a',
                Source     = "aaa"
            };

            var expression = new NonTerminalExpression();

            expression.Interpret(context);
            Console.WriteLine(context.Result);

            /*
             *  True
             */

            Console.ReadKey();
        }