Socket Client

最新推荐文章于 2023-02-07 17:32:52 发布
最新推荐文章于 2023-02-07 17:32:52 发布
阅读量177 收藏
点赞数
文章标签： Socket thread .net 活动

using System;
using System.IO;
using System.ComponentModel;
using System.Collections;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace MyKJ
...{
/** <summary>
/// MyTcpIpClient 提供在Net TCP_IP 协议上基于消息的客户端
/// </summary>
public class MyTcpIpClient : System.ComponentModel.Component
...{
private int bufferSize=2048;
private string tcpIpServerIP="127.0.0.1";
private int tcpIpServerPort=11000;
private Socket ClientSocket=null;
private ManualResetEvent connectDone = new ManualResetEvent(false);
private ManualResetEvent sendDone = new ManualResetEvent(false);

private void ConnectCallback(IAsyncResult ar)
...{
try
...{
Socket client = (Socket) ar.AsyncState;
client.EndConnect(ar);

}
catch (Exception e)
...{
OnErrorEvent(new ErrorEventArgs(e));
}
finally
...{
connectDone.Set();
}
}
private void SendCallback(IAsyncResult ar)
...{
try
...{
Socket client = (Socket) ar.AsyncState;
int bytesSent = client.EndSend(ar);
//Console.WriteLine(bytesSent);
}
catch (Exception e)
...{
OnErrorEvent(new ErrorEventArgs(e));
}
finally
...{
sendDone.Set();
}
}
private void ReceiveCallback(IAsyncResult ar)
...{
Socket handler=null;
try
...{
lock(ar)
...{
StateObject state = (StateObject) ar.AsyncState;
handler = state.workSocket;

int bytesRead = handler.EndReceive(ar);

if (bytesRead > 0)
...{
int ReadPiont=0;
while(ReadPiont<bytesRead)
...{
if(state.Cortrol==0 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<24)&0xff000000;
state.packSize=bi1;
ReadPiont++;
state.Cortrol=1;
}

if(state.Cortrol==1 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<16)&0x00ff0000;
state.packSize=state.packSize+bi1;
ReadPiont++;
state.Cortrol=2;
}

if(state.Cortrol==2 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<8)&0x0000ff00;
state.packSize=state.packSize+bi1;
ReadPiont++;
state.Cortrol=3;
}

if(state.Cortrol==3 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=bi1&0xff;
state.packSize=state.packSize+bi1-4;
ReadPiont++;
state.Cortrol=4;
}

if(state.Cortrol==4 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<24)&0xff000000;
state.residualSize=bi1;
ReadPiont++;
state.Cortrol=5;
state.packSize-=1;
}

if(state.Cortrol==5 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<16)&0x00ff0000;
state.residualSize=state.residualSize+bi1;
ReadPiont++;
state.Cortrol=6;
state.packSize-=1;
}

if(state.Cortrol==6 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<8)&0x0000ff00;
state.residualSize=state.residualSize+bi1;
ReadPiont++;
state.Cortrol=7;
state.packSize-=1;
}
if(state.Cortrol==7 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=bi1&0xff;
state.residualSize=state.residualSize+bi1;
state.Datastream.SetLength(0);
state.Datastream.Position=0;

ReadPiont++;
state.Cortrol=8;
state.packSize-=1;
}

if(state.Cortrol==8 && ReadPiont<bytesRead)
...{
int bi1=bytesRead-ReadPiont;
int bi2=(int)(state.residualSize-state.Datastream.Length);
if(bi1>=bi2)
...{
state.Datastream.Write(state.buffer,ReadPiont,bi2);
ReadPiont+=bi2;
OnInceptEvent(new InceptEventArgs(state.Datastream,handler));
state.Cortrol=9;
state.packSize-=bi2;
}
else
...{
state.Datastream.Write(state.buffer,ReadPiont,bi1);
ReadPiont+=bi1;
state.packSize-=bi1;
}
}
if(state.Cortrol==9 && ReadPiont<bytesRead)
...{
int bi1=bytesRead-ReadPiont;
if(bi1<state.packSize)
...{
state.packSize=state.packSize-bi1;
ReadPiont+=bi1;
}
else
...{
state.Cortrol=0;
ReadPiont+=(int)state.packSize;
}
}
}
}
else
...{
throw(new Exception("读入的数据小于1bit"));
}
if(handler.Connected==true)
...{
handler.BeginReceive(state.buffer,0,bufferSize,0,
new AsyncCallback(ReceiveCallback), state);
}
}
}
catch (Exception e)
...{
OnErrorEvent(new ErrorEventArgs(e));

}
}

/** <summary>
/// 连接服务器
/// </summary>
public void Conn()
...{
try
...{
ClientSocket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse(tcpIpServerIP);
IPEndPoint remoteEP = new IPEndPoint(ipAddress, tcpIpServerPort);
connectDone.Reset();
ClientSocket.BeginConnect(remoteEP,new AsyncCallback(ConnectCallback),ClientSocket);
connectDone.WaitOne();
StateObject state = new StateObject(bufferSize,ClientSocket);
ClientSocket.BeginReceive(state.buffer,0,bufferSize,0,
new AsyncCallback(ReceiveCallback), state);
}
catch(Exception e)
...{
OnErrorEvent(new ErrorEventArgs(e));
}

}
/** <summary>
/// 断开连接
/// </summary>
public void Close()
...{
try
...{
if(ClientSocket.Connected==true)
...{
ClientSocket.Shutdown(SocketShutdown.Both);
ClientSocket.Close();
}
}
catch(Exception e)
...{
OnErrorEvent(new ErrorEventArgs(e));
}

}
/** <summary>
/// 发送一个流数据
/// </summary>
/// <param name="Astream">数据流</param>
public void Send(Stream Astream)
...{
try
...{
if(ClientSocket.Connected==false)
...{
throw(new Exception("没有连接服务器不可以发送信息!"));
}
Astream.Position=0;
byte[] byteData=new byte[bufferSize];
int bi1=(int)((Astream.Length+8)/bufferSize);
int bi2=(int)Astream.Length;
if(((Astream.Length+8)%bufferSize)>0)
...{
bi1=bi1+1;
}
bi1=bi1*bufferSize;

byteData[0]=System.Convert.ToByte(bi1>>24);
byteData[1]=System.Convert.ToByte((bi1&0x00ff0000)>>16);
byteData[2]=System.Convert.ToByte((bi1&0x0000ff00)>>8);
byteData[3]=System.Convert.ToByte((bi1&0x000000ff));

byteData[4]=System.Convert.ToByte(bi2>>24);
byteData[5]=System.Convert.ToByte((bi2&0x00ff0000)>>16);
byteData[6]=System.Convert.ToByte((bi2&0x0000ff00)>>8);
byteData[7]=System.Convert.ToByte((bi2&0x000000ff));

int n = Astream.Read(byteData, 8, byteData.Length-8);

while (n>0)
...{
ClientSocket.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), ClientSocket);
sendDone.WaitOne();
byteData=new byte[bufferSize];
n = Astream.Read(byteData,0,byteData.Length);
}
}
catch (Exception e)
...{
OnErrorEvent(new ErrorEventArgs(e));
}
}

/** <summary>
/// 构造
/// </summary>
/// <param name="container">父控件</param>
public MyTcpIpClient(System.ComponentModel.IContainer container)
...{
container.Add(this);
InitializeComponent();

//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}
/** <summary>
/// 构造
/// </summary>
public MyTcpIpClient()
...{
InitializeComponent();

//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}

Component Designer generated code#region Component Designer generated code
/** <summary>
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// </summary>
private void InitializeComponent()
...{

}
#endregion

/** <summary>
/// 要连接的服务器IP地址
/// </summary>
public string TcpIpServerIP
...{
get
...{
return tcpIpServerIP;
}
set
...{
tcpIpServerIP=value;
}
}

/** <summary>
/// 要连接的服务器所使用的端口
/// </summary>
public int TcpIpServerPort
...{
get
...{
return tcpIpServerPort;
}
set
...{
tcpIpServerPort=value;
}
}

/** <summary>
/// 缓冲器大小
/// </summary>
public int BufferSize
...{
get
...{
return bufferSize;
}
set
...{
bufferSize=value;
}
}

/** <summary>
/// 连接的活动状态
/// </summary>
public bool Activ
...{
get
...{
if(ClientSocket==null)
...{
return false;
}
return ClientSocket.Connected;
}
}
/** <summary>
/// 接收到数据引发的事件
/// </summary>
public event InceptEvent Incept;
/** <summary>
/// 引发接收数据事件
/// </summary>
/// <param name="e">接收数据</param>
protected virtual void OnInceptEvent(InceptEventArgs e)
...{
if (Incept != null)
...{
Incept(this, e);
}
}
/** <summary>
/// 发生错误引发的事件
/// </summary>
public event ErrorEvent Error;
/** <summary>
/// 引发错误事件
/// </summary>
/// <param name="e">错误数据</param>
protected virtual void OnErrorEvent(ErrorEventArgs e)
...{
if (Error != null)
...{
Error(this, e);
}
}

}

/** <summary>
/// 接收数据事件
/// </summary>
public class InceptEventArgs : EventArgs
...{
private readonly Stream datastream;
private readonly Socket clientSocket;
/** <summary>
/// 构造
/// </summary>
/// <param name="Astream">接收到的数据</param>
/// <param name="ClientSocket">接收的插座</param>
public InceptEventArgs(Stream Astream,Socket ClientSocket)
...{
datastream=Astream;
clientSocket=ClientSocket;
}
/** <summary>
/// 接受的数据流
/// </summary>
public Stream Astream
...{
get ...{ return datastream;}
}
/** <summary>
/// 接收的插座
/// </summary>
public Socket ClientSocket
...{
get ...{ return clientSocket;}
}
}
/** <summary>
/// 定义接收委托
/// </summary>
public delegate void InceptEvent(object sender, InceptEventArgs e);
/** <summary>
/// 错处事件
/// </summary>
public class ErrorEventArgs : EventArgs
...{
private readonly Exception error;
/** <summary>
/// 构造
/// </summary>
/// <param name="Error">错误信息对象</param>
public ErrorEventArgs(Exception Error)
...{
error=Error;
}
/** <summary>
/// 错误信息对象
/// </summary>
public Exception Error
...{
get ...{ return error;}
}
}
/** <summary>
/// 错误委托
/// </summary>
public delegate void ErrorEvent(object sender, ErrorEventArgs e);



}

服务器端:

using System;
using System.IO;
using System.ComponentModel;
using System.Collections;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace MyKJ
...{
/** <summary>
/// MyTcpIpClient 提供在Net TCP_IP 协议上基于消息的服务端
/// </summary>
public class MyTcpIpServer : System.ComponentModel.Component
...{
private int bufferSize=2048;
private string tcpIpServerIP="";
private int tcpIpServerPort=11000;
private Socket listener=null;
private ManualResetEvent allDone = new ManualResetEvent(false);
private ManualResetEvent sendDone = new ManualResetEvent(false);
private Thread thread=null;

private void StartListening()
...{
try
...{
listener = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);

IPAddress ipAddress;
if(tcpIpServerIP.Trim()=="")
...{
ipAddress=IPAddress.Any;
}
else
...{
ipAddress=IPAddress.Parse(tcpIpServerIP);
}
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, tcpIpServerPort);

listener.Bind(localEndPoint);
listener.Listen(10);
while (true)
...{
allDone.Reset();
listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
allDone.WaitOne();
}
}
catch (Exception e)
...{
OnErrorServerEvent(new ErrorServerEventArgs(e,listener));
}
}

private void ReadCallback(IAsyncResult ar)
...{
Socket handler=null;
try
...{
lock(ar)
...{
StateObject state = (StateObject) ar.AsyncState;
handler = state.workSocket;

int bytesRead = handler.EndReceive(ar);

if (bytesRead > 0)
...{
int ReadPiont=0;
while(ReadPiont<bytesRead)
...{
if(state.Cortrol==0 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<24)&0xff000000;
state.packSize=bi1;
ReadPiont++;
state.Cortrol=1;
}

if(state.Cortrol==1 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<16)&0x00ff0000;
state.packSize=state.packSize+bi1;
ReadPiont++;
state.Cortrol=2;
}

if(state.Cortrol==2 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<8)&0x0000ff00;
state.packSize=state.packSize+bi1;
ReadPiont++;
state.Cortrol=3;
}

if(state.Cortrol==3 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=bi1&0xff;
state.packSize=state.packSize+bi1-4;
ReadPiont++;
state.Cortrol=4;
}

if(state.Cortrol==4 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<24)&0xff000000;
state.residualSize=bi1;
ReadPiont++;
state.Cortrol=5;
state.packSize-=1;
}

if(state.Cortrol==5 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<16)&0x00ff0000;
state.residualSize=state.residualSize+bi1;
ReadPiont++;
state.Cortrol=6;
state.packSize-=1;
}

if(state.Cortrol==6 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=(bi1<<8)&0x0000ff00;
state.residualSize=state.residualSize+bi1;
ReadPiont++;
state.Cortrol=7;
state.packSize-=1;
}
if(state.Cortrol==7 && ReadPiont<bytesRead)
...{
long bi1=state.buffer[ReadPiont];
bi1=bi1&0xff;
state.residualSize=state.residualSize+bi1;
state.Datastream.SetLength(0);
state.Datastream.Position=0;

ReadPiont++;
state.Cortrol=8;
state.packSize-=1;
}

if(state.Cortrol==8 && ReadPiont<bytesRead)
...{
int bi1=bytesRead-ReadPiont;
int bi2=(int)(state.residualSize-state.Datastream.Length);
if(bi1>=bi2)
...{
state.Datastream.Write(state.buffer,ReadPiont,bi2);
ReadPiont+=bi2;
OnInceptServerEvent(new InceptServerEventArgs(state.Datastream,state.workSocket,this));
state.Cortrol=9;
state.packSize-=bi2;


}
else
...{
state.Datastream.Write(state.buffer,ReadPiont,bi1);
ReadPiont+=bi1;
state.packSize-=bi1;
}
}
if(state.Cortrol==9 && ReadPiont<bytesRead)
...{
int bi1=bytesRead-ReadPiont;
if(bi1<state.packSize)
...{
state.packSize=state.packSize-bi1;
ReadPiont+=bi1;
}
else
...{
state.Cortrol=0;
ReadPiont+=(int)state.packSize;
}
}
}
if(handler.Connected==true)
...{
handler.BeginReceive(state.buffer,0,bufferSize,0,
new AsyncCallback(ReadCallback), state);
}
}
else
...{
handler.Shutdown(SocketShutdown.Both);
handler.Close();
//throw(new Exception("读入的数据小于1bit"));
}
}
}
catch (Exception e)
...{
OnErrorServerEvent(new ErrorServerEventArgs(e,handler));

}
}

private void SendCallback(IAsyncResult ar)
...{
Socket client = (Socket) ar.AsyncState;
try
...{
int bytesSent = client.EndSend(ar);
}
catch (Exception e)
...{
OnErrorServerEvent(new ErrorServerEventArgs(e,client));
}
finally
...{
sendDone.Set();
}
}

private void AcceptCallback(IAsyncResult ar)
...{
Socket handler=null;
try
...{
Socket listener = (Socket) ar.AsyncState;
handler= listener.EndAccept(ar);
StateObject state = new StateObject(bufferSize,handler);
state.workSocket = handler;
handler.BeginReceive(state.buffer,0,bufferSize,0,
new AsyncCallback(ReadCallback), state);
}
catch (Exception e)
...{
OnErrorServerEvent(new ErrorServerEventArgs(e,handler));
}
finally
...{
allDone.Set();
}
}

/** <summary>
/// 析构
/// </summary>
/// <param name="disposing">不知道</param>
protected override void Dispose(bool disposing)
...{
Abort();
}

/** <summary>
/// 引发接收事件
/// </summary>
/// <param name="e">数据</param>
protected virtual void OnInceptServerEvent(InceptServerEventArgs e)
...{
if (InceptServer != null)
...{
InceptServer(this, e);
}
}
/** <summary>
/// 引发错误事件
/// </summary>
/// <param name="e">数据</param>
protected virtual void OnErrorServerEvent(ErrorServerEventArgs e)
...{
if (ErrorServer != null)
...{
ErrorServer(this, e);
}
}

/** <summary>
/// 开始监听访问
/// </summary>
public void Listening()
...{
//StartListening();
thread=new Thread(new ThreadStart(StartListening));
thread.Name="MyTcpIpServer.Listening";
thread.Start();
}
/** <summary>
/// 异常中止服务
/// </summary>
public void Abort()
...{
if(thread!=null)
...{
thread.Abort();
listener.Close();
}
}

/** <summary>
///构造
/// </summary>
/// <param name="container">父控件</param>
public MyTcpIpServer(System.ComponentModel.IContainer container)
...{
container.Add(this);
InitializeComponent();

//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}

/** <summary>
/// 构造
/// </summary>
public MyTcpIpServer()
...{
InitializeComponent();

//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}

Component Designer generated code#region Component Designer generated code
/** <summary>
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// </summary>
private void InitializeComponent()
...{

}
#endregion

/** <summary>
/// 要连接的服务器IP地址
/// </summary>
public string TcpIpServerIP
...{
get
...{
return tcpIpServerIP;
}
set
...{
tcpIpServerIP=value;
}
}

/** <summary>
/// 要连接的服务器所使用的端口
/// </summary>
public int TcpIpServerPort
...{
get
...{
return tcpIpServerPort;
}
set
...{
tcpIpServerPort=value;
}
}

/** <summary>
/// 缓冲器大小
/// </summary>
public int BufferSize
...{
get
...{
return bufferSize;
}
set
...{
bufferSize=value;
}
}

/** <summary>
/// 连接的活动状态
/// </summary>
public bool Activ
...{
get
...{
return listener.Connected;
}
//set
//{
// activ=value;
//}
}

/** <summary>
/// 发送一个流数据
/// </summary>
public void Send(Socket ClientSocket,Stream Astream)
...{
try
...{
if(ClientSocket.Connected==false)
...{
throw(new Exception("没有连接客户端不可以发送信息!"));
}
Astream.Position=0;
byte[] byteData=new byte[bufferSize];
int bi1=(int)((Astream.Length+8)/bufferSize);
int bi2=(int)Astream.Length;
if(((Astream.Length+8)%bufferSize)>0)
...{
bi1=bi1+1;
}
bi1=bi1*bufferSize;

byteData[0]=System.Convert.ToByte(bi1>>24);
byteData[1]=System.Convert.ToByte((bi1&0x00ff0000)>>16);
byteData[2]=System.Convert.ToByte((bi1&0x0000ff00)>>8);
byteData[3]=System.Convert.ToByte((bi1&0x000000ff));

byteData[4]=System.Convert.ToByte(bi2>>24);
byteData[5]=System.Convert.ToByte((bi2&0x00ff0000)>>16);
byteData[6]=System.Convert.ToByte((bi2&0x0000ff00)>>8);
byteData[7]=System.Convert.ToByte((bi2&0x000000ff));

int n = Astream.Read(byteData, 8, byteData.Length-8);

while (n>0)
...{
ClientSocket.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), ClientSocket);
sendDone.WaitOne();
byteData=new byte[bufferSize];
n = Astream.Read(byteData,0,byteData.Length);
}
}
catch (Exception e)
...{
OnErrorServerEvent(new ErrorServerEventArgs(e,ClientSocket));
}
}

/** <summary>
/// 接收到数据事件
/// </summary>
public event InceptServerEvent InceptServer;
/** <summary>
/// 发生错误事件
/// </summary>
public event ErrorServerEvent ErrorServer;
}
/** <summary>
/// 状态对象
/// </summary>
public class StateObject
...{
/** <summary>
/// 构造
/// </summary>
/// <param name="bufferSize">缓存</param>
/// <param name="WorkSocket">工作的插座</param>
public StateObject(int bufferSize,Socket WorkSocket)
...{
buffer = new byte[bufferSize];
workSocket=WorkSocket;
}
/** <summary>
/// 缓存
/// </summary>
public byte[] buffer = null;
/** <summary>
/// 工作插座
/// </summary>
public Socket workSocket = null;
/** <summary>
/// 数据流
/// </summary>
public Stream Datastream=new MemoryStream();
/** <summary>
/// 剩余大小
/// </summary>
public long residualSize=0;
/** <summary>
/// 数据包大小
/// </summary>
public long packSize=0;
/** <summary>
/// 计数器
/// </summary>
public int Cortrol=0;
}

/** <summary>
/// 接收事件
/// </summary>
public class InceptServerEventArgs : EventArgs
...{
private readonly Stream datastream;
private readonly Socket serverSocket;
private readonly MyTcpIpServer tcpIpServer;
/** <summary>
/// 构造
/// </summary>
/// <param name="Astream">数据</param>
/// <param name="ServerSocket">工作插座</param>
/// <param name="TcpIpServer">提供服务的TCP/IP对象</param>
public InceptServerEventArgs(Stream Astream,Socket ServerSocket,MyTcpIpServer TcpIpServer)
...{
datastream=Astream;
serverSocket=ServerSocket;
tcpIpServer=TcpIpServer;
}
/** <summary>
/// 数据
/// </summary>
public Stream Astream
...{
get ...{ return datastream;}
}
/** <summary>
/// 工作插座
/// </summary>
public Socket ServerSocket
...{
get ...{ return serverSocket;}
}
/** <summary>
/// 提供TCP/IP服务的服务器对象.
/// </summary>
public MyTcpIpServer TcpIpServer
...{
get ...{ return tcpIpServer;}
}
}
/** <summary>
/// 接收数据委托
/// </summary>
public delegate void InceptServerEvent(object sender, InceptServerEventArgs e);
/** <summary>
/// 错误事件委托
/// </summary>
public class ErrorServerEventArgs : EventArgs
...{
private readonly Exception error;
private readonly Socket serverSocket;
/** <summary>
/// 构造
/// </summary>
/// <param name="Error">数据</param>
/// <param name="ServerSocket">问题插座</param>
public ErrorServerEventArgs(Exception Error,Socket ServerSocket)
...{
error=Error;
serverSocket=ServerSocket;
}
/** <summary>
/// 数据
/// </summary>
public Exception Error
...{
get ...{ return error;}
}
/** <summary>
/// 问题插座
/// </summary>
public Socket ServerSocket
...{
get ...{ return serverSocket;}
}
}
/** <summary>
///错误事件委托
/// </summary>
public delegate void ErrorServerEvent(object sender, ErrorServerEventArgs e);
}

iteye_15968
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C#学习10】socket、Unity简易聊天室
kiritoV的博客
12-07 375
目录
Android开发，Socket Client端和Socket Server端数据发送和接收
最新发布
09-06
Socket分为客户端（Socket Client）和服务器端（Socket Server），它们共同构成了基于TCP/IP协议的通信模型。本篇文章将详细探讨Android环境下如何进行Socket Client端和Socket Server端的数据发送与接收。 1. **...
C#socket客户端自己输入消息发送到服务端通信实现通信
dcujcivw769565的博客
02-06 142
一，服务端代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; using System.Net; namespace ServerDemo1 { class Program ...
Socket Client 长连接及心跳检测
qq_22074337的博客
04-29 4001
说明: springBoot下socket一对一建立长连接通讯，包括客户端心跳检测、掉线重连、收发信息等
Android SocketClient库的使用
小钟的博客
02-07 668
Android 使用Socket
socket（三）：搭建client客户端的基本步骤
a_lazy_zhu的博客
05-04 750
# -*- coding:utf-8 -*- ''' TCP协议 socket 客户端 ''' import socket #1.创建套接字实例 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建socket实例 #2.连接服务器 sock.connect(("127.0.0.1",8000)) #参数是一个双元素...
python socket client
02-06
pytnon写的tcp client，包括json和信号间通信，给有需要的参考一下
SocketClient
10-20
SocketClient是一种基于套接字（Socket）协议的网络通信客户端程序。在计算机网络中，套接字是应用程序通过网络进行通信的编程接口，它允许两个网络应用之间建立连接并交换数据。SocketClient通常用于实现客户端应用...
C# SocketClient 基础版
07-24
本文将深入探讨"C# SocketClient 基础版"的相关知识点，帮助开发者理解如何在C#环境中构建一个基本的Socket客户端。 Socket是网络编程中的一个核心概念，它提供了一种在不同计算机之间进行数据交换的标准接口。TCP...
Socket Client
04-24
extension SocketClient: AsyncSocketDelegate { func socketDidConnect(_ sock: AsyncSocket, to host: String, port: Int) { print("已连接到主机: \(host) \(port)") // 发送数据到服务器... } func socket...
socketClient
09-26
最基本的socket客户端工具，用来进行网络编程时对服务器软件测试.自己工作时使用，大家就别下载了。
Linux——网络socket（server、client）
weixin_45062087的博客
07-20 2358
Linux——网络socket（server、client） 前言： 对于APUE网络socket，我们需要了解就是server和client之间的通信建立过程。首先我们需要知道两台不同网段的pc是怎么通信的，当一台pc通过应用程序发一段消息过来给另一台pc时，pc获取到数据包之后就行拆包解析，这些都是操作系统内核的工作，对于server而言，需要告诉内核使用什么ip和端口来建立起服务，当有client接入时，内核先进行解析，得到client的ip和访问端口之后再给server（对应的应用程序），最后完成通
C# Socket编程 通过线程方式的异步
超胆孤侠
10-31 3102
文章目录前言TCP编程 前言 通过几个图可以很好的总结编程逻辑 https://www.cnblogs.com/dream844/archive/2012/06/12/2546083.html 这个博客总结的很好，但是有些内容我不是很理解，以后遇到再去研究好了 https://www.cnblogs.com/jikexianfeng/p/6413262.html 介绍什么是DMA 异步是目的，为...
1、Socket网络编程之建立Server、Client连接
m0_64810555的博客
07-07 1333
从今天开始，攻坚socket网络编程，会写一大堆学习记录哦！基于C/S结构，socket网络编译便不可或缺Server和Client。针对socket的创建。首先创建一个项目，命名为Server，引用必要的空间后，紧接着在Main函数进行如下编译： 服务端创建完毕，接着同理马，创建另一个项目，命名为Client，引用命名空间结束后，接着进行Client项目的编写，代码如下： 测试阶段：1.不打开服务端，去使用客户端 2.打开服务端，去使用客户端。...
Socket网络编程学习笔记 （7）TCP快速入门
喜欢历史的码农
02-23 1919
1.TCP是什么 TCP，（Transmission Control Protocol，缩写为TCP）。TCP是传输控制协议；是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。TCP与UDP意义完成第四层传输所指定的功能与职责。 （1）TCP的机制： 三次握手、四次挥手 具有校验机制、可靠、数据传输稳定 （2）三次握手图解： （2）TCP能做的功能 聊天消息传输、推送 单人语音、视频聊天等 几乎UDP能做的都能做，但需要考虑复杂性、性能问题 限制：无
WebSocket和Socket Client连共同Sever端并实现相互通信（C#、JS、C++）
刘朋
09-15 5534
分析websocket client传过来的http header中包含“Upgrade: websocket”，只需要在socket server端，检测到客户端连上来之后，马上接收一次信息，并判断本次接收到的信息是否包含websocket就可以了。3、开启C#实现的socket server，再用websocket连接下，server端检测到有客户端连上来了，客户端也没有报错，说明websocket已连到socket server。
Android中Socket通讯类
weizhiai12的专栏
03-28 1906
public class SocketClient {     public boolean mClientFlag = false;     private static Socket client;               public SocketClient()     {         Log.d("WineStock", "WineStock SocketCli
【操作系统-网络编程】 Socket 通信 Server&Client （全双工Socket，Full Duplex Socket）
MaxwellWong
04-13 4495
实验内容：进程间通信 — 管道和 socket 通信 - 编译运行课件 Lecture11 示例代码 alg.11-1, alg.11-2.1, alg.11-2.2，指出你认为不合适的地方并加以改进。
socketclient库
07-27
SocketClient 是一个用于在 Python 中创建和管理 Socket 连接的库。它提供了一组简单易用的函数和类，使得在客户端与服务器之间进行通信变得更加方便。 你可以使用 SocketClient 来建立与远程服务器的连接，并发送...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值