[转]实现自己的ASP.NET宿主系统

实现自己的ASP.NET宿主系统

一、 宿主概念 
                            托管是.net的一个很基础的概念，所有的.net应用 程序代码要完全发挥作用需要进入托管的环境（clr --common language runtime），而这个环境实际上就是称作宿主(host) 为将要启动的.net代码准备的。目前来讲windows系统上，能够担负这个重任的有3类已存程序： 
                            1、 shell(通常是explorer)，提供从用户桌面启动.net程序,创建一个进程，启动此进程建立clr 
                            2、 浏览器宿主（internet explorer），处理从web下载的.net代码执行。 
                            3、 服务器宿主（如iis的辅助进程aspnet_wp.exe） 
                             通常来讲，我们开发的asp.net的程序运行在iis的环境下（实际上由一个isapi控制启动clr），但实际上asp.net程序可以摆脱iis单 独在任何托管环境下运行。本文讨论了asp.net程序如何在自定义的环境中启动，希望有助于我们了解asp.net的执行原理，同时使我们开发的 asp.net能够在任何.net环境下执行，不管是服务器操作系统还是普通的桌面操作系统。                             二、 iis宿主中asp.net的执行分析 
                              关于iis中asp.net的执行细节，很多文章做了详尽权威的分析，本文不打算赘述，在此给出一些参考： 
                              http://www.yesky.com/softchannel/72342380468043776/20030924/1731387.shtml 
                              http://chs.gotdotnet.com/quickstart/aspplus/doc/procmodel.aspx 
                              这些文章大致重点分析了：宿主环将如何启动、asp.net应用程序如何产生程序集、如何加载，同宿主的交互等细节。 
                            三、 构造自己的asp.net宿主程序 
                              asp.net 是作为微软asp的替代技术出现的，所以我们重点讨论如何通过web方式应用asp.net（显然还有其他方式），具体就是：我们用.net平台的语言编 写一个控制台程序，这个程序启动一个asp.net应用环境，执行关于aspx的请求。具体来讲，需要做以下工作： 
                              1、实现一个web server，监听所有的web请求，实现http web hosting 
                              2、 启动一个应用程序域，创建一个asp.net的applicationhost，建立一个asp.net的应用程序域，另外还建立一个 httpworkerrequest的具体实现类，该类可以处理aspx请求，编译aspx页，编译后的托管代码缓存入当前应用程序域，然后执行代码，得 到执行结果。建议在继续阅读下文前，仔细翻查msdn中的关于这两个类得参考说明。 
                              system.web.hosting.applicationhost 类用于建立一个独立的应用程序域。当然不是普通的应用程序域，而是为asp.net建立执行环境，准备需要的空间、数据结构等。仅有一个静态方法 static object createapplicationhost( 
                              type host //具体的用户实现类，就是asp.net应用域需要加载的类 
                              string virtualdir, //此应用域在整个web中的执行目录，虚拟目录 
                              string physicaldir //对应的物理目录 
                              ); 
                               而其中的host 参数指向一个具体的类，由于该类实际上属于两个应用域之间的联系类，在两个应用程序域之间编组传递数据，所以必须要继承自 marshalbyrefobject，以允许在支持应用程序中跨应用程序域边界访问（至于为什么，建议翻查参考3）。 
                               可以看到，我们需要启动两个应用程序域（web server功能应用程序域和asp.net 应用程序域），而这两个（应用程序）域之间通过跨（应用程 序）域的流对象引用来实现，使得在asp.net域中执行的结果可以通过web server域返回给请求者。 
                              可以大致下图表达 
                              执行asp.net的web服务器端

web客户端 
                            代码实现分析：

