How to determine which constructor Autofac uses when resolving

Question

I'm using a custom JsonConverter and JsonSerializerSettings.TypeNameHandling = TypeNameHandling.Objects to create the required instances during deserialization. The instances are created by resolving the types from an Autofac IOC container. Everything works fine, except...

I have several "core objects" that request a unique Id in the constructor from a service (which is correctly injected into the constructor). When deserializing this should not happen because it is fairly expensive and the Ids will be populated from the Json file anyway once the instance has been created.

Currently, when resolving from within the custom JsonConverter I'm using _scope.Resolve<T>(new TypedParameter(typeof(IIdService), null)); to then - in the called constructor - check for null and act accordingly.

Some people apparently consider multiple constructors worse than a code-smell when using an IOC (which makes me wonder why Autofac offers several features regarding the topic), but in the context of deserialization I think it can make perfect sense.

As far as I can tell Autofac has mechanisms to decide which constructor to use during registration, but not when resolving. My preferred solution would be to add a custom attribute to a constructor (e.g. [CtorForDeserializing]) and use that for deciding. Is that possible?

Answer 1

There are a couple of extension points Autofac has for reflection-based activations but doesn't have well documented yet that may help you out: IConstructorFinder and IConstructorSelector.

IConstructorFinder is used to locate all the available constructors on a type. The core example is the DefaultConstructorFinder which locates only public constructors. If you wanted to, say, hide constructors with particular attributes or start finding internal/private constructors, you could create a custom finder. This really only happens once so you don't get to make runtime choices here.

IConstructorSelector is used to choose, at resolve time, which constructor should be used to instantiate the object. There are a couple of these in core Autofac, but the primary example is the MostParametersConstructorSelector which selects the constructor that has the most available matching parameters at the time. Constructors get found by the IConstructorFinder and then that set of constructors is what is presented to the IConstructorSelector to choose from. This is where you could make more runtime choices since it happens every time the object is resolved.

There are extension methods to help you add your finder/selector to a registration:

builder.RegisterType<MyType>()
       .FindConstructorsWith(new MyConstructorFinder())
       .UsingConstructor(new MyConstructorSelector());

You don't have to customize both things, you can just do one or the other if you want. I'm just showing you the extensions.

Answer 2

Actually Autofac is able to decide which constructor to use both ways - during registration or resolution. For resolution part here is the quote from documentation: "Autofac automatically uses the constructor for your class with the most parameters that are able to be obtained from the container" (see here).

Consider following example.

public interface ISomeService
{
    Guid Id { get; }
}

public class SomeService : ISomeService
{
    public Guid Id { get; }

    public SomeService()
    {
        Id = Guid.NewGuid();
    }

    public SomeService(Guid id)
    {
        Id = id;
    }
}

// Startup.cs:
builder.RegisterType<SomeService>().As<ISomeService>().InstancePerLifetimeScope();

// TestController.cs:
[Route("api/[controller]")]
public class TestController : Controller
{
    private readonly IComponentContext _context;

    public TestController(IComponentContext context)
    {
        _context = context;
    }

    [HttpGet]
    public IActionResult Get()
    {
        var service = _context.Resolve<ISomeService>();
        return Ok(service.Id);
    }

    [HttpGet("{id}")]
    public IActionResult Get(Guid id)
    {
        var service = _context.Resolve<ISomeService>(new NamedParameter("id", id));
        return Ok(service.Id);
    }
}

// GET http://localhost:5000/api/test/e0198f72-6337-4880-b608-68935122cdea
// each and every response will be the same: e0198f72-6337-4880-b608-68935122cdea

// GET http://localhost:5000/api/test
// this way it responds with some random guid each time endpoint is called

Answer 3

Travis Illig sent me in the right direction - thanks!

I ended up implementing a solution around the following details:

Implement custom attributes, e.g.: public class DeserializeCtorAttribute : Attribute { }, which will be used by the (also to be implemented) IConstructorFinder.

Implement an empty generic interface, e.g.: IDeserializable<T>, which will be used for resolving the services/components.

Let relevant component classes implement the interface (MyClass : IDeserializable<MyClass>) and add an extra registration for the component:

_builder.RegisterType<MyClass>().As<IDeserializable<MyClass>>()
                .FindConstructorsWith(MyConstructorFinder);

Use the implemented DeserializeCtorAttribute in the desired constructor of MyClass.

Let the JsonConverter create the required instance by calling (MyClass) scope.Resolve(IDeserializable<MyClass>); casting is required, but safe. Due to the registration the instance will be created using the desired constructor.