我来自ninject，但我决定尝试一下AutoFac，因为它似乎更积极地开发。到目前为止，我可以说注册装饰器并不像使用.WhenInjectedExactlyInto语法那样简单。无论如何，请忍受我，因为我是AutoFac Newbie。
这是问题：
i具有由A_Decorator装饰的接口IA的类型A。A_Decorator实现了接口IA和IB，反过来应由AB_Decorator装饰，该CC_8也将同时实现IA和IB。AB_Decorator采用IA和IB类型的两种依赖项（因此，这是两者的装饰器），但它们都应分辨到A_Decorator的同一实例。看起来像这样：AB_Decorator(A_Decorator(A) as IA, A_Decorator(A) as IB)。当请求类型IA或从AUTOFAC容器中键入IB的服务时，他们应引用一个AB_Decorator实例。
用Word描述有点棘手，但是这是我可以提出的最简单的代码示例（我已经在构造函数中添加了实例ID和跟踪消息以查看正在发生的事情）：
using System;
using Autofac;
namespace AutofacExample
{
internal interface IA { }
internal interface IB { }
class A : IA
{
static int _instanceCounter;
readonly int Id = ++_instanceCounter;
public A()
{
Console.WriteLine(this);
}
public override string ToString()
{
return $"{GetType().Name}[{nameof(Id)}={Id}]";
}
}
class A_Decorator : IA, IB
{
static int _instanceCounter = 10;
readonly int Id = ++_instanceCounter;
/* decorated1 should reference instance of A */
public A_Decorator(IA decoratedA)
{
Console.WriteLine($"{this}({nameof(decoratedA)}={decoratedA})");
}
public override string ToString()
{
return $"{GetType().Name}[{nameof(Id)}={Id}]";
}
}
class AB_Decorator : IA, IB
{
static int _instanceCounter = 100;
readonly int Id = ++_instanceCounter;
/* Both decorated1 and decorated2 should reference the same instance of A_Decorator */
public AB_Decorator(IA decoratedA, IB decoratedB)
{
Console.WriteLine($"{this}({nameof(decoratedA)}={decoratedA}, {nameof(decoratedB)}={decoratedB})");
}
public override string ToString()
{
return $"{GetType().Name}[{nameof(Id)}={Id}]";
}
}
class Program
{
static void Main(string[] args)
{
ContainerBuilder builder = new ContainerBuilder();
builder
.RegisterType<A>()
.Named<IA>(nameof(A))
.SingleInstance();
builder
.RegisterType<A_Decorator>()
.Named<IA>(nameof(A_Decorator))
.Named<IB>(nameof(A_Decorator))
.SingleInstance();
builder
.RegisterType<AB_Decorator>()
.Named<IA>(nameof(AB_Decorator))
.Named<IB>(nameof(AB_Decorator))
.SingleInstance();
/* A is decorated by A_Decorator as IA */
builder
.RegisterDecorator<IA>(
(c, decorated) =>
c.ResolveNamed<IA>(nameof(A_Decorator), TypedParameter.From(decorated)),
nameof(A))
//.Keyed<IA>("innerA")
//.Keyed<IB>("innerB")
.SingleInstance();
/* Trying to register AB_Decorator as IA creates circular dependency */
//builder
// .RegisterDecorator<IA>(
// (c, decorated) =>
// c.ResolveNamed<IA>(nameof(AB_Decorator), TypedParameter.From(decorated)),
// "innerA")
// .SingleInstance();
/* A_Decorator is decorated by AB_Decorator as IB */
builder
.RegisterDecorator<IB>(
(c, decorated) =>
c.ResolveNamed<IB>(nameof(AB_Decorator), TypedParameter.From(decorated)),
nameof(A_Decorator) /* "innerB" */)
.SingleInstance();
IContainer container = builder.Build();
IA a = container.Resolve<IA>();
IB b = container.Resolve<IB>();
Console.WriteLine($"{nameof(a)} == {nameof(b)} ? {ReferenceEquals(a, b)}");
Console.WriteLine($"{nameof(a)} is {a.GetType().Name}");
Console.WriteLine($"{nameof(b)} is {b.GetType().Name}");
}
}
}
不幸的是，请求IA的实例给我A_Decorator，而对于IB，我获得了AB_Decorator。试图删除额外的装饰器注册块会导致循环依赖性异常（DependencyResolutionException: Circular component dependency detected: System.Object -> AutofacExample.AB_Decorator -> System.Object -> AutofacExample.AB_Decorator），我无法使其工作尝试各种命名注册的组合。
有人知道解决方案吗？预先感谢。
问题
问题在于AB_Decorator的装饰器注册。特别是lambda函数解决AB_Decorator：
( c, decorated ) => c.ResolveNamed<IA>( nameof( AB_Decorator ), TypedParameter.From( decorated ) );
AB_Decorator的构造函数进行了2个参数，这两个参数都应该是A_Decorator的同一实例，该实例与decorated相同。但是，decorated仅通过TypedParameter.From( decorated )作为参数传递。因此，AUTOFAC将尝试通过容器解决第二个参数。
现在，IB的注册表明，我们应该获得一个包裹在AB_Decorator中的A_Decorator的单例实例。因此，要解决IB，容器必须构造AB_Decorator。有问题，我们目前正在尝试将AB_Decorator解析为IA，但是我们需要IB来满足用于IA构建的AB_Decorator的构造函数参数。和IB在容器中注册为AB_Decorator。所以你得到：
AB_Decorator(A_Decorator(A) as IA, AB_Decorator(A_Decorator(A) as IA, AB_Decorator(etc...))
解决方案
解决AB_Decorator时，我们需要将decorated传递到两个参数中。这样：
builder
.RegisterDecorator<IA>(
( c, decorated ) =>
c.ResolveNamed<IA>( nameof( AB_Decorator ),
new TypedParameter( typeof( IA ), decorated ),
new TypedParameter( typeof( IB ), decorated )
)
,"innerA"
)
.SingleInstance();
builder
.RegisterDecorator<IB>(
( c, decorated ) =>
c.ResolveNamed<IB>( nameof( AB_Decorator ),
new TypedParameter( typeof( IA ), decorated ),
new TypedParameter( typeof( IB ), decorated )
)
, nameof( A_Decorator ) /* "innerB" */
)
.SingleInstance();
现在，我们向IA和IB参数发送decorated。直接构建TypedParameter实例，我可以指定我希望该实例在参数列表中满足的类型，在这种情况下为AB_Decorator。
您去这里：
ContainerBuilder builder = new ContainerBuilder();
builder
.RegisterType<A>()
.Named<IA>(nameof(A))
.SingleInstance();
builder
.RegisterType<A_Decorator>()
.Named<IA>(nameof(A_Decorator))
.Named<IB>(nameof(A_Decorator))
.WithParameter(new ResolvedParameter((pi, c) => pi.Name == "decoratedA",
(pi, c) => c.ResolveNamed<IA>(nameof(A))))
.SingleInstance();
builder
.RegisterType<AB_Decorator>()
.As<IA, IB>()
.WithParameter(new ResolvedParameter((pi, c) => pi.Name == "decoratedA",
(pi, c) => c.ResolveNamed<IA>(nameof(A_Decorator))))
.WithParameter(new ResolvedParameter((pi, c) => pi.Name == "decoratedB",
(pi, c) => c.ResolveNamed<IB>(nameof(A_Decorator))))
.SingleInstance();
IContainer container = builder.Build();
打印：
A[Id=1]
A_Decorator[Id=11](decoratedA=A[Id=1])
AB_Decorator[Id=101](decoratedA=A_Decorator[Id=11], decoratedB=A_Decorator[Id=11])
a == b ? True
a is AB_Decorator
b is AB_Decorator
API令人困惑，因为在这种情况下您不需要RegisterDecorator()（它是为了一次装饰一组组件）。
（如果我们可以烘烤整体，那将是很好的：
.WithParameter(new ResolvedParameter((pi, c) => pi.Name == "decoratedA",
(pi, c) => c.ResolveNamed<IA>(nameof(A))))
成语降至AUTOFAC中的更简单的WithParameter()过载；我认为，如果您在这里看到胜利，这将是一个很好的建议。）