ASP.NET网页设计封装stream，在读写stream时供应事务通...

中间码是基于一个虚拟机器。源代码是最高层的，理论上从源代码开始直接编译成本地码能提供最大优化的。而中间码只能是转译成本地码，效率上难免受到损耗。根据虚拟机器所设定的体系结构的特点，和本地机器的差异的多少。前阵子的事情触及一些收集编程，利用了面向流的体例做传输数据。在代码过程当中，碰到一个新需求就是要统计流量。实在最复杂的举措就时在读写流的中央增添代码，把功效增添上往就能够。可是我以为那样对我道理的代码框架影响较年夜，基于只管不影响本来的代码的思索，我想到了Decorator计划形式。
先把代码贴出来，在做注释吧：

以下为援用的内容：
publicclassEventStream:Stream
{
publiceventEventHandler<FStreamDataEventArgs>OnBeforeRead;
publiceventEventHandler<FStreamDataEventArgs>OnBeforeWrite;privateStreamstream;
publicEventStream(Streamstream)
{
if(stream==null)thrownewArgumentNullException("EventStream");
this.stream=stream;
}
[====Streammembers====]#region[====Streammembers====]
publicoverrideboolCanRead
{
get{returnstream.CanRead;}
}
publicoverrideboolCanSeek
{
get{returnstream.CanSeek;}
}
publicoverrideboolCanWrite
{
get{returnstream.CanWrite;}
}
publicoverridevoidFlush()
{
stream.Flush();
}
publicoverridelongLength
{
get{returnstream.Length;}
}
publicoverridelongPosition
{
get
{
returnstream.Position;
}
set
{
stream.Position=value;
}
}
publicoverrideintRead(byte[]buffer,intoffset,intcount)
{
intreadSize=stream.Read(buffer,offset,count);
if(OnBeforeRead!=null)
OnBeforeRead(this,newFStreamDataEventArgs(buffer,offset,readSize));
returnreadSize;
}
publicoverridelongSeek(longoffset,SeekOriginorigin)
{
returnstream.Seek(offset,origin);
}
publicoverridevoidSetLength(longvalue)
{
stream.SetLength(value);
}
publicoverridevoidWrite(byte[]buffer,intoffset,intcount)
{
if(OnBeforeWrite!=null)
OnBeforeWrite(this,newFStreamDataEventArgs(buffer,offset,count));
stream.Write(buffer,offset,count);
}
publicoverrideIAsyncResultBeginRead(byte[]buffer,intoffset,intcount,
AsyncCallbackcallback,objectstate)
{
InternalAsyncStatemyState=newInternalAsyncState(
newFStreamDataEventArgs(buffer,offset,count),state);
AsyncCallbackmyCallback=newAsyncCallback(
newInternalCallback(OnBeforeRead,callback).Callback);
returnnewEventStreamAsyncResult(
stream.BeginRead(buffer,offset,count,myCallback,myState));
}
publicoverrideintEndRead(IAsyncResultasyncResult)
{
EventStreamAsyncResultesar=asyncResultasEventStreamAsyncResult;
if(esar!=null)
returnstream.EndRead(esar.InternalAsyncResult);
else
returnstream.EndRead(asyncResult);
}
publicoverrideIAsyncResultBeginWrite(byte[]buffer,intoffset,intcount,AsyncCallbackcallback,objectstate)
{
InternalAsyncStatemyState=newInternalAsyncState(
newFStreamDataEventArgs(buffer,offset,count),state);
AsyncCallbackmyCallback=newAsyncCallback(
newInternalCallback(OnBeforeWrite,callback).Callback);
returnnewEventStreamAsyncResult(
stream.BeginWrite(buffer,offset,count,myCallback,myState));
}
publicoverridevoidEndWrite(IAsyncResultasyncResult)
{
stream.EndWrite(asyncResult);
}
#endregion
privateclassInternalCallback
{
privateAsyncCallbackcallback;
privateEventHandler<FStreamDataEventArgs>internalHandler;
publicInternalCallback(EventHandler<FStreamDataEventArgs>internalHandler,AsyncCallbackcallback)
{
this.internalHandler=internalHandler;
this.callback=callback;
}
internalvoidCallback(IAsyncResultasyncResult)
{
InternalAsyncStatemyState=asyncResult.AsyncStateasInternalAsyncState;
if(internalHandler!=null&&myState!=null)
internalHandler(this,myState.StreamDataEventArgs);
callback(newEventStreamAsyncResult(asyncResult));
}
}
privateclassInternalAsyncState
{
objectstate;
FStreamDataEventArgsstreamDataEventArgs;
publicobjectState
{
get{returnstate;}
}
publicFStreamDataEventArgsStreamDataEventArgs
{
get{returnstreamDataEventArgs;}
}
publicInternalAsyncState(FStreamDataEventArgsstreamDataEventArgs,objectstate)
{
this.streamDataEventArgs=streamDataEventArgs;
this.state=state;
}
}
privateclassEventStreamAsyncResult:IAsyncResult
{
IAsyncResultar;
publicEventStreamAsyncResult(IAsyncResultar)
{
if(ar==null)thrownewArgumentNullException("EventStreamAsyncResult");
this.ar=ar;
}
IAsyncResultMembers#regionIAsyncResultMembers
publicobjectAsyncState
{
get
{
InternalAsyncStatemyState=ar.AsyncStateasInternalAsyncState;
if(myState!=null)
returnmyState.State;
else
returnar.AsyncState;
}
}
internalIAsyncResultInternalAsyncResult
{
get{returnar;}
}
publicSystem.Threading.WaitHandleAsyncWaitHandle
{
get{returnar.AsyncWaitHandle;}
}
publicboolCompletedSynchronously
{
get{returnar.CompletedSynchronously;}
}
publicboolIsCompleted
{
get{returnar.IsCompleted;}
}
#endregion
}
}
publicclassFStreamDataEventArgs:EventArgs
{
privatebyte[]buffer;
privateintoffset;
privateintcount;
publicFStreamDataEventArgs(byte[]buffer,intoffset,intcount)
{
if(buffer==null)thrownewArgumentNullException("FStreamDataEventArgs");
if(offset+count>buffer.Length)thrownewArgumentOutOfRangeException("FStreamDataEventArgs");
this.buffer=buffer;
this.offset=offset;
this.count=count;
}
/**////<summary>
///数据缓存
///</summary>
publicbyte[]Buffer
{
get{returnbuffer;}
}
/**////<summary>
///数据入手下手地位
///</summary>
publicintOffset
{
get{returnoffset;}
}
/**////<summary>
///数据长度
///</summary>
publicintCount
{
get{returncount;}
}
}


