public void EnqueueTest()
{
ThreadBridge.Enqueue(() =>
{
Console.WriteLine("EnqueueTest");
});
}
/// <summary>
/// 建構子
/// </summary>
/// <param name="socketPort"></param>
/// <param name="isKeepNewConnectionWhenOverLimit">是否保留新連線</param>
/// <param name="clientHeartBeatFrequency">客端心跳間隔</param>
/// <param name="clientSameIPLimitCount">同 IP 的最大連線數</param>
/// <param name="outputMessage">輸出訊息</param>
public ProxyServer(int socketPort, bool isKeepNewConnectionWhenOverLimit, int clientHeartBeatFrequency, int clientSameIPLimitCount, Action <string> outputMessage)
{
fOutputMessage = outputMessage;
fIsKeepNewConnectionWhenOverLimit = isKeepNewConnectionWhenOverLimit;
fClientHeartBeatFrequency = clientHeartBeatFrequency;
fClientSameIPLimitCount = clientSameIPLimitCount;
// Listener worker
fTcpListener = new TcpListener(IPAddress.Any, socketPort);
fToken = new CancellationTokenSource();
//事件處理
OnStatus = new ThreadEvent <string>();
OnData = new ThreadEvent <string>();
OnConnectionStatus = new ThreadEvent <ProxyClient>();
// 平行結構
fClientTmpQueue = new ThreadBridge <ProxyClient>();
fClientMoveQueue = new ThreadBridge <ProxyClient>();
fCastingMessage = new ThreadBridge <AckTask>();
// connection pool
fClientPool = new List <ProxyClient>();
//connection worker
fTaskListener = Task.Factory.StartNew(ListenerAsync, fToken.Token);
// boradcastor
fBroadcastor = Task.Factory.StartNew(BroadcastingAsync, fToken.Token);
}
public void thread(System.Func <object[], object> func, System.Func <object[], object> callback)
{
Thread t = new Thread(new ThreadStart(delegate { func(null);
ThreadBridge.Invoke((delegate { callback(null); })); Thread.CurrentThread.Abort(); }));
t.Start();
}
void PeerReceiveCallBack(IAsyncResult ar)
{
Socket _clientHander = (Socket)ar.AsyncState;
int byteLength = 0;
byte[] receivedData;
byteLength = _clientHander.EndReceive(ar);
receivedData = buffer;
buffer = null;
buffer = new byte[BufferSize];
if (byteLength > 0)
{
_clientHander.BeginReceive(
buffer,
0,
BufferSize,
SocketFlags.None,
new AsyncCallback(PeerReceiveCallBack),
_clientHander
);
}
else
{
socketHandler.Close();
if (OnDisconnected != null)
{
OnDisconnected(null);
}
return;
}
try
{
if (ResponseCallBack != null)
{
ThreadBridge.Invoke(() => { ResponseCallBack(token, receivedData); });
}
}
catch (Exception e)
{
Logger.LogError(e.Message + ":::" + e.StackTrace);
}
}
public void DequeueTest1()
{
ThreadBridge.Enqueue(() =>
{
Console.WriteLine("EnqueueTest1");
});
ThreadBridge.Enqueue(() =>
{
Console.WriteLine("EnqueueTest2");
});
//Dequeue all.
//ThreadBridge.Dequeue();
//Dequeue one.
ThreadBridge.Dequeue(1);
}
public static void Invoke(System.Action _delegate)
{
if (_instance == null)
{
var obj = FindObjectOfType <ThreadBridge>();
if (obj == null)
{
var _obj = new GameObject("Invoker", typeof(ThreadBridge));
_instance = _obj.GetComponent <ThreadBridge>();
}
else
{
_instance = obj;
}
}
_instance.delegates.Add(_delegate);
}
void BeginResponseCallBack(IAsyncResult ar)
{
UdpPeer peer = (UdpPeer)ar.AsyncState;
int rev = peer.serverSocket.EndReceiveFrom(ar, ref peer.remoteEndPoint);
if (rev > 0)
{
if (ResponseCallback != null)
{
ThreadBridge.Invoke(() => { ResponseCallback(peer.remoteEndPoint, peer.buffer); });
}
peer.ResetBuffer();
socketHandler.BeginReceiveFrom
(peer.buffer, 0, bufferSize, SocketFlags.None,
ref peer.remoteEndPoint, new AsyncCallback(BeginResponseCallBack), peer);
}
}
void ReceivedAsynCallBack(IAsyncResult ar)
{
Socket socketHandler = (Socket)ar.AsyncState;
int byteLength = socketHandler.EndReceive(ar);
if (byteLength > 0)
{
if (OnReceived != null)
{
ThreadBridge.Invoke(() => { OnReceived(buffer); });
}
}
socketHandler.BeginReceive(
buffer,
0,
BufferSize,
SocketFlags.None,
new AsyncCallback(ReceivedAsynCallBack),
socketHandler
);
}
void AcceptCallBack(IAsyncResult ar)
{
Socket ListenerHandler = (Socket)ar.AsyncState;
Socket ClientHandler = ListenerHandler.EndAccept(ar);
ListenerHandler.BeginAccept(new AsyncCallback(AcceptCallBack), ListenerHandler);
string token = Token.GenToken(randomFactor.Next(2, 32));
Token[token] = new TcpConnectedPeer(token, ClientHandler, OnClientReceived, this);
try
{
if (OnClientConnected != null)
{
ThreadBridge.Invoke(() => { OnClientConnected(Token[token].token); });
}
}
catch (Exception e)
{
Logger.LogError(e.Message + "Tcp Server AcceptCallBack:::::::\n" + e.StackTrace);
}
}
public void DequeueTest()
{
EnqueueTest();
ThreadBridge.Dequeue();
}
void Awake()
{
_instance = this;
}
public static void MainCall(Action action)
{
ThreadBridge.Invoke(action);
}
