Der Dienst mit Gültigkeitsbereich kann vom Root-Anbieter .Net Core 2 nicht aufgelöst werden

Wenn ich versuche, meine App auszuführen, wird der Fehler angezeigt

InvalidOperationException: Cannot resolve 'API.Domain.Data.Repositories.IEmailRepository' from root provider because it requires scoped service 'API.Domain.Data.EmailRouterContext'.

Was seltsam ist, ist, dass dieses EmailRepository und diese Schnittstelle, soweit ich das beurteilen kann, genau so eingerichtet sind wie alle meine anderen Repositorys, aber für sie wird kein Fehler ausgegeben. Der Fehler tritt nur auf, wenn ich versuche, die App zu verwenden.UseEmailingExceptionHandling (); Linie. Hier sind einige meiner Startup.cs-Dateien.

public class Startup
{
    public IConfiguration Configuration { get; protected set; }
    private APIEnvironment _environment { get; set; }

    public Startup(IConfiguration configuration, IHostingEnvironment env)
    {
        Configuration = configuration;

        _environment = APIEnvironment.Development;
        if (env.IsProduction()) _environment = APIEnvironment.Production;
        if (env.IsStaging()) _environment = APIEnvironment.Staging;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var dataConnect = new DataConnect(_environment);

        services.AddDbContext<GeneralInfoContext>(opt => opt.UseSqlServer(dataConnect.GetConnectString(Database.GeneralInfo)));
        services.AddDbContext<EmailRouterContext>(opt => opt.UseSqlServer(dataConnect.GetConnectString(Database.EmailRouter)));

        services.AddWebEncoders();
        services.AddMvc();

        services.AddScoped<IGenInfoNoteRepository, GenInfoNoteRepository>();
        services.AddScoped<IEventLogRepository, EventLogRepository>();
        services.AddScoped<IStateRepository, StateRepository>();
        services.AddScoped<IEmailRepository, EmailRepository>();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole();

        app.UseAuthentication();

        app.UseStatusCodePages();
        app.UseEmailingExceptionHandling();

        app.UseMvcWithDefaultRoute();
    }
}

Hier ist das EmailRepository

public interface IEmailRepository
{
    void SendEmail(Email email);
}

public class EmailRepository : IEmailRepository, IDisposable
{
    private bool disposed;
    private readonly EmailRouterContext edc;

    public EmailRepository(EmailRouterContext emailRouterContext)
    {
        edc = emailRouterContext;
    }

    public void SendEmail(Email email)
    {
        edc.EmailMessages.Add(new EmailMessages
        {
            DateAdded = DateTime.Now,
            FromAddress = email.FromAddress,
            MailFormat = email.Format,
            MessageBody = email.Body,
            SubjectLine = email.Subject,
            ToAddress = email.ToAddress
        });
        edc.SaveChanges();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
                edc.Dispose();
            disposed = true;
        }
    }
}

Und schließlich die Ausnahmebehandlung für Middleware

public class ExceptionHandlingMiddleware
{
    private const string ErrorEmailAddress = "errors@ourdomain.com";
    private readonly IEmailRepository _emailRepository;

    private readonly RequestDelegate _next;

    public ExceptionHandlingMiddleware(RequestDelegate next, IEmailRepository emailRepository)
    {
        _next = next;
        _emailRepository = emailRepository;
    }

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await _next.Invoke(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex, _emailRepository);
        }
    }

    private static Task HandleExceptionAsync(HttpContext context, Exception exception,
        IEmailRepository emailRepository)
    {
        var code = HttpStatusCode.InternalServerError; // 500 if unexpected

        var email = new Email
        {
            Body = exception.Message,
            FromAddress = ErrorEmailAddress,
            Subject = "API Error",
            ToAddress = ErrorEmailAddress
        };

        emailRepository.SendEmail(email);

        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int) code;
        return context.Response.WriteAsync("An error occured.");
    }
}

public static class AppErrorHandlingExtensions
{
    public static IApplicationBuilder UseEmailingExceptionHandling(this IApplicationBuilder app)
    {
        if (app == null)
            throw new ArgumentNullException(nameof(app));
        return app.UseMiddleware<ExceptionHandlingMiddleware>();
    }
}

