点对点通讯

最新推荐文章于 2021-04-25 11:39:15 发布
最新推荐文章于 2021-04-25 11:39:15 发布
阅读量1.4k 收藏
点赞数
文章标签： string dataset exception null class table

点对点通讯通用类

 

using System;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms;


///<summary> 
///C#对底层数据操作的通用类
///</summary> 
namespace Class1
{
 /// <summary>
 /// 数据连接设置
 /// </summary>
 public class SqlConnect
 { 
  static string sqlconnstr;


  /// <summary> 
  /// 连接字符串
  /// </summary> 
  public string ConnString 
  {  
   set   {    sqlconnstr=value;   }  
   get   {    return sqlconnstr;   } 
  }


  /// <summary> 
  /// 取得连接
  /// </summary>
  /// <returns></returns> 
  public SqlConnection GetSqlConnection() 
  {  
   SqlConnection _connection=null;  
   if(sqlconnstr==null || sqlconnstr=="")  
   {   
    string SystemDir=System.Environment.SystemDirectory;   
    DisposalConductService DisposalConductService1= new DisposalConductService(SystemDir+"//CBERP_Dis.DLL") ;   
    sqlconnstr = "server="+DisposalConductService1.GetValue("ServerName","(local)")    
     +";user id="+DisposalConductService1.GetValue("SqlAccount","sa")    
     +";password="+DisposalConductService1.GetValue("PassWord","jiayu520")    
     +";Database="+DisposalConductService1.GetValue("Database","CBERP"); 
   }  
   try  
   {   
    _connection = new SqlConnection(sqlconnstr);   
    _connection.Open();  
   }  
   catch(SqlException SE)  
   {   
    if(SE.Number==17 || SE.Number==18456)   
    {    
     if(MessageBox.Show("数据库访问参数设置不正确,是否对需要对其进行设置?","提示",MessageBoxButtons.YesNo,MessageBoxIcon.Question)==DialogResult.Yes)    
     {     
      sqlconnstr="";     
      DisposalConduct config = new DisposalConduct();     
      config.ShowDialog();     
      _connection=GetSqlConnection();    
     }    
     else    
     {     
      MessageBox.Show("建立数据库连接失败,程序不能继续运行!","错误",MessageBoxButtons.OK,MessageBoxIcon.Stop);     
      Application.ExitThread();     
      Application.Exit();    
     }   
    }   
    else   
    {    
     MessageBox.Show(SE.Message,"提示信息",MessageBoxButtons.OK,MessageBoxIcon.Information);   
     _connection.Close();   
    }  
   }  
   return _connection; 
  }


  /// <summary>
  /// 数据配置
  /// </summary>
  public class DataCatena : IDisposable
  { 
   private SqlConnection _connection; 
   /// <summary>  /// 数据配置  /// </summary> 
   public DataCatena()  
   {  
    SqlConnect sqlconnect = new SqlConnect();  
    _connection = sqlconnect.GetSqlConnection(); 
    _connection.Close(); 
   }


   /// <summary> 
   /// 数据配置 
   /// </summary>
   /// <param name="connStr">连接字符串</param> 
   public DataCatena(String connStr)  
   {  
    _connection = new SqlConnection(connStr); 
   }


   /// <summary> 
   /// 取得DataView 
   /// </summary> 
   /// <param name="Sqlstr">连接字符串</param> 
   /// <returns>数据视图</returns> 
   public DataView GetDataView(String Sqlstr) 
   {  
    DataView dv=null;  
    SqlDataAdapter myCommand = new SqlDataAdapter(Sqlstr, _connection);  
    DataSet ds = new DataSet();  
    try  
    {   
     myCommand.Fill(ds,"table");   
     dv=ds.Tables["table"].DefaultView; 
    }  
    catch(SqlException exc)  
    {   
     DebugBox db = new DebugBox(Sqlstr + "/r/n" + exc.Message);   
     db.Show();  
    }  
    return dv; 
   }


   /// <summary> 
   /// 清理资源
   /// </summary> 
   public void Dispose() 
   {  
    Dispose(true);  
    GC.SuppressFinalize(true);
   }


   /// <summary>
   /// 清理所有正在使用的资源。
   /// </summary>
   /// <param name="disposing"></param>
   protected virtual void Dispose(bool disposing) 
   { 
    if (! disposing)    return;
    if (this._connection != null)  
    {   
     this._connection.Dispose();  
    } 
   }


