Pure DI für .NET

Um den Prinzipien von OOP und SOLID zu folgen , werden häufig Abhängigkeitsinjektionsbibliotheken verwendet. Es gibt viele dieser Bibliotheken, und alle sind durch eine Reihe gemeinsamer Funktionen verbunden:

• API zum Definieren des Abhängigkeitsgraphen

  
  
  
  
  

• Zusammensetzung von Objekten

  
  
  
  
  

• Objektlebenszyklusmanagement

  
  
  
  
  

Ich war daran interessiert zu verstehen, wie es funktioniert, und der beste Weg, dies zu tun, besteht darin, eine eigene IoC.Container- Abhängigkeitsinjektionsbibliothek zu schreiben . Es ermöglicht Ihnen, komplexe Dinge auf einfache Weise zu erledigen: Es funktioniert gut mit generischen Typen - andere nicht , es ermöglicht Ihnen, Code ohne Infrastrukturabhängigkeiten zu erstellen und bietet eine gute Leistung im Vergleich zu anderen ähnlichen Lösungen, jedoch NICHT im Vergleich zu einem reinen DI-Ansatz.

Mit klassischen Abhängigkeitsinjektionsbibliotheken können wir das Abhängigkeitsdiagramm einfach definieren und verlieren an Leistung. Dies zwingt uns, Kompromisse zu suchen. Wenn Sie also mit einer großen Anzahl von Objekten arbeiten müssen, kann die Verwendung der Abhängigkeitsinjektionsbibliothek die Ausführung der Anwendung verlangsamen. Einer der Kompromisse besteht darin, die Verwendung von Bibliotheken in diesem Teil des Codes zu vermeiden und Objekte auf altmodische Weise zu erstellen. Dadurch wird das vordefinierte und vorhersagbare Diagramm beendet, und jeder dieser Sonderfälle erhöht die Gesamtkomplexität des Codes. Zusätzlich zu den Auswirkungen auf die Leistung können klassische Bibliotheken aufgrund von Fehlkonfigurationen zu Laufzeitproblemen führen.

In reinem DI erfolgt die Objektzusammensetzung manuell: Normalerweise gibt es viele Konstruktoren, die andere Konstruktoren als Argumente verwenden, und so weiter. Es fallen keine zusätzlichen Gemeinkosten an. Der Compiler überprüft die Richtigkeit der Komposition. Das Verwalten der Lebensdauer von Objekten oder anderer Probleme wird behandelt, wenn sie auf eine Weise auftreten, die für eine bestimmte Situation effektiv ist oder vom Autor des Codes bevorzugt wird. Mit zunehmender Anzahl neuer Klassen oder mit jeder neuen Abhängigkeit wächst die Komplexität des Objektzusammensetzungscodes immer schneller. Irgendwann können Sie die Kontrolle über diese Komplexität verlieren, was die weitere Entwicklung erheblich verlangsamt und zu Fehlern führt. Daher ist meiner Erfahrung nach reines DI anwendbar, solange die Codemenge klein ist.

Was ist, wenn wir nur die besten dieser Ansätze beibehalten:

• API

  
  
  
  
  

• DI

  
  
  
  
  

• ""

  
  
  
  
  

, . , - . .NET , /API . , JIT.

, - Pure.DI! - , . NuGet beta , :

• Pure.DI.Contracts API

  
  
  
  
  

• Pure.DI

  
  
  
  
  

Pure.DI.Contracts , .NET Framework 3.5, .NET Standard .NET Core , , .NET 5 6, .NET Framework 2, . API, , , C#. API IoC.Container.

.NET 5 source code generator Roslyn Pure.DI. IDE , . “” . , .

, , “” “”:

interface IBox<out T> { T Content { get; } }

interface ICat { State State { get; } }

enum State { Alive, Dead }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

“ ” :

class CardboardBox<T> : IBox<T>
{
    public CardboardBox(T content) => Content = content;

    public T Content { get; }
}

class ShroedingersCat : ICat
{
  //  
  private readonly Lazy<State> _superposition;

  public ShroedingersCat(Lazy<State> superposition) =>
    _superposition = superposition;

  //    
  //        
  public State State => _superposition.Value;

  public override string ToString() => $"{State} cat";
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, . DI, SOLID.

, , . Pure.DI.Contracts Pure.DI. “” :

static partial class Glue
{
  //    ,
  //   ,     
  private static readonly Random Indeterminacy = new();

