Come risolvere la dipendenza della classe statica con Unity?

Question

Ho il seguente metodo di estensione, che esiste (naturalmente) in una classe statica.

public static class MyExtensions 
{ 
    [Dependency] 
    private static IMyDataContext _myDataContext { get; set; } 

    public static void MyExtensionMethod(this MyType myType) 
    { 
     // do stuff 

     _myDataContext.DoAwesomeThing(); 
    } 
} 

dell'oggetto _myDataContext è nullo.

Normalmente userei lo UnityContainer per registrare il tipo, ma poiché questa è una classe statica, non posso.

Cosa è necessario per creare un'istanza _ myDataContext in modo che non sia nullo quando è necessario?

Answer 1

Come già accennato, Unity non può essere utilizzato per risolvere la classe perché è statico. Ci sono alcune opzioni per questo. Il mio preferito è usare il pattern Abstract Factory. Tendo a modificare il modello solo un po 'per lavorare bene con DI.

La fabbrica tipicamente tipo di assomiglia a questo:

/// <summary> 
/// Creates an IMyDataContext instance 
/// </summary> 
public static class MyDataContextFactory 
{ 
    /// <summary> 
    /// The factory used to create an instance 
    /// </summary> 
    static Func<IMyDataContext> factory; 

    /// <summary> 
    /// Initializes the specified creation factory. 
    /// </summary> 
    /// <param name="creationFactory">The creation factory.</param> 
    public static void SetFactory(Func<IMyDataContext> creationFactory) 
    { 
     factory = creationFactory; 
    } 

    /// <summary> 
    /// Creates a new IMyDataContext instance. 
    /// </summary> 
    /// <returns>Returns an instance of an IMyDataContext </returns> 
    public static IMyDataContext CreateContext() 
    { 
     if (factory == null) throw new InvalidOperationException("You can not create a context without first building the factory."); 

     return factory(); 
    } 
} 

Nel vostro processo di bootstrap (dove mai si imposta le registrazioni di servizio), è possibile inizializzare la fabbrica per risolvere il vostro dipendenza.

MyDataContextFactory.SetFactory(() => this.Container.Resolve<IMyDataContext>()); 

Ora nel metodo di estensione, si recupera un contesto.

public static class MyExtensions 
{ 
    public static void MyExtensionMethod(this MyType myType) 
    { 
     MyDataContextFactory.CreateContext().DoAwesomeThing(); 
    } 
} 

tua registrazione Unità del contesto, in grado di gestire le diverse configurazioni diverse del servizio, se ci sono le condizioni per risolverlo. Se esiste la possibilità che il contesto possa essere impostato da qualcosa di diverso da Unity, quel proprietario può semplicemente passare un nuovo delegato che verrà utilizzato dal metodo di estensione.

Io tendo ad evitare di passare i contenitori stessi nelle mie fabbriche, poiché questo inizia a strisciante stretto accoppiamento dei contenitori alla mia app. Se ho intenzione di passare qualcosa in fabbrica, preferirei che fosse un delegato di fabbrica usato per risolvere tramite DI, piuttosto che passare il contenitore DI in sé.