详解通过.NET缓存提高TCP传输速度

在这里我们将介绍的是通过.NET缓存提高TCP传输速度，这也是提高网络性能的方法，希望对大家有所帮助。

成都创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站设计、成都网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的桥东网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

.NET提供了一个NetworkStream 用于TCP 的读写，实际使用时发现直接操作效率很低，哪怕把TCP 的发送缓存和接受缓存设置很大也没有太大提高。后来在对 NetworkStream 读写前设置了缓存，性能一下子提高了很多。

从实际测试结果看设置自己的写缓存，对性能的提升最为显著。我分析了一下，其原因很可能是在向NetworkStream 序列化对象时，序列化程序调用了大量的Write 方法向NetworkStream写入数据，每次向NetworkStream写入数据，数据被首先写入TCP的发送缓存，并且由调用线程设置一个信号通知.Net framework 内部的TCP线程发送缓冲区中已经有数据，TCP线程被激活并读取发送缓冲区中的数据，组包并向网卡写入数据。频繁的调用 NetworkStream.Write 写入小块数据将导致调用线程和TCP线程反复切换，并大量触发网卡中断，导致发送效率低下。如果我们在发送前将数据缓存并按较大的数据块发送给TCP线程，则大大减少线程切换和网卡中断数量，从而大大提高传输效率。

问题到这里还没有结束，我们发送的对象往往较大，如果我们将发送对象全部序列化到buffer中再发送，那么势必占用大量内存，实际上我们无法忍受这种对内存无限制申请的行为，试想一个1G大小的对象，我们在发送前为它另外再开辟1个G的内存来缓存，对于系统来说简直是无法忍受。由于我们用.net 发送数据,我们在发送时需要将对象序列化到流中，而不能像 C/C++那样直接通过指针来读取数据（当然你也可以用unsafe代码，但这种方式会带来其他问题，而且并不为大家所推荐），所以我们需要开发一个专门用 TCP 发送缓存的流来处理读写前的缓存。为此我开发了一个 TcpCacheStream 类，这个类被用在读写 NetworkStream 前先进行缓存。

调用方法很简单

发送过程  

 
 
 
    
  
  
  
  1. object msg;  
    2. 
  
  
  
  2. //初始化 msg 过程省略  
    3. 
  
  
  
  3. System.Net.Sockets.NetworkStream _ClientStream;  
    4. 
  
  
  
  4. //初始化 _ClientStream 过程省略  
    5. 
  
  
  
  5.    
    6. 
  
  
  
  6. //创建TcpCacheStream   
    7. 
  
  
  
  7. TcpCacheStream tcpStream = new TcpCacheStream(_ClientStream);  
    8. 
  
  
  
  8.    
    9. 
  
  
  
  9. //二进制序列化 msg 对象到 TcpCacheStream   
    10. 
  
  
  
  10. IFormatter formatter = new BinaryFormatter();  
    11. 
  
  
  
  11. formatter.Serialize(tcpStream, msg);  
    12. 
  
  
  
  12.    
    13. 
  
  
  
  13. //将缓存中最后一包的数据发送出去  
    14. 
  
  
  
  14. tcpStream.Flush(); 
    15.

接收过程

 
 
 
    
  
  
  
  1. System.Net.Sockets.NetworkStream _ClientStream;  
    2. 
  
  
  
  2. //初始化 _ClientStream 过程省略  
    3. 
  
  
  
  3.    
    4. 
  
  
  
  4. //创建TcpCacheStream   
    5. 
  
  
  
  5. TcpCacheStream tcpStream = new TcpCacheStream(_ClientStream);  
    6. 
  
  
  
  6.    
    7. 
  
  
  
  7. //从 TcpCacheStream 二进制反序列化  
    8. 
  
  
  
  8. IFormatter formatter = new BinaryFormatter();  
    9. 
  
  
  
  9. objcet result = formatter.Deserialize(tcpStream); 
    10.

TcpCacheStream 类为调用者封装了缓存的过程，这个缓存过程实际并不复杂，发送时数据先写入TcpCacheStream的buf中，当buf满后才向NetworkStream 写入数据，否则只缓存。由于最后一包不能保证正好填满buf，我们在写入数据后一定要调用 Flush 方法，将所有数据都发送出去。接收的过程反过来，如果buf中没有数据，就先将数据读入到buf中，然后再COPY给调用者，如果已经有数据则直接COPY给调用者。

