将实例传递给 ASP.NET Core 依赖注入的缺点

Question

I have a class that needs a connection string as a parameter to its constructor:

public class MyClassHere
{
     private string connectionString;

     public MyClassHere(string connectionString)
     {
        this.connectionString = connectionString;
     }
}

I have added that class as a singleton to my service like this:

services.AddSingleton<MyClassHere>();

Clearly this does not work, because it takes a string in the constructor.

I have seen examples that say do this:

services.AddSingleton<MyClassHere>(new MyClassHere("Some Connnection String"));

But I have also read vague things say that when you do this the dependency injection system will not clean up your objects for you.

What (if any) are the drawbacks to passing an instance into the dependency injection system (rather than just letting it make it for you)?

Answer 1

One drawback of doing this is that if the constructor of MyClassHere were to change, you'd have to update the usage of it in your DI registration. Which may or may not be trivial depending on how it's used.

Regardless, one way to handle this scenario in .NET Core while maintaining all of the benefits of dependency injection is by using the Options pattern .

---

Here's what that might look like given your example:

public class MyOptions
{
    public string ConnectionString { get; set; }
}

public class MyClassHere
{
    private readonly string _connectionString;

    public MyClassHere(IOptions<MyOptions> options)
    {
        _connectionString = options.Value.ConnectionString;
    }

    public void Foo() => Console.WriteLine(_connectionString);
}

And here's an example of the registration:

static void Main(string[] args)
{
    var myClass = new ServiceCollection()
        .Configure<MyOptions>(o =>
        {
            o.ConnectionString = "bar";
        })
        .AddSingleton<MyClassHere>()
        .BuildServiceProvider()
        .GetService<MyClassHere>();

    myClass.Foo();

    Console.ReadLine();
}

Which outputs "bar" as expected.