Microsoft Unity. Как указать определенный параметр в конструкторе?

Question

Я использую Microsoft Unity.У меня есть интерфейс ICustomerService и его реализация CustomerService.Я могу зарегистрировать их для контейнера Unity, используя следующий код:

container.RegisterType<ICustomerService, CustomerService>(new TransientLifetimeManager());

Если CustomerService имеет определенный параметр в своем конструкторе (например, ISomeService1), я использую следующий код (мне нужно указатьSomeService1):

container.RegisterType<ICustomerService, CustomerService>(new TransientLifetimeManager(), new InjectionConstructor(new SomeService1()));

Здесь нет проблем.

Проблема возникает, когда класс CustomerService имеет два параметра (не один параметр, как в предыдущем примере) в своем конструкторе (например, ISomeService1 и ISomeService2).Он работает нормально, когда я использую следующий код: container.RegisterType<ICustomerService, CustomerService>(new TransientLifetimeManager(), new InjectionConstructor(new SomeService1(), new SomeService2()));

Проблема в том, что я не хочу указывать SomeService2() для второго параметра.Я хочу указать только первый параметр - SomeService1().Но я получаю сообщение об ошибке, что мне нужно указать ни один или оба параметра.

Как указать только первый параметр конструктора?

Answer 1

Ваш лучший ответ - на самом деле использовать контейнер.

То, что вы делаете, говорит: «при создании этого типа используйте этот конкретный экземпляр объекта».Это не использует возможности контейнера для создания экземпляра для вас.Вместо этого вы должны зарегистрировать IService1 и IService2 в контейнере.Затем скажите контейнеру разрешить эти зависимости для вас.

Это выглядит примерно так:

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

Что это делает, так это сообщает контейнеру "всякий раз, когда существует зависимость типа IService1, newсоздайте новый объект типа SomeService1 и передайте его так же, как и для IService2.

Итак, вам нужно сообщить контейнеру, что делать с ICustomerService.В большинстве случаев вы должны сделать следующее:

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

Это говорит контейнеру: при разрешении ICustomerService создайте новый экземпляр CustomerService, используя конструктор, который принимает IService1 и IService2.Чтобы получить эти параметры, перезвоните в контейнер для разрешения этих типов.

Это немного многословно и часто встречается, поэтому есть несколько ярлыков.Во-первых, вы можете передать объект Type вместо нового ResolvedParameter, например, так:

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

В качестве еще одного сокращения, если CustomerService имеет только один конструктор, или если тот, который вы хотите вызвать, - это тот, который принимаетсамый большой список параметров, вы можете полностью исключить InjectionConstructor, так как это конструктор, который контейнер выберет при отсутствии другой конфигурации.

container.RegisterType<ICustomerService, CustomerService>();

Используемая форма обычно используется, когда вы хотитеконкретное значение, передаваемое параметру конструктора, а не разрешению службы обратно через контейнер.

Чтобы ответить на исходный вопрос - ну, вы не можете сделать именно то, что сказали.Параметру конструктора нужно какое-то значение.Однако вы можете поместить туда все, что захотите, но обычно null работает.

Обратите внимание, что вы также можете смешать две формы.Например, если вы хотите разрешить IService1 и передать значение NULL для параметра IService2, сделайте следующее:

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

* EDIT *

На основе приведенного ниже комментария,на самом деле вам нужна еще одна функция - именованные регистрации.

По сути, у вас есть две реализации IService1 и одна из IService2.Итак, что вы можете сделать, это зарегистрировать их обоих, а затем сообщить контейнеру, какой из них использовать.

Прежде всего, чтобы зарегистрировать вторую реализацию, вам нужно дать явное имя:

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

Затем вы можете указать контейнеру разрешить IService1, но использовать имя.Это основная причина, по которой существует тип ResolvedParameter.Поскольку вы просто хотите использовать значение по умолчанию для IService2, вы можете использовать typeof () как сокращение.Вам все еще нужно указать оба типа для параметров, но вам не нужно определенное значение.Если это имеет смысл.

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

Это должно делать то, что вам нужно.

Answer 2

В качестве альтернативы ответа Криса Тавареса вы можете разрешить контейнеру разрешить только второй параметр:

container.RegisterType<ICustomerService, CustomerService>(
    new InjectionConstructor(new SomeService1(), new ResolvedParameter<IService2>());

Answer 3

Крис Таварес дал хороший ответ с большим количеством информации.

Если у вас есть много параметров для внедрения, обычно это интерфейсы или экземпляры, которые могут быть разрешены Unity (с использованием методов difnet).Но что, если вы хотите предоставить только один параметр, который не может быть разрешен автоматически, например, строку для имени файла?

Теперь вам нужно предоставить все typeof(IMyProvider) и одну строку или экземпляр.Но, честно говоря, Unity может предоставить только типы, потому что у Unity уже есть стратегия выбора лучшего ctor.

Поэтому я написал код для замены 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;
            }
        }
    }
}

Использование:

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

Answer 4

Вы можете использовать иерархию контейнеров.Зарегистрируйте общую реализацию в родительском контейнере, этот экземпляр будет разрешен, если разрешен через главный контейнер.Затем создайте дочерний контейнер и зарегистрируйте альтернативную реализацию в дочернем контейнере.Эта реализация разрешается, если разрешается через дочерний контейнер, т.е. регистрация в дочернем контейнере переопределяет регистрацию в родительском контейнере.

Вот пример:

public interface IService {}

public interface IOtherService {}

// Standard implementation of IService
public class StandardService : IService {}

// Alternative implementaion of IService
public class SpecialService : IService {}

public class OtherService : IOtherService {}

public class Consumer
{
    public Consumer(IService service, IOtherService otherService)
    {}
}

private void Test()
{
    IUnityContainer parent = new UnityContainer()
        .RegisterType<IService, StandardService>()
        .RegisterType<IOtherService, OtherService>();

    // Here standardWay is initialized with StandardService as IService and OtherService as IOtherService
    Consumer standardWay = parent.Resolve<Consumer>();

    // We construct child container and override IService registration
    IUnityContainer child = parent.CreateChildContainer()
        .RegisterType<IService, SpecialService>();

    // And here specialWay is initialized with SpecialService as IService and still OtherService as IOtherService
    Consumer specialWay = child.Resolve<Consumer>();

    // Profit!
}

Обратите внимание, что при использовании иерархии контейнеров вы ничего не можете знатьо количестве параметров в конструкторе, и это здорово, потому что, пока вы связаны с количеством параметров и их типами, вы не можете использовать полную мощность IoC.Чем меньше ты знаешь, тем лучше.

Answer 5

Вы можете установить по умолчанию второй параметр для конструктора (например, =null) или предложить конструктор с одним параметром в дополнение к конструктору с двумя параметрами, перегрузив его.