Design patterns
Statische Fabrikmethode

Statische Factory-Methode

Wir können unseren Konstrukteuren einen aussagekräftigen Namen geben.

Wir können mehrere Konstruktoren mit derselben Anzahl und demselben Typ von Parametern bereitstellen, was wir, wie wir zuvor gesehen haben, mit Klassenkonstruktoren nicht machen können.

public class RandomIntGenerator {
    private final int min;
    private final int max;
 
    private RandomIntGenerator(int min, int max) {
        this.min = min;
        this.max = max;
    }
     
    public static RandomIntGenerator between(int max, int min) {
        return new RandomIntGenerator(min, max);
    }
     
    public static RandomIntGenerator biggerThan(int min) {
        return new RandomIntGenerator(min, Integer.MAX_VALUE);
    }
     
    public static RandomIntGenerator smallerThan(int max) {
        return new RandomIntGenerator(Integer.MIN_VALUE, max);
    }
 
    public int next() {...}
}

Direkten Zugriff auf Konstruktor ausblenden

Wir können den direkten Zugriff auf ressourcenintensive Konstruktoren vermeiden, z. B. für Datenbanken. öffentliche Klasse DbConnection {private static final int MAX_CONNS = 100; private static int totalConnections = 0;

   private static Set<DbConnection> availableConnections = new HashSet<DbConnection>();

   private DbConnection()
   {
     // ...
     totalConnections++;
   }

   public static DbConnection getDbConnection()
   {
     if(totalConnections < MAX_CONNS)
     {
       return new DbConnection();
     }

     else if(availableConnections.size() > 0)
     {
         DbConnection dbc = availableConnections.iterator().next();
         availableConnections.remove(dbc);
         return dbc;
     }

     else {
       throw new NoDbConnections();
     }
   }

   public static void returnDbConnection(DbConnection dbc)
   {
     availableConnections.add(dbc);
     //...
   }
}

Statische Factory-Methode C #

Die statische Factory-Methode ist eine Variation des Factory-Method- Musters. Es wird verwendet, um Objekte zu erstellen, ohne den Konstruktor selbst aufrufen zu müssen.

Wann ist die statische Factory-Methode zu verwenden?

• wenn Sie der Methode, die Ihr Objekt generiert, einen aussagekräftigen Namen geben wollen.
• Wenn Sie die Erstellung überkomplexer Objekte vermeiden möchten, lesen Sie Tuple Msdn .
• wenn Sie die Anzahl der erstellten Objekte begrenzen wollen (Caching)
• wenn Sie ein Objekt eines Subtyps seines Rückgabetyps zurückgeben möchten.

Es gibt einige Nachteile wie

• Klassen ohne einen öffentlichen oder geschützten Konstruktor können nicht in der statischen Factory-Methode initialisiert werden.
• Statische Factory-Methoden sind wie normale statische Methoden, sie unterscheiden sich daher nicht von anderen statischen Methoden (dies kann von IDE zu IDE variieren)

Beispiel

Pizza.cs

public class Pizza
{
    public int SizeDiameterCM
    {
        get;
        private set;
    }
         
    private Pizza()
    {
        SizeDiameterCM = 25;
    }

    public static Pizza GetPizza()
    {
        return new Pizza();
    }

    public static Pizza GetLargePizza()
    {
        return new Pizza()
        {
            SizeDiameterCM = 35
        };
    }

    public static Pizza GetSmallPizza()
    {
        return new Pizza()
        {
            SizeDiameterCM = 28
        };
    }

    public override string ToString()
    {
        return String.Format("A Pizza with a diameter of {0} cm",SizeDiameterCM);
    }
}

Program.cs

class Program
{
    static void Main(string[] args)
    {
        var pizzaNormal = Pizza.GetPizza();
        var pizzaLarge = Pizza.GetLargePizza();
        var pizzaSmall = Pizza.GetSmallPizza();


        String pizzaString = String.Format("{0} and {1} and {2}",pizzaSmall.ToString(), pizzaNormal.ToString(), pizzaLarge.ToString());
        Console.WriteLine(pizzaString);
    }
}

Ausgabe

Eine Pizza mit einem Durchmesser von 28 cm und eine Pizza mit einem Durchmesser von 25 cm und eine Pizza mit einem Durchmesser von 35 cm