TcpCacheStream 的代码如下：

 
 
 
    
  
  
  
  1. [Serializable]  
    2. 
  
  
  
  2.     public class TcpCacheStream : Stream  
    3. 
  
  
  
  3.     {  
    4. 
  
  
  
  4.         #region Private fields  
    5. 
  
  
  
  5.         const int BUF_SIZE = 4096;  
    6. 
  
  
  
  6.         private byte[] _Buf = new byte[BUF_SIZE];  
    7. 
  
  
  
  7.          private MemoryStream _CacheStream = new MemoryStream(BUF_SIZE);  
    8. 
  
  
  
  8.         private NetworkStream _NetworkStream;  
    9. 
  
  
  
  9.          private int _BufLen = 0;  
    10. 
  
  
  
  10.         #endregion  
    11. 
  
  
  
  11.         #region Private properties  
    12. 
  
  
  
  12.         private MemoryStream CacheStream  
    13. 
  
  
  
  13.         {  
    14. 
  
  
  
  14.             get 
    15. 
  
  
  
  15.             {  
    16. 
  
  
  
  16.                 return _CacheStream;  
    17. 
  
  
  
  17.             }  
    18. 
  
  
  
  18.         }  
    19. 
  
  
  
  19.    
    20. 
  
  
  
  20.         #endregion  
    21. 
  
  
  
  21.        #region Public properties  
    22. 
  
  
  
  22.         ///   
    23. 
  
  
  
  23.         /// get or set the Network Stream  
    24. 
  
  
  
  24.         ///   
    25. 
  
  
  
  25.         public NetworkStream NetworkStream  
    26. 
  
  
  
  26.         {  
    27. 
  
  
  
  27.             get 
    28. 
  
  
  
  28.             {  
    29. 
  
  
  
  29.                 return _NetworkStream;  
    30. 
  
  
  
  30.             }  
    31. 
  
  
  
  31.         }  
    32. 
  
  
  
  32.         #endregion  
    33. 
  
  
  
  33.         public TcpCacheStream(NetworkStream networkStream)  
    34. 
  
  
  
  34.         {  
    35. 
  
  
  
  35.             _NetworkStream = networkStream;  
    36. 
  
  
  
  36.         }  
    37. 
  
  
  
  37.         #region Implement stream class  
    38. 
  
  
  
  38.         public override bool CanRead  
    39. 
  
  
  
  39.         {  
    40. 
  
  
  
  40.             get 
    41. 
  
  
  
  41.             {  
    42. 
  
  
  
  42.                 return true;  
    43. 
  
  
  
  43.             }  
    44. 
  
  
  
  44.         }  
    45. 
  
  
  
  45.         public override bool CanSeek  
    46. 
  
  
  
  46.         {  
    47. 
  
  
  
  47.             get 
    48. 
  
  
  
  48.             {  
    49. 
  
  
  
  49.                 return false;  
    50. 
  
  
  
  50.             }  
    51. 
  
  
  
  51.         }  
    52. 
  
  
  
  52.    
    53. 
  
  
  
  53.         public override bool CanWrite  
    54. 
  
  
  
  54.         {  
    55. 
  
  
  
  55.             get 
    56. 
  
  
  
  56.             {  
    57. 
  
  
  
  57.                 return true;  
    58. 
  
  
  
  58.             }  
    59. 
  
  
  
  59.         }  
    60. 
  
  
  
  60.          public override void Flush()  
    61. 
  
  
  
  61.         {  
    62. 
  
  
  
  62.             NetworkStream.Write(_Buf, 0, _BufLen);  
    63. 
  
  
  
  63.             NetworkStream.Flush();  
    64. 
  
  
  
  64.         }  
    65. 
  
  
  
  65.          public override long Length  
    66. 
  
  
  
  66.         {  
    67. 
  
  
  
  67.             get 
    68. 
  
  
  
  68.             {  
    69. 
  
  
  
  69.                 throw new Exception("This stream can not seek!");  
    70. 
  
  
  
  70.             }  
    71. 
  
  
  
  71.         }  
    72. 
  
  
  
  72.    
    73. 
  
  
  
  73.         public override long Position  
    74. 
  
  
  
  74.         {  
    75. 
  
  
  
  75.             get 
    76. 
  
  
  
  76.             {  
    77. 
  
  
  
  77.                 throw new Exception("This stream can not seek!");  
    78. 
  
  
  
  78.             }  
    79. 
  
  
  
  79.    
    80. 
  
  
  
  80.             set 
    81. 
  
  
  
  81.             {  
    82. 
  
  
  
  82.                 throw new Exception("This stream can not seek!");  
    83. 
  
  
  
  83.             }  
    84. 
  
  
  
  84.         }  
    85. 
  
  
  
  85.    
    86. 
  
  
  
  86.         public override int Read(byte[] buffer, int offset, int count)  
    87. 
  
  
  
  87.         {  
    88. 
  
  
  
  88.             int len = 0;  
    89. 
  
  
  
  89.    
    90. 
  
  
  
  90.             //If cache is not empty, read from cache  
    91. 
  
  
  
  91.             if (CacheStream.Length > CacheStream.Position)  
    92. 
  
  
  
  92.             {  
    93. 
  
  
  
  93.                 len = CacheStream.Read(buffer, offset, count);  
    94. 
  
  
  
  94.                 return len;  
    95. 
  
  
  
  95.             }  
    96. 
  
  
  
  96.    
    97. 
  
  
  
  97.             //Fill cache  
    98. 
  
  
  
  98.             len = NetworkStream.Read(_Buf, 0, BUF_SIZE);  
    99. 
  
  
  
  99.    
    100. 
  
  
  
  100.             if (len == 0)  
    101. 
  
  
  
  101.             {  
    102. 
  
  
  
  102.                 return 0;  
    103. 
  
  
  
  103.             }  
    104. 
  
  
  
  104.    
    105. 
  
  
  
  105.             CacheStream.Position = 0;  
    106. 
  
  
  
  106.             CacheStream.Write(_Buf, 0, len);  
    107. 
  
  
  
  107.             CacheStream.SetLength(len);  
    108. 
  
  
  
  108.             CacheStream.Position = 0;  
    109. 
  
  
  
  109.    
    110. 
  
  
  
  110.             len = CacheStream.Read(buffer, offset, count);  
    111. 
  
  
  
  111.    
    112. 
  
  
  
  112.             return len;  
    113. 
  
  
  
  113.         }  
    114. 
  
  
  
  114.    
    115. 
  
  
  
  115.         public override long Seek(long offset, SeekOrigin origin)  
    116. 
  
  
  
  116.         {  
    117. 
  
  
  
  117.             throw new Exception("This stream can not seek!");  
    118. 
  
  
  
  118.         }  
    119. 
  
  
  
  119.    
    120. 
  
  
  
  120.         public override void SetLength(long value)  
    121. 
  
  
  
  121.         {  
    122. 
  
  
  
  122.             throw new Exception("This stream can not seek!");  
    123. 
  
  
  
  123.         }  
    124. 
  
  
  
  124.    
    125. 
  
  
  
  125.         public override void Write(byte[] buffer, int offset, int count)  
    126. 
  
  
  
  126.         {  
    127. 
  
  
  
  127.             if (offset + count > buffer.Length)  
    128. 
  
  
  
  128.             {  
    129. 
  
  
  
  129.                 throw new ArgumentException("Count + offset large then buffer.Length");  
    130. 
  
  
  
  130.             }  
    131. 
  
  
  
  131.    
    132. 
  
  
  
  132.             int remain = count - (BUF_SIZE - _BufLen);  
    133. 
  
  
  
  133.    
    134. 
  
  
  
  134.             if (remain < 0)  
    135. 
  
  
  
  135.             {  
    136. 
  
  
  
  136.                 Array.Copy(buffer, offset, _Buf, _BufLen, count);  
    137. 
  
  
  
  137.                 _BufLen = BUF_SIZE + remain;  
    138. 
  
  
  
  138.             }  
    139. 
  
  
  
  139.             else 
    140. 
  
  
  
  140.             {  
    141. 
  
  
  
  141.                 Array.Copy(buffer, offset, _Buf, _BufLen, BUF_SIZE - _BufLen);  
    142. 
  
  
  
  142.                 NetworkStream.Write(_Buf, 0, _Buf.Length);  
    143. 
  
  
  
  143.    
    144. 
  
  
  
  144.                 Array.Copy(buffer, offset + BUF_SIZE - _BufLen, _Buf, 0, remain);  
    145. 
  
  
  
  145.    
    146. 
  
  
  
  146.                 _BufLen = remain;  
    147. 
  
  
  
  147.             }  
    148. 
  
  
  
  148.         }  
    149. 
  
  
  
  149.          #endregion  
    150. 
  
  
  
  150.     } 
    151. 
 
 
 
            

                标题名称：详解通过.NET缓存提高TCP传输速度
                

                标题来源：http://www.csdahua.cn/qtweb/news19/258319.html
            

            

                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                

            

                广告
                
            

            

                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网
            

        

        

            
成都快上网为您推荐相关内容

            
        

    

    

        

            
网站营销知识

            
        

        

            
行业网站建设

            
        

    





    

        腾讯香港免备案空间　　 　网站建设公司　　 　攀枝花网站建设　　 　江油网站建设　　 　网站制作　　 　成都网站优化　　 　网络推广公司　　 　护栏打桩机　　 　成都托管服务器　　 　微信小程序　　 　边坡柔性防护网　　 　B2C电商系统　　 　四川搅拌罐车　　 　简阳电信机房　　 　成都虚拟主机　　 　关键词优化　　 　新都四新网站建设　　 　安娜尚美　　 　成都未宇聚　　 　微信小程序