578888com,古剑奇谭2帝女玄霜,炼金医师
最近看了一下开源项目asp.net katana，感觉公开的接口非常的简洁优雅，channel 9 说是受到node.js的启发设计的，katana是一个比较老的项目，现在已经整合到asp.net core中。
从github克隆下来的项目,这个博客专门是从代码角度去理解katana项目，所以本篇随笔针对已经对owin有所了解的人，如果只是入门的话可以跑一下msdn的源码再来阅读本篇文章。
代码结构如上，简单分析一下各个文件夹的含义，这对于理解katana项目的整体结构有一个大的轮廓。
.build文件夹顾名思义就是编译的文件夹，在没使用vs的时候你可以单击build.cmd 去编译这个项目，十分的方便。
.nuget就是包管理工具的配置文件，这个我们可以忽略。同理.prerelease。
development是本次的研究重点，当你打开这个文件夹的时候你会发现一个类库microsoft.owin的类库，这个是owin组件的经典实现。
functiontests是单元测试的类库
hosting 是server的抽象层，owin 将服务器进行抽象化，hosting 就是能够管理server的一层，像webapp就能开启一个httplister服务，详细稍后再讲。
middleware是一些中间件的实现，在katana已经将管道模型虚拟化成中间件
performance 和sandbox 是微软的一些测试工具
security 是微软已经写好的验证中间件，其中包括jwt和oauth的验证方式
server 就是服务器的实现
owin.analysis是我本人建的web程序用来debug
上面已经介绍了各个文件夹所对应的功能，相必大部分人都是一脸蒙蔽，但是不用担心，下面就来看看具体的代码，当然是从最小的例子出发。点击 你就能跳到msdn得到最小的例子。里面的一系列操作就为了添加下面的一个类和几个reference.现在我们看一下这个类。
我要评论 1 using microsoft.owin;
2
3 [assembly: owinstartup(typeof(owin.analysis.startup))]
4 namespace owin.analysis
5 {
6 public class startup
7 {
8 public void configuration(iappbuilder app)
9 {
10 app.run(context =>
11 {
12 context.response.contenttype = "text/plain";
13 return context.response.writeasync("hello world");
14 });
15 }
16 }
17 }
看起来这个代码十分的优雅，添加几个reference和一个类就让请求到达hello world。我们先分析这个类，首先程序集特性owinstartupatribute将当前类保存在元数据中。然后写了一个configuration方法，获取一个iappbuilder 参数调用run方法，run方法传递一个委托进去，我们的处理逻辑就在这一个委托里。
这里面我们分析一下核心接口iappbuilder的经典实现者appbuilder，iappbuilder的接口如下，
using system;
using system.collections.generic;
namespace owin
{
public interface iappbuilder
{
idictionary<string, object> properties { get; }//请求的参数
object build(type returntype);//中间件链接
iappbuilder new();//创建一个新的对象
iappbuilder use(object middleware, params object[] args);//注册中间件
}
}
好的我们来分析一下appbuilder中间件的注册实现。在app.run 打完break point你就可以进入app.use方法，首先在appbuilderuseextensions这个类里对use的入口写了一大堆扩展方法。app.run就是其中的一个，当你用app.run注册中间件的时候是没有下一个中间件的引用的。
public static void run(this iappbuilder app, func<iowincontext, task> handler)
{
if (app == null)
{
throw new argumentnullexception("app");
}
if (handler == null)
{
throw new argumentnullexception("handler");
}
app.use<usehandlermiddleware>(handler);
}
在经典的实现中，参数middleware会有两种情况，一种是delegate，一种是type,如果是type类型，则他的构造方法接受next为参数，并且里面有一个公开的invoke方法。如果是委托，当前委托作为参数传递到next中。
public iappbuilder use(object middleware, params object[] args)
{
_middleware.add(tomiddlewarefactory(middleware, args));
return this;
}
下面的代码是tomiddlewarefactory的实现，在第9行和第27行分别判断了中间件对象是委托类型还是type类型，由于本题例子是type对象，我们分析一下toconstructormiddlewarefactory方法。
1 private static tuple<type, delegate, object[]> tomiddlewarefactory(object middlewareobject, object[] args)
2 {
3 if (middlewareobject == null)
4 {
5 throw new argumentnullexception("middlewareobject");
6 }
7
8 var middlewaredelegate = middlewareobject as delegate;
9 if (middlewaredelegate != null)
10 {
11 return tuple.create(getparametertype(middlewaredelegate), middlewaredelegate, args);
12 }
13
14 tuple<type, delegate, object[]> factory = toinstancemiddlewarefactory(middlewareobject, args);
15 if (factory != null)
16 {
17 return factory;
18 }
19
20 factory = togeneratormiddlewarefactory(middlewareobject, args);
21 if (factory != null)
22 {
23 return factory;
24 }
25
26 if (middlewareobject is type)
27 {
28 return toconstructormiddlewarefactory(middlewareobject, args, ref middlewaredelegate);
29 }
30
31 throw new notsupportedexception(string.format(cultureinfo.currentculture,
32 resources.exception_middlewarenotsupported, middlewareobject.gettype().fullname));
33 }
在第5行获取type类型的所有构造方法，第8行获取构造方法的所有参数，在第14行有个trick,用zip方法判断参数类型是否和构造方法类型是一致的。如果是一致的则继续往下走，在第22行和第23行利用委托将构造方法创建成lambda表达式，然后生成元祖，第一个是next的类型，第二个是type的构造方法，第三个是type构造方法所需的参数。然后将元祖加入到appbuild所维护的中间件对象。
1
2 private static tuple<type, delegate, object[]> toconstructormiddlewarefactory(object middlewareobject, object[] args, ref delegate middlewaredelegate)
3 {
4 var middlewaretype = middlewareobject as type;
5 constructorinfo[] constructors = middlewaretype.getconstructors();
6 foreach (var constructor in constructors)
7 {
8 parameterinfo[] parameters = constructor.getparameters();
9 type[] parametertypes = parameters.select(p => p.parametertype).toarray();
10 if (parametertypes.length != args.length + 1)
11 {
12 continue;
13 }
14 if (!parametertypes
15 .skip(1)
16 .zip(args, testargforparameter)
17 .all(x => x))
18 {
19 continue;
20 }
21
22 parameterexpression[] parameterexpressions = parameters.select(p => expression.parameter(p.parametertype, p.name)).toarray();
23 newexpression callconstructor = expression.new(constructor, parameterexpressions);
24 middlewaredelegate = expression.lambda(callconstructor, parameterexpressions).compile();
25 return tuple.create(parameters[0].parametertype, middlewaredelegate, args);
26 }
27
28 throw new missingmethodexception(string.format(cultureinfo.currentculture,
29 resources.exception_noconstructorfound, middlewaretype.fullname, args.length + 1));
30 }
这个时候我们已经将中间件注册到appbuilder对象了。注册完中间件的对象我们还需要做一件事就是将这些中间件chained together,这些实现就是build 方法中，而build方法buildinternal方法，这个时候会产生一个entry point供调用。
现在我们重点看一下这个build方法。
public object build(type returntype)
{
return buildinternal(returntype);
}
build方法调用私有的buildinternal的方法。
private object buildinternal(type signature)
{
object app;
if (!_properties.trygetvalue(constants.builderdefaultapp, out app))
{
app = notfound;
}
foreach (var middleware in _middleware.reverse())
{
type neededsignature = middleware.item1;
delegate middlewaredelegate = middleware.item2;
object[] middlewareargs = middleware.item3;
app = convert(neededsignature, app);
object[] invokeparameters = new[] { app }.concat(middlewareargs).toarray();
app = middlewaredelegate.dynamicinvoke(invokeparameters);
app = convert(neededsignature, app);
}
return convert(signature, app);
}
我们可以看到它是怎样将中间件chained together的，在我们之前注册的时候实际上middleware元祖会保存三个信息，第一个type就是构造函数的第一个类型，第二个委托是usehandlermiddleware的构造方法，第三个是构造方法的参数（除了第一个），reverse的方法会将中间件逆序，这样保证调用的顺序就是你注册的顺序，后面的是chain的逻辑，app的变量实际上就是下一个中间件构造函数的next，当得到第一个中间件的时候，里面的next会保存第二个中间件的处理逻辑，同样第二个next就是第三个...，这样chained together得到的就是第一个中间件的逻辑，所以你们在用app.use的方法就会有一个参数next，并且需要手动调用一下。
得到这些之后需要的就是要将中间件注册到application管道事件呢。因为asp.net的是一个大的切面框架。
public void initialize(httpapplication application)
{
for (integratedpipelineblueprintstage stage = _blueprint.firststage; stage != null; stage = stage.nextstage)
{
var segment = new integratedpipelinecontextstage(this, stage);
switch (stage.name)
{
case constants.stageauthenticate:
application.addonauthenticaterequestasync(segment.beginevent, segment.endevent);
break;
case constants.stagepostauthenticate:
application.addonpostauthenticaterequestasync(segment.beginevent, segment.endevent);
break;
case constants.stageauthorize:
application.addonauthorizerequestasync(segment.beginevent, segment.endevent);
break;
case constants.stagepostauthorize:
application.addonpostauthorizerequestasync(segment.beginevent, segment.endevent);
break;
case constants.stageresolvecache:
application.addonresolverequestcacheasync(segment.beginevent, segment.endevent);
break;
case constants.stagepostresolvecache:
application.addonpostresolverequestcacheasync(segment.beginevent, segment.endevent);
break;
case constants.stagemaphandler:
application.addonmaprequesthandlerasync(segment.beginevent, segment.endevent);
break;
case constants.stagepostmaphandler:
application.addonpostmaprequesthandlerasync(segment.beginevent, segment.endevent);
break;
case constants.stageacquirestate:
application.addonacquirerequeststateasync(segment.beginevent, segment.endevent);
break;
case constants.stagepostacquirestate:
application.addonpostacquirerequeststateasync(segment.beginevent, segment.endevent);
break;
case constants.stageprehandlerexecute:
application.addonprerequesthandlerexecuteasync(segment.beginevent, segment.endevent);
break;
default:
throw new notsupportedexception(
string.format(cultureinfo.invariantculture, resources.exception_unsupportedpipelinestage, stage.name));
}
}
// application.presendrequestheaders += presendrequestheaders; // null refs for async un-buffered requests with bodies.
application.addonendrequestasync(beginfinalwork, endfinalwork);
}
这里面有一个概念就是integratedpipelineblueprintstage，这个是一个链表结构，每个对应的就是管道事件，每个stage都有entry point，这样方便我们在不同的管道事件中运行中间件，在beginevent里我们得到stage 的entry point，然后异步调用得到结果。entry point 就是我们上例build得到的结果。
private async task runapp(appfunc entrypoint, idictionary<string, object> environment, taskcompletionsource<object> tcs, stageasyncresult result)
{
try
{
await entrypoint(environment);
tcs.trysetresult(null);
result.trycomplete();
}
catch (exception ex)
{
// flow the exception back through the owin pipeline.
tcs.trysetexception(ex);
result.trycomplete();
}
}
然后我们分析一下怎么在不同的管道中注册事件。在msdn的文档描述的。
app.usestagemarker(pipelinestage.authenticate)
这个api会创建一个integratedpipelineblueprintstage，上文说这是一个链表结构，之间用next属性连接。在不同的stage中会有entry point，然后在上面的例子中注册到不同的管道中去调用。下图是api的代码。
public static iappbuilder usestagemarker(this iappbuilder app, string stagename)
{
if (app == null)
{
throw new argumentnullexception("app");
}
object obj;
if (app.properties.trygetvalue(integratedpipelinestagemarker, out obj))
{
var addmarker = (action<iappbuilder, string>)obj;
addmarker(app, stagename);
}
return app;
}
好的，到这里了，谢谢大家阅读，如果有任何不理解的欢迎交流：）
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
asp.net搭建博客，使用BlogEngine.NET+MySql搭建博客
网友评论