using system; 
                              using system.web ; 
                              using system.web.hosting; 
                              using system.io; 
                              using system.net; 
                              using system.net.sockets ; 
                              using system.text ; 
                              using system.threading ; 
                            namespace myiis 
                              { 
                              class asphostserver 
                              { 
                              [stathread] 
                              static void main(string[] args) 
                              { 
                              //创建并启动服务器 
                              myserver myserver=new myserver(“/”, ”c:\\inetpub\\wwwroot\\myweb”); 
                              } 
                              } 
                            class myserver //处理http协议的服务器类 
                              { 
                              private aspdotnethost aspnethost; //asp.net host的实例 
                              private tcplistener mytcp; //web监听套接字 
                              bool bsvcrunning=true; //服务是否运行指示 
                              filestream fs; //处理http请求的普通文本要求 
                            public myserver(string virtualdir ,vstring realpath) 
                              {//在构造函数中启动web监听服务 
                              try 
                              { 
                              mytcp=new tcplistener(8001); 
                              mytcp.start(); //启动在8001端口的监听 
                              console.writeline("服务启动"); 
                              //利用createapplicationhost方法建立一个独立的应用程序域执行asp.net程序 
                              aspnethost = ( aspdotnethost )applicationhost.createapplicationhost 
                              ( typeof( aspdotnethost ) , virtualdir , realpath); 
                              thread t=new thread(new threadstart(mainsvcthread)); 
                              t.start(); //服务线程启动 负责处理每一个客户端的请求 
                              } 
                              catch(nullreferenceexception) 
                              { 
                              console.writeline("nullreferenceexception throwed!") ; 
                              } 
                              } 
                            public void mainsvcthread() //asp.net host的web服务器的主要服务线程 
                              { 
                              int s=0; 
                              string strrequest; //请求信息 
                              string strdir; //请求的目录 
                              string strrequestfile; //请求的文件名 
                              string strerr=""; //错误信息 
                              string strrealdir; //实际目录 
                              string strwebroot=rpath; //应用根目录 
                              string strrealfile=""; //正在请求的文件的磁盘路径 
                              string strresponse=""; //回应响应缓冲区 
                              string strmsg=""; //格式化响应信息 
                              byte[] bs; //输出字节缓冲区 
                            while(bsvcrunning) 
                              { 
                              socket sck=mytcp.acceptsocket(); //每个请求到来 
                              if(sck.connected) 
                              { 
                              console.writeline("client {0} connected!",sck.remoteendpoint); 
                              byte[] brecv=new byte[1024]; //缓冲区 
                              int l=sck.receive(brecv,brecv.length,0); 
                              string strbuf=encoding.default.getstring(brecv); //转换成字符串，便于分析 
                              s=strbuf.indexof("http",1); 
                              string httpver=strbuf.substring(s,8); // http/1.1 之类的 
                              strrequest=strbuf.substring(0,s-1); 
                              strrequest.replace("\\","/"); 
                              if((strrequest.indexof(".")<1) && (!strrequest.endswith("/"))) 
                              { 
                              strrequest += "/"; 
                              } 
                              s=strrequest.lastindexof("/")+1; 
                              strrequestfile  = strrequest.substring(s); strdir=strrequest.substring(strrequest.indexof ("/"),strrequest.lastindexof("/")-3); //取得访问的url 
                              if(strdir=="/") 
                              { 
                              strrealdir=strwebroot; 
                              } 
                              else 
                              { 
                              strdir=strdir.replace("/","\\"); 
                              strrealdir=strwebroot + strdir; 
                              } 
                              console.writeline("client request dir: {0}" , strrealdir); 
                              if(strrequestfile.length==0) 
                              { 
                              strrequestfile="default.htm"; //缺省文档 
                              } 
                              int itotlabytes=0; //总计需要输出的字节 
                              strresponse=""; //输出内容 
                              strrealfile = strrealdir +"\\"+ strrequestfile; 
                              if(strrealfile.endswith(".aspx")) //这里有bug!! 
                              { 
                              string output=""; 
                              //注意我下面的语句们给host对象processrequest方法传递了一个ref类型的参数， 
                              //aspnethost会从asp.net的执行应用程序域执行一个请求后返回流给当前web server所在的域，这实际上发生了一个域间的调用 
                              aspnethost.processrequest (strrequestfile, ref output);//转换成字节流 
                              bs=system.text.encoding.default.getbytes (output); 
                              itotlabytes=bs.length ; //调用套接字将执行结果返回 
                              writeheader(httpver,"text/html",itotlabytes,"200 ok",ref sck); 
                              flushbuf(bs,ref sck); 
                              } 
                              else 
                              {try 
                              { 
                              fs=new filestream( strrealfile,filemode.open,fileaccess.read,fileshare.read ); 
                              binaryreader reader=new binaryreader(fs); //读取 
                              bs=new byte[fs.length ]; 
                              int rb; 
                              while((rb=reader.read(bs,0,bs.length ))!=0) 
                              { 
                              strresponse =strresponse +encoding.default.getstring(bs,0,rb); 
                              itotlabytes =itotlabytes+rb; 
                              } 
                              reader.close(); 
                              fs.close(); 
                              writeheader(httpver,"text/html",itotlabytes,"200 ok",ref sck); 
                              flushbuf(bs,ref sck); 
                              } 
                              catch(system.io.filenotfoundexception ) 
                              {//假设找不到文件，报告404 writeheader(httpver,"text/html",itotlabytes,"404 ok",ref sck); 
                              } 
                              } 
                              } 
                              sck.close(); //http请求结束 
                              } 
                              } 
                            // writeheader想客户端发送http头 
                              public void writeheader(string ver,string mime,int len,string statucode,ref socket sck) { 
                              string buf=""; 
                            if(mime.length ==0) 
                              { 
                              mime="text/html"; 
                            buf=buf+ver+ statucode + "\r\n"; 
                              buf=buf+"server:myiis"+"\r\n"; 
                              buf=buf+"content-type:"+mime +"\r\n"; 
                              buf=buf+"accept-rabges:bytes"+"\r\n"; 
                              buf=buf+"content-length:"+ len +"\r\n\r\n"; 
                              byte[] bs=encoding.default.getbytes(buf); 
                              flushbuf(bs,ref sck); 
                              } 
                              } 
                            // flushbuf刷新向客户发送信息缓冲区 
                              public void flushbuf(byte[] bs,ref socket sck) 
                              { 
                              int inum=0; 
                              try 
                              { 
                              if(sck.connected) 
                              { 
                              if((inum=sck.send(bs,bs.length ,0))==-1) 
                              { 
                              console.writeline("flush err:send data err"); 
                              } 
                              else 
                              { 
                              console.writeline("send bytes :{0}",inum); 
                              } 
                              } 
                              else 
                              { 
                              console.writeline("client diconnectioned!"); 
                              } 
                              } 
                              catch(exception e) 
                              { 
                              console.writeline("error:{0}",e); 
                              } 
                              } 
                              } 
                            // aspdotnethost类实例需要跨越两个应用程序域，所以继承自marshalbyrefobject 
                              class aspdotnethost:marshalbyrefobject 
                              { 
                              public void processrequest( string filename ,ref string output) 
                              { 
                              memorystream ms=new memorystream(); //内存流，当然为了速度 
                              streamwriter sw = new streamwriter(ms); //输出 
                              sw.autoflush  = true; //设为自动刷新 /先构造一个httpworkrequest请求类，以便asp.net能够分析获取请求信息，同时传入一个输出流对象供asp.net执行期间返回html流 
                              httpworkerrequest worker = new simpleworkerrequest( filename, "" ,sw) ; // 调度某个页，这里面的包含很多细节，后面分析 
                              httpruntime.processrequest( worker ) ; 
                              streamreader sr= new streamreader(ms); //准备从内存流中读取 
                              ms.position =0; //移动指针到头 
                              output = sr.readtoend(); 
                              } 
                              } 
                              } 
                              httpruntime.processrequest( worker ) ;

