Le but d'une factory est de créer un objet de façon dynamique à partir de son type.

Quand on veut implémenter des factory, on doit choisir entre une méthode rapide mais peu typée ou bien fortement typée mais assez fastidieuse.

Ainsi soit on crée une version standard qui renvoie un objet de type object que l'on va devoir transtyper au sortir de la méthode, soit on crée une méthode pour chaque type d'objet que l'on veut instancier, mais cela peut devenir assez long surtout si l'on a beaucoup d'objets à traiter.

L'idéal serait donc de pouvoir combiner les deux en ayant une solution élégante (fortement typée) et rapide à implémenter.

Et si les Generics du framework 2.0 étaient la réponse au problème ?

Si on connait la classe à instancier, le framework nous fournit la méthode générique suivante :

T Activator.CreateInstance<T>() où T est le type de la classe à instancier. Ex :

Business businessObject = Activator.CreateInstance<Business>();

Ceci répond en partie à notre problématique.

Mais bien souvent on ne dispose que de l'interface et d'une chaîne décrivant le type à instancier (stockée dans un fichier de configuration par exemple).
Dans un tel cas, cette méthode devient inutilisable puisqu'une interface ne peut être instanciée.

La solution consiste donc à créer notre propre méthode générique :

   1: public static class Helper

   2: {

   3:     public static T GetInstance<T>(string typeToCreate)

   4:     {

   5:         Type instanceType = Type.GetType(typeToCreate, true, true);

   6:         T instance = (T)Activator.CreateInstance(instanceType);

   7:  

   8:         return instance;

   9:     }

  10: }

  11:  

  12: public class Work

  13: {

  14:     public void DoWork()

  15:     {

  16:         [...]

  17:  

  18:         IBusiness businessObject = 

  19: Helper.GetInstance<IBusiness>("Business.Interfaces.IBusiness, Business");

  20:  

  21:         [...]

  22:     }

  23: }

Ainsi, le code reste fortement typé dans la classe utilisatrice, et la couche technique est centralisée dans une seule et même méthode.