DotNet 学习笔记 OWIN

Open Web Interface for .NET (OWIN)
 
-------------------------------------------------------------------------
Running OWIN middleware in the ASP.NET pipeline
"dependencies": {
    "Microsoft.AspNetCore.Server.IISIntegration": "1.0.0",
    "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
    "Microsoft.AspNetCore.Owin": "1.0.0"
  },
 
public Task OwinHello(IDictionary<string, object> environment)
{
    string responseText = "Hello World via OWIN";
    byte[] responseBytes = Encoding.UTF8.GetBytes(responseText);
 
    // OWIN Environment Keys: http://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, , responseBytes.Length);
}
 
public void Configure(IApplicationBuilder app)
{
    app.UseOwin(pipeline =>
    {
        pipeline(next => OwinHello);
    });
}
app.UseOwin(pipeline =>
{
    pipeline(next =>
    {
        // do something before
        return OwinHello;
        // do something after
    });
});
-------------------------------------------------------------------------------------------------
Using ASP.NET Hosting on an OWIN-based server
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Owin;
using Microsoft.Extensions.Options;
using Nowin;
 
namespace NowinSample
{
    public class NowinServer : IServer
    {
        private INowinServer _nowinServer;
        private ServerBuilder _builder;
 
        public IFeatureCollection Features { get; } = new FeatureCollection();
 
        public NowinServer(IOptions<ServerBuilder> options)
        {
            Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
            _builder = options.Value;
        }
 
        public void Start<TContext>(IHttpApplication<TContext> application)
        {
            // Note that this example does not take into account of Nowin's "server.OnSendingHeaders" callback.
            // Ideally we should ensure this method is fired before disposing the context.
            Func<IDictionary<string, object>, Task> appFunc = async env =>
            {
                // The reason for 2 level of wrapping is because the OwinFeatureCollection isn't mutable
                // so features can't be added
                var features = new FeatureCollection(new OwinFeatureCollection(env));
 
                var context = application.CreateContext(features);
                try
                {
                    await application.ProcessRequestAsync(context);
                }
                catch (Exception ex)
                {
                    application.DisposeContext(context, ex);
                    throw;
                }
 
                application.DisposeContext(context, null);
            };
 
            // Add the web socket adapter so we can turn OWIN websockets into ASP.NET Core compatible web sockets.
            // The calling pattern is a bit different
            appFunc = OwinWebSocketAcceptAdapter.AdaptWebSockets(appFunc);
 
            // Get the server addresses
            var address = Features.Get<IServerAddressesFeature>().Addresses.First();
 
            var uri = new Uri(address);
            var port = uri.Port;
            IPAddress ip;
            if (!IPAddress.TryParse(uri.Host, out ip))
            {
                ip = IPAddress.Loopback;
            }
 
            _nowinServer = _builder.SetAddress(ip)
                                    .SetPort(port)
                                    .SetOwinApp(appFunc)
                                    .Build();
            _nowinServer.Start();
        }
 
        public void Dispose()
        {
            _nowinServer?.Dispose();
        }
    }
}
 
using System;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.Extensions.DependencyInjection;
using Nowin;
using NowinSample;
 
namespace Microsoft.AspNetCore.Hosting
{
    public static class NowinWebHostBuilderExtensions
    {
        public static IWebHostBuilder UseNowin(this IWebHostBuilder builder)
        {
            return builder.ConfigureServices(services =>
            {
                services.AddSingleton<IServer, NowinServer>();
            });
        }
 
        public static IWebHostBuilder UseNowin(this IWebHostBuilder builder, Action<ServerBuilder> configure)
        {
            builder.ConfigureServices(services =>
            {
                services.Configure(configure);
            });
            return builder.UseNowin();
        }
    }
}
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
 
namespace NowinSample
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var host = new WebHostBuilder()
                .UseNowin()
                .UseContentRoot(Directory.GetCurrentDirectory())
                .UseIISIntegration()
                .UseStartup<Startup>()
                .Build();
 
            host.Run();
        }
    }
}
 
------------------------------------------------------------------------------
Run ASP.NET Core on an OWIN-based server and use its WebSockets support
 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[];
            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, , 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);
        }
    }
}
------------------------------------------------------------------------------------------------
OWIN keys
Request Data (OWIN v1.0.0)
 
Key                Value (type)                Description
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   
 
Request Data (OWIN v1.1.0)
 
Key                Value (type)            Description
owin.RequestId             String                 Optional 
 
Response Data (OWIN v1.0.0)
 
Key                Value (type)            Description
owin.ResponseStatusCode     int                 Optional
owin.ResponseReasonPhrase     String                 Optional
owin.ResponseHeaders         IDictionary<string,string[]>
owin.ResponseBody         Stream 
 
Other Data (OWIN v1.0.0)
 
Key                Value (type)            Description
owin.CallCancelled         CancellationToken
owin.Version             String   
 
Common Keys
 
Key                Value (type)            Description
ssl.ClientCertificate         X509Certificate
ssl.LoadClientCertAsync     Func<Task>
server.RemoteIpAddress         String
server.RemotePort         String
server.LocalIpAddress         String
server.LocalPort         String
server.IsLocal             bool
server.OnSendingHeaders     Action<Action<object>,object>   
 
SendFiles v0.3.0
 
Key                Value (type)            Description
sendfile.SendAsync         See delegate signature         Per Request 
 
Opaque v0.3.0
 
Key                Value (type)            Description
opaque.Version             String
opaque.Upgrade             OpaqueUpgrade             See delegate signature
opaque.Stream             Stream
opaque.CallCancelled         CancellationToken   
 
WebSocket v0.3.0
 
Key                Value (type)            Description
websocket.Version         String
websocket.Accept         WebSocketAccept         See delegate signature.
websocket.AcceptAlt                           Non-spec
websocket.SubProtocol         String                 See RFC6455 Section 4.2. Step 5.5
websocket.SendAsync         WebSocketSendAsync         See delegate signature.
websocket.ReceiveAsync         WebSocketReceiveAsync        See delegate signature.
websocket.CloseAsync         WebSocketCloseAsync         See delegate signature.
websocket.CallCancelled     CancellationToken
websocket.ClientCloseStatus     int Optional
websocket.ClientCloseDescription String             Optional