.NET DI 内部构造函数和控制台日志记录

Question

I have the following classes in ProjectA :

public class ApplicationBuilder
{
    private readonly IServiceCollection _services;
    
    internal ApplicationBuilder() => _services = new ServiceCollection();

    public ApplicationBuilder ConfigureServices(Action<IServiceCollection> services)
    {
        _services.AddSingleton<ILoggerFactory, LoggerFactory>();
        _services.AddSingleton(typeof(ILogger<>), typeof(Logger<>));
        _services
            .AddLogging(builder => builder
                .AddConsole()
                .ClearProviders()
                .SetMinimumLevel(LogLevel.Information));
        
        _services.AddSingleton<Application>();

        services.Invoke(_services);
        
        return this;
    }
    
    public Application Build()
    {
        var provider = _services.BuildServiceProvider();
        
        return provider.GetRequiredService<Application>();
    }
}

[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyInjection")]

public class Application
{
    private readonly ILogger<Application> _logger;
    internal Application(ILogger<Application> logger) => _logger = logger;
    
    public static ApplicationBuilder Create() => new();

    public void Run()
    {
        _logger.LogInformation("Application started");
        while (true)
        {
            
        }
    }
}

And the following in ProjectB :

Application.Create()
    .ConfigureServices(services =>
    {
        
    })
    .Build()
    .Run();

I get the following exception: Unhandled exception. System.InvalidOperationException: A suitable constructor for type 'Application' could not be located. Ensure the type is concrete and services are registered for all parameters of a public constructor. Unhandled exception. System.InvalidOperationException: A suitable constructor for type 'Application' could not be located. Ensure the type is concrete and services are registered for all parameters of a public constructor.

I thought [assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyInjection")] would allow DI to construct the type but apparently not. Is there some way to create my own constructor resolver that can use internal constructors?

Also if I skip this problem and make the constructor public (which I don't want to do), the logger doesn't log anything. Am I missing something with the setup for the logger?

Thanks

EDIT: Turns out AddLogging / ClearProviders() was the problem with the logger, I normally do this when using full .NET hosts to clear out the default framework messages but as they aren't here anyways it was clearing out the console logging provider.

Answer 1

Edit: I saw your issue was different, but still, consider this a rewrite for how it can be done.

First of all, remember Application is from System.Windows namespace. So I wouldn't use it. Further below, I'll rewrite the code with some other name.

---

 internal Application(ILogger<Application> logger) => _logger = logger;

Why not removing the internal keyword as a whole alongside the code above? Let's try rewriting it in a way you don't need to do crazy internal witchcraft.

---

A better approach

Interfaces:

They can be set up in Project B or in a standalone Abstractions project shared by both Project A and Project B .

The following is an interface for configuring services (which returns the second interface when calling ConfigureServices :

/// <summary>
/// Configures the service application and returns the service built.
/// </summary>
/// <typeparam name="TApplication">Application Type</typeparam>
public interface IAppBuilderConfigureServices<TApplication>
    where TApplication: class
{
    /// <summary>
    /// Creates a service injection container.
    /// </summary>
    /// <param name="services">Opts for configuring services.</param>
    /// <returns>App Service Builder</returns>
    IAppBuildService<TApplication> ConfigureServices(Action<IServiceCollection> services);
}

Interface for building the service:

/// <summary>
/// Builds the configuration and gets <see cref="TApplication"/> from container.
/// </summary>
/// <typeparam name="TApplication">Application Type</typeparam>
public interface IAppBuildService<TApplication>
    where TApplication: class
{
    /// <summary>
    /// App Service builder that returns Singleton of <see cref="TApplication"/>
    /// </summary>
    /// <returns>Instance of <see cref="TApplication"/></returns>
    TApplication Build();
}

Project A:

internal application builder:

/// <summary>
/// Internally builds the service application and returns the service built.
/// </summary>
/// <typeparam name="TApplication">Application Type</typeparam>
internal class AppBuilder<TApplication> : IAppBuilderConfigureServices<TApplication>, IAppBuildService<TApplication>
    where TApplication: class
{
    private readonly IServiceCollection _services = new ServiceCollection();
    
    public IAppBuildService<TApplication> ConfigureServices(Action<IServiceCollection> services)
    {
        _services.AddLogging(s => s.ClearProviders().AddConsole().SetMinimumLevel(LogLevel.Debug));
        _services.AddSingleton<TApplication>();

        services.Invoke(_services);
        return this;
    }

    public TApplication Build() => _services.BuildServiceProvider().GetRequiredService<TApplication>();
}

public static class AppBuilder
{
    /// <summary>
    /// Creates an instance of <see cref="IAppBuilderConfigureServices{TApplication}"/>
    /// </summary>
    /// <typeparam name="TApplication">Application Type</typeparam>
    /// <returns>Application builder</returns>
    public static IAppBuilderConfigureServices<TApplication> Create<TApplication>()
        where TApplication : class =>
        new AppBuilder<TApplication>();
}

Project B:

Just of an example of how it MyApp can be configured.

public static class ProjectB
{
    public static MyApp Initialize()
    {
        return AppBuilder.Create<MyApp>()
            .ConfigureServices(config =>
            {
                // ...
            })
            .Build();
    }
}

Finally, your application code:

public class MyApp
{
    private readonly ILogger<MyApp> _logger;

    public MyApp(ILogger<MyApp> logger) => _logger = logger;

    public void HelloWorld()
    {
        _logger.LogInformation("Hello, World!");
    }
}

This is a draft but I think you get the idea. I'm using interfaces to make it more readable, sorry about the summaries, as I wanted to demonstrate what things were going to do.

---

Usage:

ProjectB.Initialize().HelloWorld();