Design patterns
Statische fabrieksmethode

Statische fabrieksmethode

We kunnen onze constructeurs een betekenisvolle naam geven.

We kunnen verschillende constructeurs hetzelfde aantal en type parameters bieden, iets dat we, zoals we eerder zagen, niet kunnen doen met klasseconstructors.

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() {...}
}

Directe toegang tot constructor verbergen

We kunnen voorkomen dat we directe toegang bieden tot bronnenintensieve constructeurs, zoals voor databases. public class DbConnection {private statische finale int MAX_CONNS = 100; private statische 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 fabrieksmethode C #

De statische fabrieksmethode is een variatie op het patroon van de fabrieksmethode . Het wordt gebruikt om objecten te maken zonder de constructor zelf te hoeven bellen.

Wanneer de Static Factory-methode te gebruiken

• als u een betekenisvolle naam wilt geven aan de methode die uw object genereert.
• zie Tuple Msdn als u wilt voorkomen dat objecten te complex worden gemaakt .
• als u het aantal gemaakte objecten wilt beperken (caching)
• als u een object van een subtype van hun retourtype wilt retourneren.

Er zijn enkele nadelen zoals

• Klassen zonder een openbare of beschermde constructor kunnen niet worden geïnitialiseerd in de statische fabrieksmethode.
• Statische fabrieksmethoden zijn als normale statische methoden, dus ze zijn niet te onderscheiden van andere statische methoden (dit kan variëren van IDE tot IDE)

Voorbeeld

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);
    }
}

uitgang

Een pizza met een diameter van 28 cm en een pizza met een diameter van 25 cm en een pizza met een diameter van 35 cm