Update: Ich habe diesen Link https://github.com/aspnet/DependencyInjection/issues/578 gefunden, wodurch ich die BuildWebHost-Methode meiner Program.cs-Datei geändert habe

public static IWebHost BuildWebHost(string[] args)
{
    return WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .Build();
}

dazu

public static IWebHost BuildWebHost(string[] args)
{
    return WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .UseDefaultServiceProvider(options =>
            options.ValidateScopes = false)
        .Build();
}

Ich weiß nicht genau, was los ist, aber es scheint jetzt zu funktionieren.

Sie haben den IEmailRepositoryals Scoped Service in der StartupKlasse registriert . Dies bedeutet, dass Sie es nicht als Konstruktorparameter einfügen können, Middlewareda nur SingletonDienste durch Einfügen eines Konstruktors in aufgelöst werden können Middleware. Sie sollten die Abhängigkeit Invokewie folgt auf die Methode verschieben:

public ExceptionHandlingMiddleware(RequestDelegate next)
{
    _next = next;
}

public async Task Invoke(HttpContext context, IEmailRepository emailRepository)
{
    try
    {
        await _next.Invoke(context);
    }
    catch (Exception ex)
    {
        await HandleExceptionAsync(context, ex, emailRepository);
    }
}

Eine weitere Möglichkeit , die Instanz von scoped Abhängigkeit zu erhalten , ist Service - Provider (zu injizieren IServiceProvider) in den Middleware - Konstruktor erstellen scopein InvokeMethode und dann den gewünschten Dienst aus dem Anwendungsbereich erhalten:

using (var scope = _serviceProvider.CreateScope()) {
    var _emailRepository = scope.ServiceProvider.GetRequiredService<IEmailRepository>();

    //do your stuff....
}

Schauen Sie sich Resolving Dienstleistungen in einem Verfahren Körper in asp.net Kern Dependency Injection Best Practices Tipps Tricks für weitere Details.

Middleware ist immer ein Singleton, sodass Sie im Konstruktor Ihrer Middleware keine Abhängigkeiten als Konstruktorabhängigkeiten festlegen können.

Middleware unterstützt die Methodeninjektion für die Invoke-Methode. Sie können also einfach das IEmailRepository emailRepository als Parameter zu dieser Methode hinzufügen. Es wird dort injiziert und ist in Ordnung.

public async Task Invoke(HttpContext context, IEmailRepository emailRepository)
{

    ....
}

Ihr middlewareund das servicemüssen miteinander kompatibel sein, um das serviceüber das constructorvon Ihnen injizieren zu können middleware. Hier wurde Ihr middlewareals erstellt, convention-based middlewarewas bedeutet, dass es als fungiert singleton serviceund Sie Ihren Dienst als erstellt haben scoped-service. Sie können also kein a scoped-servicein den Konstruktor von a injizieren, singleton-serviceweil es das zwingt scoped-service, als singletonEins zu agieren . Hier sind jedoch Ihre Optionen.

1. Fügen Sie Ihren Service als Parameter in die InvokeAsyncMethode ein.
2. Machen Sie Ihren Service nach Möglichkeit zu einem Singleton.
3. Verwandle deine middlewarein eine factory-basedEins.

A Factory-based middlewarekann als scoped-service. Sie können also eine andere scoped-serviceüber den Konstruktor dieser Middleware einfügen. Im Folgenden habe ich Ihnen gezeigt, wie Sie eine factory-basedMiddleware erstellen .

Dies ist nur zur Demonstration. Also habe ich den ganzen anderen Code entfernt.

public class Startup
{
    public Startup()
    {
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<TestMiddleware>();
        services.AddScoped<TestService>();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseMiddleware<TestMiddleware>();
    }
}

Die TestMiddleware:

public class TestMiddleware : IMiddleware
{
    public TestMiddleware(TestService testService)
    {
    }

    public Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        return next.Invoke(context);
    }
}

Die TestService:

public class TestService
{
}