/// <summary>
/// �������,�Ѿ������ʧ��
/// </summary>
/// <param name="port">�˿ں�</param>
/// <param name="server">������</param>
public void Start(int port, ServerBase server)
{
if (port < 1024 || null == server)
return;
if (this.listenermap.ContainsKey(port))
return;
ThreadManager.QueueUserWorkItem(delegate(object obj) { this.start(port, server); }, null);
}
/// <summary>
/// �������,�Ѿ���������,��ռ������Լ�������
/// </summary>
/// <param name="port">�˿ں�</param>
/// <param name="server">������</param>
private void start(int port, ServerBase server)
{
if (port < 1024 || null == server)
return;
if (this.listenermap.ContainsKey(port))
return;
server.Port = port;
IPEndPoint localport = new IPEndPoint(IPAddress.Any, port);
TcpListener listener = new TcpListener(localport);
this.listenermap.Add(port, listener);
try
{
listener.Start();
}
catch
{
this.listenermap.Remove(port);
return;
}
while (true)
{
Socket client = null;
try
{
client = listener.AcceptSocket();
}
catch (Exception ex)
{
ErrorRequestEventArgs args = new ErrorRequestEventArgs(client, server, new byte[0], ex);
this.raiseEvent(args);
if (!this.listenermap.ContainsKey(port))
return;
listener.Start();
continue;
}
ClientInfo info = new ClientInfo(client);
Monitor.Enter(server);
server.ClientList.Add(info);
Monitor.PulseAll(server);
Monitor.Exit(server);
ThreadManager.QueueUserWorkItem(delegate(object obj) { this.readData(info, server); }, null);
ThreadManager.QueueUserWorkItem(delegate(object obj) { this.writeData(info, server); }, null);
}
}
/// <summary>
/// ������д��ͨѶ����
/// </summary>
/// <param name="client">�ͻ�������</param>
/// <param name="server">������</param>
private void writeData(ClientInfo clientinfo, ServerBase server)
{
if (null == clientinfo || null == server)
return;
Socket client = clientinfo.Client;
List<byte[]> responseList = clientinfo.BufferResponse;
while (true)
{
//������ʱ�ر��˳�
if (DateTime.Now - clientinfo.OPdt > server.TimeDisconn)
{
this.closeClientInfo(clientinfo, server);
DisconnEventArgs args = new DisconnEventArgs(client, server);
this.raiseEvent(args);
return;
}
for (int i = 0; i < 80; i++)
{
if (responseList.Count > 0)
break;
Thread.Sleep(5);
}
if (responseList.Count < 1)
continue;
//ͬ���¼�����������Ӧ����
clientinfo.OPdt = DateTime.Now;
Monitor.Enter(clientinfo);
byte[][] responseArray = responseList.ToArray();
responseList.Clear();
Monitor.PulseAll(clientinfo);
Monitor.Exit(clientinfo);
try
{
for (int i = 0; i < responseArray.Length; i++)
{
client.Send(responseArray[i]);
ResponseSrvEventArgs argresp = new ResponseSrvEventArgs(client, server, responseArray[i]);
this.raiseEvent(argresp);
}
}
catch (Exception ex)
{
this.closeClientInfo(clientinfo, server);
DisconnEventArgs args = new DisconnEventArgs(client, server, ex);
this.raiseEvent(args);
return;
}
clientinfo.OPdt = DateTime.Now;
}
}
/// <summary>
/// �رտͻ������Ӳ��ͷŻ�����Ϣ
/// </summary>
/// <param name="clientinfo"></param>
/// <param name="server"></param>
private void closeClientInfo(ClientInfo clientinfo, ServerBase server)
{
try
{
clientinfo.Client.Close();
Monitor.Enter(clientinfo);
clientinfo.BufferResponse.Clear();
Monitor.PulseAll(clientinfo);
Monitor.Exit(clientinfo);
Monitor.Enter(server);
server.ClientList.Remove(clientinfo);
Monitor.PulseAll(server);
Monitor.Exit(server);
}
catch { }
}
/// <summary>
/// ��������ȡͨѶ����
/// </summary>
/// <param name="client">�ͻ�������</param>
/// <param name="server">������</param>
private void readData(ClientInfo clientinfo, ServerBase server)
{
if (null == clientinfo || null == server)
return;
Socket client = clientinfo.Client;
bool isopen = false;
int iM = 1048576, available = 0;
try
{
isopen = client.Connected;
available = isopen ? client.Available : 0;
}
catch { return; }
List<byte[]> responseList = clientinfo.BufferResponse;
byte[] buffer = new byte[client.ReceiveBufferSize];
MemoryStream stream = new MemoryStream();
byte[] b = null;
while (true)
{
while (available > 0)
{
try
{
//ִ������
byte[] request = stream.ToArray();
long pos = stream.Position;
int len = client.Receive(buffer);
available = client.Available;
clientinfo.OPdt = DateTime.Now;
if (request.Length > 0)
{
stream = new MemoryStream();
long lenr = request.LongLength;
for (int i = 0; i * iM < lenr; i++)
stream.Write(request, iM * i, lenr > (i + 1) * iM ? iM : (int)(lenr - i * iM));
}
stream.Seek(pos, SeekOrigin.Begin);
byte[] reqarg = new byte[len];
Array.Copy(buffer, reqarg, len);
RequestEventArgs argreq = new RequestEventArgs(client, server, reqarg);
this.raiseEvent(argreq);
b = server.Execute(clientinfo, buffer, len, ref stream);
}
catch (Exception ex)
{
byte[] request = stream.ToArray();
stream = new MemoryStream();
ErrorRequestEventArgs argerr = new ErrorRequestEventArgs(client, server, request, ex);
this.raiseEvent(argerr);
if (ex is SocketException)
{
isopen = false;
break;
}
continue;
}
//��Ӧ���д�뻺��,����ͬ���¼�д����Ӧ
if (null != b && b.Length > 0)
{
Monitor.Enter(clientinfo);
responseList.Add(b);
Monitor.PulseAll(clientinfo);
Monitor.Exit(clientinfo);
}
}//while (available > 0)
while(available < 1)
{
Thread.Sleep(10);
try
{
isopen = client.Connected;
available = isopen ? client.Available : 0;
if (!isopen) break;
}
catch
{
available = 0;
isopen = false;
break;
}
}
if (!isopen)
{
this.closeClientInfo(clientinfo, server);
return;
}
}//while (true)
}
/// <summary>
/// 请求事件参数构造函数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器服务实例</param>
/// <param name="ex">异常事件</param>
public DisconnEventArgs(Socket client, ServerBase server,Exception ex)
{
Client = client;
Server = server;
Exception = ex;
}
/// <summary>
/// 请求事件参数构造函数
/// </summary>
/// <param name="server">服务器服务实例</param>
/// <param name="client">客户端实例</param>
/// <param name="request">请求数据内容</param>
public ExtendEventArgs(ServerBase server, ClientInfo client, byte[] request)
{
Server = server;
Client = client;
Request = request;
if (null != request)
ContentLen = request.Length;
}
/// <summary>
/// 服务器端异常事件参数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器服务实例</param>
/// <param name="request">请求数据内容</param>
/// <param name="ex">服务端异常</param>
public ErrorRequestEventArgs(Socket client, ServerBase server, byte[] request,Exception ex)
{
Client = client;
Server = server;
Request = request;
if (null != request)
ContentLen = request.Length;
Exception = ex;
}
/// <summary>
/// 请求事件参数构造函数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器服务实例</param>
public DisconnEventArgs(Socket client, ServerBase server)
{
Client = client;
Server = server;
}
/// <summary>
/// 请求事件参数构造函数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器服务实例</param>
/// <param name="request">请求数据内容</param>
public RequestEventArgs(Socket client, ServerBase server, byte[] request)
{
Client = client;
Server = server;
Request = request;
if (null != request)
ContentLen = request.Length;
}
/// <summary>
/// 服务端响应事件参数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器实例</param>
/// <param name="response">响应数据</param>
public ResponseSrvEventArgs(Socket client, ServerBase server, byte[] response)
{
Client = client;
Server = server;
Response = response;
if (null != response)
ContentLen = response.Length;
}
/// <summary>
/// 请求事件参数构造函数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器服务实例</param>
/// <param name="ex">异常事件</param>
public DisconnEventArgs(Socket client, ServerBase server, Exception ex)
{
Client = client;
Server = server;
Exception = ex;
}
/// <summary>
/// 请求事件参数构造函数
/// </summary>
/// <param name="client">发出请求的客户端</param>
/// <param name="server">服务器服务实例</param>
public DisconnEventArgs(Socket client, ServerBase server)
{
Client = client;
Server = server;
}
/// <summary>
/// 服务器读取通讯数据
/// </summary>
/// <param name="client">客户端连接</param>
/// <param name="server">服务器</param>
private void readData(ClientInfo clientinfo, ServerBase server)
{
if (null == clientinfo || null == server)
{
return;
}
Socket client = clientinfo.Client;
bool isopen = false;
int iM = 1048576, available = 0;
try
{
isopen = client.Connected;
available = isopen ? client.Available : 0;
}
catch { return; }
List <byte[]> responseList = clientinfo.BufferResponse;
byte[] buffer = new byte[client.ReceiveBufferSize];
MemoryStream stream = new MemoryStream();
byte[] b = null;
while (true)
{
while (available > 0)
{
try
{
//执行请求
byte[] request = stream.ToArray();
long pos = stream.Position;
int len = client.Receive(buffer);
available = client.Available;
clientinfo.OPdt = DateTime.Now;
if (request.Length > 0)
{
stream = new MemoryStream();
long lenr = request.LongLength;
for (int i = 0; i *iM < lenr; i++)
{
stream.Write(request, iM * i, lenr > (i + 1) * iM ? iM : (int)(lenr - i * iM));
}
}
stream.Seek(pos, SeekOrigin.Begin);
byte[] reqarg = new byte[len];
Array.Copy(buffer, reqarg, len);
RequestEventArgs argreq = new RequestEventArgs(client, server, reqarg);
this.raiseEvent(argreq);
b = server.Execute(clientinfo, buffer, len, ref stream);
}
catch (Exception ex)
{
byte[] request = stream.ToArray();
stream = new MemoryStream();
ErrorRequestEventArgs argerr = new ErrorRequestEventArgs(client, server, request, ex);
this.raiseEvent(argerr);
if (ex is SocketException)
{
isopen = false;
break;
}
continue;
}
//响应结果写入缓存,触发同步事件写入响应
if (null != b && b.Length > 0)
{
Monitor.Enter(clientinfo);
responseList.Add(b);
Monitor.PulseAll(clientinfo);
Monitor.Exit(clientinfo);
}
}//while (available > 0)
while (available < 1)
{
Thread.Sleep(10);
try
{
isopen = client.Connected;
available = isopen ? client.Available : 0;
if (!isopen)
{
break;
}
}
catch
{
available = 0;
isopen = false;
break;
}
}
if (!isopen)
{
this.closeClientInfo(clientinfo, server);
return;
}
}//while (true)
}
/// <summary>
/// 服务器写入通讯数据
/// </summary>
/// <param name="client">客户端连接</param>
/// <param name="server">服务器</param>
private void writeData(ClientInfo clientinfo, ServerBase server)
{
if (null == clientinfo || null == server)
return;
Socket client = clientinfo.Client;
List<byte[]> responseList = clientinfo.BufferResponse;
while (true)
{
//心跳超时关闭退出
if (DateTime.Now - clientinfo.OPdt > server.TimeDisconn)
{
server.Close(clientinfo);
//string msgex = "心跳超时退出，剩余连接数：" + Convert.ToString(server.ClientList.Count);
//ExceptionManager.Publish(new Exception(msgex));
DisconnEventArgs args = new DisconnEventArgs(client, server);
this.raiseEvent(args);
return;
}
for (int i = 0; i < 80; i++)
{
if (responseList.Count > 0)
break;
Thread.Sleep(5);
}
if (responseList.Count < 1)
continue;
//同步事件触发发送响应数据
clientinfo.OPdt = DateTime.Now;
Monitor.Enter(clientinfo);
byte[][] responseArray = responseList.ToArray();
responseList.Clear();
Monitor.PulseAll(clientinfo);
Monitor.Exit(clientinfo);
try
{
for (int i = 0; i < responseArray.Length; i++)
{
client.Send(responseArray[i]);
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " S发送：" + CommandBase.Parse(responseArray[i]));
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " S发送：" + CommandBase.Parse(responseArray[i]));
ResponseSrvEventArgs argresp = new ResponseSrvEventArgs(client, server, responseArray[i]);
this.raiseEvent(argresp);
}
}
catch (Exception ex)
{
server.Close(clientinfo);
//NameValueCollection attr = new NameValueCollection();
//attr["剩余连接数"] = Convert.ToString(server.ClientList.Count);
//ExceptionManager.Publish(ex, attr);
DisconnEventArgs args = new DisconnEventArgs(client, server, ex);
this.raiseEvent(args);
return;
}
clientinfo.OPdt = DateTime.Now;
}
}
/// <summary>
/// 服务器读取通讯数据
/// </summary>
/// <param name="client">客户端连接</param>
/// <param name="server">服务器</param>
private void readData(ClientInfo clientinfo, ServerBase server)
{
if (null == clientinfo || null == server)
return;
Socket client = clientinfo.Client;
bool isopen = false;
int iM = 1048576, available = 0;
try
{
isopen = client.Connected;
available = isopen ? client.Available : 0;
}
catch { return; }
List<byte[]> responseList = clientinfo.BufferResponse;
byte[] buffer = new byte[client.ReceiveBufferSize];
MemoryStream stream = new MemoryStream();
byte[] b = null;
while (true)
{
while (available > 0)
{
try
{
//执行请求
byte[] request = stream.ToArray();
long pos = stream.Position;
int len = client.Receive(buffer);
string msgrp = Encoding.GetEncoding("GB2312").GetString(buffer, 0, len);
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " S接收：" + msgrp);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " S接收：" + msgrp);
clientinfo.OPdt = DateTime.Now;
if (request.Length > 0)
{
stream = new MemoryStream();
long lenr = request.LongLength;
for (int i = 0; i * iM < lenr; i++)
stream.Write(request, iM * i, lenr > (i + 1) * iM ? iM : (int)(lenr - i * iM));
}
stream.Seek(pos, SeekOrigin.Begin);
byte[] reqarg = new byte[len];
Array.Copy(buffer, reqarg, len);
RequestEventArgs argreq = new RequestEventArgs(client, server, reqarg);
this.raiseEvent(argreq);
b = server.Execute(clientinfo, buffer, len, ref stream);
available = client.Available;
}
catch (Exception ex)
{
byte[] request = stream.ToArray();
stream = new MemoryStream();
//NameValueCollection attr = new NameValueCollection();
//attr["剩余连接数"] = Convert.ToString(server.ClientList.Count);
//ExceptionManager.Publish(ex, attr);
ErrorRequestEventArgs argerr = new ErrorRequestEventArgs(client, server, request, ex);
this.raiseEvent(argerr);
if (ex is SocketException)
{
isopen = false;
break;
}
try { available = 0; isopen = client.Connected; available = isopen ? client.Available : 0; }
catch { isopen = false; }
continue;
}
//响应结果写入缓存,触发同步事件写入响应
if (null != b && b.Length > 0)
{
Monitor.Enter(clientinfo);
responseList.Add(b);
Monitor.PulseAll(clientinfo);
Monitor.Exit(clientinfo);
}
}//while (available > 0)
while(available < 1)
{
Thread.Sleep(10);
try
{
isopen = client.Connected;
available = isopen ? client.Available : 0;
if (!isopen) break;
}
catch
{
available = 0;
isopen = false;
break;
}
}
if (!isopen)
{
server.Close(clientinfo);
return;
}
}//while (true)
}
