Exemple #1
0
        public static void Main(string[] args)
        {
            // Abstract factory #1

            Console.WriteLine("======= Abstract Factory =======");

            AbstractFactory factory1 = new ConcreteFactory1();
            Client          client1  = new Client(factory1);

            client1.Run();

            // Abstract factory #2
            AbstractFactory factory2 = new ConcreteFactory2();
            Client          client2  = new Client(factory2);

            client2.Run();

            VocaloidFactory  vocaloidFactory = new ConcreteVocaloidFactory();
            AbstractVocaloid hatsuneMiku     = vocaloidFactory.CreateAVocaloid();
            AbstractVocaloid anotherMiku     = vocaloidFactory.CreateAMiku();

            hatsuneMiku.singForMe();
            anotherMiku.singForMe();

            Console.WriteLine("\n======= Factory Method =======");

            Document[] documents = new Document[2];
            documents [0] = new Resume();
            documents [1] = new Report();

            foreach (Document document in documents)
            {
                Console.WriteLine("\n" + document.GetType().Name + "--");
                foreach (Page page in document.Pages)
                {
                    Console.WriteLine(" " + page.GetType().Name);
                }
            }

            Console.WriteLine("\n======= Singleton Method =======\n");

            Singleton s1 = Singleton.Instance();
            Singleton s2 = Singleton.Instance();

            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            // Wait for user input
            Console.ReadKey();
        }
        public static void CreateSingleton()
        {
            // Klic konstruktorja se ne prevede
            //Singleton single = new Singleton();

            // Pokličimo funkcijo enkrat
            Singleton single1 = Singleton.Instance();

            Console.WriteLine($"Naključni ID prve instance je: {single1.RandomID}");

            // In ponovno
            Singleton single2 = Singleton.Instance();

            Console.WriteLine($"Naključni ID druge instance je: {single2.RandomID}");
        }
 static void Main(string[] args)
 {
     _ = Singleton.Instance();
 }
Exemple #4
0
 //
 static void Main(string[] args)
 {
     //
     Singleton.Instance().DoSomething();
 }
        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();
        }