点对点传输

最新推荐文章于 2021-11-19 14:44:10 发布
最新推荐文章于 2021-11-19 14:44:10 发布
阅读量1.1k 收藏
点赞数
分类专栏： C# 文章标签： socket string exception byte null class
作者 ：tashanzhishi
 
一、通讯基类
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

面介绍了通讯的基类，下面就是使用那个类进行发送和接收的部分：

二、发送部分：
发送咱们使用了多线程，可以同时进行多个任务，比如发送文件、发送文本等，互不影响：
发送文本方法：
private void StartSendText(string strHost,int iPort,string strInfo)
       {
           SendText stText = new SendText(strHost,iPort,strInfo,new CommunClass.OnSend(OnSendDrawProgress)) ;
           StartThread(new ThreadStart(stText.Send)) ;
       }
下面是他调用用到的一些方法：
开始一个线程
private void StartThread(ThreadStart target)
       {
           Thread doStep = new Thread(target) ;          
           doStep.IsBackground = true ;
           doStep.Start() ;
       }
 发送一部分（本文设置的是1024字节）成功后的回调方法
        public void OnSendDrawProgress(int iTotal,int iSending)
       {  
           if (iTotal != pbMain.Maximum)
               pbMain.Maximum = iTotal ;
                pbMain.Value = iSending ;
       }
因为使用的是线程，所以发送文本使用的是一个发送文本类的方法，该类如下：
public class SendText
     {
          private string Host ;
          private int Port ;
          private string Info ;
          private CommunClass.OnSend onsend ;
         public SendText(string strHost,int iPort,string strInfo,
              CommunClass.OnSend onSend)
         {
              Host = strHost ;
              Port = iPort ;
              Info = strInfo ;
              onsend = onSend ;
         }
         public void Send()
         {
              Socket s = null ;
              try
              {
                   s = CommunClass.ConnectToServer(Host,Port) ;
 
                   CommunClass.WriteCommandToSocket(s,"SENDTEXT") ;
                   CommunClass.WriteCommandDescToSocket(s,"") ;                  
                   CommunClass.WriteDynamicTextToSocket(s,Info,onsend) ;
              }
              catch (Exception e)
              {
                   MessageBox.Show(e.Message) ;
              }
              finally
              {
                   if (s != null)
                        s.Close() ;
              }
         }
 
     }//end class
      
这样就可以使用一个线程发送文本了。
发送文件的方法也类似：
private void StartSendFile(string strHost,int iPort,string strFile)
       {
           SendFile sfFile = new SendFile(strHost,iPort,strFile,this.pbMain) ;
           pbMain.Value = 0 ;
           StartThread(new ThreadStart(sfFile.Send)) ;       
       }
发送文件的类：
public class SendFile
     {
          private string Host ;
          private int Port ;
          private string FileToSend ;
          private ProgressBar pbar;
 
         public SendFile(string strHost,int iPort,string strFile,ProgressBar pbMain)
         {
              Host = strHost ;
              Port = iPort ;
              FileToSend = strFile ;
              pbar = pbMain ;
         }
         public void Send()
         {
              Socket s = null ;
              try
              {                  
                   s = CommunClass.ConnectToServer(Host,Port) ;
 
                   CommunClass.WriteCommandToSocket(s,"SENDFILE") ;
                   CommunClass.WriteCommandDescToSocket(s,"") ;
                  
                   CommunClass.WriteFileToSocket(s,FileToSend,new CommunClass.OnSend(OnSendDrawProgress)) ;
              }
              catch (Exception e)
              {
                   MessageBox.Show(e.Message) ;
              }
              finally
              {
                   if (s != null)
                        s.Close() ;
              }
         }
        
 
         public void OnSendDrawProgress(int iTotal,int iSending)
         {   
              if (iTotal != pbar.Maximum)
                   pbar.Maximum = iTotal ;
           
              pbar.Value = iSending ;
         }        
    
     }//end class
当然，你发送一个命令让服务器端启动一个程序（靠，这不成木马了吗？）也可以：
俺这里只给出一部分代码，其余的您自己可以发挥以下：
public class ExeCuteFile
     {
          private string Host ;
          private int Port ;
          private string FileName ;
          private string cmdParam ;
        
         public ExeCuteFile(string strHost,int iPort,string strFileName,string strCmdParam)
         {
              Host = strHost ;
              Port = iPort ;
              FileName = strFileName ;
              cmdParam = strCmdParam ;
         }
        
         public void Send()
         {
                   Socket s = null ;
              try
              {
                   s = CommunClass.ConnectToServer(Host,Port) ;
 
                   CommunClass.WriteCommandToSocket(s,"EXECUTEFILE") ;
                   CommunClass.WriteCommandDescToSocket(s,FileName) ;
                   CommunClass.WriteDynamicTextToSocket(s,"",null) ;
                   MessageBox.Show(CommunClass.ReadDynamicTextFromSocket(s)) ;
              }
              catch (Exception e)
              {
                   MessageBox.Show(e.Message) ;
              }
              finally
              {
                   if (s != null)
                        s.Close() ;
              }
 
         }
     }
