Interfaz web abierta para .NET (OWIN) con ASP.NET Core

Por Steve Smith y Rick Anderson

ASP.NET Core:

• Es compatible con la interfaz web abierta para .NET (OWIN).
• Tiene reemplazos compatibles con .NET Core para las bibliotecas Microsoft.Owin.* (Katana).

OWIN permite que las aplicaciones web se desacoplen de los servidores web. Define una manera estándar para usar software intermedio en una canalización a fin de controlar las solicitudes y las respuestas asociadas. El software intermedio y las aplicaciones de ASP.NET Core pueden interoperar con aplicaciones, servidores y software intermedio basados en OWIN.

OWIN proporciona una capa de desacoplamiento que permite que dos marcos de trabajo con modelos de objetos dispares se usen juntos. El paquete Microsoft.AspNetCore.Owin proporciona dos implementaciones del adaptador:

• De ASP.NET Core a OWIN
• De OWIN a ASP.NET Core

Esto permite que ASP.NET Core se hospede sobre un servidor/host compatible con OWIN, o bien que otros componentes compatibles con OWIN se ejecuten sobre ASP.NET Core.

Consulta o descarga el código de ejemplo (cómo descargarlo)

Ejecución de software intermedio de OWIN en la canalización de ASP.NET Core

La compatibilidad con OWIN de ASP.NET Core se implementa como parte del paquete Microsoft.AspNetCore.Owin. Puedes importar compatibilidad con OWIN en el proyecto mediante la instalación de este paquete.

El software intermedio de OWIN cumple la especificación de OWIN, que requiere una interfaz Func<IDictionary<string, object>, Task> y el establecimiento de determinadas claves (como owin.ResponseBody). En el siguiente software intermedio simple de OWIN se muestra "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);
}

La firma de ejemplo devuelve un valor Task y acepta un valor IDictionary<string, object>, según los requisitos de OWIN.

En el código siguiente se muestra cómo agregar el software intermedio OwinHello (mostrado arriba) a la canalización ASP.NET Core con el método de extensión UseOwin.

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

Puedes configurar la realización de otras acciones en la canalización de OWIN.

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

Ejecución de ASP.NET Core en un servidor basado en OWIN y uso de su compatibilidad con WebSockets

Otro ejemplo de la manera en que ASP.NET Core puede aprovechar las características de los servidores basados en OWIN es el acceso a funciones como WebSockets. El servidor web de OWIN de .NET que se usa en el ejemplo anterior cuenta con compatibilidad integrada con WebSockets, cuyas ventajas puede aprovechar la aplicación ASP.NET Core. En el ejemplo siguiente se muestra una aplicación web simple que admite WebSockets y devuelve todo lo que se envía al servidor a través de WebSockets.

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);
    }
}

Entorno de OWIN

Puedes construir un entorno de OWIN por medio de HttpContext.

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

Claves de OWIN

OWIN depende de un objeto IDictionary<string,object> para comunicar información mediante un intercambio de solicitud/respuesta HTTP. ASP.NET Core implementa las claves que se enumeran a continuación. Consulta las extensiones de la especificación principal y las directrices principales y claves comunes de OWIN.

Datos de solicitud (OWIN v1.0.0)

Datos de solicitud (OWIN v1.1.0)

Datos de respuesta (OWIN v1.0.0)

Otros datos (OWIN v1.0.0)

Claves comunes

SendFiles v0.3.0

Opaque v0.3.0

WebSocket v0.3.0

Recursos adicionales

• Consulte el origen en GitHub acerca de las claves OWIN admitidas en la capa de traducción.
• Middleware
• Servidores