Refactorisation d'une classe statique à utiliser avec l'injection de dépendances

Nous avons besoin d'utiliser un non géré bibliothèque dans notre code qui a des méthodes statiques. J'aimerais vous présenter le fonctionnement de la bibliothèque en tant que dépendance dans mon code. Et en plus d'avoir des méthodes statiques, la bibliothèque dispose d'une méthode d'initialisation et paramétrage de la méthode, à la fois globales. Donc je ne peux pas juste envelopper dans une instance de la classe, parce que si une instance modifie un paramètre, tous les autres cas seront touchés, et si une instance est initialisé, tous les autres cas seront réinitialisés.

J'ai pensé à de la présenter comme une classe singleton. De cette manière, il sera une instance de la classe, mais il n'y aura qu'un seul exemple donc je ne vais pas avoir à vous soucier de changer les paramètres ou de l'initialisation. Que pensez-vous de cette approche? Je suis assez nouveau à l'injection de dépendance modèle et je ne suis pas sûr si le pattern singleton est une bonne solution? Quelle serait votre solution à un cas similaire?

Edit: L'initialisation prend un paramètre trop, donc je ne peux pas verrouiller les appels de méthode et de ré-initialiser et modifier les paramètres à chaque fois qu'il est appelé.

Edit 2: Voici la signature de certaines méthodes:

public static void Initialize(int someParameter)
//Parameter can only be changed by re-initalization which
//will reset all the settings back to their default values.

public static float[] Method1(int someNumber, float[] someArray)

public static void ChangeSetting(string settingName, int settingValue)

source d'informationauteur hattenn

c#dependency-injection refactoring singleton static-classes

Si vous ne devez définir les paramètres une fois au démarrage, alors je vous recommande de faire un non-statique de la classe wrapper qui fait tout l'initialisation de la classe statique dans son propre constructeur statique. De cette façon, vous pouvez être assuré que cela ne se produira qu'une fois:

public class MyWrapper
{
    public MyWrapper()
    {
        //Do any necessary instance initialization here
    }

    static MyWrapper()
    {
        UnManagedStaticClass.Initialize();
        UnManagedStaticClass.Settings = ...;
    }

    public void Method1()
    {
        UnManagedStaticClass.Method1();
    }
}

Toutefois, si vous devez changer les réglages chaque fois que vous l'appelez, et vous voulez faire de votre cas thread-safe, alors je vous recommande de verrouillage sur un objet statique, de sorte que vous ne pas écraser accidentellement les paramètres statiques alors qu'ils sont encore en cours d'utilisation par un autre thread:

public class MyWrapper
{
    public MyWrapper()
    {
        //Do any necessary instance initialization here
    }

    static MyWrapper()
    {
        UnManagedStaticClass.Initialize();
    }

    static object lockRoot = new Object();

    public void Method1()
    {
        lock (lockRoot)
        {
            UnManagedStaticClass.Settings = ...;
            UnManagedStaticClass.Method1();
        }
    }
}

Si vous avez besoin de passer des paramètres d'initialisation dans votre classe d'instance du constructeur, alors vous pourriez le faire aussi par le fait d'avoir une statique indicateur champ:

public class MyWrapper
{
    public MyWrapper(InitParameters p)
    {
        lock (lockRoot)
        {
            if (!initialized)
            {
                UnManagedStaticClass.Initialize(p);
                initialized = true;
            }
        }
    }

    static bool initialized = false;
    static object lockRoot = new Object();

    public void Method1()
    {
        lock (lockRoot)
        {
            UnManagedStaticClass.Settings = ...;
            UnManagedStaticClass.Method1();
        }
    }
}

Si vous avez aussi besoin de ré-initialiser à chaque fois, mais vous êtes inquiet au sujet de la performance en raison de la ré-initialisation est trop lent, alors la seule autre option (à l'extérieur de la redoutable singleton) est de détecter automatiquement si vous avez besoin de ré-initialiser et seulement lorsque c'est nécessaire. Au moins, le seul moment où il va se passer c'est lorsque deux threads à l'aide de deux instances différentes en même temps. Vous pourriez faire comme ceci:

public class MyWrapper
{
    public MyWrapper(InitParameters initParameters, Settings settings)
    {
        this.initParameters = initParameters;
        this.settings = settings;
    }

    private InitParameters initParameters;
    private Settings settings;
    static MyWrapper currentOwnerInstance;
    static object lockRoot = new Object();

    private void InitializeIfNecessary()
    {
        if (currentOwnerInstance != this)
        {
            currentOwnerInstance = this;
            UnManagedStaticClass.Initialize(initParameters);
            UnManagedStaticClass.Settings = settings;
        }
    }

    public void Method1()
    {
        lock (lockRoot)
        {
            InitializeIfNecessary();
            UnManagedStaticClass.Method1();
        }
    }
}

Je voudrais utiliser un apatrides de classe de service, et de passer de l'état d'info pour la classe statique à chaque appel de méthode. Sans connaître les détails de vous en classe, je vais juste vous montrer un autre exemple de ce avec un c# static de la classe.

public static class LegacyCode
{
    public static void Initialize(int p1, string p2)
    {
        //some static state
    }
    public static void ChangeSettings(bool p3, double p4)
    {
        //some static state
    }
    public static void DoSomething(string someOtherParam)
    {
        //execute based on some static state
    }
}

public class LegacyCodeFacadeService
{
    public void PerformLegacyCodeActivity(LegacyCodeState state, LegacyCodeParams legacyParams)
    {
        lock (_lockObject)
        {
            LegacyCode.Initialize(state.P1, state.P2);
            LegacyCode.ChangeSettings(state.P3, state.P4);
            LegacyCode.DoSomething(legacyParams.SomeOtherParam);
            //do something to reset state, perhaps
        }
    }
}

Vous aurez à remplir les blancs un peu, mais j'espère que vous obtenez l'idée. Le point est de définir l'état sur l'objet statique pour le temps minimum nécessaire, et de bloquer l'accès à ce que tout le temps, donc pas d'autres appelants peuvent être affectés par votre état global de changement. Vous devez créer de nouvelles instances de cette classe pour l'utiliser, il est entièrement injectable et vérifiables (à l'exception de l'étape de l'extraction d'une interface, j'ai sauté par souci de concision).

Il ya beaucoup d'options dans la mise en œuvre ici. Par exemple, si vous avez à changer LegacyCodeState beaucoup, mais seulement à un petit nombre d'états particuliers, vous pourriez avoir des surcharges qui font le travail de gestion de ces états.

MODIFIER

C'est préférable à un singleton dans beaucoup de façons, le plus important est que vous ne serez pas en mesure d'accumuler et de couple à l'état global: cela active l'état global de non-état global si c'est le seul point d'entrée à votre classe statique. Toutefois, dans le cas où vous finissez par avoir besoin d'un singleton, vous pouvez le rendre facile pour passer en encapsulant le constructeur ici.

public class LegacyCodeFacadeService
{
    private LegacyCodeFacadeService() { }

    public static LegacyCodeFacadeService GetInstance()
    {
        //now we can change lifestyle management strategies later, if needed
        return new LegacyCodeFacadeService();
    }

    public void PerformLegacyCodeActivity(LegacyCodeState state, LegacyCodeParams legacyParams)
    {
        lock (_lockObject)
        {
            LegacyCode.Initialize(state.P1, state.P2);
            LegacyCode.ChangeSettings(state.P3, state.P4);
            LegacyCode.DoSomething(legacyParams.SomeOtherParam);
            //do something to reset state, perhaps
        }
    }
}

Vous devez vous connecter pour publier un commentaire.