Objet .NET Framework utilisant Dependency Injection?

Question

je suis en train de trouver un exemple dans .NET d'une classe qui utilise l'injection Dépendance (par exemple, une classe qui utilise un Builder ou Factory afin de créer l'objet complet - l'injection de dépendances comme il le fait)

En parcourant Reflector, j'aurais pensé que certains des objets plus complexes ado.net ou WebRequest utiliseraient l'injection de dépendance - mais non. Quelqu'un peut-il pointer vers un exemple dans le cadre .NET d'un objet qui utilise l'injection de dépendance pour faire son travail?

Answer 1

Voici quelques exemples d'injection de dépendance dans le cadre:

ChannelDispatcher de WCF a l'injection de constructeur (dépendance obligatoire) de IChannelListener. En général, WCF relies on configuration pour effectuer l'injection au niveau utilisateur de dépendances facultatives. System.Xml fait l'injection de dépendance de poor-man dans un certain nombre d'endroits.

Par exemple, XmlDocument a une injection de constructeur (interne) sur XmlImplementation. Le constructeur par défaut instancie juste le XmlImplementation nécessaire. XmlImplementation lui-même dépend de XmlNameTable. XmlResolvers sont un autre exemple d'injection.

La fonction CompositionContainer de MEF dépend facultativement d'un ComposablePartCatalog et d'ExportProviders. ImportEngine a injection constructeur de ExportProvider

Controller ASP.NET MVC a injection setter sur IActionInvoker et ITempDataProvider (ils ont des implémentations par défaut) liants modèles sont également injectables. Si vous débutez avec l'injection de dépendance, IMHO le framework .NET est le pire endroit où vous pouvez apprendre: la plupart du temps vous n'aurez pas le code source, c'est le niveau du framework (pas l'application). niveau) avec des exigences assez particulières. En particulier Microsoft est très attention à rendre les choses publiques (par défaut est interne), par opposition à la plupart des projets open source, afin de mieux gérer leurs changements de rupture.

Answer 2

Je pense qu'il y a des DI répandus partout dans le .NET Framework, mais c'est une forme spéciale de DI appelée "Property Injection" - dans le monde Java, elle est souvent appelée "Setter Injection".

Answer 3

est ici un vrai simple (stupide) exemple d'injection de dépendance par une usine:

public class MyService1Factory { 
    public IMyService1 Create() { 
     MyService2 service = new MyService2(); 
     // provides dependent IMyService2 for MyService 
     return new MyService(service); 
    } 
} 

public class MyService : IMyService1 { 
    private IMyService2 service; 

    // MyService depends upon IMyService2, an instance of this "dependency" is 
    // passed in (or "injected") via a simple constructor param 
    public MyService(IMyService2 myService2) { 
     service = myService2; 
    } 
} 

Answer 4

Il y a beaucoup d'endroits dans le .NET Framework qui utilise l'injection de dépendance. Tout d'abord, .NET Framework utilise beaucoup de patterns GoF et certains d'entre eux s'appuient fortement sur Dependency Injection. Par exemple, Decorator Design Pattern utilise toujours injection Constructor et Strategy Design Pattern utilise l'injection Constructor ou d'une méthode d'injection:

// Decorator on Streams (uses Constructor Injection) 
var ms = new MemoryStream(); 
var bs = new BufferedStream(ms); 

// Strategy of sorting (uses Method Injection) 
var list = new List<int>(); 
list.Sort(new CustomComparer()); 

// Strategy of sorting (Constructor Injection) 
var sortedArray = new SortedList<int, string>(
         new CustomComparer()); 

// Strategy of starting new task using TaskScheduler 
// (Method Injection) 
var task = Task.Factory.StartNew(
    () => { }, 
    CancellationToken.None, 
    TaskCreationOptions.None, 
    TaskScheduler.Default); 

    // All method that takes IFormatProvider and 
    // similar strategies is an example of the Method Injection 
    IFormatProvider provider = null; 
    42.ToString(provider); 

Toute utilisation de Abstract Factory Design Pattern signifie que vous allez à l'objet usine « injecter » à l'aide d'injection Constructor ou d'une méthode d'injection et il y a une beaucoup d'exemples dans .NET Framework de ce modèle comme DbProviderFactory.Pour obtenir plus d'exemple qui montrera ce que les types BCL utilisent Constructor Injection, j'ai écrit une requête LINQ simple (je le montrerai plus tard) qui énumère tous les types accessibles pour trouver des types avec un constructeur public qui accepte un interface ou type abstrait en tant que paramètre. Cette requête a montré beaucoup d'autres usages du constructeur Injection dans .NET Framework (ici quelques exemples):

// ResourceReader takes a Stream 
Stream ms = new MemoryStream(); 
var resourceReader = new ResourceReader(ms); 

// BinaryReader/BinaryWriter, StreamReader/StreamWriter 
// takes a Stream as well 
var textReader = new StreamReader(ms); 

// MethodCall takes a IMessage 
IMessage message = new System.Runtime.Remoting.Messaging.MethodResponse(null, null); 
var methodCall = new System.Runtime.Remoting.Messaging.MethodCall(message); 

// Icon takes a Stream 
var icon = new System.Drawing.Icon(ms); 

// DbEnumerator takes a IDataReader 
IDataReader dataReader = new DataTableReader(new DataTable()); 
var dbEnumerator = new System.Data.Common.DbEnumerator(dataReader); 

Ceci est seulement la liste limitée des types et .NET Framework contient beaucoup plus de types qui repose sur cette technique. Constructor Injection était une technique largement utilisée bien avant que ce terme apparaisse, donc je ne suis pas surpris que cela soit si largement utilisé. Vous pouvez utiliser suivant LINQ-requête pour obtenir beaucoup plus d'autres échantillons d'injection constructeur (et avec une légère modification, vous pouvez écrire une requête qui va trouver Méthode modèles d'injection):

var types = 
    AppDomain.CurrentDomain.GetAssemblies() 
     .SelectMany(a => a.GetTypes()) 
     .SelectMany(t => t.GetConstructors() 
           .Where(c => c.GetParameters() 
               .Any(cp => 
                (cp.ParameterType.IsAbstract || 
                cp.ParameterType.IsInterface)))) 

     .Select(ci => new {Type = ci.DeclaringType, Constructor = ci.GetConstructorInfo()}) 
     .Where(t => !t.Type.Namespace.Contains("Internal"));