/// <summary>
/// Метод вызываемый при завершении попытки поключения клиента
/// </summary>
public void ConnectCallback(IAsyncResult ar)
{
string result = "Подключение успешно!";
try
{
// Получаем подключенного клиента
TcpClientData myTcpClient = (TcpClientData)ar.AsyncState;
NetworkStream ns = myTcpClient.tcpClient.GetStream();
myTcpClient.tcpClient.EndConnect(ar);
// Запускаем асинхронный метод чтения сетевых данных для подключенного TCP клиента
myTcpClient.buffer = new byte[global.LENGTHHEADER];
ns.BeginRead(myTcpClient.buffer, 0, myTcpClient.buffer.Length, new AsyncCallback(ReadCallback), myTcpClient);
Parent.ChangeBackColor(Color.Goldenrod);
}
catch (Exception e)
{
//MessageBox.Show(e.Message);
// Обработка ошибок подключения
DisconnectClient();
result = "Подключение провалено!";
SoundError();
}
// Активация события успешного или неуспешного подключения к серверу,
// здесь серверу можно отослать ознакомительные данные о себе (например, имя клиента)
if (Connected != null)
{
Connected.BeginInvoke(this, result, null, null);
}
}
private void ProcessConnect(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
_isConnected = true;
_clientToken = new ClientToken(0, e.AcceptSocket, _receiveEvent, _sendEvent);
_receiveEvent.UserToken = _sendEvent.UserToken = e.UserToken = _clientToken;
StartReceive(_receiveEvent);
//Fire Connected event
if (Connected != null)
{
if (CallConnectedAsync)
{
Connected.BeginInvoke(this, r => Connected.EndInvoke(r), null);
}
else
{
Connected(this);
}
}
}
else
{
ProcessConnectionError(e);
}
}
/// <summary>
/// 启动服务器
/// </summary>
/// <param name="ServerIP"></param>
/// <param name="Port"></param>
/// <returns></returns>
public Boolean Start()
{
try
{
//msgQueue = new ConcurrentQueue<byte[]>(); //启动的时候重新初始化队列
_dataBuffer = new byte[1024 * 100];
_NoFullPack = string.Empty;
IPEndPoint iep = new IPEndPoint(IPAddress.Parse(_IPAddress), _Port);
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
clientSocket.Connect(iep);
clientSocket.BeginReceive(_dataBuffer, 0, _dataBuffer.Length, 0, new AsyncCallback(RecieveCallBack), clientSocket);
_IsRun = true;
this.LastConnectTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
this._LastKeepAliveTime = DateTime.Now;
Connected?.BeginInvoke("已链接", "1", this, null, null);
//发送数据线程
this.SendMessageThread(0);
//心跳监测线程
//this.KeepAliveThread(30);
//心跳超时检测
//this.KeepAliveTimeoutTestThread();
}
catch (Exception ex)
{
_IsRun = false;
//_logger.Error(ex.Message,ex);
LogManager.Error(ex.Message, ex);
}
return(_IsRun);
}
/// <summary>
/// UDP重新连接方法
/// </summary>
private void TcpAutoReconnect()
{
while (true)
{
Thread.Sleep(1000);
//假如属性提示未连接，则UDP重连线程挂起
if (!IsConnected)
{
Auto_UdpReconnect.WaitOne();
}
//假如属性提示已连接但实际上连接已断开，尝试重连
//else if (IsConnected && !IsSocketConnected())
else if (IsConnected && !IsConnected_Socket)
{
string temp = string.Format("UDP主机地址：{0}，端口号：{1}", ServerIp, ServerPort); //UDP连接的主机地址与端口
LastErrorMessage = "UDP连接意外断开，正在尝试重连。" + temp;
FileClient.WriteFailureInfo(LastErrorMessage);
try
{
BaseClient.Close();
BaseClient = HoldLocalPort ? new UdpClient(LocalEndPoint) : new UdpClient();
BaseClient.Connect(ServerIp, ServerPort);
SetName();
//重连次数+1，同时调用事件委托
ReconnTimer++;
if (ReconnTimerChanged != null)
{
ReconnTimerChanged.BeginInvoke(Name, ReconnTimer, null, null);
}
if (Connected != null)
{
Connected.BeginInvoke(Name, new EventArgs(), null, null);
}
//NetStream = BaseClient.GetStream();
if (AutoReceive)
{
BaseClient.BeginReceive(new AsyncCallback(ReceiveCallBack), this);
}
//NetStream.BeginRead(Buffer, 0, Buffer.Length, new AsyncCallback(TcpCallBack), this);
//IsSocketConnected();
FileClient.WriteFailureInfo("UDP重新连接成功。" + temp);
}
//假如出现异常，将错误信息写入日志并进入下一次循环
catch (Exception e)
{
LastErrorMessage = string.Format("UDP重新连接失败：{0}。", e.Message) + temp;
FileClient.WriteExceptionInfo(e, LastErrorMessage, false);
continue;
//TODO: 是否抛出异常？
//throw; //假如不需要抛出异常，注释此句
}
}
}
}
/// <summary>
/// 侦听回调方法
/// </summary>
/// <param name="ar"></param>
private void OnAccept(IAsyncResult ar)
{
try
{
Socket new_accept = _socket.EndAccept(ar); //新连接socket
ZProxySocket proxy = GetProxy(new_accept); //创建代理socket
proxy.DisConnected += new DisConnectedEventHandler(proxy_DisConnected);
proxy.MessageReceived += new MessageReceivedEventHandler(proxy_MessageReceived);
proxy.StartReceive(); //代理socket开始接收数据
if (Connected != null)
{
Connected.BeginInvoke(proxy, null, null); //激发Connected事件
}
_socket.BeginAccept(new AsyncCallback(OnAccept), null); //开始下一次异步侦听
}
catch
{
}
}
public void ConnectCallback(IAsyncResult ar)
{
string result = "Подключение успешно!";
try
{
NodeData node = (NodeData)ar.AsyncState;
//режим работы узлов и клиента определееются отдельно
if (modeNetwork == Mode.Node)
{
node.typeNode = NodeData.TypeNode.NODE;
}
else
{
node.typeNode = NodeData.TypeNode.CLIENT;
}
NetworkStream ns = node.newNode.GetStream();
node.newNode.EndConnect(ar);
node.buffer = new byte[ConstField.LENGTHHEADER];
ns.BeginRead(node.buffer, 0, node.buffer.Length, new AsyncCallback(ReadCallback), node);
if (modeNetwork == Mode.Client)
{
SendData("client");
}
}
catch (Exception e)
{
DisconnectNode();
result = "Подключение провалено!";
globalState = "ConnectCallback error | " + e;
}
if (Connected != null)
{
Connected.BeginInvoke(this, result, null, null);
}
}
/// <summary>
/// 利用特定的本地端口与TCP服务端连接
/// </summary>
/// <param name="server">TCP服务端IP</param>
/// <param name="port">端口号</param>
/// <param name="localIp">本地IP</param>
/// <param name="localPort">指定的本地端口（假如小于等于0则随机）</param>
/// <returns>假如建立连接成功，返回1，否则返回0</returns>
public int Connect(string server, int port, string localIp, int localPort)
{
//尝试建立连接
int result = 1;
try
{
ServerIp = server;
ServerPort = port;
//BaseClient = new TcpClient(ServerIp, ServerPort);
BaseClient = !string.IsNullOrWhiteSpace(localIp) && localPort > 0 ? new TcpClient(new IPEndPoint(IPAddress.Parse(localIp), localPort)) : new TcpClient();
BaseClient.Connect(ServerIp, ServerPort);
SetName(); //修改连接名称
//重置重连次数，同时调用事件委托
ReconnTimer = 0;
if (ReconnTimerChanged != null)
{
ReconnTimerChanged.BeginInvoke(Name, ReconnTimer, null, null);
}
BaseClient.ReceiveBufferSize = ReceiveBufferSize; //接收缓冲区的大小
NetStream = BaseClient.GetStream(); //发送与接收数据的数据流对象
raiser.Run();
}
catch (Exception e)
{
LastErrorMessage = string.Format("无法建立TCP连接，IP{0}，端口号{1}：{2}", ServerIp, ServerPort, e.Message);
if (logging)
{
FileClient.WriteExceptionInfo(e, LastErrorMessage, false);
}
Close();
result = 0;
throw; //假如不需要抛出异常，注释此行
}
IsConnected = BaseClient.Connected;
IsSocketConnected();
if (IsConnected)
{
//调用Tcp连接事件委托
if (Connected != null)
{
Connected.BeginInvoke(Name, (new EventArgs()), null, null);
}
if (Thread_TcpReconnect == null)
{
Auto_TcpReconnect = new AutoResetEvent(true);
Thread_TcpReconnect = new Thread(new ThreadStart(TcpAutoReconnect))
{
IsBackground = true
};
//Thread_TcpReconnect.IsBackground = true;
Thread_TcpReconnect.Start();
}
else
{
Auto_TcpReconnect.Set();
}
if (AutoReceive)
{
NetStream.BeginRead(Buffer, 0, Buffer.Length, new AsyncCallback(TcpCallBack), this);
}
}
return(result);
}
public void HandleConnection(object unused)
{
Thread.Sleep(10);
LingerOption lingerOption = new LingerOption(true, 10);
connection.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
try
{
connection.Connect(ep);
}
catch {}
int ret;
decimal dTimeOut = DateTime.Now.ToFileTime();
string aData = "";
string bData = "";
byte[] RecvBytes;
if (connection.Connected)
{
Connected.BeginInvoke(null, null, null, null);
}
while (connection.Connected && !disconnect)
{
if (connection.Available > 0)
{
RecvBytes = new byte[connection.Available];
ret = connection.Receive(RecvBytes, 0, RecvBytes.Length, SocketFlags.None);
aData = aData + Encoding.ASCII.GetString(RecvBytes).Substring(0, ret);
while (aData.IndexOf(newline) > -1)
{
bData = Regex.Split(aData, newline)[0].ToString();
HandleData(bData);
aData = aData.Substring((aData.IndexOf(newline) + 2));
}
dTimeOut = DateTime.Now.ToFileTime();
}
else
{
/*
* myData.bStayConnected = ((dTimeOut + 9000000000 /* 30 minutes )/* < DateTime.Now.ToFileTime() ? false : true);
* /*if (!myData.bStayConnected)
* {
* Send("451 Timeout" + newline);
* }
*/
Thread.Sleep(1);
}
}
//mySocket.Shutdown(SocketShutdown.Both);
connection.Close();
try
{
Disconnected.BeginInvoke(null, null, null, null);
}
catch {}
}