包括了那些细节呢？大体上如下： 
                              1、首先，worker对象传入给 asp.net的应用程序域，告知发生了对于哪一个aspx文件的请求，以及当前目录是什么，如果在执行期间发生的输出内容应该写到哪里(sw对象)。这 发生一个由web server当前应用程序域到我们自己建立的asp.net应用程序域的跨（应用程序）域调用，还可能由于是第一次访问，会发生了全局 事件、或者session事件等。 
                              2、asp.net的应用程序域会检测请求的 aspx文件是否存在，不存在，就报错；如果存在还要看看代码缓存中是否存在上次编译的代码，如果存在且asp.net检测到不需要重新编译，会直接执行 缓存中的代码；如果不存在或者代码过期需要重新编译，就需要读取aspx文件，编译成.net的代码，存入缓存。可能有些页存在代码和模板分离成多个文 件，甚至包括一些资源文件，这些都需要读取后编译成.net的虚拟机代码，然后在托管环境里执行。 
                              3、执行asp.net的编译代码缓存中的代码，输出数据利用sw对象输出。 
                              当然，根据不同的配置，还有很多方法的调用/事件的发生等细节不同。 
                              如何调试运行以上程序，观察结果呢？ 
                               建立一个控制台类型工程，将上述代码录入后编译，将得到的程序拷贝在作为站点应用起始目录（譬如c:\inetpub\wwwroot\myweb）的 bin子目录下，然后启动，这样在其中创建asp.net应用程序域才不会因为程序集加载失败而出错。建立一个asp.net工程在目录下，添加 default.htm文件和测试用的test.aspx，加入.net执行代码，然后启动ie，在地址栏分别输入：http://127.0.0.1: 8001/default.htm http://127.0.0.1:8001/test.aspx感受一下执行过程。甚至你可以建立的工程中设定断点 之类，仔细调试和观察其中的细节。亲手试一试吧，一定有收获的！ 
                            四、 自己构造asp.net宿主的意义 
                              费了半天劲搞自己的asp.net宿主，对于我们有何意义呢？ 
                               首先，是大致从代码级清楚分析asp.net执行细节，自己学习了解执行细节，除了可以在出现asp.net故障可以进行精确定位和排除外，还可以帮助我 们在写asp.net应用程序时写出更有效率和健壮的代码。 
                              其次，我们可以提供一个思路，可以将我们的asp.net程序运行于低配置机器上，脱离iis。asp.net的“原配”宿主iis需要运行在server os上，要知道在安全专 家眼中，iis可是大隐患的源头之一。我们可以将很多传统程序利用asp.net编写，但脱离iis独立执行，譬如在win98系统上执行 asp.net。web server和asp.net都在托管环境中执行，相比较isapi建立宿主然后执行，除提高效率外，还可以使用.net平台提 供的丰富管理调控功能，写b/s程序更接近传统程序编写方式，这对于程序员来讲都是效率（编写代码的效率和执行效果效率）的保证。 
                               另外，对于采用asp.net做的项目，大家可以很方便进行开发调试、运行维护、安装。即使是普通桌面程序，我们也可以通过类似制作网页的方式编写这些界 面和代码，然后独立建立类似本例中的host环境，根据用户交互请求加载执行某些页面，然后将界面在客户端通过相关组件显示出来。你可以通过此获得 asp.net的即时编译功能和asp.net宿主托管环境，大量可自由使用的api，便于开发、安装、维护。毕竟，托管环境几乎准备了您需要的一切功 能。 
                            五、 参考资料 
                              1、.net msdn 
                              2、清华大学出版社《.net网络高级编程》andrew krowczyk viond kumar原著 
                              3、清华大学出版社《.net框架程序设计(修订版)》jsfftry richter著