Modèle d'usine en C #: comment s'assurer qu'une instance d'objet ne peut être créée que par une classe d'usine?

Récemment, j'ai pensé à sécuriser une partie de mon code. Je suis curieux de savoir comment on peut s'assurer qu'un objet ne peut jamais être créé directement, mais uniquement via une méthode d'une classe d'usine. Disons que j'ai une classe "objet métier" et que je veux m'assurer que toute instance de cette classe aura un état interne valide. Pour ce faire, je devrai effectuer quelques vérifications avant de créer un objet, probablement dans son constructeur. Tout va bien jusqu'à ce que je décide que je souhaite que cette vérification fasse partie de la logique métier. Alors, comment puis-je faire en sorte qu'un objet métier puisse être créé uniquement via une méthode de ma classe de logique métier, mais jamais directement? Le premier désir naturel d'utiliser un bon vieux mot-clé "ami" de C ++ échouera avec C #. Nous avons donc besoin d'autres options ...

Essayons un exemple:

public MyBusinessObjectClass
{
    public string MyProperty { get; private set; }

    public MyBusinessObjectClass (string myProperty)
    {
        MyProperty = myProperty;
    }
}

public MyBusinessLogicClass
{
    public MyBusinessObjectClass CreateBusinessObject (string myProperty)
    {
        // Perform some check on myProperty

        if (true /* check is okay */)
            return new MyBusinessObjectClass (myProperty);

        return null;
    }
}

Tout va bien jusqu'à ce que vous vous souveniez que vous pouvez toujours créer une instance MyBusinessObjectClass directement, sans vérifier l'entrée. Je voudrais exclure complètement cette possibilité technique.

Alors, qu'en pense la communauté?

Il semble que vous souhaitiez simplement exécuter une logique métier avant de créer l'objet - alors pourquoi ne créez-vous pas simplement une méthode statique à l'intérieur de la "BusinessClass" qui fait tout le travail de vérification sale de "myProperty" et rend le constructeur privé?

public BusinessClass
{
    public string MyProperty { get; private set; }

    private BusinessClass()
    {
    }

    private BusinessClass(string myProperty)
    {
        MyProperty = myProperty;
    }

    public static BusinessClass CreateObject(string myProperty)
    {
        // Perform some check on myProperty

        if (/* all ok */)
            return new BusinessClass(myProperty);

        return null;
    }
}

L'appeler serait assez simple:

BusinessClass objBusiness = BusinessClass.CreateObject(someProperty);

Vous pouvez rendre le constructeur privé et la fabrique un type imbriqué:

public class BusinessObject
{
    private BusinessObject(string property)
    {
    }

    public class Factory
    {
        public static BusinessObject CreateBusinessObject(string property)
        {
            return new BusinessObject(property);
        }
    }
}

Cela fonctionne car les types imbriqués ont accès aux membres privés de leurs types englobants. Je sais que c'est un peu restrictif, mais j'espère que cela aidera ...

Ou, si vous voulez être vraiment sophistiqué, inversez le contrôle: demandez à la classe de renvoyer l'usine et d'instrumenter l'usine avec un délégué qui peut créer la classe.

public class BusinessObject
{
  public static BusinessObjectFactory GetFactory()
  {
    return new BusinessObjectFactory (p => new BusinessObject (p));
  }

  private BusinessObject(string property)
  {
  }
}

public class BusinessObjectFactory
{
  private Func<string, BusinessObject> _ctorCaller;

  public BusinessObjectFactory (Func<string, BusinessObject> ctorCaller)
  {
    _ctorCaller = ctorCaller;
  }

  public BusinessObject CreateBusinessObject(string myProperty)
  {
    if (...)
      return _ctorCaller (myProperty);
    else
      return null;
  }
}

:)

Vous pouvez rendre le constructeur de votre classe MyBusinessObjectClass interne et le déplacer ainsi que la fabrique dans leur propre assembly. Désormais, seule la fabrique devrait être capable de construire une instance de la classe.

