Add support for field/property and method injection to Microsoft.Extensions.Dependencyinjection

[muhamad]

Hi everyone,

I've created the package AspNetCore.ControllerInjection which add support for field, property and method injection for AspNet core controller, and I would like to extend Microsoft.Extensions.Dependencyinjection to support such functionality, and because such task is big I would like to know if it would be acceptable?

I know the implementation would be different but I know how to do it, I just need to know before I go on doing it.

[davidfowl]

No we have no plans to support this. You should use another DI container if you need this feature.

[huoyaoyuan]

Please consider to provide good integration as a first party component, since it has been moved into runtime repo.
Once C# have required properties, property injection and validation with required-ness should be a strong feature request.

[sab39]

What is the recommendation if you have an existing substantial codebase built on the default DI container but want to start using property injection without rewriting everything? Having looked at other containers, they all seem to have completely separate ways of registering services, which sounds like it'd require completely rewriting all the services.Add[Lifetime]() methods that already exist. Is there an extensibility point or provider or factory that would make it possible to plug property injection into the default container without having to replace the entire container?

[muhamad]

@sab39 All the Add[LifeTime] methods add an instance of ServiceDescriptor to the ServiceCollection. So to not break current IServiceCollection we can extend ServiceDescriptor and add new members to it in order to support field\property injection.

However, before we go on lets have some definitions:
1. InjectableService: is the one you use AddX to specify its injection policy.
2. InjectedService: is a type that have a constructor/field/property to get injected.

An InjectableService can be InjectedService but not the other way a round, because not every type needs injections. However for current ServiceProvider implementation any service must be included in the cache in order to activate it.

So we can define two extension methods (the signature is defined below)

1. Include: we use it to mark a member in the InjectedService to be injected.
   the member type is a child of BaseService.
2. IncludeRequired: we use it to mark a member in the InjectedService to be injected and an exception is thrown if the service of member type not found.

public static class ServiceCollectionMembersExtensions
{
    // this method is to inject a service into a member from memberSelection expression after creating instance of type InjectedService
    // the return type of the expression is the type of service to inject into this member
    public static IServiceCollection Include<InjectedService>(
        this IServiceCollection serviceCollection,
        Expression<Func<InjectedService, object>> memberSelection)
    {
        return serviceCollection;
    }

    // this method is to inject service into a member referenced in the memberSelection expression after activating type InjectedService
    // the return type of the expression is the type of service to inject into this member
    // if the member type is not present an exception will throw
    public static IServiceCollection IncludeRequired<InjectedService>(
        this IServiceCollection serviceCollection,
        Expression<Func<InjectedService, object>> memberSelection)
    {
        return serviceCollection;
    }
}

The return value of Expression<Func<InjectedService, object>> is the type of the service to inject into this member after some cleanup (e.g. the nullable).

Of course, we will extend ServiceDescriptor to include some other members which will be needed to guide the ServiceProvider during building the cache.

During building the cache, we can create a function which take the created object and IServiceProvider instance then sets the value for each member to be injected by getting the values from IServiceProvider instance using GetService<T> or GetRequiredService<T>.

see this example

class ClassRoom
{
   string Title { get; set; }
}

class Student
{
    ClassRoom ClassRoom { get; set; }
}

// registeration
services.AddSingelton(new ClassRoom { Title="Class 101" });
services.Include<Student>(e => e.ClassRoom);

// creation
var student = serviceProvider.GetService<Student>();
Console.WriteLine(student.ClassRoom.Title); // should print 'Class 101'