Aktywacja oprogramowania pośredniczącego opartego na fabryce na platformie ASP.NET Core

Artykuł
2024-11-06

Uwaga

Nie jest to najnowsza wersja tego artykułu. Aby zapoznać się z bieżącą wersją, zobacz wersję tego artykułu platformy .NET 9.

Ostrzeżenie

Ta wersja ASP.NET Core nie jest już obsługiwana. Aby uzyskać więcej informacji, zobacz zasady pomocy technicznej platformy .NET i platformy .NET Core. Aby zapoznać się z bieżącą wersją, zobacz wersję tego artykułu platformy .NET 9.

Ważne

Te informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany, zanim zostanie wydany komercyjnie. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Aby zapoznać się z bieżącą wersją, zobacz wersję tego artykułu platformy .NET 9.

IMiddlewareFactory/IMiddleware to punkt rozszerzalności aktywacji oprogramowania pośredniczącego, który oferuje następujące korzyści:

Aktywacja na żądanie klienta (iniekcja usług o określonym zakresie)
Silne wpisywanie oprogramowania pośredniczącego

UseMiddleware metody rozszerzenia sprawdzają, czy zarejestrowany typ oprogramowania pośredniczącego implementuje IMiddlewareelement . Jeśli tak, IMiddlewareFactory wystąpienie zarejestrowane w kontenerze jest używane do rozpoznawania IMiddleware implementacji zamiast używania opartej na konwencji logiki aktywacji oprogramowania pośredniczącego. Oprogramowanie pośredniczące jest rejestrowane jako usługa o określonym zakresie lub przejściowym w kontenerze usługi aplikacji.

IMiddleware program jest aktywowany na żądanie klienta (połączenie), więc usługi o określonym zakresie można wstrzykiwać do konstruktora oprogramowania pośredniczącego.

IMiddleware

IMiddleware definiuje oprogramowanie pośredniczące dla potoku żądania aplikacji. Metoda InvokeAsync(HttpContext, RequestDelegate) obsługuje żądania i zwraca wartość reprezentującą Task wykonywanie oprogramowania pośredniczącego.

Oprogramowanie pośredniczące aktywowane zgodnie z konwencją:

public class ConventionalMiddleware
{
    private readonly RequestDelegate _next;

    public ConventionalMiddleware(RequestDelegate next)
        => _next = next;

    public async Task InvokeAsync(HttpContext context, SampleDbContext dbContext)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            dbContext.Requests.Add(new Request("Conventional", keyValue));

            await dbContext.SaveChangesAsync();
        }

        await _next(context);
    }
}

Oprogramowanie pośredniczące aktywowane przez :MiddlewareFactory

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly SampleDbContext _dbContext;

    public FactoryActivatedMiddleware(SampleDbContext dbContext)
        => _dbContext = dbContext;

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            _dbContext.Requests.Add(new Request("Factory", keyValue));

            await _dbContext.SaveChangesAsync();
        }

        await next(context);
    }
}

Rozszerzenia są tworzone dla oprogramowania pośredniczącego:

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseConventionalMiddleware(
        this IApplicationBuilder app)
        => app.UseMiddleware<ConventionalMiddleware>();

    public static IApplicationBuilder UseFactoryActivatedMiddleware(
        this IApplicationBuilder app)
        => app.UseMiddleware<FactoryActivatedMiddleware>();
}

Nie można przekazać obiektów do oprogramowania pośredniczącego aktywowanego przez fabrykę za pomocą polecenia UseMiddleware:

public static IApplicationBuilder UseFactoryActivatedMiddleware(
    this IApplicationBuilder app, bool option)
{
    // Passing 'option' as an argument throws a NotSupportedException at runtime.
    return app.UseMiddleware<FactoryActivatedMiddleware>(option);
}

Oprogramowanie pośredniczące aktywowane przez fabrykę jest dodawane do wbudowanego kontenera w programie Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<SampleDbContext>
    (options => options.UseInMemoryDatabase("SampleDb"));

builder.Services.AddTransient<FactoryActivatedMiddleware>();

Oba oprogramowanie pośredniczące jest rejestrowane w potoku przetwarzania żądań, również w pliku Program.cs:

var app = builder.Build();

app.UseConventionalMiddleware();
app.UseFactoryActivatedMiddleware();

IMiddlewareFactory

IMiddlewareFactory Udostępnia metody tworzenia oprogramowania pośredniczącego. Implementacja fabryki oprogramowania pośredniczącego jest zarejestrowana w kontenerze jako usługa o określonym zakresie.

Domyślna IMiddlewareFactory implementacja , MiddlewareFactoryznajduje się w pakiecie Microsoft.AspNetCore.Http .

Dodatkowe zasoby

IMiddlewareFactory/IMiddleware to punkt rozszerzalności aktywacji oprogramowania pośredniczącego.

Korzyści:

Aktywacja na żądanie klienta (iniekcja usług o określonym zakresie)
Silne wpisywanie oprogramowania pośredniczącego

IMiddleware program jest aktywowany na żądanie klienta (połączenie), więc usługi o określonym zakresie można wstrzykiwać do konstruktora oprogramowania pośredniczącego.

