Otwieranie interfejsu internetowego dla platformy .NET (OWIN) przy użyciu platformy ASP.NET Core

  • Artykuł

Przez Steve Smith i Rick Anderson

ASP.NET Core:

  • Obsługuje interfejs Open Web Interface for .NET (OWIN).
  • Zawiera zamienniki zgodne z platformą .NET Core dla Microsoft.Owin.* bibliotek (Katana).

OWIN umożliwia oddzielenie aplikacji internetowych od serwerów internetowych. Definiuje standardowy sposób użycia oprogramowania pośredniczącego w potoku do obsługi żądań i skojarzonych odpowiedzi. ASP.NET Core aplikacje i oprogramowanie pośredniczące mogą współdziałać z aplikacjami opartymi na OWIN, serwerami i oprogramowaniem pośredniczącym.

OWIN udostępnia warstwę rozdzielającą, która umożliwia korzystanie ze sobą dwóch struktur z różnymi modelami obiektów. Pakiet Microsoft.AspNetCore.Owin zawiera dwie implementacje adapterów:

  • ASP.NET Core do OWIN
  • OWIN do ASP.NET Core

Umożliwia to hostowanie ASP.NET Core na serwerze/hoście zgodnym z OWIN lub w przypadku innych składników zgodnych Z OWIN, które mają być uruchamiane na podstawie ASP.NET Core.

Uwaga

Korzystanie z tych kart wiąże się z kosztami wydajności. Aplikacje używające tylko składników ASP.NET Core nie powinny używać Microsoft.AspNetCore.Owin pakietu ani adapterów.

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

Uruchamianie oprogramowania pośredniczącego OWIN w potoku ASP.NET Core

obsługa OWIN platformy ASP.NET Core jest wdrażana w ramach Microsoft.AspNetCore.Owin pakietu. Możesz zaimportować obsługę OWIN do projektu, instalując ten pakiet.

Oprogramowanie pośredniczące OWIN jest zgodne ze specyfikacją OWIN, która wymaga interfejsu Func<IDictionary<string, object>, Task> i należy ustawić określone klucze (takie jak owin.ResponseBody). Następujące proste oprogramowanie pośredniczące OWIN wyświetla komunikat "Hello World":

public Task OwinHello(IDictionary<string, object> environment)
{
    string responseText = "Hello World via OWIN";
    byte[] responseBytes = Encoding.UTF8.GetBytes(responseText);

    // OWIN Environment Keys: https://owin.org/spec/spec/owin-1.0.0.html
    var responseStream = (Stream)environment["owin.ResponseBody"];
    var responseHeaders = (IDictionary<string, string[]>)environment["owin.ResponseHeaders"];

    responseHeaders["Content-Length"] = new string[] { responseBytes.Length.ToString(CultureInfo.InvariantCulture) };
    responseHeaders["Content-Type"] = new string[] { "text/plain" };

    return responseStream.WriteAsync(responseBytes, 0, responseBytes.Length);
}

Przykładowy podpis zwraca Task element i akceptuje element zgodnie z IDictionary<string, object> wymaganiami OWIN.

Poniższy kod pokazuje, jak dodać OwinHello oprogramowanie pośredniczące (pokazane powyżej) do potoku ASP.NET Core za pomocą UseOwin metody rozszerzenia.

public void Configure(IApplicationBuilder app)
{
    app.UseOwin(pipeline =>
    {
        pipeline(next => OwinHello);
    });
}

Możesz skonfigurować inne akcje do wykonania w potoku OWIN.

Uwaga

Nagłówki odpowiedzi powinny być modyfikowane tylko przed pierwszym zapisem w strumieniu odpowiedzi.

Uwaga

Z powodów związanych z wydajnością zaleca się zniechęcenie wielu UseOwin wywołań. Składniki OWIN będą działać najlepiej, jeśli zostaną zgrupowane razem.

app.UseOwin(pipeline =>
{
    pipeline(next =>
    {
        return async environment =>
        {
            // Do something before.
            await next(environment);
            // Do something after.
        };
    });
});

Uruchamianie ASP.NET Core na serwerze opartym na protokole OWIN i korzystanie z obsługi obiektów WebSocket

