Design Patterns - Factory Method C#

Creational -> Factory Method

Das FactoyMethod Pattern definiert ein interface zur Erstellung von Objekten, die selbst entscheiden welche Subklassen Sie instanzieren.

Beispiel:

 class Program
    {
        static void Main(string[] args)
        {

            var cupCakes = new ICupCake[2];

            cupCakes[0] = new CherryCake();

            cupCakes[1] = new StrawberryCake();

            foreach (var cupCake in cupCakes)
            {
                Console.WriteLine(cupCake.GetType().Name);
                List<Fixings> list = cupCake.GetFixings();
                foreach (var fixing in list)
                {
                    Console.WriteLine("-- " + fixing.Name);
                }
            }

        }
    }

    public interface ICupCake
    {
        List<Fixings> GetFixings();
    }

    class CherryCake : ICupCake
    {
        readonly List<Fixings> _fixings = new List<Fixings>();

        public CherryCake()
        {
            _fixings.Add(new Fixings { Name = "Cherries" });
        }

        public List<Fixings> GetFixings()
        {
            return _fixings;
        }
    }

    class StrawberryCake : ICupCake
    {
        readonly List<Fixings> _fixings = new List<Fixings>();

        public StrawberryCake()
        {
            _fixings.Add(new Fixings { Name = "Strawberries" });
        }

        public List<Fixings> GetFixings()
        {
            return _fixings;
        }
    }

    public class Fixings
    {
        public string Name;
    }

Design Pattern - Singleton C#

Creational -> Singleton

Das Singleton Pattern stellt sicher, dass es vom gewünschten Objekt nur eine Instanz gibt und diese Global zu erreichen ist.

Beispiel:

class Program
    {
        static void Main(string[] args)
        {
            Overlord overlord1 = Overlord.GetOverlord();
            Overlord overlord2 = Overlord.GetOverlord();
            Overlord overlord3 = Overlord.GetOverlord();
            Overlord overlord4 = Overlord.GetOverlord();

            // Same instance?
            if (overlord1 == overlord2 && overlord2 == overlord3 && overlord3 == overlord4)
            {
                Console.WriteLine("Same overlord!");
            }


            // Summon 15 minions

            Overlord overlord = Overlord.GetOverlord();

            for (int i = 0; i < 15; i++)
            {
                var server = overlord.Minion;
                Console.WriteLine("Command your minion: " + server);
            }

            Console.ReadKey();

        }
    }


    class Overlord
    {
        private static Overlord _instance;
        private List<string> _minions = new List<string>();
        private Random _randomMinion = new Random();

        private static object syncLock = new object();
 
        // protected constructor
        protected Overlord()
        {
            _minions.Add("Minion1");
            _minions.Add("Minion2");
            _minions.Add("Minion3");
            _minions.Add("Minion4");
            _minions.Add("Minion5");
        }

        public static Overlord GetOverlord()
        {

          if (_instance == null)
          {
 
            lock (syncLock)
            {
 
              if (_instance == null)
              {
                _instance = new Overlord();
              }
            }
          }

          return _instance;
        }

        public string Minion
        {
          get
          {
            int random = _randomMinion.Next(_minions.Count);
            return _minions[random];
          }
        }
      }

Design Patterns - Abstract Factory C#

Creational -> Abstract Factory

Die Abstract Factory implementiert eine Schnittstelle zur Erzeugung von ähnlichen und/oder abhängigen Objektgruppen ohne diese direkt anzugeben oder zu kennen.

Hauptklasse:

1:  class Program  
2:    {  
3:      static void Main(string[] args)  
4:      {  
5:        // Factory #2  
6:        Abstract.AbstractFactory factory1 = new ConcreteFactory1();  
7:        var c1 = new Program(factory1);  
8:        c1.Run();  
9:        // Factory #1  
10:        Abstract.AbstractFactory factory2 = new ConcreteFactory2();  
11:        var c2 = new Program(factory2);  
12:        c2.Run();  
13:        Console.Read();  
14:      }  
15:      public Program(Abstract.AbstractFactory factory)  
16:      {  
17:        _abstractProductA = factory.CreateProductA();  
18:        _abstractProductB = factory.CreateProductB();  
19:      }  
20:      public void Run()  
21:      {  
22:        _abstractProductB.Interact(_abstractProductA);  
23:      }  
24:      private readonly AbstractProductA _abstractProductA;  
25:      private readonly AbstractProductB _abstractProductB;  
26:    }  

AbstractFactory.cs

1:  namespace AbstractFactory.Abstract  
2:  {  
3:    abstract class AbstractFactory  
4:    {  
5:      public abstract AbstractProductA CreateProductA();  
6:      public abstract AbstractProductB CreateProductB();  
7:    }  
8:  }  

AbstractProductA.cs

1:  namespace AbstractFactory.Abstract  
2:  {  
3:    abstract class AbstractProductA  
4:    {  
5:    }  
6:  }  

AbstractProductB.cs

1:  namespace AbstractFactory.Abstract  
2:  {  
3:    abstract class AbstractProductB  
4:    {  
5:      public abstract void Interact(AbstractProductA a);  
6:    }  
7:  }  

ConcreteFactory1.cs

1:  using AbstractFactory.Abstract;  
2:  using AbstractFactory.Product;  
3:  namespace AbstractFactory.Concrete  
4:  {  
5:    class ConcreteFactory1 : Abstract.AbstractFactory  
6:    {  
7:      public override AbstractProductA CreateProductA()  
8:      {  
9:        return new ProductA1();  
10:      }  
11:      public override AbstractProductB CreateProductB()  
12:      {  
13:        return new ProductB1();  
14:      }  
15:    }  
16:  }  

ConcreteFactory2.cs

1:  using AbstractFactory.Abstract;  
2:  using AbstractFactory.Product;  
3:  namespace AbstractFactory.Concrete  
4:  {  
5:    class ConcreteFactory2 : Abstract.AbstractFactory  
6:    {  
7:      public override AbstractProductA CreateProductA()  
8:      {  
9:        return new ProductA2();  
10:      }  
11:      public override AbstractProductB CreateProductB()  
12:      {  
13:        return new ProductB2();  
14:      }  
15:    }  
16:  }  

AbstractProductA1.cs

1:  using AbstractFactory.Abstract;  
2:  namespace AbstractFactory.Product  
3:  {  
4:    class ProductA1 : AbstractProductA  
5:    {  
6:    }  
7:  }  

AbstractProductA2.cs

1:  using AbstractFactory.Abstract;  
2:  namespace AbstractFactory.Product  
3:  {  
4:    class ProductA2 : AbstractProductA  
5:    {  
6:    }  
7:  }  

AbstractProductB1.cs

1:  using System;  
2:  using AbstractFactory.Abstract;  
3:  namespace AbstractFactory.Product  
4:  {  
5:    class ProductB1 : AbstractProductB  
6:    {  
7:      public override void Interact(AbstractProductA a)  
8:      {  
9:        Console.WriteLine(GetType().Name + " interacts with " + a.GetType().Name);  
10:      }  
11:    }  
12:  }  

AbstractProductB2.cs

1:  using System;  
2:  using AbstractFactory.Abstract;  
3:  namespace AbstractFactory.Product  
4:  {  
5:    class ProductB2 : AbstractProductB  
6:    {  
7:      public override void Interact(AbstractProductA a)  
8:      {  
9:        Console.WriteLine(GetType().Name + " interacts with " + a.GetType().Name);  
10:      }  
11:    }  
12:  }