三、下面是服务器端接受信息的代码：
创建监听：
/// <summary>
         /// 再给定的主机和端口上创建监听程序
         ///</summary>
         ///<param name="strAddress"></param>
         ///<param name="iPort"></param>
          private void BuildingServer(string strAddress,int iPort)
         {
              IPAddress ipAddress = Dns.Resolve(strAddress).AddressList[0];
             
              try
              {
                   listener = new TcpListener(ipAddress, iPort);   
              }
              catch ( Exception e)
              {
                   AddInfo(e.Message) ;
              }
         }

 

开始监听：
/// <summary>
         /// 开始监听
         ///</summary>
          private void StartListen()
         {
              bool done = false;       
 
              listener.Start();
              while (!done)
              {
                   Socket s = listener.AcceptSocket() ;
                   if(s != null)
                   {
                        DealWithSocket dws = new DealWithSocket(s,this.tbLog) ;
                        StartThread(new ThreadStart(dws.DealWith)) ;
                   }
              }        
         }
 
private void StartThread(ThreadStart target)
         {
              Thread doStep = new Thread(target) ;
              doStep.IsBackground = true ;
              doStep.Start() ;
         }
开始监听后，对于每一个监听到的客户端的连接都用一个单独的线程来处理,处理通过类DealWithSocket来完成,下面是类代码:
public class DealWithSocket
     {
          private Socket s = null ;
          private TextBox tbLog = null ;
         public DealWithSocket(Socket newSocket,TextBox tbInfo)
         {
              s = newSocket ;
              tbLog = tbInfo ;
         }
 
         public void DealWith()
         {
              string strCmd = CommunClass.ReadCommandFromSocket(s) ;
              string strDesc = CommunClass.ReadCommandDescFromSocket(s) ;
              AddInfo(strCmd) ;
              switch(strCmd)
              {
                   case "SENDFILE" :
                        CommunClass.ReadDynamicFileFromSocket(s,"e://rrr.txt") ;                       
                       break ;
                   case "EXECUTEFILE" :
                       string strParam = CommunClass.ReadDynamicTextFromSocket(s) ;
                       string strResult = ExeCuteFile(strDesc,strParam) ;
                        CommunClass.WriteDynamicTextToSocket(s,strResult,null) ;
                       break ;
                   default:              
                       string strDetail = CommunClass.ReadDynamicTextFromSocket(s) ;
                        AddInfo(strDetail) ;
                       break ;
              }
              try
              {
                   s.Close() ;
              }
              catch (Exception e)
              {
                   AddInfo(e.Message) ;
              }
         }
          private void AddInfo(string strInfo)
         {
              string Info = DateTime.Now.ToLongTimeString() + " "+ strInfo +"/r/n" ;
              tbLog.Text += Info ;
              tbLog.Refresh() ;
         }
          private string ExeCuteFile(string strFileName,string strCmdParam)
         {
              System.Diagnostics.Process proc = new System.Diagnostics.Process() ;
              proc.StartInfo.FileName = strFileName ;
              proc.StartInfo.Arguments = strCmdParam ;
              try
              {
                   proc.Start() ;
                   return "OK" ;
              }
              catch(Exception err)
              {
                   return err.Message ;
              }
         }
     }//end class
  