   /// <summary> 取得数据适配器</summary> 
   /// <param name="Sqlstr">SQL语句</param> 
   /// <returns>数据适配器</returns> 
   public SqlDataAdapter GetSqlDA(string Sqlstr) 
   {  
    SqlDataAdapter myCommand = new SqlDataAdapter(Sqlstr, _connection); 
    return myCommand; 
   }


   /// <summary>取得数据表</summary> 
   /// <param name="Sqlstr">SQL语句</param> 
   /// <returns>数据表</returns> 
   public DataTable GetDT(String Sqlstr) 
   {  
    SqlDataAdapter myCommand = new SqlDataAdapter(Sqlstr, _connection); 
    DataSet ds = new DataSet();  
    try  
    {   
     myCommand.Fill(ds,"table"); 
    }  
    catch(SqlException exc)  
    {   
     DebugBox db = new DebugBox(Sqlstr + "/r/n" + exc.ToString());  
     db.Show(); 
    }  
    return ds.Tables["table"];
   }


   /// <summary>执行语句</summary>
   /// <param name="Sqlstr">SQL语句</param>
   /// <returns></returns> 
   public object ExecWithValue(String Sqlstr) 
   {  
    object result=null;   
    _connection.Open();  
    SqlCommand myCommand = new SqlCommand(Sqlstr, _connection);  
    try  
    {   
     result=myCommand.ExecuteScalar(); 
    }  
    catch (SqlException exc)  
    {   
     DebugBox db = new DebugBox(Sqlstr + "/r/n" + exc.ToString());   
     db.Show();    //MessageBox.Show(exc.Message); 
    }   _connection.Close();  
    return result;
   }


   /// <summary>返回相应的行数</summary>
   /// <param name="Sqlstr">SQL语句</param>
   /// <returns>行数</returns> 
   public int Exec(String Sqlstr) 
   {  
    int sucess=0;        
    SqlCommand myCommand = new SqlCommand(Sqlstr, _connection); 
    _connection.Open();  
    try  
    {  
     myCommand.ExecuteNonQuery(); 
    }  
    catch (SqlException exc) 
    {   
     DebugBox db = new DebugBox(Sqlstr + "/r/n" + exc.ToString());   
     db.Show();    //    MessageBox.Show(exc.Message);   
     sucess=exc.Number;  
    } 
    _connection.Close();  
    return sucess; 
   }
  }


  /// <summary>单表操作</summary>
  public class SingleTable
  { 
   private DataCatena DataCatena; 
   private SqlDataAdapter myDataAdapter;  
   private DataSet ds; 
   /// <summary>单表操作</summary>
   /// <param name="Sqlstr"></param> 
   public SingleTable(string Sqlstr) 
   {  
    DataCatena = new DataCatena();  
    myDataAdapter = DataCatena.GetSqlDA(Sqlstr); 
    ds = new DataSet();  
    myDataAdapter.Fill(ds, "Table1"); 
   }


   /// <summary>更新一个表</summary>
   /// <param name="Sqlstr"></param> 
   public void SetUpdateCommand(string Sqlstr) 
   {  
    myDataAdapter.UpdateCommand = new SqlCommand(Sqlstr,myDataAdapter.SelectCommand.Connection); 
   }


   /// <summary>返回数据表</summary>
   /// <returns></returns> 
   public DataTable GetDataTable() 
   {  
    return ds.Tables["Table1"]; 
   }


   /// <summary>返回数据适配器</summary>
   /// <returns></returns>
   public SqlDataAdapter GetDataAdapter() 
   {  
    return myDataAdapter; 
   }


   /// <summary>更新表</summary> 
   public void Update() 
   { 
    myDataAdapter.Update(ds, "Table1"); 
   }
  }


  /// <summary>自动更新</summary>
  public class AutoUpdateObj
  { 
   private DataCatena DataCatena; 
   private SqlDataAdapter myDataAdapter;  
   private SqlCommandBuilder cb; 
   private DataSet ds;
 
   /// <summary>自动更新</summary>
   /// <param name="Sqlstr"></param> 
   public AutoUpdateObj(string Sqlstr) 
   {  
    DataCatena = new DataCatena();  
    myDataAdapter = DataCatena.GetSqlDA(Sqlstr);  
    cb = new SqlCommandBuilder(myDataAdapter);  
    ds = new DataSet(); 
    myDataAdapter.Fill(ds, "Table1"); 
   }


   /// <summary>更新SQL语句</summary>
   /// <param name="Sqlstr"></param> 
   public void SetUpdateCommand(string Sqlstr) 
   {  
    myDataAdapter.UpdateCommand = new SqlCommand(Sqlstr,myDataAdapter.SelectCommand.Connection);
   }