En dehors de ce que Jon a suggéré, vous pouvez également faire en sorte que la méthode de fabrique (y compris la vérification) soit une méthode statique de BusinessObject en premier lieu. Ensuite, faites en sorte que le constructeur soit privé et tout le monde sera obligé d'utiliser la méthode statique.

public class BusinessObject
{
  public static Create (string myProperty)
  {
    if (...)
      return new BusinessObject (myProperty);
    else
      return null;
  }
}

Mais la vraie question est: pourquoi avez-vous cette exigence? Est-il acceptable de déplacer l'usine ou la méthode d'usine dans la classe?

Après tant d'années, cela a été demandé, et toutes les réponses que je vois vous disent malheureusement comment vous devez faire votre code au lieu de donner une réponse directe. La vraie réponse que vous recherchiez est d'avoir vos classes avec un constructeur privé mais un instanciateur public, ce qui signifie que vous ne pouvez créer de nouvelles instances qu'à partir d'autres instances existantes ... qui ne sont disponibles que dans l'usine:

L'interface de vos cours:

public interface FactoryObject
{
    FactoryObject Instantiate();
}

Ta classe:

public class YourClass : FactoryObject
{
    static YourClass()
    {
        Factory.RegisterType(new YourClass());
    }

    private YourClass() {}

    FactoryObject FactoryObject.Instantiate()
    {
        return new YourClass();
    }
}

Et, enfin, l'usine:

public static class Factory
{
    private static List<FactoryObject> knownObjects = new List<FactoryObject>();

    public static void RegisterType(FactoryObject obj)
    {
        knownObjects.Add(obj);
    }

    public static T Instantiate<T>() where T : FactoryObject
    {
        var knownObject = knownObjects.Where(x => x.GetType() == typeof(T));
        return (T)knownObject.Instantiate();
    }
}

Ensuite, vous pouvez facilement modifier ce code si vous avez besoin de paramètres supplémentaires pour l'instanciation ou pour prétraiter les instances que vous créez. Et ce code vous permettra de forcer l'instanciation à travers la fabrique car le constructeur de classe est privé.

Une autre option (légère) consiste à créer une méthode de fabrique statique dans la classe BusinessObject et à garder le constructeur privé.

public class BusinessObject
{
    public static BusinessObject NewBusinessObject(string property)
    {
        return new BusinessObject();
    }

    private BusinessObject()
    {
    }
}

Donc, il semble que ce que je veux ne peut pas être fait de manière «pure». C'est toujours une sorte de "rappel" à la classe logique.

Peut-être que je pourrais le faire d'une manière simple, il suffit de faire une méthode de contructor dans la classe d'objet d'abord appeler la classe logique pour vérifier l'entrée?

public MyBusinessObjectClass
{
    public string MyProperty { get; private set; }

    private MyBusinessObjectClass (string myProperty)
    {
        MyProperty  = myProperty;
    }

    pubilc static MyBusinessObjectClass CreateInstance (string myProperty)
    {
        if (MyBusinessLogicClass.ValidateBusinessObject (myProperty)) return new MyBusinessObjectClass (myProperty);

        return null;
    }
}

public MyBusinessLogicClass
{
    public static bool ValidateBusinessObject (string myProperty)
    {
        // Perform some check on myProperty

        return CheckResult;
    }
}

De cette façon, l'objet métier ne peut pas être créé directement et la méthode de vérification publique dans la logique métier ne fera aucun mal non plus.

Dans un cas de bonne séparation entre les interfaces et les implémentations, le
modèle protected-constructor-public-initializer permet une solution très soignée.

Étant donné un objet métier:

public interface IBusinessObject { }

class BusinessObject : IBusinessObject
{
    public static IBusinessObject New() 
    {
        return new BusinessObject();
    }

    protected BusinessObject() 
    { ... }
}

et une usine commerciale:

public interface IBusinessFactory { }

class BusinessFactory : IBusinessFactory
{
    public static IBusinessFactory New() 
    {
        return new BusinessFactory();
    }

    protected BusinessFactory() 
    { ... }
}

la modification suivante de l' BusinessObject.New()initialiseur donne la solution:

class BusinessObject : IBusinessObject
{
    public static IBusinessObject New(BusinessFactory factory) 
    { ... }