刚入手下手觉得很复杂，现实上写上去还挺多行代码的，Decorator形式嘛，固然先承继stream，把stream原本该做的事变先完成了。这个很复杂类内里包括一个外部的stream，stream该有的接口都由它来完成了。接上去就是增添两个事务，分离是OnBeforeRead、OnBeforeWrite。名字内里都有Before，实在我思索到数据流城市经由过程这两个事务开放出来，你想做加密甚么的都能够，固然也包含我想要的统计数据流量。
接上去就是在读写流的时分触发这两个事务就能够了。看看同步的Read、Write办法，复杂的挪用就能够了。
关头的中央就在于异步的读写。
我们先看看一样平常Stream的异步伐用代码是怎样的：
以下为援用的内容：
stream.BeginRead(buffer,0,byte2read,newAsyncCallback(EndReadCallback),state);
privatevoidEndReadCallback(IAsyncResultasyncResult)
{
objectstate=asyncResult.AsyncState;
nReadSize=stream.EndRead(asyncResult);
//
}


在不变动这个“client”代码的情形下，要怎样在stream何处晓得这里切实其实实读了几数据呢？
明显在挪用BeginRead的时分是不晓得，那就只能对这个AsyncCallback做四肢举动了。能够料想到framework外部会在完成了Read的操纵以后会挪用AsyncCallback托付来关照了局。因而我就传一个我界说好的AsyncCallback托付给BeginRead。固然还要把“client”供应的AsyncCallback给包装起来，在做完我的事变(事务关照)以后，仍是要把“client”要我办的事变给也给办了(挪用"client"的AsyncCallback托付来关照了局)。
这就在完成了“在客户代码与framework之间插一脚”。
再来看看我是怎样做到事务关照的。起首要把我要的数据给传已往，因而有了InternalAsyncState，这内里要有我触发事务必要的事务参数，还应当要包含用户大概传进的state。详细人人看看InternalAsyncState的完成。
最初多思索了一点就是，假设“client”代码不是像我写的那样，而是不休的经由过程反省Stream.BeginRead办法前往的IAsyncResult的IsCompleted属性来断定是不是Read完成的话，那我的代码就有成绩了，我前往的IAsyncResult基本就不是道理的IAsyncResult了。EventStreamAsyncResult类就是为这个而写的。
上面是利用的代码：
以下为援用的内容：
publicvoidGetResponseStream()
{
EventStreames=newEventStream(tcpClient.NetStream);
es.OnBeforeRead+=newEventHandler<FStreamDataEventArgs>(EventStream_OnBeforeRead);
es.OnBeforeWrite+=newEventHandler<FStreamDataEventArgs>(EventStream_OnBeforeWrite);
returnes;
}
转头看看代码，实在都在用Decorator形式的头脑，把本来的framework中的类都给包装起来，并在完成本来的功效之余别的加了本人的功效。
文笔一样平常，但愿能对你有匡助。

