C#进行点对点通讯和文件传输(通讯基类部分)

原创 2007年09月28日 14:03:00
最近一个项目要用到点对点文件传输,俺就到处找资料写程序,最后终于完成了,为了让别人少走些弯路,俺决定将俺程序中最重要的部分贡献出来,希望对大家有所帮助。
 
俺的程序分三部分,包括发送部分、接受部分和一个两者共享的通讯基类,这个基类才是俺心血的结晶:)
 
一、通讯基类
using System;
using System.Net.Sockets;
using System.Net ;
using System.IO ;
using System.Windows.Forms;
using System.Text;
 
namespace BaseClass
{
     ///<summary>
     /// 传送信息的格式为 给定长度的命令部分+给定长度的命令注释部分+可变长度的长度信息+可变长度的信息部分
     ///</summary>
     publicclass CommunClass
     {
         public CommunClass()
         {
              //
              // TODO: 在此处添加构造函数逻辑
              //
         }
         ///<summary>
         /// 命令部分的长度
         ///</summary>
          privatestaticreadonlyint CMDLEN = 50 ;
         ///<summary>
         /// 命令注释部分的长度
         ///</summary>
          privatestaticreadonlyint DESCLEN = 100 ;
         ///<summary>
         /// 可变长度的长度信息部分所占的字节数
         ///</summary>
          privatestaticreadonlyint DYNAMICLENGTHLEN = 10 ;
         ///<summary>
         /// 每次处理可变信息部分的长度
         ///</summary>
          privatestaticreadonlyint DEALLEN = 1024 ;            
         ///<summary>
         /// /应答的最大长度
         ///</summary>
          privatestaticreadonlyint RESPONLEN = 20 ;
         ///<summary>
         /// 用于填充命令或注释不足长度部分的字符
         ///</summary>   
          privatestaticreadonlychar FILLCHAR = '^' ;
 
         ///<summary>
         /// 成功发送一部分数据后的回调方法(也可以认为是触发的事件,但严格来说还不是)
         ///</summary>
          publicdelegatevoid OnSend(int iTotal,int iSending) ;
 
         ///<summary>
         /// 根据给定的服务器和端口号建立连接
         ///</summary>
         ///<param name="strHost">服务器名</param>
         ///<param name="iPort">端口号</param>
         ///<returns></returns>
         publicstatic Socket ConnectToServer(string strHost,int iPort)
         {            
              try
              {
                   IPAddress ipAddress = Dns.Resolve(strHost).AddressList[0];
                   IPEndPoint ipPoint = new IPEndPoint(ipAddress,iPort) ;
 
                   Socket s = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp) ;
                   s.Connect(ipPoint) ;
                   return s ;
              }
              catch (Exception e)
              {
                   throw (new Exception("建立到服务器的连接出错" + e.Message)) ;
              }
         }
         ///<summary>
         /// 将文本写到Socket中
         ///</summary>
         ///<param name="s">要发送信息的Socket</param>
         ///<param name="strInfo">要发送的信息</param>
         ///<returns>是否成功</returns>
         publicstaticbool WriteTextToSocket(Socket s,string strInfo)
         {
              byte [] buf = Encoding.UTF8.GetBytes(strInfo) ;
              try
              {
                   s.Send(buf,0,buf.Length,SocketFlags.None) ;
                   returntrue ;
              }
              catch(Exception err)
              {
                   MessageBox.Show("发送文本失败!"+err.Message) ;
                   returnfalse ;
              }
         }
         ///<summary>
         /// 将命令文本写到Socket中
         ///</summary>
         ///<param name="s">要发送命令文本的Socket</param>
         ///<param name="strInfo">要发送的命令文本</param>
         ///<returns>是否成功</returns>
         publicstaticbool WriteCommandToSocket(Socket s,string strCmd)
         {
              if (strCmd == "")
                   strCmd = "NOP" ;
              strCmd = strCmd.PadRight(CMDLEN,FILLCHAR) ;
              return WriteTextToSocket(s,strCmd) ;         
         }
         ///<summary>
         /// 将命令注释写到Socket中
         ///</summary>
         ///<param name="s">要发送命令注释的Socket</param>
         ///<param name="strInfo">要发送的命令注释</param>
         ///<returns>是否成功</returns>
         publicstaticbool WriteCommandDescToSocket(Socket s,string strDesc)
         {
              if (strDesc == "")
                   strDesc = "0" ;
              strDesc = strDesc.PadRight(DESCLEN,FILLCHAR) ;
              return WriteTextToSocket(s,strDesc) ;             
         }
         ///<summary>
         /// 发送可变信息的字节数
         ///</summary>
         ///<param name="s">要发送字节数的Socket</param>
         ///<param name="iLen">字节数</param>
         ///<returns>是否成功</returns>
         publicstaticbool WriteDynamicLenToSocket(Socket s,int iLen)
         {            
              string strLen = iLen.ToString().PadRight(DYNAMICLENGTHLEN,FILLCHAR) ;
              return WriteTextToSocket(s,strLen) ;         
         }
         ///<summary>
         /// 将缓存的指定部分发送到Socket
         ///</summary>
         ///<param name="s">要发送缓存的Socket</param>
         ///<param name="buf">要发送的缓存</param>
         ///<param name="iStart">要发送缓存的起始位置</param>
         ///<param name="iCount">要发送缓存的字节数</param>
         ///<param name="iBlock">每次发送的字节说</param>
         ///<param name="SendSuccess">每次发送成功后的回调函数</param>
         ///<returns>是否发送成功</returns>
         publicstaticbool WriteBufToSocket(Socket s,byte [] buf,int iStart,int iCount,int iBlock,OnSend SendSuccess)
         {   
              int iSended = 0 ;
              int iSending = 0 ;
              while(iSended<iCount)
              {
                   if (iSended + iBlock <= iCount)
                        iSending = iBlock ;
                   else
                        iSending = iCount - iSended ;
                   s.Send(buf,iStart+iSended,iSending,SocketFlags.None) ;                     
                   iSended += iSending ;
                   if (ReadResponsionFromSocket(s)=="OK")
                       if (SendSuccess != null)
                        SendSuccess(iCount,iSended) ;
                   else
                       returnfalse;
              }
             returntrue ;                      
         }
         ///<summary>
         /// 将长度不固定文本发送到socket
         ///</summary>
         ///<param name="s">要发送文本的Socket</param>
         ///<param name="strText">要发送的文本</param>
         ///<param name="OnSendText">成功发送一部分文本后的回调函数</param>
         ///<param name="settextlen">得到文本长度的回调函数</param>
         ///<returns></returns>
         publicstaticbool WriteDynamicTextToSocket(Socket s,string strText,
              OnSend OnSendText)
         {
              byte [] buf = Encoding.UTF8.GetBytes(strText) ;
             
              int iLen = buf.Length ;
              try
              {
                   WriteDynamicLenToSocket(s,iLen) ;
                   return WriteBufToSocket(s,buf,0,iLen,DEALLEN,OnSendText) ;
              }
              catch(Exception err)
              {
                   MessageBox.Show("发送文本失败!"+err.Message) ;
                   returnfalse ;
              }
         }
         ///<summary>
         /// 将文件写到Socket
         ///</summary>
         ///<param name="s">要发送文件的Socket</param>
         ///<param name="strFile">要发送的文件</param>
         ///<returns>是否成功</returns>
         publicstaticbool WriteFileToSocket(Socket s,string strFile,
              OnSend OnSendFile)
         {
              FileStream fs = new FileStream(strFile,FileMode.Open,FileAccess.Read,FileShare.Read) ;
              int iLen = (int)fs.Length ;
              WriteDynamicLenToSocket(s,iLen) ;
              byte [] buf = newbyte[iLen] ;
              try
              {
                   fs.Read(buf,0,iLen) ;
                   return WriteBufToSocket(s,buf,0,iLen,DEALLEN,OnSendFile) ;
              }
              catch(Exception err)
              {
                   MessageBox.Show("发送文件失败!"+err.Message) ;
                   returnfalse ;
              }
              finally
              {
                   fs.Close() ;
              }             
         }
         ///<summary>
         /// 对方对自己消息的简单回应
         ///</summary>
         ///<param name="s"></param>
         ///<returns></returns>
         publicstaticstring ReadResponsionFromSocket( Socket s)
         {
              byte [] bufCmd = newbyte[RESPONLEN] ;
              int iCount = s.Receive(bufCmd) ;
              string strRespon = Encoding.UTF8.GetString(bufCmd,0,iCount) ;
              return strRespon ;
         }
         ///<summary>
         /// 从Socket读取命令
         ///</summary>
         ///<param name="s">要读取命令的Socket</param>
         ///<returns>读取的命令</returns>
         publicstaticstring ReadCommandFromSocket( Socket s)
         {                 
              byte [] bufCmd = newbyte[CMDLEN] ;
              int iCount = s.Receive(bufCmd,0,CMDLEN,SocketFlags.Partial) ;
              string strCommand = Encoding.UTF8.GetString(bufCmd,0,CMDLEN) ;
              return strCommand = strCommand.TrimEnd(FILLCHAR) ;
         }
         ///<summary>
         /// 读取命令注释
         ///</summary>
         ///<param name="s">要读取命令注释的Socket</param>
         ///<returns>读取的命令注释</returns>
         publicstaticstring ReadCommandDescFromSocket( Socket s)
         {                 
              byte [] bufCmd = newbyte[DESCLEN] ;
              int iCount = s.Receive(bufCmd,0,DESCLEN,SocketFlags.Partial) ;
              string strCommand = Encoding.UTF8.GetString(bufCmd,0,DESCLEN) ;
              return strCommand = strCommand.TrimEnd(FILLCHAR) ;
         }
         ///<summary>
         /// 读取可变部分的长度
         ///</summary>
         ///<param name="s">要读取可变部分长度的Socket</param>
         ///<returns>读取的可变部分的长度</returns>
         publicstaticint ReadDynamicLenFromSocket( Socket s)
         {                 
              byte [] bufCmd = newbyte[DYNAMICLENGTHLEN] ;
              int iCount = s.Receive(bufCmd,0,DYNAMICLENGTHLEN,SocketFlags.Partial) ;
              string strCommand = Encoding.UTF8.GetString(bufCmd,0,DYNAMICLENGTHLEN) ;
              returnint.Parse(strCommand.TrimEnd(FILLCHAR)) ;
         }
         ///<summary>
         /// 读取文本形式的可变信息
         ///</summary>
         ///<param name="s">要读取可变信息的Socket</param>
         ///<returns>读取的可变信息</returns>
         publicstaticstring ReadDynamicTextFromSocket( Socket s)
         {            
              int iLen = ReadDynamicLenFromSocket(s) ;
 
              byte [] buf = newbyte[iLen] ;
              string strInfo = "" ;
 
              int iReceiveded = 0 ;
              int iReceiveing = 0 ;
              while(iReceiveded<iLen)
              {
                   if (iReceiveded + DEALLEN <= iLen)
                        iReceiveing = DEALLEN ;
                   else
                        iReceiveing = iLen - iReceiveded ;                   
                   s.Receive(buf,iReceiveded,iReceiveing,SocketFlags.None) ;    
                   CommunClass.WriteTextToSocket(s,"OK") ;
                   iReceiveded+= iReceiveing ;
              }
 
              strInfo = Encoding.UTF8.GetString(buf,0,iLen) ;
             
              return strInfo ;
         }
         ///<summary>
         /// 读取文件形式的可变信息
         ///</summary>
         ///<param name="s">要读取可变信息的Socket</param>
         ///<param name="strFile">读出后的文件保存位置</param>
         ///<returns>是否读取成功</returns>
         publicstaticbool ReadDynamicFileFromSocket( Socket s,string strFile)
         {            
              int iLen = ReadDynamicLenFromSocket(s) ;
              byte [] buf = newbyte[iLen] ;
              FileStream fs = new FileStream(strFile,FileMode.Create,FileAccess.Write) ;
             
              try
              {
                   int iReceiveded = 0 ;
                   int iReceiveing = 0 ;
                   while(iReceiveded<iLen)
                   {
                       if (iReceiveded + DEALLEN <= iLen)
                            iReceiveing = DEALLEN ;
                       else
                            iReceiveing = iLen - iReceiveded ;                   
                        s.Receive(buf,iReceiveded,iReceiveing,SocketFlags.None) ;    
                        CommunClass.WriteTextToSocket(s,"OK") ;
                        iReceiveded+= iReceiveing ;
                   }
                   fs.Write(buf,0,iLen) ;
                   returntrue ;
              }
              catch(Exception err)
              {
                   MessageBox.Show("接收文件失败"+err.Message) ;
                   returnfalse ;
              }
              finally
              {
                   fs.Close() ;
              }             
         }
     }//end class
}//end namespace
 