    ...
}

Ici, une référence à une usine commerciale concrète est nécessaire pour appeler l' BusinessObject.New()initialiseur. Mais le seul qui dispose de la référence requise est l'usine commerciale elle-même.

Nous avons obtenu ce que nous voulions: le seul qui puisse créer l' BusinessObjectest BusinessFactory.

    public class HandlerFactory: Handler
    {
        public IHandler GetHandler()
        {
            return base.CreateMe();
        }
    }

    public interface IHandler
    {
        void DoWork();
    }

    public class Handler : IHandler
    {
        public void DoWork()
        {
            Console.WriteLine("hander doing work");
        }

        protected IHandler CreateMe()
        {
            return new Handler();
        }

        protected Handler(){}
    }

    public static void Main(string[] args)
    {
        // Handler handler = new Handler();         - this will error out!
        var factory = new HandlerFactory();
        var handler = factory.GetHandler();

        handler.DoWork();           // this works!
    }

Je mettrais l'usine dans le même assemblage que la classe de domaine et marquerais le constructeur de la classe de domaine comme interne. De cette façon, n'importe quelle classe de votre domaine peut être en mesure de créer une instance, mais vous ne vous faites pas confiance, n'est-ce pas? Quiconque écrit du code en dehors de la couche de domaine devra utiliser votre usine.

public class Person
{
  internal Person()
  {
  }
}

public class PersonFactory
{
  public Person Create()
  {
    return new Person();
  }  
}

Cependant, je dois remettre en question votre approche :-)

Je pense que si vous voulez que votre classe Person soit valide lors de la création, vous devez mettre le code dans le constructeur.

public class Person
{
  public Person(string firstName, string lastName)
  {
    FirstName = firstName;
    LastName = lastName;
    Validate();
  }
}

