ASP.NET Core 2.0依赖注入默认实例

Question

I'm using ASP.NET Core 2.0 and Microsoft.Extensions.DependencyInjection . I have a few class where I don't want to specified its implementation or I don't need to specified.

For example:

public interface IMyService
{
    void WriteSomething();
}

public class MyService : IMyService
{
    private readonly MyObject myObject;

    public MyService(MyObject myObject)
    {
        this.myObject = myObject;
    }

    public void WriteSomething()
    {
        this.myObject.Write();
    }
}

public interface IOther
{
    string GetName();
}

public class Other : IOther
{
    public string GetName()
    {
        return "james bond";
    }
}

public class MyObject
{
    private readonly IOther other;

    public MyObject(IOther other)
    {
        this.other = other;
    }

    public void Write()
    {
        Console.WriteLine(string.Concat("hi ", this.other.GetName()));
    }
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        ...
        services.AddScoped<IOther, Other>();
        services.AddScoped<IMyService, MyService>();
        ...
    }
}

and I want to specified only IMyToolGeneral with MyToolGeneral and IOther with Other , but MyObject not, because I have a lot of classes like this (validators, helpers, ...) and I don't need to specified these.

how can I do that in ASP.NET Core 2.0 ?

edit

I need that ASP.NET Core 2.0 DI can inject a instance of MyObject without specified it in DI configuration. MyObject haven't a contract (interface) o base class, and all parameters in its constructor are specified in DI configuration.

edit II I rewrite classes and include a example in Unity (that works) and the same example in MS DI (that dont' work)

unity example (work)

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

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

        service.WriteSomething();

        Console.ReadKey();
    }

    static UnityContainer UnityConfig()
    {
        var container = new UnityContainer();

        container.RegisterType<IMyService, MyService>();

        container.RegisterType<IOther, Other>();

        return container;
    }
}

MS DI (don't work) Unhandled Exception: System.InvalidOperationException: Unable to resolve service for type 'ConsoleDI.MyObject' while attempting to activate 'ConsoleDI.MyService'.

class Program
{
    static void Main(string[] args)
    {
        var serviceProvider = new ServiceCollection()
                .AddTransient<IMyService, MyService>()
                .AddTransient<IOther, Other>()
                .BuildServiceProvider();

        var service = serviceProvider.GetService<IMyService>();

        service.WriteSomething();

        Console.ReadKey();
    }
}

Answer 1

The built-in dependency injection container, Microsoft.Extensions.DependencyInjection , does not support convention based registration. So when you would usually set up some convention that eg all types within a namespace will be registered as a transient dependency, this does not work out of the box with the standard container.

If you still want to do this, you would either have to change the dependency injection container to a more powerful one (remember that the built-in container is by design a very slim one), or create your own convention-based logic to register your dependencies. For example, you could simply loop through the current assembly and check for all types within a certain namespace and register those:

var types = Assembly.GetExecutingAssembly()
    .GetTypes()
    .Where(t => t.Namespace == "Your.Custom.Namespace");

foreach (var type in types)
{
    services.AddTransient(type);
}

---

If you don't want to register all the types, there is one more thing you can do. There are the activator utilities which offer a way to construct objects of types that are not registered themselves in the container, but require dependencies from the container to be constructed. You can use the ActivatorUtilities.CreateInstance method to create an object. For example, with your service definition, you could create a MyObject instance like this:

var myObject = ActivatorUtilities.CreateInstance<MyObject>(serviceCollection);

This will automatically get the IOther from the container and inject it into the constructor of MyObject . MyObject does not need to be registered for this, but IOther does.

So this only works for instantiating types that are not registered in the container. It does not work for dependencies that are required by other types. Dependency injection can only automatically provide instances for those dependencies that are registered in the dependency injection container.

So you cannot create a MyService object through dependency injection since its dependency, MyObject , is not registered. There is no way around this, you have to register it if you want the DI framework to automatically instantiate the object for you.

Answer 2

You can add them to DI via

services.AddScoped<MyObject>();

or something more complicated like

services.AddScoped(provider =>
{
    var res = new MyObject
    {
        Message = "Hello World 2"
    };
    return res;
});

where you can constructor the object yourself.

Sample prj here