版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

数据结构(四)——单链表 、带头结点的单链表、循环链表 及其实现

一、 链式存储       以结点的形式存储数据。除了存放一个结点的信息外,还需附设指针。               &#...

二叉树的遍历

二叉树的遍历的重要性毋庸置疑,是很多算法的基础。遍历二叉树可以分为深度优先遍历和广度优先遍历,其中,深度优先遍历又可以分为先序、中序、后序。 提供一个二叉树,可能写出其几种遍历方式的序列并不难,但要...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

iOS 面试题--转自唐巧

iOS 面试题(一)寻找最近公共 View 题目:找出两个 UIView 的最近的公共 View,如果不存在,则输出 nil 。 分析:这其实是数据结构里面的找最近公共祖先的问题。 一个UIV...

关于二叉树的几种遍历方法

先说说二叉树的存储结构,跟很多其它模型一样,也有顺序和链式两种方式。前者虽然使用简单,但是存在浪费空间的问题,举个例子,下图的二叉树,用顺序的方式存储(0表示空,没有子树)是: 二叉树就是每个结点最...

单链表的快速排序

单链表的特点是:单向。设头结点位head,则最后一个节点的next指向NULL。如果只知道头结点head,请问怎么将该链表排序?              ...

数据库视图详解

数据库视图详解 - 定义: 视图(View)是从一个或多个表(或视图)导出的表。视图与表(有时为与视图区别,也称表为基本表——Base Table)不同,视图是一个虚表,即视图...

数据结构与算法目录

数据结构与算法系列先看这里,有助于你更好地获取内容。 首先明白一个问题:为什么要研究数据结构? 这是因为所有的程序本质上是对数据进行处理,如何高效的处理数据,这依赖于数据本身的结构(如类型(整...

如何写好简历

这段时间是跳槽的高峰季,公司自然也准备吸纳些人,所以最近看了不少简历,发现好多人根本不知道该怎么写,今天就谈谈如何写好简历。个人经验,仅供参考。 行业不同,简历也千差万别。但从我这几年管理和招聘人才的...

C语言实现单链表(不带头结点)的基本操作

链表在数据结构和算法中的重要性不言而喻。这里我们要用C来实现链表(单链表)中的基本操作。对于链表的基本概念请参考《数据结构与算法之链表》这篇博客。示例代码上传至 https://github.com/...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)