如何创建一个忽略Autofac中装饰器的键注册？

Question

I have created a naive cache decorator (ServiceDecorator) which decorates implementations of IService, registered with RegisterDecorator. In some cases, I do not want a decorated instance. (Actual scenario is a REST API where ServiceA sometimes should be cached, and other times not.)

The default injection should always resolve to the service decorator, but for some special cases I would like to use meta data, attributes or other to signal that ServiceA should be used.

Is it possible to achieve this? Using Autofac 4.9.1 on .NET 4.7.2.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Autofac;
using Autofac.Core;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var cb = new ContainerBuilder();
            cb.RegisterType<ServiceA>().As<IService>();
            var context = cb.Build();
            var service = context.Resolve<IService>();
            //Output: "ServiceA"
            Console.WriteLine(service.DoStuff());

            cb = new ContainerBuilder();
            cb.RegisterType<ServiceA>().As<IService>();
            cb.RegisterDecorator<ServiceDecorator, IService>();
            context = cb.Build();
            service = context.Resolve<IService>();
            //Output: "ServiceDecorator"
            Console.WriteLine(service.DoStuff());

            cb = new ContainerBuilder();
            cb.RegisterType<ServiceA>().As<IService>();
            cb.RegisterDecorator<ServiceDecorator, IService>();
            cb.RegisterType<ServiceA>().Keyed<IService>("notdecorated");
            context = cb.Build();
            service = context.ResolveKeyed<IService>("notdecorated");
            //Output: "ServiceDecorator", but hoped for "ServiceA"
            Console.WriteLine(service.DoStuff());

            Console.ReadKey();
        }
    }


    public interface IService
    {
        string DoStuff();
    }

    public class ServiceA : IService
    {
        public string DoStuff()
        {
            return "ServiceA";
        }
    }

    public class ServiceDecorator : IService
    {
        private readonly IService _decoratedService;
        public ServiceDecorator(IService decoratedService)
        {
            _decoratedService = decoratedService;
        }
        public string DoStuff()
        {
            return "ServiceDecorator";
        }
    }

Answer 1

Certainly not the cleanest of ways, and in a more complex example im not sure how well it would work - but there is an option of adding a flag variable on it essentially

public class ServiceA : IService
    {
        public bool withDecs { get; set; } = true;
        public string DoStuff()
        {
            return "ServiceA";
        }
    }

this means you can do something like:

cb.RegisterType<ServiceA>().As<IService>();
cb.RegisterDecorator<ServiceDecorator, IService>(x=> ((ServiceA)x.CurrentInstance).withDecs);
cb.RegisterType<ServiceA>().Keyed<IService>("notdecorated").WithProperty("withDecs",false);

its not exactly elegant though it sets up the decorator to be conditional on the withDecs which is property set on the keyed so wont trigger the decorator

Answer 2

The default injection should always resolve to the service decorator, but for some special cases I would like to use meta data, attributes or other to signal that ServiceA should be used.

I wouldn't take this route, because it means runtime data is required during the construction of your object graphs. This is a code smell , to say the least.

Instead, prefer the structure of your object graphs to be unchanged during the execution of your application. Instead, in case some behavior needs to be applied for some requests, while it should be omitted during other requests of the same application, prefer building this behavior in the decorator itself, or, create an extra service that allows to switch between the no-op and the actual behavior at runtime, based on existing runtime data.

A valid approach, however, would be to apply a decorator conditionally, based on the services it decorators, and other static metadata. For instance, you could mark ServiceA with a [Cache] attribute and ServiceB with a [NoCache] attribute and apply the decorator accordingly. Note that in this case the structure of the graph will not change at runtime, b ecause ServiceA will always be decorated, while ServiceB will never be. I'm unsure, however, to apply decorator conditionally in Autofac.