   /// <summary>设置Select语句 </summary>
   /// <param name="Sqlstr"></param> 
   public void SetSelectCommand(string Sqlstr) 
   { 
    myDataAdapter.SelectCommand = new SqlCommand(Sqlstr,myDataAdapter.SelectCommand.Connection);
    cb.DataAdapter = myDataAdapter ;  
    ds.Tables.Clear(); 
   }


   /// <summary>取得数据表</summary>
   /// <returns></returns> 
   public DataTable GetDataTable() 
   {  
    ds.Clear();   myDataAdapter.Fill(ds, "Table1");  
    return ds.Tables["Table1"]; 
   }


   /// <summary> 取得数据适配器</summary>
   /// <returns></returns> 
   public SqlDataAdapter GetDataAdapter() 
   {  
    return myDataAdapter; 
   }


   /// <summary>更新</summary> 
   public void Update() 
   {  
    try 
    {   
     myDataAdapter.Update(ds, "Table1"); 
    }  
    catch(SqlException sqlex)  
    {  
     MessageBox.Show("出错原因："+sqlex.Message,"出错",MessageBoxButtons.OK,MessageBoxIcon.Error); 
    }
   }
  }
 }
}

 

点对点通讯基类

         /// 读取文件形式的可变信息


         /// </summary>


         /// <param name="s">要读取可变信息的Socket</param>


         /// <param name="strFile">读出后的文件保存位置</param>


         /// <returns>是否读取成功</returns>


         public static bool ReadDynamicFileFromSocket( Socket s,string strFile)


         {            


              int iLen =  ReadDynamicLenFromSocket(s) ;


              byte [] buf = new byte[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) ;


                   return true ;


              }


              catch(Exception err)


              {


                   MessageBox.Show("接收文件失败"+err.Message) ;


                   return false ;


              }


              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)) ;
}


下面是他调用用到的一些方法：


开始一个线?BR>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
以上就是所用的代码,希望大家批判指正.

