Manière de remplir la collection avec Unity

J’ai deux exemples de cours

class ClassToResolve { private List _coll; public ClassToResolve(List coll) { _coll = coll; } } class CollectionItem { //... }

et j’ai besoin de résoudre ClassToResolve

 var classToResolve = new ClassToResolve( new List() { new CollectionItem(), new CollectionItem(), new CollectionItem() } );

Maintenant je le résous d’une manière

 var classToResolve = new ClassToResolve( new List() { unity.Resolve(), unity.Resolve(), unity.Resolve() } );

Existe-t-il un moyen de résoudre ClassToResolve avec Unity à l’aide d’un enregistrement dynamic?

Unity comprendra que T[] dépendances T[] (tableau) sont une liste de choses (mais pas IEnumerable , ni List ). Lorsque vous modifiez le constructeur de ClassToResolve pour prendre un CollectionItem[] au lieu d’un List vous pouvez configurer vos types CollectionItem comme suit:

 container.RegisterType("a"); container.RegisterType("b"); container.RegisterType("c"); container.RegisterType("d");

Le truc ici est de nommer toutes les inscriptions. Un enregistrement par défaut (sans nom) ne fera jamais partie d’une dépendance de séquence dans Unity.

Maintenant, vous pouvez résoudre ClassToResolve sans avoir besoin de l’enregistrer:

 container.Resolve();

Si vous préférez injecter List vous pouvez append l’enregistrement suivant:

 container.RegisterType, CollectionItem[]>();

Et pour IEnumerable vous pouvez append la ligne suivante:

 container .RegisterType, CollectionItem[]>();

Vous devriez inscrire votre classe dans l’unité

 container.RegisterType()

Il vaut mieux utiliser l’interface

Utilisez ceci

 class ClassToResolve:IEnumerable { private List _coll; public ClassToResolve(IUnityContainer container) { _coll = container.ResolveAll(); } public IEnumerator GetEnumerator() { return _coll.GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public void Add(CollectionItem) { this._coll.Add(CollectionItem); } } now register you class

La réponse de @Steven est parfaitement correcte, je veux simplement suggérer un autre moyen de résoudre le problème.

Pour un code meilleur et plus propre, il vaut la peine de définir une interface pour tous les éléments de la collection.

 public interface IMyClass { void DoSomething(); } public abstract class MyClassBase : IMyClass { abstract void DoSomething(); // more code for the base class if you need it. } public class MyClassA : MyClassBase { void virtual DoSomething() { // implementation here } } public class MyClassB : MyClassBase { void virtual DoSomething() { // implementation here } } public class MyClassC : MyClassBase { void virtual DoSomething() { // implementation here } } // etc.

Maintenant, le code d’enregistrement pour le conteneur Unity serait beaucoup plus facile:

 container.RegisterTypes( AllClasses.FromLoadedAssemblies(). Where(type => typeof(IMyClass).IsAssignableFrom(type)), WithMappings.FromAllInterfaces, WithName.TypeName, WithLifetime.PerResolve); container.RegisterType, IMyClass[]>();

et le code de résolution est le même:

 var allOfMyClasses = container.ResolveAll();

J’espère que Microsoft appenda le support IEnumerable<> à la prochaine version de Unity afin de ne pas avoir besoin d’enregistrer IEnumerable .