zilin82
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#socket同步异步机制
07-24
本文详细的总结了 C#.net同步异步SOCKET通讯和多线程，并以问答的形式解释了socket异步的实现机制
Socket监听
乐天zhifengfly的专栏
04-16 850
bool isSend = false;                     Socket sendSocket;                     while (!isSend)                     {                         sendSocket = new Socket(AddressFamily.InterNetwork, So
C#中Socket.Receive 方法 (Byte[], Int32, SocketFlags)的SocketFlags的含义
热门推荐
cjmcp的专栏
06-03 1万+
查看MSDN：http://msdn.microsoft.com/zh-cn/library/26f591ax(v=vs.110).aspx 他给的例子中是这样写的： bytes = s.Receive(RecvBytes, RecvBytes.Length, 0); SocketFlags参数为0，网上很多其他代码也是写了0，但是我一直不知道为什么是0， 0代表什么意思，所以就顺着页面找
点对点文件传输
12-11
点对点文件传，包括文件，图片，快速实现文件的高速传输
NFC点对点传输AndroidBeamDemo
06-21
运用NFC beam功能传输应用数据的参考程序
点对点传输 Blubster v4.0.4.20
11-09
Blubster使用一个新的保密协议运行来实现点对点网络传输。一旦你的机器与另一台机器相联，你就可以自由地从用户的整个网络上搜寻并且下载Mp3音乐文件。
点对点传输工具
11-01
可以点对点传输！只要知道对方的ip地址。一个选接受一个选发送就可以了
基于FPGA的UDP点对点传输协议实现-论文
05-19
基于FPGA的UDP点对点传输协议实现
p2p点对点打洞聊天程序源代码
08-26
原理：打洞服务器首先告诉用户A先发一条信息给用户B（用户A得知用户B的地址信息也是通过打洞服务器），注意此时用户B是收不到的，用户B的路由同样会进行丢弃，但是这并不要紧，因为用户A发了这条信息后，用户A的路由就会记录关于用户B的路由信息（该信息记录的是将用户B的IP信息路由到用户A电脑），然后此时用户B再发给用户A一条信息，就不会进行丢弃了，因为用户A的路由里面有用户B的路由信息。欢迎改进讨论
使用C#进行点对点通讯和文件传输
记事本
03-09 3385
最近一个项目要用到点对点文件传输，俺就到处找资料写程序，最后终于完成了，为了让别人少走些弯路，俺决定将俺程序中最重要的部分贡献出来，希望对大家有所帮助。 俺的程序分三部分，包括发送部分、接受部分和一个两者共享的通讯基类，这个基类才是俺心血的结晶：） 一、通讯基类 using System; using System.Net.Sockets; using System.Net; using
项目总结——深入浅出socket网络编程
韩义--廊坊师范学院信息技术提高班第九期
09-30 1万+
前言：     为什么会有如题的概念呢，我想对于没有主动听说过socket网络编程的人来说读到题目可能就已经蒙头了，为了很好的让大家进入场景，首先说一下一个需要用到这点东西的业务需求。         首先大家应该明确的是socket网络编程是以CS的模式下才有的，比如机房收费系统，在机房收费系统中可能会遇到不同的机房使用的收费系统是使用同一个数据库的。但是对于一些显示的信息，只有每次查
C#Socket通信，解决粘包和分包问题
Trinity_Force的博客
11-19 8707
源码下载，学习的时候做的，现在可以做到一个服务端对应多个客户端同时接受消息，也解决了分包和粘包的问题，欢迎下载 (16条消息) 网络通信编程学习.7z-C#文档类资源-CSDN文库https://download.csdn.net/download/Trinity_Force/44900216 什么是粘包分包 TCP是面向连接的协议 TCP是点到点的通信 TCP提供可靠的传输服务 TCP协议提供全双工的通信 TCP协议面向字节流进行传输的，可以对用户的数据进行拆分或合并 TCP...
同步套接字通信
坚定的锡兵
04-18 1409
 同步套接字通信Socket支持下的网上点对点的通信服务端实现监听连接，客户端实现发送连接请求，建立连接后进行发送和接收数据的功能服务器端建立一个socket，设置好本机的ip和监听的端口与socket进行绑定，开始监听连接请求，当接收到连接请求后，发送确认，同客户端建立连接，开始与客户端进行通信。客户端建立一个socket，设置好服务器端的IP和提供服务的端口，发出连
SOCKET通信中TCP、UDP数据包大小的确定
黄贺群的专栏
07-30 2603
UDP和TCP协议利用端口号实现多项应用同时发送和接收数据。数据通过源端口发送出去，通过目标端口接收。有的网络应用只能使用预留或注册的静态端口；而另外一些网络应用则可以使用未被注册的动态端口。因为UDP和TCP报头使用两个字节存放端口号，所以端口号的有效范围是从0到65535。动态端口的范围是从1024到65535。 MTU最大传输单元，这个最大传输单元实际上和链路层协议有着密切的关系，
C#.net同步异步SOCKET通讯和多线程总结
weixin_34026276的博客
03-21 223
同步套接字通信 Socket支持下的网上点对点的通信 服务端实现监听连接，客户端实现发送连接请求，建立连接后进行发送和接收数据的功能 服务器端建立一个socket，设置好本机的ip和监听的端口与socket进行绑定，开始监听连接请求，当接收到连接请求后，发送确认，同客户端建立连接，开始与客户端进行通信。 客户端建立一个socket，设置好服务器端的IP和提供服务的端口，发出连接请求，接...
EtherNet/IP 点对点传输 与多点传输怎么理解
最新发布
03-25
在 EtherNet/IP 中，点对点传输和多点传输是两种不同的数据传输方式。 点对点传输是指数据传输只在两个设备之间进行，这种传输方式直接连接发送和接收设备之间的网络节点。这种传输方式对于一些需要实时性和可靠性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值