C# 为什么'；解决所有问题<；T>；是否获取默认（未命名）注册？为什么只命名注册和映射？

如果您这样做：

class Program
    {
        static void Main(string[] args)
        {
            var container = new UnityContainer();

            container.RegisterType<IService, DataService>();
            container.RegisterType<IService, LoggingService>("Logging");
            container.RegisterType<IService, CachingService>("Caching");

            var services = container.ResolveAll<IService>();

            foreach (var service in services)
                Console.WriteLine(service);

            Console.ReadKey();
        }
    }

    interface IService { }
    class DataService : IService { }
    class LoggingService : IService { }
    class CachingService : IService { }

---

为什么他们决定不使用

ResolveAll

获取默认的、未命名的映射/注册？

这样做是为了让您有一个

示例复合

iSeries设备

public class CompositeDataService : IService
{
    public readonly IService[] services;

    public CompositeDataService(IService[] services)
    {
        this.services = services;
    }
}

还有一个演示测试

[Fact]
public void Test()
{
    var container = new UnityContainer();

    container.RegisterType<IService, CompositeDataService>();
    container.RegisterType<IService, LoggingService>("Logging");
    container.RegisterType<IService, CachingService>("Caching");

    var service = container.Resolve<IService>();

    Assert.IsType<CompositeDataService>(service);
    Assert.Equal(2, ((CompositeDataService)service).services.Count());
}

带着

[TestMethod]
public void可以解析多重故障映射susingreolveall（）
{
var container=newunitycontainer（）.AddNewExtension（）；
container.RegisterType（）；
container.RegisterType（）；
container.RegisterType（）；
IFoo[]foos=container.ResolveAll（）.OrderBy（f=>f.GetType（）.Name）.ToArray（）；
Assert.AreEqual（3，foos.Length）；
Assert.IsInstanceOfType（foos[0]，typeof（One））；
IsInstanceOfType（foos[1]，typeof（Three））；
IsInstanceOfType（foos[2]，typeof（Two））；
}

[Fact]
public void Test()
{
    var container = new UnityContainer();

    container.RegisterType<IService, CompositeDataService>();
    container.RegisterType<IService, LoggingService>("Logging");
    container.RegisterType<IService, CachingService>("Caching");

    var service = container.Resolve<IService>();

    Assert.IsType<CompositeDataService>(service);
    Assert.Equal(2, ((CompositeDataService)service).services.Count());
}

using System;

using Microsoft.Practices.ObjectBuilder2;
using Microsoft.Practices.Unity;

public class Remember : UnityContainerExtension
{
    protected override void Initialize()
    {
        this.Context.Registering += this.OnRegistering;
        this.Context.RegisteringInstance += this.OnRegisteringInstance;
    }

    private void OnRegisteringInstance(object sender, RegisterInstanceEventArgs e)
    {
        if(string.IsNullOrEmpty(e.Name))
        {
            string uniqueName = Guid.NewGuid().ToString();

            this.Context.RegisterNamedType(e.RegisteredType, uniqueName);

            this.Context.Policies.Set<IBuildKeyMappingPolicy>(
                new BuildKeyMappingPolicy(new NamedTypeBuildKey(e.RegisteredType)), 
                new NamedTypeBuildKey(e.RegisteredType, uniqueName));
        }
    }

    private void OnRegistering(object sender, RegisterEventArgs e)
    {
        if (e.TypeFrom != null && string.IsNullOrEmpty(e.Name))
        {
            string uniqueName = Guid.NewGuid().ToString();

            this.Context.RegisterNamedType(e.TypeFrom, uniqueName);

            if (e.TypeFrom.IsGenericTypeDefinition && e.TypeTo.IsGenericTypeDefinition)
            {
                this.Context.Policies.Set<IBuildKeyMappingPolicy>(
                    new GenericTypeBuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo)),
                    new NamedTypeBuildKey(e.TypeFrom, uniqueName));
            }
            else
            {
                this.Context.Policies.Set<IBuildKeyMappingPolicy>(
                    new BuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo)),
                    new NamedTypeBuildKey(e.TypeFrom, uniqueName));
            }
        }
    }
}

[TestMethod]
public void CanResolveMultipeDefaultMappingsUsingResolveAll()
{
    var container = new UnityContainer().AddNewExtension<Remember>();

    container.RegisterType<IFoo, One>();
    container.RegisterType<IFoo, Two>();
    container.RegisterType<IFoo, Three>();

    IFoo[] foos = container.ResolveAll<IFoo>().OrderBy(f => f.GetType().Name).ToArray();

    Assert.AreEqual(3, foos.Length);
    Assert.IsInstanceOfType(foos[0], typeof(One));
    Assert.IsInstanceOfType(foos[1], typeof(Three));
    Assert.IsInstanceOfType(foos[2], typeof(Two));
}