LeeLin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据链路层-点对点通信方式
se7en_q的博客
03-06 7845
数据链路层中的点对点通信方式
点对点通信协议
qq_46156328的博客
11-07 1387
点对点通信的三种基本协议 在叙述三种协议之前，先提出流量控制的概念 数据链路层的流量控制： ​ 较高的发送速度和较低的接受能力的不匹配，会造成传输出错，因此流量控制也是数据链路层的一项重要工作。 数据链路层和传输层的区别： 数据链路层的流量控制是点对点的，而传输层的流量控制是端到端的 数据链路层流量控制手段：接收方回复机制(接收方确认后给发送端一个ACK) 传输层流量控制手段：接收端给发送端一个窗口公告 停止等待协议 信道利用率太低 无差错情况 无差错情况很好理解，相当于发送端发送一次请求，接
Tcp点对点通讯
12-04
TCP服务器客户端，实现点对点通讯，且可读取文件内容进行传输
LabVIEW TCP通信（一点对多点通讯）
07-09
LabVIEW实现TCP通信（一点对多点通讯），一个服务器发送波形数据，两个客户端接收数据并绘制波形图。 项目可直接运行~
websocket私聊点对点通讯
06-11
不需要配置web.xml直接启动tomcat7以上版本，就可以连接成功
Visual C＃实现网络点对点通讯程序.rar_c# 网络通讯_点对点
09-23
点对点通讯工具，本人自编。
Lora开发板点对点通讯
11-19
实现两块Lora板点对点通讯
CC2530——点对点通信
FranzLiszt的博客
04-25 4688
点对点通信内容简介代码分析全部代码全部头文件 内容简介 申明：下面用到的方法为basicrf封装好的，在网上下载好之后，之间include导入即可 通过ZIGBBE自组网，将俩个ZIGBBE盒进行连接，下面简称A和B 通信：A将采集到的数据通过无线发送给B，B接收后在发送给PC端模拟串口软件 代码分析 采集光照数据，将采集到的模拟量转成数字量，然后在解析数据量，转成可视化光照数据 void hal_adc_Init1(void) { APCFG |=1; P0SEL |= (1 <&
点对点即时通讯软件
WinLin
12-07 4410
一、题目分析            要实现一个简单的聊天工具，实现即时聊天、文件传输功能。根据我们所学的知识，可以采用socket套接字编程。 自己采用的是MFC中CSocket结合TCP传输协议来实现。使用了多套接字分别来实现消息传递和文件传输。 使用的知识点有: 1.使用CSocket类来实现建立套接字、监听、接受连接、发送数据、接收数据； 2.使用加速键来实现对键盘输入的控制，实现回车及发送消息； 二、概要设计 （一）服务器端   如图所示： class CServSocket继承
HTML5WebSocket实现点对点聊天
纸上得来终觉浅,绝知此事要躬行
10-07 1万+
昨天使用HTML5的websocket与Tomcat实现了多人聊天，那是最简单也是最基本的，其中注意的就是开发环境，要满足jdk1.7和tomcat8，当然了tom7 的7.063也行！ 今天是国庆的最后一天，苦逼的加班，继续搞代码！令人欣慰的是，我用google找到了关于websocket的点对点聊天，更好的是可以和大多数系统很好的配合起来看下效果图 因为是模拟的，这里给出的是两个JSP页
深入浅出讲解 NAT 和 UDP/TCP 点对点通讯
iw1210的专栏
08-14 1万+
深入浅出讲解 NAT 和 UDP/TCP 点对点通讯 转自：http://blog.csdn.net/g_brightboy/article/details/12704933 一、什么是NAT？为什么要使用NAT？ NAT是将私有地址转换为合法IP地址的技术，通俗的讲就是将内网与内网通信时怎么将内网私有IP地址转换为可在网络中传播的合法IP地址。NAT的出现完美地解决了lP地址不足的
UDP协议点对点（P2P）通讯（或者说NAT穿越）实例
iw1210的专栏
07-24 1万+
UDP协议点对点（P2P）通讯实例。 【实验环境】 一个服务端Server，两个客户端：Client1和Client2 。Server和Client1在Linux系统上运行，Client2在Windows上运行。 Server端源代码： #include #include #include #include #include #include
数据链路层点对点通信
传播AI技术，共创智能世界
02-10 1861
点对点通信 1.当主机H1向主机H2发送数据时，从协议的层次看，数据进入路由器后要先从物理层上升到网络层，在转发表中找到下一跳的地址后，再下到物理层转发出去。 点对点信道的数据链路层在进行通信时的主要步骤如下： （1）结点A的数据链路层把网络层交下来的IP数据报添加首部和尾部封装成帧。 （2）结点A把封装好的帧发送给结点B的数据链路层。 （3）若结点B的数据链路层收到的帧无差错，则从收到的帧中提取出IP数据报交给上面的网络层；否则丢弃这个帧。 2.三个基本问题：封装成帧、透明传输、差错检测。 封装成帧就是
点对点通信-简介
bytxl的专栏
11-27 8090
点对点连接是两个系统或进程之间的专用通信链路。想象一下直接连接两个系统的一条线路。两个系统独占此线路进行通信。点对点通信的对立面是广播,在广播通信中,一个系统可以向多个系统传输。 电话呼叫是面向电路的两部电话机之间的点对点链路。但是，呼叫通常是通过电话公司中继线多路复用的；因此虽然电路本身可能是虚拟的,但用户在进行点对点通信会话。 端到端连接是指通过交换网络的两个系统间的连接。例如,因
【网络编程】点对点的通信方式
热门推荐
沙师弟专栏
03-27 1万+
全双工通信允许数据同时在两个方向上传输，又称为双向同时通信，即通信的双方可以同时发送和接收数据。全双工方式无需进行方向的切换，因此，没有切换操作所产生的时间延迟，这对那些不能有时间延误的交互式应用（例如远程监测和控制系统）十分有利。在单工通信中，通信的信道是单向的，发送端与接收端也是固定的，即发送端只能发送信息，不能接收信息；在半双工模式下，每个站都可以发送和接收，但不能同时进行。例如：手持对讲机是日常生活中最为常见的一种半双工通信方式，手持对讲机的双方可以互相通信，但在同一个时刻，只能由一方在讲话。
06点对点通信
吾竹清风2017
09-20 460
注意要点： （1）父子进程共享文件描述符,注意各自的职责 （2）注意避免僵尸进程的产生 （3）信号处理就是软中断 5p2pclient.c #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;string.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;sys/socket.h&amp;gt; #include &am
WebRTC 简单实现点对点通讯程序
最新发布
08-12
为了实现 WebRTC 点对点通讯程序，你需要以下几步： 1. 在你的 HTML 文件中引入 WebRTC 的 JavaScript 库。 2. 使用 `getUserMedia()` 方法获取访问用户的媒体设备的权限。 3. 使用 `RTCPeerConnection` 对象建立...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值