예제 #1
0
        static void Invock3()
        {
            //基础功能类
            var c = new ConcreteComponent();
            //装饰A类
            var dA = new ConcreteDecoratorA();
            //装饰B类
            var dB = new ConcreteDecoratorB();

            dA.Component = c;
            dB.Component = dA;
            dB.Operation();
        }
예제 #2
0
        static void Main(string[] args)
        {
            var a = DesignPatterns.Singleton.Singleton.GetInstanceUnSafe;

            var b = DesignPatterns.Singleton.Singleton.GetInstanceUnSafe;

            if (a == b)
            {
                Console.WriteLine("Singleton works, both variables contain the same instance.");
            }
            else
            {
                Console.WriteLine("Singleton failed, variables contain different instances.");
            }

            var c = NotSingleton.GetInstanceUnSafe;

            var d = NotSingleton.GetInstanceUnSafe;

            if (c == d)
            {
                Console.WriteLine("Singleton works, both variables contain the same instance.");
            }
            else
            {
                Console.WriteLine("Singleton failed, variables contain different instances.");
            }

            Client client = new Client();

            var simple = new ConcreteComponent();

            Console.WriteLine("Client: I get a simple component:");
            client.ClientCode(simple);
            Console.WriteLine();

            ConcreteDecoratorA decorator1 = new ConcreteDecoratorA(simple);
            ConcreteDecoratorB decorator2 = new ConcreteDecoratorB(decorator1);
            ConcreteDecoratorC decorator3 = new ConcreteDecoratorC(decorator2);

            Console.WriteLine("Client: Now I've got a decorated component:");
            client.ClientCode(decorator3);

            new DesignPatterns.Factory.Client().Main();
        }
예제 #3
0
        private static void DemonstrateDecorator()
        {
            // First create a component that should be decorated
            var component = new ConcreteComponent();

            // Then create a decorator and supply the component to it, this expands the components functionality.
            var decoratorA = new ConcreteDecoratorA(component);

            // The pattern allows both adding the base component, or another decorator.
            var decoratorB1 = new ConcreteDecoratorB(component);
            var decoratorB2 = new ConcreteDecoratorB(decoratorA); // Expands the functionality even more.

            component.Operation();
            decoratorA.Operation();
            decoratorB1.Operation();
            decoratorB2.Operation();
            decoratorB2.AddedBehavior();
        }
예제 #4
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();
        }