/// <summary>
/// 重置eventhandler，这个函数相当危险，必须在ondata车callstack中调用
/// </summary>
/// <param name="handler"></param>
/// <returns></returns>
public bool ResetCientEventHandler(IClientEventHandler handler)
{
if (handler == null)
{
return(false);
}
m_clientEventHandler = handler;
return(true);
}
public TCPClient(string host, int port, IClientEventHandler eventHandler)
{
IPAddress ipv4Addresses = Array.Find(
Dns.GetHostEntry(string.Empty).AddressList,
a => a.AddressFamily == AddressFamily.InterNetwork);
IPHostEntry ipHostInfo = Dns.GetHostEntry(Config.Host);
_remoteEp = new IPEndPoint(ipv4Addresses, Config.Port);
_eventHandler = eventHandler;
}
// Token: 0x0600525C RID: 21084 RVA: 0x00186A2C File Offset: 0x00184C2C
public Client(IClientEventHandler handler, Func <Stream, Type, int, object> deserializeMessageAction = null)
{
if (handler == null)
{
throw new Exception("Client::Client, called failed, handler is null");
}
this.m_clientEventHandler = handler;
this.m_protoProvider = new LibClientProtoProvider();
this.m_messageDeserializeAction = deserializeMessageAction;
this.m_connect = new Connection(this.m_protoProvider, deserializeMessageAction);
}
/// <summary>
/// Construstor with
/// </summary>
/// <param name="eventHandler"></param>
/// <param name="clientConfig"></param>
/// <param name="loggerFactory"></param>
/// <param name="dataProcessorType"></param>
public TcpClientService(IClientEventHandler eventHandler,
ClientConfig clientConfig, ILoggerFactory loggerFactory,
EnumDataProcessorType dataProcessorType, Func <byte[], byte[]> getIdFunc = null)
{
_createDataProcessorFunc = CreateDataProcesorFunc(clientConfig, loggerFactory, dataProcessorType, getIdFunc);
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <TcpClientService>();
_clientConfig = clientConfig;
_eventHandler = eventHandler;
_dataSynchronizator = new DataSynchronizator <byte[]>(loggerFactory.CreateLogger <DataSynchronizator <byte[]> >());
_dataProcessor = _createDataProcessorFunc();
ManageAutoConnect();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dataProcessor"></param>
public TcpClientService(IClientEventHandler eventHandler,
ClientConfig clientConfig, ILoggerFactory loggerFactory,
Func <IDataProcessor> createDataProcessorFunc)
{
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <TcpClientService>();
_clientConfig = clientConfig;
_eventHandler = eventHandler;
_dataSynchronizator = new DataSynchronizator <byte[]>(loggerFactory.CreateLogger <DataSynchronizator <byte[]> >());
_dataProcessor = createDataProcessorFunc();
_createDataProcessorFunc = createDataProcessorFunc;
ManageAutoConnect();
}
public Server(string host, int port, IClientEventHandler clientHandler, IServerEventHandler severHandler)
{
_port = port;
_host = host; // ?? throw new NullReferenceException("host is null");
_clientHandler = clientHandler; // ?? throw new NullReferenceException("clientHandler is null");
_severHandler = severHandler;
IPAddress ipv4Addresses = Array.Find(
Dns.GetHostEntry(string.Empty).AddressList,
a => a.AddressFamily == AddressFamily.InterNetwork);
IPHostEntry ipHostInfo = Dns.GetHostEntry(host);
_localEndPoint = new IPEndPoint(ipv4Addresses, port);
_listener = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
}
/// <summary>
/// 发起对指定ip端口的连接，并返回client对象
/// </summary>
/// <returns>The client for sending message.</returns>
/// <param name="address">Address.</param>
/// <param name="port">Port.</param>
/// <param name="clientEventHandler">handler for receiving messages and exceptions.</param>
/// <param name="bufferSize">Buffer size.</param>
/// <param name="priority"></param>
public static Client ConnectTo(IPAddress address, int port, IClientEventHandler clientEventHandler,
int bufferSize = DefaultInputBufferSize, int priority = 1)
{
var tcpClient = new TcpClient();
// 进行连接
// 因为外面调用的时候，采用了同步方法，所以为了避免出现死锁问题，不用async方法 2016/3/17 ouyangxiong
tcpClient.Connect(address, port);
// 用得到的socket对象构造client
var client = new Client(tcpClient);
// 启动为client服务的task
// ClientWorkProc的执行线程，不能与SynchronizationContext的线程在同一个线程中，所以此处用Task.Run来执行，让系统线程池来执行
//Task.Run(() => { ClientWorkProc(client, clientEventHandler, bufferSize).Wait(); }); // todo:ouyang test
Task.Factory.StartNew(() => { ClientWorkProc(client, clientEventHandler, bufferSize).Wait(); }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskSchedulerHelper.TaskSchedulers[priority]);
if (client.Closed)
{
return(null);
}
return(client);
}
public Server(string host, int port, IClientEventHandler clientHandler) : this(host, port, clientHandler, null)
{
}
public ClientParser(IClientEventHandler splitter)
{
this.splitter = splitter;
}
// Token: 0x06005275 RID: 21109 RVA: 0x001873B0 File Offset: 0x001855B0
public static IClient CreateClient(IClientEventHandler handler, Func <Stream, Type, int, object> deserializeMessageAction = null)
{
return(new Client(handler, deserializeMessageAction));
}
/// <summary>
/// client的服务虚拟线程函数
/// </summary>
public static async Task ClientWorkProc(Client client, IClientEventHandler clientEventHandler,
int bufferSize)
{
//Socket socket = client.Socket;
var tcpClient = client.TcpClient;
var buffer = new byte[bufferSize];
int bytesLeft = 0;
List <Task> tasks;
IClientEventHandler tempHandler;
// 保存clientEventHandler
client.m_clientEventHandler = clientEventHandler;
try
{
var netStream = tcpClient.GetStream();
// 构造task数组，用来进行Task.WhenAny
tasks = new List <Task>
{
// 构造取消task
client.MakeCancelTask(),
// 构造消息队列task
client.m_localMessages.DequeueAsync(),
// 构造tcp关联task
netStream.ReadAsync(buffer, 0, buffer.Length, client.m_cancellationToken).IgnoreExceptions(),
};
while (!client.Closed)
{
Task completedTask;
bool disconnectOccured = false;
if (client.IsPause)
{
client.WaitResume();
}
try
{
// 在task数组上等待任意一个task返回
completedTask = await Task.WhenAny(tasks);
}
catch (IOException)
{
// 只有socket被关闭的时候才会出现这个exception
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
throw;
}
catch (ObjectDisposedException)
{
// tcpclient被释放也会产生这个异常
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
throw;
}
switch (tasks.IndexOf(completedTask))
{
case 2:
int byteReceived;
try
{
byteReceived = await(Task <int>) completedTask;
}
catch (IOException)
{
// 只有socket被关闭的时候才会出现这个exception
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
else
{
throw;
}
}
catch (ObjectDisposedException)
{
// tcpclient被释放也会产生这个异常
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
else
{
throw;
}
}
// Connection closed.
if (byteReceived == 0)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
int bytesHandled = 0;
if (!client.Disconnected)
{
bytesLeft += byteReceived;
// 取得锁进行回调
tempHandler = client.m_clientEventHandler;
using (await ContextLock.Create(tempHandler))
{
//将从网络得来的数据交给玩家现场处理
bytesHandled = await client.m_clientEventHandler.OnData(buffer, bytesLeft);
}
}
// 检查ondata返回的参数是否正确
if (bytesHandled < 0 || bytesHandled > bytesLeft)
{
// 如果ondata对数据的处理有问题，直接抛出异常
throw new ErrorOnDataResultException(bytesHandled, bytesLeft);
}
// 将消耗掉的数据移除
bytesLeft -= bytesHandled;
if (buffer.Length == bytesLeft)
{
// 如果ondata对数据的处理有问题，直接抛出异常
throw new ErrorOnDataResultException(bytesHandled, bytesLeft);
}
// If any data left, move ahead.
if (bytesLeft > 0)
{
Array.Copy(buffer, bytesHandled, buffer, 0, bytesLeft);
}
// 重新构造tcp关联task对象
try
{
tasks[2] = netStream.ReadAsync(buffer, bytesLeft, buffer.Length - bytesLeft,
client.m_cancellationToken).IgnoreExceptions();
}
catch (IOException)
{
// 只有socket被关闭的时候才会出现这个exception
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
throw;
}
catch (ObjectDisposedException)
{
// tcpclient被释放也会产生这个异常
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
goto LB_DISCONNECT;
}
throw;
}
break;
case 1:
{
// 继续从消息队列取新的消息
tasks[1] = client.m_localMessages.DequeueAsync();
var taskMessaging = (Task <ILocalMessage>)completedTask;
// 取得锁调用回调
tempHandler = client.m_clientEventHandler;
using (await ContextLock.Create(tempHandler)) //将玩家现场锁住 如果当前玩家现场正在处理消息就等着
{
//将本地消息丢到玩家现场处理
await client.m_clientEventHandler.OnMessage(taskMessaging.Result);
}
break;
}
case 0:
{
// cancel 发生了
// 如果没有调用过ondisconnect，调用一下
if (!client.m_onDisconnectedCalled)
{
disconnectOccured = true;
}
client.m_cancellationTokenSource = null;
if (!client.Closed)
{
tasks[0] = client.MakeCancelTask();
}
break;
}
}
LB_DISCONNECT:
// 处理断开连接
if (disconnectOccured && !client.m_onDisconnectedCalled)
{
client.m_onDisconnectedCalled = true;
// 获取锁调用回调
tempHandler = client.m_clientEventHandler;
using (await ContextLock.Create(tempHandler))
{
await client.m_clientEventHandler.OnDisconnected();
}
// 设置网络接收task为null，不再接受数据
tasks.RemoveAt(2);
}
} // end while (!client.Closed)
}
catch (Exception e)
{
if (!client.Closed)
{
tempHandler = client.m_clientEventHandler;
using (ContextLock.Create(tempHandler).Result)
{
client.m_clientEventHandler.OnException(e);
}
// 当有异常产生的时候，直接释放当前客户端，OnException将会是现场上的最后一次回调
client.Close();
}
}
}
public DiscordEventService(IClientEventHandler clientEventHandler, ICommandEventHandler commandEventHandler)
{
_clientEventHandler = clientEventHandler;
_commandEventHandler = commandEventHandler;
}
