Microsoft L'Unité. Comment spécifier un certain paramètre dans le constructeur?

Votre meilleure réponse est d'utiliser effectivement le conteneur.

Ce que vous faites en disant: "lors de la construction de ce type, l'utilisation spécifique de cette instance de l'objet." Ce n'est pas de profiter de la capacité du conteneur à construire instance pour vous. Au lieu de cela, vous devez vous inscrire IService1 et IService2 dans le conteneur. Alors, dites-le conteneur de résoudre ces dépendances pour vous.

Il ressemble à quelque chose comme ceci:

container.RegisterType<IService1, SomeService1>();
container.RegisterType<IService2, SomeService2>();

Ce que cela fait, c'est dire le récipient "dès qu'il y a une dépendance de type IService1, les nouvelles en place d'un nouvel objet de type SomeService1 et de la main-ce qui" et de même pour IService2.

Alors, la prochaine, vous devez indiquer au conteneur de quoi faire à propos de ICustomerService. Dans la plupart des généralité, vous devrez faire cela:

container.RegisterType<ICustomerService, CustomerService>(
    //Note, don't need to explicitly say transient, that's the default
    new InjectionConstructor(new ResolvedParameter<IService1>(),
        new ResolvedParameter<IService2>()));

Cela indique au conteneur: lors de la résolution de ICustomerService, les nouvelles en place une instance de CustomerService en utilisant le constructeur qui prend IService1 et IService2. Pour obtenir ces paramètres, de retour d'appel dans le récipient pour résoudre ces types de.

C'est un peu verbeux, et un cas commun, donc il y a quelques raccourcis. Tout d'abord, vous pouvez passer d'un Type d'objet au lieu de faire de nouveaux ResolvedParameter, comme suit:

container.RegisterType<ICustomerService, CustomerService>(
    new InjectionConstructor(typeof(IService1), typeof (IService2)));

Comme une autre abréviation, si CustomerService a qu'un seul constructeur, ou si celui que vous voulez appeler est celui qui prend la plus grande liste de paramètres, vous pouvez laisser le InjectionConstructor complètement, comme c'est le constructeur qui le conteneur va chercher dans l'absence de toute autre configuration.

container.RegisterType<ICustomerService, CustomerService>();

Le formulaire que vous utilisez est généralement utilisé lorsque vous souhaitez une valeur spécifique passé pour un paramètre du constructeur plutôt que de résoudre le service de retour à travers le récipient.

Pour répondre à votre question initiale - eh bien, vous ne pouvez pas faire exactement ce que vous avez dit. Le paramètre de constructeur a besoin d'Une valeur de quelque sorte. Vous pourriez mettre autre chose dans la vous voulez, bien que nulle fonctionne normalement.

Remarque vous pouvez également mélanger les deux formes. Par exemple, si vous voulez résoudre IService1 et passer la valeur null pour le IService2 paramètre, faites ceci:

container.RegisterType<ICustomerService, CustomerService>(
    new InjectionConstructor(typeof(IService1), null));

* EDIT *

Basé sur le commentaire ci-dessous, ce que vous voulez vraiment est une autre caractéristique nommée enregistrements.

En gros, vous avez deux implémentations de IService1 et l'un des IService2. Donc, ce que vous pouvez faire est de vous inscrire à la fois, puis de dire le récipient à utiliser.

Tout d'abord, pour inscrire le deuxième de la mise en œuvre, vous avez besoin de donner un nom explicite:

container.RegisterType<IService1, OtherService1Impl>("other");

Alors vous pouvez dire le récipient pour résoudre IService1 mais utiliser le nom. C'est la principale raison que la ResolvedParameter type n'existe. Puisque vous voulez juste valeur par défaut pour IService2, vous pouvez utiliser typeof() comme une abréviation. Vous avez encore besoin de spécifier les types des paramètres, mais vous n'avez pas besoin d'une valeur spécifique. Si cela a un sens.

container.RegisterType<ICustomerService, CustomerService>(
    new InjectionConstructor(new ResolvedParameter<IService1>("other"), typeof(IService2));

Qui devrait faire ce que vous avez besoin.

Chris Tavares a donné une bonne réponse avec beaucoup d'informations.

Si vous avez beaucoup de Paramètres à injecter habituellement, ce sont des interfaces ou des instances qui peuvent être résolus par l'Unité (à l'aide de la differnet techniques). Mais que faire si vous voulez fournir un seul Paramètre qui ne peut pas être résolu automatiquement, par exemple, une chaîne de caractères pour un nom de fichier?

Maintenant, vous devez fournir tous les typeof(IMyProvider) et d'une chaîne ou d'une instance. Mais pour être honnête, juste à fournir les types de pourrait être fait par l'Unité, parce que l'Unité a déjà une stratégie pour choisir le meilleur ctor.