  static Glue()
  {
    DI.Setup()
      //    
      .Bind<State>().To(_ => (State)Indeterminacy.Next(2))
      //     
      .Bind<ICat>().To<ShroedingersCat>()
      //     
      .Bind<IBox<TT>>().To<CardboardBox<TT>>()
      //         
      //   
      .Bind<Program>().As(Singleton).To<Program>();
  }
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Setup()



DI “”. static partial , , “DI”. Setup()



string . “Indeterminacy”, Glue static partial, .

Setup()



Bind<>()



To<>()



, :

.Bind().To()

ICat - , , .NET . ShroedingersCat - , .NET . , , . - , . , Bind<>()



, To<>()



. :

• Bind<>()
  
  
  
  ,

  
  
  
  
  

• As(Lifetime)
  
  
  
  , ,

  
  
  
  
  

• Tag(object)
  
  
  
  , , ,

  
  
  
  
  

, :

• Transient - ,

  
  
  
  
  

• Singleton - ,

  
  
  
  
  

• PerThread -

  
  
  
  
  

• PerResolve -

  
  
  
  
  

• Binding - ILifetime

  
  
  
  
  

, , . , :

.Bind().Tag(“Fat”).Tag(“Fluffy”).To()

, Bind<>()



To<>()



- . , . , , typeof(IBox<>)



API , “TT”. - IBox<TT>



, CardboardBox<TT>



. ? , . TT, TT1, TT2 .. API . . c , [GenericTypeArgument]



, :

[GenericTypeArgument]
public class TTMy: IMyInterface { }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

To<>()



. . , “ ” . [Obsolete]



. , , , - . To<>(factory)



. , ,

.Bind<IBox>().To<CardboardBox>()

.Bind<IBox>().To(ctx => new CardboardBox(ctx.Resolve()))

To<>(factory)



lambda , . lambda , - ctx, . ctx.Resolve()



TT . Resolve()



, - object.

!

class Program
{
  //      
  public static void Main() => Glue.Resolve<Program>().Run();

  private readonly IBox<ICat> _box;

  internal Program(IBox<ICat> box) => _box = box;

  private void Run() => Console.WriteLine(_box);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

void Main()



Glue.Resolve<Program>()



. Composition Root, , , , , . Resolve<>()



:

static class ProgramSingleton
{
  static readonly Program Shared = 
    new Program(
      new CardboardBox<ICat>(
        new ShroedingersCat(
          new Lazy<State>(
            new Func<State>(
              (State)Indeterminacy.Next(2))))));
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, Program Singleton Resolve<>()



Program . , Shared



ProgramSingleton, Glue.

, . ,

ShroedingersCat(Lazy<State> superposition)

Lazy<>



.NET. , Lazy<>



? , Pure.DI BCL Lazy<>, Task<>, Tuple<..>



, . , . DependsOn()



, , .

, ? - Func<>



, BCL . , ICat



, - Func<ICat>



, .

. , . , IEnumerable<ICat>,



ICat[]



.NET, IReadOnlyCollection<T>



. , IEnumerable<ICat>



.

, , API . To<>(factory)



c lambda , , .

, , - . API . , , , TagAttribute:

• : .Bind<ICat>().Tag(“Fat”).Tag(“Fluffy”).To<FatCat>()
  
  
  
  

  
  
  
  
  

• : BigBox([Tag(“Fat”)] T content) { }
  
  
  
  

  
  
  
  
  

TagAttribute :

• TypeAttribute - , , , ,

  
  
  
  
  

• OrderAttribute - , /

  
  
  
  
  

• OrderAttribute -

  
  
  
  
  

, , Pure.DI.Contracts. , , , . , :

• TypeAttribute<>()
  
  
  
  

  
  
  
  
  

• TagAttribute<>()
  
  
  
  

  
  
  
  
  

• OrderAttribute<>()
  
  
  
  

  
  
  
  
  

, - : , , . 0, , . , , , “InjectAttribute”, , .

. , Roslyn API, IDE , . . , IDE , , . . , , , . , fallback : IFallback



. Resolve<>()



Wird aufgerufen, wenn eine Abhängigkeit nicht gefunden werden kann und: das erstellte Objekt zur Injektion zurückgibt, eine Ausnahme auslöst oder null zurückgibt , um das Standardverhalten zu belassen. Wenn die Fallback- Strategie angehängt ist, ändert der Generator den Fehler in eine Warnung, vorausgesetzt, die Situation liegt unter Ihrer Kontrolle und der Code wird kompilierbar.

Hoffe, diese Bibliothek ist hilfreich. Alle Kommentare und Ideen werden sehr geschätzt.