Innym przykładem wykorzystania funkcji serwerów opartych na protokole OWIN przez platformę ASP.NET Core jest dostęp do funkcji, takich jak WebSocket. Serwer internetowy OWIN platformy .NET używany w poprzednim przykładzie obsługuje wbudowane gniazda sieci Web, które mogą być używane przez aplikację ASP.NET Core. W poniższym przykładzie pokazano prostą aplikację internetową, która obsługuje gniazda sieci Web i zwraca wszystkie elementy wysyłane do serwera za pośrednictwem obiektów WebSocket.

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.Use(async (context, next) =>
        {
            if (context.WebSockets.IsWebSocketRequest)
            {
                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
                await EchoWebSocket(webSocket);
            }
            else
            {
                await next();
            }
        });

        app.Run(context =>
        {
            return context.Response.WriteAsync("Hello World");
        });
    }

    private async Task EchoWebSocket(WebSocket webSocket)
    {
        byte[] buffer = new byte[1024];
        WebSocketReceiveResult received = await webSocket.ReceiveAsync(
            new ArraySegment<byte>(buffer), CancellationToken.None);

        while (!webSocket.CloseStatus.HasValue)
        {
            // Echo anything we receive
            await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, received.Count), 
                received.MessageType, received.EndOfMessage, CancellationToken.None);

            received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), 
                CancellationToken.None);
        }

        await webSocket.CloseAsync(webSocket.CloseStatus.Value, 
            webSocket.CloseStatusDescription, CancellationToken.None);
    }
}

Środowisko OWIN

Środowisko OWIN można skonstruować przy użyciu polecenia HttpContext.


   var environment = new OwinEnvironment(HttpContext);
   var features = new OwinFeatureCollection(environment);

Klucze OWIN

OWIN zależy IDictionary<string,object> od obiektu do przekazywania informacji w ramach wymiany żądań/odpowiedzi HTTP. ASP.NET Core implementuje klucze wymienione poniżej. Zapoznaj się ze specyfikacją podstawową, rozszerzeniami i kluczowymi wytycznymi OWIN i kluczami wspólnymi.

Żądanie danych (OWIN v1.0.0)

Klucz Wartość (typ) opis
owin. RequestScheme String
owin. RequestMethod String
owin. RequestPathBase String
owin. RequestPath String
owin. RequestQueryString String
owin. RequestProtocol String
owin. RequestHeaders IDictionary<string,string[]>
owin. RequestBody Stream

Żądanie danych (OWIN w wersji 1.1.0)

Klucz Wartość (typ) opis
owin. Requestid String Opcjonalnie

Dane odpowiedzi (OWIN v1.0.0)

Klucz Wartość (typ) opis
owin. ResponseStatusCode int Opcjonalnie
owin. ResponseReasonPhrase String Opcjonalnie
owin. OdpowiedźHeaders IDictionary<string,string[]>
owin. Treść odpowiedzi Stream

Inne dane (OWIN v1.0.0)

Klucz Wartość (typ) opis
owin. CallCancelled CancellationToken
owin. Wersja String

Typowe klucze

Klucz Wartość (typ) opis
Ssl. Clientcertificate X509Certificate
Ssl. LoadClientCertAsync Func<Task>
Serwera. RemoteIpAddress String
Serwera. RemotePort String
Serwera. LocalIpAddress String
Serwera. Port_lokalny String
Serwera. OnSendingHeaders Action<Action<object>,object>

SendFiles v0.3.0

Klucz Wartość (typ) opis
Sendfile. Sendasync Zobacz podpis delegata Na żądanie

Nieprzezroczyste v0.3.0

Klucz Wartość (typ) opis
Nieprzezroczyste. Wersja String
Nieprzezroczyste. Uaktualnienia OpaqueUpgrade Zobacz podpis delegata
Nieprzezroczyste. Strumienia Stream
Nieprzezroczyste. CallCancelled CancellationToken

WebSocket v0.3.0

Klucz Wartość (typ) opis
Websocket. Wersja String
Websocket. Zaakceptować WebSocketAccept Zobacz podpis delegata
Websocket. AcceptAlt Brak specyfikacji
Websocket. SubProtocol String Zobacz sekcję RFC6455 4.2.2 Krok 5.5
Websocket. Sendasync WebSocketSendAsync Zobacz podpis delegata
Websocket. ReceiveAsync WebSocketReceiveAsync Zobacz podpis delegata
Websocket. CloseAsync WebSocketCloseAsync Zobacz podpis delegata
Websocket. CallCancelled CancellationToken
Websocket. ClientCloseStatus int Opcjonalnie
Websocket. ClientCloseDescription String Opcjonalnie

Dodatkowe zasoby