You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
857 lines
24 KiB
C#
857 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Net.Sockets;
|
|
using System.Net;
|
|
using System.Threading;
|
|
|
|
namespace demo.ClassHelper.NetOperate
|
|
{
|
|
class TcpClientHelper
|
|
{
|
|
private static System.Threading.ManualResetEvent TimeoutObject = new System.Threading.ManualResetEvent(false);
|
|
|
|
public static Socket CreateTcpClient()
|
|
{
|
|
return new Socket(AddressFamily.InterNetwork,
|
|
SocketType.Stream, ProtocolType.Tcp);
|
|
}
|
|
|
|
public static bool ConnectToServer(Socket client, string ip, int port, int timeout = -1)
|
|
{
|
|
bool ret = false;
|
|
try
|
|
{
|
|
if (client == null)
|
|
{
|
|
client = CreateTcpClient();
|
|
}
|
|
client.SendTimeout = 300;
|
|
|
|
client.Connect(IPAddress.Parse(ip), port);
|
|
ret = client.Poll(-1, SelectMode.SelectWrite);
|
|
if (ret)
|
|
{
|
|
ret = true;
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
string str = e.ToString();
|
|
DisConnectServer(client);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public static void DisConnectServer(Socket client)
|
|
{
|
|
try
|
|
{
|
|
if (client != null)
|
|
{
|
|
//client.Shutdown(SocketShutdown.Both);
|
|
client.Disconnect(true);
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
public static bool GetClientStatus(Socket client)
|
|
{
|
|
if (client==null)
|
|
{
|
|
return false;
|
|
//return !((client.Client.Poll(1000, SelectMode.SelectRead) && (client.Client.Available == 0)) || !client.Client.Connected);
|
|
}
|
|
return client.Connected;
|
|
}
|
|
|
|
public static void Close(Socket client)
|
|
{
|
|
try
|
|
{
|
|
if (client != null)
|
|
{
|
|
client.Shutdown(SocketShutdown.Both);
|
|
client.Close();
|
|
client.Dispose();
|
|
client = null;
|
|
}
|
|
}
|
|
catch (SocketException ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
public static bool SendMsgToServer(Socket client, string msg, int timeOut = 0)
|
|
{
|
|
bool ret = false;
|
|
try
|
|
{
|
|
client.SendTimeout = timeOut;
|
|
int len = msg.Length;
|
|
byte[] data = new byte[msg.Length];
|
|
data = Encoding.Default.GetBytes(msg);
|
|
int retLen = client.Send(data);
|
|
if (len == retLen)
|
|
{
|
|
ret = true;
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Exception(ex.Message);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public static bool SendMsgToServer(Socket client, byte[] msg, int timeOut = 0)
|
|
{
|
|
bool ret = false;
|
|
try
|
|
{
|
|
client.SendTimeout = timeOut;
|
|
int len = msg.Length;
|
|
int retLen = client.Send(msg);
|
|
if (len == retLen)
|
|
{
|
|
ret = true;
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Exception(ex.Message);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public static bool SendFileToServer(Socket client, string path, int timeOut = 0)
|
|
{
|
|
bool flag = false;
|
|
try
|
|
{
|
|
client.SendTimeout = timeOut;
|
|
client.SendFile(path);
|
|
flag = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return flag;
|
|
}
|
|
|
|
public static bool ReceiveMsg(Socket client, byte[] buffer, int timeOut = 0)
|
|
{
|
|
bool ret = false;
|
|
try
|
|
{
|
|
client.ReceiveTimeout = timeOut;
|
|
int recvLen = client.Receive(buffer);
|
|
if (recvLen > 0)
|
|
{
|
|
ret = true;
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Exception(ex.Message);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public static bool ReceiveMsg(Socket client, ref string msg, int timeOut = 0)
|
|
{
|
|
bool ret = false;
|
|
byte[] buffer = new byte[5000];
|
|
try
|
|
{
|
|
client.ReceiveTimeout = timeOut;
|
|
int receiveCount = client.Receive(buffer);
|
|
if (receiveCount > 0)
|
|
{
|
|
ret = true;
|
|
byte[] tempBuffer = new byte[receiveCount];
|
|
Buffer.BlockCopy(buffer, 0, tempBuffer, 0, receiveCount);
|
|
msg = Encoding.Default.GetString(tempBuffer);
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Exception(ex.Message);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#region
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// public class AsyncTcpClient : IDisposable
|
|
// {
|
|
// #region Fields
|
|
|
|
// private TcpClient tcpClient;
|
|
// private bool disposed = false;
|
|
// private int retries = 0;
|
|
|
|
// #endregion
|
|
|
|
// #region Ctors
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteEP">远端服务器终结点</param>
|
|
// public AsyncTcpClient(IPEndPoint remoteEP)
|
|
// : this(new[] { remoteEP.Address }, remoteEP.Port)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteEP">远端服务器终结点</param>
|
|
// /// <param name="localEP">本地客户端终结点</param>
|
|
// public AsyncTcpClient(IPEndPoint remoteEP, IPEndPoint localEP)
|
|
// : this(new[] { remoteEP.Address }, remoteEP.Port, localEP)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteIPAddress">远端服务器IP地址</param>
|
|
// /// <param name="remotePort">远端服务器端口</param>
|
|
// public AsyncTcpClient(IPAddress remoteIPAddress, int remotePort)
|
|
// : this(new[] { remoteIPAddress }, remotePort)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteIPAddress">远端服务器IP地址</param>
|
|
// /// <param name="remotePort">远端服务器端口</param>
|
|
// /// <param name="localEP">本地客户端终结点</param>
|
|
// public AsyncTcpClient(
|
|
// IPAddress remoteIPAddress, int remotePort, IPEndPoint localEP)
|
|
// : this(new[] { remoteIPAddress }, remotePort, localEP)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteHostName">远端服务器主机名</param>
|
|
// /// <param name="remotePort">远端服务器端口</param>
|
|
// public AsyncTcpClient(string remoteHostName, int remotePort)
|
|
// : this(Dns.GetHostAddresses(remoteHostName), remotePort)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteHostName">远端服务器主机名</param>
|
|
// /// <param name="remotePort">远端服务器端口</param>
|
|
// /// <param name="localEP">本地客户端终结点</param>
|
|
// public AsyncTcpClient(
|
|
// string remoteHostName, int remotePort, IPEndPoint localEP)
|
|
// : this(Dns.GetHostAddresses(remoteHostName), remotePort, localEP)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteIPAddresses">远端服务器IP地址列表</param>
|
|
// /// <param name="remotePort">远端服务器端口</param>
|
|
// public AsyncTcpClient(IPAddress[] remoteIPAddresses, int remotePort)
|
|
// : this(remoteIPAddresses, remotePort, null)
|
|
// {
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 异步TCP客户端
|
|
// /// </summary>
|
|
// /// <param name="remoteIPAddresses">远端服务器IP地址列表</param>
|
|
// /// <param name="remotePort">远端服务器端口</param>
|
|
// /// <param name="localEP">本地客户端终结点</param>
|
|
// public AsyncTcpClient(
|
|
// IPAddress[] remoteIPAddresses, int remotePort, IPEndPoint localEP)
|
|
// {
|
|
// this.Addresses = remoteIPAddresses;
|
|
// this.Port = remotePort;
|
|
// this.LocalIPEndPoint = localEP;
|
|
// this.Encoding = Encoding.Default;
|
|
|
|
// if (this.LocalIPEndPoint != null)
|
|
// {
|
|
// this.tcpClient = new TcpClient(this.LocalIPEndPoint);
|
|
// }
|
|
// else
|
|
// {
|
|
// this.tcpClient = new TcpClient();
|
|
// }
|
|
|
|
// Retries = 3;
|
|
// RetryInterval = 5;
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region Properties
|
|
|
|
// /// <summary>
|
|
// /// 是否已与服务器建立连接
|
|
// /// </summary>
|
|
// public bool Connected { get { return tcpClient.Client.Connected; } }
|
|
// /// <summary>
|
|
// /// 远端服务器的IP地址列表
|
|
// /// </summary>
|
|
// public IPAddress[] Addresses { get; private set; }
|
|
// /// <summary>
|
|
// /// 远端服务器的端口
|
|
// /// </summary>
|
|
// public int Port { get; private set; }
|
|
// /// <summary>
|
|
// /// 连接重试次数
|
|
// /// </summary>
|
|
// public int Retries { get; set; }
|
|
// /// <summary>
|
|
// /// 连接重试间隔
|
|
// /// </summary>
|
|
// public int RetryInterval { get; set; }
|
|
// /// <summary>
|
|
// /// 远端服务器终结点
|
|
// /// </summary>
|
|
// public IPEndPoint RemoteIPEndPoint
|
|
// {
|
|
// get { return new IPEndPoint(Addresses[0], Port); }
|
|
// }
|
|
// /// <summary>
|
|
// /// 本地客户端终结点
|
|
// /// </summary>
|
|
// protected IPEndPoint LocalIPEndPoint { get; private set; }
|
|
// /// <summary>
|
|
// /// 通信所使用的编码
|
|
// /// </summary>
|
|
// public Encoding Encoding { get; set; }
|
|
|
|
// #endregion
|
|
|
|
// #region Connect
|
|
|
|
// /// <summary>
|
|
// /// 连接到服务器
|
|
// /// </summary>
|
|
// /// <returns>异步TCP客户端</returns>
|
|
// public AsyncTcpClient Connect()
|
|
// {
|
|
// if (!Connected)
|
|
// {
|
|
// // start the async connect operation
|
|
// tcpClient.BeginConnect(
|
|
// Addresses, Port, HandleTcpServerConnected, tcpClient);
|
|
// }
|
|
|
|
// return this;
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 关闭与服务器的连接
|
|
// /// </summary>
|
|
// /// <returns>异步TCP客户端</returns>
|
|
// public AsyncTcpClient Close()
|
|
// {
|
|
// if (Connected)
|
|
// {
|
|
// retries = 0;
|
|
// tcpClient.Close();
|
|
// RaiseServerDisconnected(Addresses, Port);
|
|
// }
|
|
|
|
// return this;
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region Receive
|
|
|
|
// private void HandleTcpServerConnected(IAsyncResult ar)
|
|
// {
|
|
// try
|
|
// {
|
|
// tcpClient.EndConnect(ar);
|
|
// RaiseServerConnected(Addresses, Port);
|
|
// retries = 0;
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// ExceptionHandler.Handle(ex);
|
|
// if (retries > 0)
|
|
// {
|
|
// Logger.Debug(string.Format(CultureInfo.InvariantCulture,
|
|
// "Connect to server with retry {0} failed.", retries));
|
|
// }
|
|
|
|
// retries++;
|
|
// if (retries > Retries)
|
|
// {
|
|
// // we have failed to connect to all the IP Addresses,
|
|
// // connection has failed overall.
|
|
// RaiseServerExceptionOccurred(Addresses, Port, ex);
|
|
// return;
|
|
// }
|
|
// else
|
|
// {
|
|
// Logger.Debug(string.Format(CultureInfo.InvariantCulture,
|
|
// "Waiting {0} seconds before retrying to connect to server.",
|
|
// RetryInterval));
|
|
// Thread.Sleep(TimeSpan.FromSeconds(RetryInterval));
|
|
// Connect();
|
|
// return;
|
|
// }
|
|
// }
|
|
|
|
// // we are connected successfully and start asyn read operation.
|
|
// byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
|
|
// tcpClient.GetStream().BeginRead(
|
|
// buffer, 0, buffer.Length, HandleDatagramReceived, buffer);
|
|
// }
|
|
|
|
// private void HandleDatagramReceived(IAsyncResult ar)
|
|
// {
|
|
// NetworkStream stream = tcpClient.GetStream();
|
|
|
|
// int numberOfReadBytes = 0;
|
|
// try
|
|
// {
|
|
// numberOfReadBytes = stream.EndRead(ar);
|
|
// }
|
|
// catch
|
|
// {
|
|
// numberOfReadBytes = 0;
|
|
// }
|
|
|
|
// if (numberOfReadBytes == 0)
|
|
// {
|
|
// // connection has been closed
|
|
// Close();
|
|
// return;
|
|
// }
|
|
|
|
// // received byte and trigger event notification
|
|
// byte[] buffer = (byte[])ar.AsyncState;
|
|
// byte[] receivedBytes = new byte[numberOfReadBytes];
|
|
// Buffer.BlockCopy(buffer, 0, receivedBytes, 0, numberOfReadBytes);
|
|
// RaiseDatagramReceived(tcpClient, receivedBytes);
|
|
// RaisePlaintextReceived(tcpClient, receivedBytes);
|
|
|
|
// // then start reading from the network again
|
|
// stream.BeginRead(
|
|
// buffer, 0, buffer.Length, HandleDatagramReceived, buffer);
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region Events
|
|
|
|
// /// <summary>
|
|
// /// 接收到数据报文事件
|
|
// /// </summary>
|
|
// public event EventHandler<TcpDatagramReceivedEventArgs<byte[]>> DatagramReceived;
|
|
// /// <summary>
|
|
// /// 接收到数据报文明文事件
|
|
// /// </summary>
|
|
// public event EventHandler<TcpDatagramReceivedEventArgs<string>> PlaintextReceived;
|
|
|
|
// private void RaiseDatagramReceived(TcpClient sender, byte[] datagram)
|
|
// {
|
|
// if (DatagramReceived != null)
|
|
// {
|
|
// DatagramReceived(this,
|
|
// new TcpDatagramReceivedEventArgs<byte[]>(sender, datagram));
|
|
// }
|
|
// }
|
|
|
|
// private void RaisePlaintextReceived(TcpClient sender, byte[] datagram)
|
|
// {
|
|
// if (PlaintextReceived != null)
|
|
// {
|
|
// PlaintextReceived(this,
|
|
// new TcpDatagramReceivedEventArgs<string>(
|
|
// sender, this.Encoding.GetString(datagram, 0, datagram.Length)));
|
|
// }
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 与服务器的连接已建立事件
|
|
// /// </summary>
|
|
// public event EventHandler<TcpServerConnectedEventArgs> ServerConnected;
|
|
// /// <summary>
|
|
// /// 与服务器的连接已断开事件
|
|
// /// </summary>
|
|
// public event EventHandler<TcpServerDisconnectedEventArgs> ServerDisconnected;
|
|
// /// <summary>
|
|
// /// 与服务器的连接发生异常事件
|
|
// /// </summary>
|
|
// public event EventHandler<TcpServerExceptionOccurredEventArgs> ServerExceptionOccurred;
|
|
|
|
// private void RaiseServerConnected(IPAddress[] ipAddresses, int port)
|
|
// {
|
|
// if (ServerConnected != null)
|
|
// {
|
|
// ServerConnected(this,
|
|
// new TcpServerConnectedEventArgs(ipAddresses, port));
|
|
// }
|
|
// }
|
|
|
|
// private void RaiseServerDisconnected(IPAddress[] ipAddresses, int port)
|
|
// {
|
|
// if (ServerDisconnected != null)
|
|
// {
|
|
// ServerDisconnected(this,
|
|
// new TcpServerDisconnectedEventArgs(ipAddresses, port));
|
|
// }
|
|
// }
|
|
|
|
// private void RaiseServerExceptionOccurred(
|
|
// IPAddress[] ipAddresses, int port, Exception innerException)
|
|
// {
|
|
// if (ServerExceptionOccurred != null)
|
|
// {
|
|
// ServerExceptionOccurred(this,
|
|
// new TcpServerExceptionOccurredEventArgs(
|
|
// ipAddresses, port, innerException));
|
|
// }
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region Send
|
|
|
|
// /// <summary>
|
|
// /// 发送报文
|
|
// /// </summary>
|
|
// /// <param name="datagram">报文</param>
|
|
// public void Send(byte[] datagram)
|
|
// {
|
|
// if (datagram == null)
|
|
// throw new ArgumentNullException("datagram");
|
|
|
|
// if (!Connected)
|
|
// {
|
|
// RaiseServerDisconnected(Addresses, Port);
|
|
// throw new InvalidProgramException(
|
|
// "This client has not connected to server.");
|
|
// }
|
|
|
|
// tcpClient.GetStream().BeginWrite(
|
|
// datagram, 0, datagram.Length, HandleDatagramWritten, tcpClient);
|
|
// }
|
|
|
|
// private void HandleDatagramWritten(IAsyncResult ar)
|
|
// {
|
|
// ((TcpClient)ar.AsyncState).GetStream().EndWrite(ar);
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 发送报文
|
|
// /// </summary>
|
|
// /// <param name="datagram">报文</param>
|
|
// public void Send(string datagram)
|
|
// {
|
|
// Send(this.Encoding.GetBytes(datagram));
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region IDisposable Members
|
|
|
|
// /// <summary>
|
|
// /// Performs application-defined tasks associated with freeing,
|
|
// /// releasing, or resetting unmanaged resources.
|
|
// /// </summary>
|
|
// public void Dispose()
|
|
// {
|
|
// Dispose(true);
|
|
// GC.SuppressFinalize(this);
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// Releases unmanaged and - optionally - managed resources
|
|
// /// </summary>
|
|
// /// <param name="disposing"><c>true</c> to release both managed
|
|
// /// and unmanaged resources; <c>false</c>
|
|
// /// to release only unmanaged resources.
|
|
// /// </param>
|
|
// protected virtual void Dispose(bool disposing)
|
|
// {
|
|
// if (!this.disposed)
|
|
// {
|
|
// if (disposing)
|
|
// {
|
|
// try
|
|
// {
|
|
// Close();
|
|
|
|
// if (tcpClient != null)
|
|
// {
|
|
// tcpClient = null;
|
|
// }
|
|
// }
|
|
// catch (SocketException ex)
|
|
// {
|
|
// ExceptionHandler.Handle(ex);
|
|
// }
|
|
// }
|
|
|
|
// disposed = true;
|
|
// }
|
|
// }
|
|
|
|
// #endregion
|
|
// }
|
|
|
|
//使用举例
|
|
//复制代码
|
|
//代码如下:
|
|
|
|
//class Program
|
|
// {
|
|
// static AsyncTcpClient client;
|
|
|
|
// static void Main(string[] args)
|
|
// {
|
|
// LogFactory.Assign(new ConsoleLogFactory());
|
|
|
|
// // 测试用，可以不指定由系统选择端口
|
|
// IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9999);
|
|
// IPEndPoint localEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9998);
|
|
// client = new AsyncTcpClient(remoteEP, localEP);
|
|
// client.Encoding = Encoding.UTF8;
|
|
// client.ServerExceptionOccurred +=
|
|
// new EventHandler<TcpServerExceptionOccurredEventArgs>(client_ServerExceptionOccurred);
|
|
// client.ServerConnected +=
|
|
// new EventHandler<TcpServerConnectedEventArgs>(client_ServerConnected);
|
|
// client.ServerDisconnected +=
|
|
// new EventHandler<TcpServerDisconnectedEventArgs>(client_ServerDisconnected);
|
|
// client.PlaintextReceived +=
|
|
// new EventHandler<TcpDatagramReceivedEventArgs<string>>(client_PlaintextReceived);
|
|
// client.Connect();
|
|
|
|
// Console.WriteLine("TCP client has connected to server.");
|
|
// Console.WriteLine("Type something to send to server...");
|
|
// while (true)
|
|
// {
|
|
// try
|
|
// {
|
|
// string text = Console.ReadLine();
|
|
// client.Send(text);
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// Console.WriteLine(ex.Message);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// static void client_ServerExceptionOccurred(
|
|
// object sender, TcpServerExceptionOccurredEventArgs e)
|
|
// {
|
|
// Logger.Debug(string.Format(CultureInfo.InvariantCulture,
|
|
// "TCP server {0} exception occurred, {1}.",
|
|
// e.ToString(), e.Exception.Message));
|
|
// }
|
|
|
|
// static void client_ServerConnected(
|
|
// object sender, TcpServerConnectedEventArgs e)
|
|
// {
|
|
// Logger.Debug(string.Format(CultureInfo.InvariantCulture,
|
|
// "TCP server {0} has connected.", e.ToString()));
|
|
// }
|
|
|
|
// static void client_ServerDisconnected(
|
|
// object sender, TcpServerDisconnectedEventArgs e)
|
|
// {
|
|
// Logger.Debug(string.Format(CultureInfo.InvariantCulture,
|
|
// "TCP server {0} has disconnected.", e.ToString()));
|
|
// }
|
|
|
|
// static void client_PlaintextReceived(
|
|
// object sender, TcpDatagramReceivedEventArgs<string> e)
|
|
// {
|
|
// Console.Write(string.Format("Server : {0} --> ",
|
|
// e.TcpClient.Client.RemoteEndPoint.ToString()));
|
|
// Console.WriteLine(string.Format("{0}", e.Datagram));
|
|
// }
|
|
// }
|
|
|
|
//补充代码
|
|
//复制代码
|
|
//代码如下:
|
|
|
|
///// <summary>
|
|
// /// Internal class to join the TCP client and buffer together
|
|
// /// for easy management in the server
|
|
// /// </summary>
|
|
// internal class TcpClientState
|
|
// {
|
|
// /// <summary>
|
|
// /// Constructor for a new Client
|
|
// /// </summary>
|
|
// /// <param name="tcpClient">The TCP client</param>
|
|
// /// <param name="buffer">The byte array buffer</param>
|
|
// public TcpClientState(TcpClient tcpClient, byte[] buffer)
|
|
// {
|
|
// if (tcpClient == null)
|
|
// throw new ArgumentNullException("tcpClient");
|
|
// if (buffer == null)
|
|
// throw new ArgumentNullException("buffer");
|
|
|
|
// this.TcpClient = tcpClient;
|
|
// this.Buffer = buffer;
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// Gets the TCP Client
|
|
// /// </summary>
|
|
// public TcpClient TcpClient { get; private set; }
|
|
|
|
// /// <summary>
|
|
// /// Gets the Buffer.
|
|
// /// </summary>
|
|
// public byte[] Buffer { get; private set; }
|
|
|
|
// /// <summary>
|
|
// /// Gets the network stream
|
|
// /// </summary>
|
|
// public NetworkStream NetworkStream
|
|
// {
|
|
// get { return TcpClient.GetStream(); }
|
|
// }
|
|
// }
|
|
|
|
//复制代码
|
|
//代码如下:
|
|
|
|
///// <summary>
|
|
// /// 与客户端的连接已建立事件参数
|
|
// /// </summary>
|
|
// public class TcpClientConnectedEventArgs : EventArgs
|
|
// {
|
|
// /// <summary>
|
|
// /// 与客户端的连接已建立事件参数
|
|
// /// </summary>
|
|
// /// <param name="tcpClient">客户端</param>
|
|
// public TcpClientConnectedEventArgs(TcpClient tcpClient)
|
|
// {
|
|
// if (tcpClient == null)
|
|
// throw new ArgumentNullException("tcpClient");
|
|
|
|
// this.TcpClient = tcpClient;
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 客户端
|
|
// /// </summary>
|
|
// public TcpClient TcpClient { get; private set; }
|
|
// }
|
|
|
|
//复制代码
|
|
//代码如下:
|
|
|
|
///// <summary>
|
|
// /// 与客户端的连接已断开事件参数
|
|
// /// </summary>
|
|
// public class TcpClientDisconnectedEventArgs : EventArgs
|
|
// {
|
|
// /// <summary>
|
|
// /// 与客户端的连接已断开事件参数
|
|
// /// </summary>
|
|
// /// <param name="tcpClient">客户端</param>
|
|
// public TcpClientDisconnectedEventArgs(TcpClient tcpClient)
|
|
// {
|
|
// if (tcpClient == null)
|
|
// throw new ArgumentNullException("tcpClient");
|
|
|
|
// this.TcpClient = tcpClient;
|
|
// }
|
|
// /// <summary>
|
|
// /// 客户端
|
|
// /// </summary>
|
|
// public TcpClient TcpClient { get; private set; }
|
|
// }
|
|
|
|
//复制代码
|
|
//代码如下:
|
|
|
|
///// <summary>
|
|
// /// 与服务器的连接发生异常事件参数
|
|
// /// </summary>
|
|
// public class TcpServerExceptionOccurredEventArgs : EventArgs
|
|
// {
|
|
// /// <summary>
|
|
// /// 与服务器的连接发生异常事件参数
|
|
// /// </summary>
|
|
// /// <param name="ipAddresses">服务器IP地址列表</param>
|
|
// /// <param name="port">服务器端口</param>
|
|
// /// <param name="innerException">内部异常</param>
|
|
// public TcpServerExceptionOccurredEventArgs(
|
|
// IPAddress[] ipAddresses, int port, Exception innerException)
|
|
// {
|
|
// if (ipAddresses == null)
|
|
// throw new ArgumentNullException("ipAddresses");
|
|
|
|
// this.Addresses = ipAddresses;
|
|
// this.Port = port;
|
|
// this.Exception = innerException;
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// 服务器IP地址列表
|
|
// /// </summary>
|
|
// public IPAddress[] Addresses { get; private set; }
|
|
// /// <summary>
|
|
// /// 服务器端口
|
|
// /// </summary>
|
|
// public int Port { get; private set; }
|
|
// /// <summary>
|
|
// /// 内部异常
|
|
// /// </summary>
|
|
// public Exception Exception { get; private set; }
|
|
|
|
// /// <summary>
|
|
// /// Returns a <see cref="System.String"/> that represents this instance.
|
|
// /// </summary>
|
|
// /// <returns>
|
|
// /// A <see cref="System.String"/> that represents this instance.
|
|
// /// </returns>
|
|
// public override string ToString()
|
|
// {
|
|
// string s = string.Empty;
|
|
// foreach (var item in Addresses)
|
|
// {
|
|
// s = s + item.ToString() + ',';
|
|
// }
|
|
// s = s.TrimEnd(',');
|
|
// s = s + ":" + Port.ToString(CultureInfo.InvariantCulture);
|
|
|
|
// return s;
|
|
// }
|
|
// }
|
|
|
|
#endregion
|
|
}
|
|
}
|