Cette solution est basée sur l' idée courante d'utiliser un jeton dans le constructeur. Fait dans cette réponse, assurez-vous que l'objet créé uniquement par l'usine (C #)

  public class BusinessObject
    {
        public BusinessObject(object instantiator)
        {
            if (instantiator.GetType() != typeof(Factory))
                throw new ArgumentException("Instantiator class must be Factory");
        }

    }

    public class Factory
    {
        public BusinessObject CreateBusinessObject()
        {
            return new BusinessObject(this);
        }
    }

De multiples approches avec différents compromis ont été mentionnées.

• L'imbrication de la classe de fabrique dans la classe de construction privée permet uniquement à la fabrique de construire 1 classe. À ce stade, vous êtes mieux avec une Createméthode et un ctor privé.
• L'utilisation de l'héritage et d'un ctor protégé pose le même problème.

Je voudrais proposer la fabrique comme une classe partielle qui contient des classes imbriquées privées avec des constructeurs publics. Vous cachez à 100% l'objet que votre usine est en train de construire et n'exposez que ce que vous choisissez via une ou plusieurs interfaces.

Le cas d'utilisation que j'ai entendu pour cela serait lorsque vous souhaitez suivre 100% des instances dans l'usine. Cette conception ne garantit à personne d'autre que l'usine d'avoir accès à la création d'instances de «produits chimiques» définis dans «l'usine» et élimine le besoin d'un assemblage séparé pour y parvenir.

== ChemicalFactory.cs ==
partial class ChemicalFactory {
    private  ChemicalFactory() {}

    public interface IChemical {
        int AtomicNumber { get; }
    }

    public static IChemical CreateOxygen() {
        return new Oxygen();
    }
}


== Oxygen.cs ==
partial class ChemicalFactory {
    private class Oxygen : IChemical {
        public Oxygen() {
            AtomicNumber = 8;
        }
        public int AtomicNumber { get; }
    }
}



== Program.cs ==
class Program {
    static void Main(string[] args) {
        var ox = ChemicalFactory.CreateOxygen();
        Console.WriteLine(ox.AtomicNumber);
    }
}

Je ne comprends pas pourquoi vous voulez séparer la "logique métier" de l '"objet métier". Cela ressemble à une distorsion de l'orientation de l'objet, et vous finirez par vous nouer en adoptant cette approche.

Je ne pense pas qu'il existe une solution qui ne soit pas pire que le problème, tout ce qu'il a ci-dessus nécessite une usine statique publique, ce qui, à mon humble avis, est un problème pire et n'empêchera pas les gens d'appeler l'usine pour utiliser votre objet - cela ne cache rien. Il est préférable d'exposer une interface et / ou de conserver le constructeur comme interne si vous le pouvez, c'est la meilleure protection car l'assembly est du code de confiance.

Une option est d'avoir un constructeur statique qui enregistre une fabrique quelque part avec quelque chose comme un conteneur IOC.

Voici une autre solution dans la veine du "juste parce que vous pouvez ne signifie pas que vous devriez" ...

Il répond aux exigences de garder le constructeur d'objet métier privé et de placer la logique d'usine dans une autre classe. Après cela, cela devient un peu sommaire.

La classe de fabrique a une méthode statique pour créer des objets métier. Il dérive de la classe d'objet métier afin d'accéder à une méthode de construction protégée statique qui appelle le constructeur privé.

La fabrique est abstraite, vous ne pouvez donc pas en créer une instance (car ce serait également un objet métier, ce serait donc bizarre), et elle a un constructeur privé afin que le code client ne puisse pas en dériver.

Ce qui n'est pas empêché, c'est que le code client dérive également de la classe d'objet métier et appelle la méthode de construction statique protégée (mais non validée). Ou pire, en appelant le constructeur par défaut protégé, nous avons dû ajouter pour obtenir la classe d'usine à compiler en premier lieu. (Ce qui, par ailleurs, est susceptible de poser problème avec tout modèle qui sépare la classe de fabrique de la classe d'objets métier.)

Je n'essaie pas de suggérer à quiconque sain d'esprit de faire quelque chose comme ça, mais c'était un exercice intéressant. FWIW, ma solution préférée serait d'utiliser un constructeur interne et la limite d'assemblage comme garde.

using System;

public class MyBusinessObjectClass
{
    public string MyProperty { get; private set; }

    private MyBusinessObjectClass(string myProperty)
    {
        MyProperty = myProperty;
    }

    // Need accesible default constructor, or else MyBusinessObjectFactory declaration will generate:
    // error CS0122: 'MyBusinessObjectClass.MyBusinessObjectClass(string)' is inaccessible due to its protection level
    protected MyBusinessObjectClass()
    {
    }

    protected static MyBusinessObjectClass Construct(string myProperty)
    {
        return new MyBusinessObjectClass(myProperty);
    }
}

public abstract class MyBusinessObjectFactory : MyBusinessObjectClass
{
    public static MyBusinessObjectClass CreateBusinessObject(string myProperty)
    {
        // Perform some check on myProperty

        if (true /* check is okay */)
            return Construct(myProperty);

        return null;
    }

    private MyBusinessObjectFactory()
    {
    }
}

J'apprécierais entendre quelques réflexions sur cette solution. Le seul capable de créer «MyClassPrivilegeKey» est l'usine. et 'MyClass' l'exige dans le constructeur. Évitant ainsi la réflexion sur les entrepreneurs privés / «enregistrement» à l'usine.

public static class Runnable
{
    public static void Run()
    {
        MyClass myClass = MyClassPrivilegeKey.MyClassFactory.GetInstance();
    }
}

public abstract class MyClass
{
    public MyClass(MyClassPrivilegeKey key) { }
}

public class MyClassA : MyClass
{
    public MyClassA(MyClassPrivilegeKey key) : base(key) { }
}

public class MyClassB : MyClass
{
    public MyClassB(MyClassPrivilegeKey key) : base(key) { }
}


public class MyClassPrivilegeKey
{
    private MyClassPrivilegeKey()
    {
    }

    public static class MyClassFactory
    {
        private static MyClassPrivilegeKey key = new MyClassPrivilegeKey();

        public static MyClass GetInstance()
        {
            if (/* some things == */true)
            {
                return new MyClassA(key);
            }
            else
            {
                return new MyClassB(key);
            }
        }
    }
}