Donc j'ai codé un remplacement pour InjectionConstructor:

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using Microsoft.Practices.ObjectBuilder2;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.ObjectBuilder;
using Microsoft.Practices.Unity.Utility;
namespace Microsoft.Practices.Unity
{
///<summary>
///A class that holds the collection of information for a constructor, 
///so that the container can be configured to call this constructor.
///This Class is similar to InjectionConstructor, but you need not provide
///all Parameters, just the ones you want to override or which cannot be resolved automatically
///The given params are used in given order if type matches
///</summary>
public class InjectionConstructorRelaxed : InjectionMember
{
private List<InjectionParameterValue> _parameterValues;
///<summary>
///Create a new instance of <see cref="InjectionConstructor"/> that looks
///for a constructor with the given set of parameters.
///</summary>
///<param name="parameterValues">The values for the parameters, that will
///be converted to <see cref="InjectionParameterValue"/> objects.</param>
public InjectionConstructorRelaxed(params object[] parameterValues)
{
_parameterValues = InjectionParameterValue.ToParameters(parameterValues).ToList();
}
///<summary>
///Add policies to the <paramref name="policies"/> to configure the
///container to call this constructor with the appropriate parameter values.
///</summary>
///<param name="serviceType">Interface registered, ignored in this implementation.</param>
///<param name="implementationType">Type to register.</param>
///<param name="name">Name used to resolve the type object.</param>
///<param name="policies">Policy list to add policies to.</param>
public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies)
{
ConstructorInfo ctor = FindExactMatchingConstructor(implementationType);
if (ctor == null)
{
//if exact matching ctor not found, use the longest one and try to adjust the parameters.
//use given Params if type matches otherwise use the type to advise Unity to resolve later
ctor = FindLongestConstructor(implementationType);
if (ctor != null)
{
//adjust parameters
var newParams = new List<InjectionParameterValue>();
foreach (var parameter in ctor.GetParameters())
{
var injectionParameterValue =
_parameterValues.FirstOrDefault(value => value.MatchesType(parameter.ParameterType));
if (injectionParameterValue != null)
{
newParams.Add(injectionParameterValue);
_parameterValues.Remove(injectionParameterValue);
}
else
newParams.Add(InjectionParameterValue.ToParameter(parameter.ParameterType));
}
_parameterValues = newParams;
}
else
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
"No constructor found for type {0}.",
implementationType.GetTypeInfo().Name));
}
}
policies.Set<IConstructorSelectorPolicy>(
new SpecifiedConstructorSelectorPolicy(ctor, _parameterValues.ToArray()),
new NamedTypeBuildKey(implementationType, name));
}
private ConstructorInfo FindExactMatchingConstructor(Type typeToCreate)
{
var matcher = new ParameterMatcher(_parameterValues);
var typeToCreateReflector = new ReflectionHelper(typeToCreate);
foreach (ConstructorInfo ctor in typeToCreateReflector.InstanceConstructors)
{
if (matcher.Matches(ctor.GetParameters()))
{
return ctor;
}
}
return null;
}
private static ConstructorInfo FindLongestConstructor(Type typeToConstruct)
{
ReflectionHelper typeToConstructReflector = new ReflectionHelper(typeToConstruct);
ConstructorInfo[] constructors = typeToConstructReflector.InstanceConstructors.ToArray();
Array.Sort(constructors, new ConstructorLengthComparer());
switch (constructors.Length)
{
case 0:
return null;
case 1:
return constructors[0];
default:
int paramLength = constructors[0].GetParameters().Length;
if (constructors[1].GetParameters().Length == paramLength)
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
"The type {0} has multiple constructors of length {1}. Unable to disambiguate.",
typeToConstruct.GetTypeInfo().Name,
paramLength));
}
return constructors[0];
}
}
private class ConstructorLengthComparer : IComparer<ConstructorInfo>
{
///<summary>
///Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
///</summary>
///<param name="y">The second object to compare.</param>
///<param name="x">The first object to compare.</param>
///<returns>
///Value Condition Less than zero is less than y. Zero equals y. Greater than zero is greater than y.
///</returns>
[SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", Justification = "Validation done by Guard class")]
public int Compare(ConstructorInfo x, ConstructorInfo y)
{
Guard.ArgumentNotNull(x, "x");
Guard.ArgumentNotNull(y, "y");
return y.GetParameters().Length - x.GetParameters().Length;
}
}
}
}

Utilisation:

container.RegisterType(new TransientLifetimeManager(), new InjectionConstructorRelaxed(
new SomeService1("with special options")
//, new SomeService2() //not needed, normal unity resolving used
//equivalent to: , typeof(SomeService2)
));

Vous pouvez par défaut de la deuxième paramètre du constructeur (par exemple, =null) ou de proposer un seul paramètre du constructeur en plus de ces deux paramètre de constructeur par le surcharger.