Wyświetl lub pobierz przykładowy kod (jak pobrać)

IMiddleware

Oprogramowanie pośredniczące aktywowane zgodnie z konwencją:

public class ConventionalMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, AppDbContext db)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "ConventionalMiddleware", 
                    Value = keyValue
                });

            await db.SaveChangesAsync();
        }

        await _next(context);
    }
}

Oprogramowanie pośredniczące aktywowane przez :MiddlewareFactory

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly AppDbContext _db;

    public FactoryActivatedMiddleware(AppDbContext db)
    {
        _db = db;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            _db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "FactoryActivatedMiddleware", 
                    Value = keyValue
                });

            await _db.SaveChangesAsync();
        }

        await next(context);
    }
}

Rozszerzenia są tworzone dla oprogramowania pośredniczącego:

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseConventionalMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ConventionalMiddleware>();
    }

    public static IApplicationBuilder UseFactoryActivatedMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<FactoryActivatedMiddleware>();
    }
}

Nie można przekazać obiektów do oprogramowania pośredniczącego aktywowanego przez fabrykę za pomocą polecenia UseMiddleware:

public static IApplicationBuilder UseFactoryActivatedMiddleware(
    this IApplicationBuilder builder, bool option)
{
    // Passing 'option' as an argument throws a NotSupportedException at runtime.
    return builder.UseMiddleware<FactoryActivatedMiddleware>(option);
}

Oprogramowanie pośredniczące aktywowane przez fabrykę jest dodawane do wbudowanego kontenera w programie Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<AppDbContext>(options =>
        options.UseInMemoryDatabase("InMemoryDb"));

    services.AddTransient<FactoryActivatedMiddleware>();

    services.AddRazorPages();
}

Oba oprogramowanie pośredniczące jest zarejestrowane w potoku przetwarzania żądań w Startup.Configureprogramie :

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
    }

    app.UseConventionalMiddleware();
    app.UseFactoryActivatedMiddleware();

    app.UseStaticFiles();
    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

IMiddlewareFactory

Domyślna IMiddlewareFactory implementacja , MiddlewareFactoryznajduje się w pakiecie Microsoft.AspNetCore.Http .

Dodatkowe zasoby

IMiddlewareFactory/IMiddleware to punkt rozszerzalności aktywacji oprogramowania pośredniczącego.

Korzyści:

Aktywacja na żądanie klienta (iniekcja usług o określonym zakresie)
Silne wpisywanie oprogramowania pośredniczącego

IMiddleware program jest aktywowany na żądanie klienta (połączenie), więc usługi o określonym zakresie można wstrzykiwać do konstruktora oprogramowania pośredniczącego.

Wyświetl lub pobierz przykładowy kod (jak pobrać)

IMiddleware

Oprogramowanie pośredniczące aktywowane zgodnie z konwencją:

public class ConventionalMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, AppDbContext db)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "ConventionalMiddleware", 
                    Value = keyValue
                });

            await db.SaveChangesAsync();
        }

        await _next(context);
    }
}

Oprogramowanie pośredniczące aktywowane przez :MiddlewareFactory

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly AppDbContext _db;

    public FactoryActivatedMiddleware(AppDbContext db)
    {
        _db = db;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            _db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "FactoryActivatedMiddleware", 
                    Value = keyValue
                });

            await _db.SaveChangesAsync();
        }

        await next(context);
    }
}

Rozszerzenia są tworzone dla oprogramowania pośredniczącego:

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseConventionalMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ConventionalMiddleware>();
    }

    public static IApplicationBuilder UseFactoryActivatedMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<FactoryActivatedMiddleware>();
    }
}

Nie można przekazać obiektów do oprogramowania pośredniczącego aktywowanego przez fabrykę za pomocą polecenia UseMiddleware:

public static IApplicationBuilder UseFactoryActivatedMiddleware(
    this IApplicationBuilder builder, bool option)
{
    // Passing 'option' as an argument throws a NotSupportedException at runtime.
    return builder.UseMiddleware<FactoryActivatedMiddleware>(option);
}

Oprogramowanie pośredniczące aktywowane przez fabrykę jest dodawane do wbudowanego kontenera w programie Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<AppDbContext>(options =>
        options.UseInMemoryDatabase("InMemoryDb"));

    services.AddTransient<FactoryActivatedMiddleware>();

    services.AddMvc()
        .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Oba oprogramowanie pośredniczące jest zarejestrowane w potoku przetwarzania żądań w Startup.Configureprogramie :

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
    }

    app.UseConventionalMiddleware();
    app.UseFactoryActivatedMiddleware();

    app.UseStaticFiles();
    app.UseMvc();
}

IMiddlewareFactory

Domyślna IMiddlewareFactory implementacja , MiddlewareFactoryznajduje się w pakiecie Microsoft.AspNetCore.Http .

Udostępnij za pośrednictwem

Aktywacja oprogramowania pośredniczącego opartego na fabryce na platformie ASP.NET Core

IMiddleware

IMiddlewareFactory

Dodatkowe zasoby

IMiddleware

IMiddlewareFactory

Dodatkowe zasoby

IMiddleware

IMiddlewareFactory

Dodatkowe zasoby

Dodatkowe zasoby