学习asp.net两个月有余了，除了对html、web控件比较熟悉（应该是说都能理解和接受）之外，竟不知道自己还会什么。看了两本书：《精通asp.net网络编程》（人民邮电出版社）、《asp.net实用案例教程》（清华大学出版社）。

主流网站开发语言之ASP:ASP是微软（Microsoft）所开发的一种后台脚本语言，它的语法和VisualBASIC类似，可以像SSI（ServerSideInclude）那样把后台脚本代码内嵌到HTML页面中。虽然ASP简单易用，但是它自身存在着许多缺陷，最重要的就是安全性问题。

对于中小项目来说.net技术是完全可以胜任，但为什么现在大型公司或网站都选择php或java呢？就是因为微软不够开放，没有提供从硬件到应用服务器再到业务应用的整套解决方案。

ASP.net的服务器，要求安装一个.net环境，当然我这里指的是windows系统，顺便点一下，.net只能放在windows环境里来运行。Asp.net1.1的就装Framework1.1，Asp.net2.0的就装Framework2.0。

ASP.Net和ASP的最大区别在于编程思维的转换，而不仅仅在于功能的增强。ASP使用VBS/JS这样的脚本语言混合html来编程，而那些脚本语言属于弱类型、面向结构的编程语言，而非面向对象。

ASP.net1.1和2.0在程序上的语法也有很大不同，现在2.0属于新出来的，不知道半年后会不会有3.0(说笑一下)。Windows2003系统自动支持ASP和ASP.net环境，不用安装任何程序。Asp.net属于编译语言。ASP的最大不同(ASP属于解释语言)。

平台无关性是PHP的最大优点，但是在优点的背后，还是有一些小小的缺点的。如果在PHP中不使用ODBC，而用其自带的数据库函数（这样的效率要比使用ODBC高）来连接数据库的话，使用不同的数据库，PHP的函数名不能统一。这样，使得程序的移植变得有些麻烦。不过，作为目前应用最为广泛的一种后台语言，PHP的优点还是异常明显的。

代码逻辑混乱，难于管理：由于ASP是脚本语言混合html编程，所以你很难看清代码的逻辑关系，并且随着程序的复杂性增加，使得代码的管理十分困难，甚至超出一个程序员所能达到的管理能力，从而造成出错或这样那样的问题。