Silverlight异步Socket通信

   public   void  receiveAsync()
        {
            receiveAsync(_receiveSocketArgs);
        }

         private   void  receiveAsync(socketasynceventargs socketasynceventargs)
        {
             if  ( ! _acceptedSocket.ReceiveAsync(socketasynceventargs))
            {
                receiveCallBACk(_acceptedSocket, socketasynceventargs);
            }
        }

         void  receiveCallBACk( object  sender, socketasynceventargs E)
        {
             if  (e.socketError  !=  SocketError.success)
            {
                 return ;
            }
            _receiveBuffer.offset  +=  e.bytesTransferred;
             if  (_receiveBuffer.IsmessageReceived())
            {
                 if  (OnReceive  !=   null )
                {
                    Networkmessage msg  =  Networkmessage.Deserialize(_receiveBuffer.buffer);
                    _receiveBuffer.AdjustBuffer();
                    OnReceive( this ,  new  receiveArgs(msg));
                }
            }
             else
            {
                 // adjust the buffer pointer
                e.SetBuffer(_receiveBuffer.offset, _receiveBuffer.Remaining);
            }
             // queue a an async read request
            receiveAsync(_receiveSocketArgs);
        }

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Xml.serialization;
using  System.IO;

namespace  SilverlightSocketDemo.Server
{
    [XmlInclude( typeof (MymessagE))]
     public   abstract   class  Networkmessage
    {
         public   static   readonly   int  LENGTH_BYTES  =   4 ;
       
         // first 4 bytes of the buffer will contain the length of the serialized Networkmessage
         // this@R_794_3816@ treats input argument as immutable
         public   static  Networkmessage Deserialize( byte [] buffer)
        {
             int  length  =  BitConverter.ToInt32(buffer,  0 );
             int  starTindex  =   sizeof ( int );
             String  strNetworkmessage  =  Encoding.UTF8.GetString(buffer, starTindex, length);

            StringReader StringReader  =   new  StringReader(strNetworkmessagE);
            Xmlserializer xmlserializer  =   new  Xmlserializer( typeof (NetworkmessagE));
             return  (NetworkmessagE)xmlserializer.Deserialize(StringReader);

        }

         // the first 4 bytes of the serialized byte array will contain the length of the buffer that
         // contains the prevIoUsly serialized Networkmessage;
         public   static   byte [] serialize(Networkmessage msg)
        {
            StringWriter StringWriter  =   new  StringWriter();
            Xmlserializer xmlserializer  =   new  Xmlserializer( typeof (NetworkmessagE));
            xmlserializer.serialize(StringWriter, msg);
             byte [] messageBytes  =  Encoding.UTF8.GetBytes(StringWriter.ToString());
             byte [] lengthBytes  =  BitConverter.GetBytes(messageBytes.Length);
             byte [] finalBytes  =   new   byte [lengthBytes.Length  +  messageBytes.Length];
             // copy the length of the serialized object
            array.Copy(lengthBytes,  0 , finalBytes, lengthBytes.Length);
            array.Copy(messageBytes, lengthBytes.Length, BitConverter.ToInt32(lengthBytes,  0 ));
             return  finalBytes;
        }

    }

     public   class  Mymessage : Networkmessage
    {
         public   String  User {  get ;  set ; }
         public   String  Content {  get ;  set ; }
         public   override   String  ToString()
        {
             return  User + " : " + Content;
        }
    }

     public   class  SocketBuffer
    {
         public   const   int  BUFFERSIZE  =   1024 ;
         protected   byte [] _buffer;
         protected   int  _offset  =   0 ;
         public  SocketBuffer()
        {
            _buffer  =   new   byte [BUFFERSIZE];
        }
         public  SocketBuffer( int  sizE)
        {
            _buffer  =   new   byte [size];
        }
         public   byte [] Buffer
        {
             get  {  return  _buffer; }
             set  { _buffer  =  value; }
        }
         // offset will allways inDicate the length of the buffer that is filled
         public   int  Offset
        {
             get  {  return  _offset; }
             set  { _offset  =  value; }
        }

         public   int  remaining
        {
             get  {  return  _buffer.Length  -  _offset; }
        }
    }

     public   class  receiveBuffer : SocketBuffer
    {
         // removes a serlialized message from the buffer, copies the partial message to the begining
         // and adjusts the offset
         public   void  AdjustBuffer()
        {
             int  messageSize  =  BitConverter.ToInt32(_buffer,  0 );
             int  lengthToCopy  =  _offset  -  Networkmessage.LENGTH_BYTES  -  messageSize;
            array.Copy(_buffer, _offset, _buffer, lengthToCopy);
            _offset  =  lengthToCopy;
        }
         // this method checks if a complete message is received
         public   bool  IsmessageReceived()
        {
             if  (_offset  <   4 )
                 return   false ;
             int  sizeToRecieve  =  BitConverter.ToInt32(_buffer,  0 );
             // check if we have a complete Networkmessage
             if  ((_offset  -   4 )  <  sizeToRecievE)
                 return   false ;  // we have not received the complete message yet
             // we received the complete message and may be more
             return   true ;
        }
    }
}