Design patterns
Méthode d'usine statique

Méthode d'usine statique

Nous pouvons fournir un nom significatif à nos constructeurs.

Nous pouvons fournir plusieurs constructeurs avec le même nombre et le même type de paramètres, ce que nous avons vu précédemment, ce que nous ne pouvons pas faire avec les constructeurs de classes.

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

Cacher l'accès direct au constructeur

Nous pouvons éviter de fournir un accès direct aux constructeurs exigeants en ressources, comme pour les bases de données. classe publique 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);
     //...
   }
}

Méthode d'usine statique C #

La méthode d'usine statique est une variante du modèle de méthode d'usine . Il est utilisé pour créer des objets sans avoir à appeler le constructeur vous-même.

Quand utiliser la méthode d'usine statique

• si vous voulez donner un nom significatif à la méthode qui génère votre objet.
• si vous voulez éviter la création d'objets trop complexes, voir Tuple Msdn .
• si vous souhaitez limiter le nombre d'objets créés (mise en cache)
• si vous voulez retourner un objet de n'importe quel sous-type de leur type de retour.

Il y a quelques inconvénients comme

• Les classes sans constructeur public ou protégé ne peuvent pas être initialisées dans la méthode de fabrique statique.
• Les méthodes d'usine statiques sont comme les méthodes statiques normales, elles ne peuvent donc pas être distinguées des autres méthodes statiques (cela peut varier d'un IDE à l'autre)

Exemple

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

Sortie

Une pizza d'un diamètre de 28 cm et une pizza d'un diamètre de 25 cm et une pizza d'un diamètre de 35 cm