private void SendPackageInner(NetworkStream stream, TcpJsonPackage tcpJsonPackage)
{
var buffer = tcpJsonPackage.ToBytes();
stream.Write(buffer, 0, buffer.Length);
stream.Flush();
tcpJsonPackage.Callback?.Invoke();
}
private void DoReceiveJson(TcpJsonPackage package)
{
var dataType = Type.GetType(package.DataType);
lock (mJsonHandlers)
{
foreach (var handler in mJsonHandlers)
{
if (handler.Type == dataType)
{
handler.Callback.DynamicInvoke(JsonConvert.DeserializeObject(package.Data, dataType), this);
}
}
}
}
internal void FlushNamedStream(TcpJsonNamedStream tcpJsonNamedStream)
{
var buffer = tcpJsonNamedStream.GetWriteCacheAndClear();
if (buffer.Length > 0)
{
var package = new TcpJsonPackage
{
Type = TcpJsonPackageType.NamedStream,
DataType = tcpJsonNamedStream.Name,
DataBytes = buffer
};
SendPackage(package);
}
}
private void DoReceiveRequest(TcpJsonPackage package)
{
var requestType = Type.GetType(package.DataType);
var dataType = typeof(TcpJsonRequest <>).MakeGenericType(requestType);
var requestBody = JsonConvert.DeserializeObject(package.Data, dataType) as TcpJsonRequest;
var handler = mReceiveRequestCallbacks.FirstOrDefault(c => c.URI.Equals(requestBody.URI, StringComparison.OrdinalIgnoreCase) && (c.RequestType == requestType || c.RequestType.IsAssignableFrom(requestType)));
var responsePackage = new TcpJsonPackage {
Type = TcpJsonPackageType.Response
};
object responseBody = null;
if (handler == null)
{
responseBody = new TcpJsonResponse <string> {
Id = requestBody.Id, Object = "No handle this request"
};
responsePackage.DataType = "ERROR";
return;
}
try
{
var response = handler.Callback.DynamicInvoke(requestBody.Object, this);
var responseDataType = response != null?response.GetType() : handler.ResponseType;
var responseType = typeof(TcpJsonResponse <>).MakeGenericType(responseDataType);
var responseData = responseType.GetConstructor(Type.EmptyTypes).Invoke(null);
responseType.GetProperty("Id").SetValue(responseData, requestBody.Id, null);
responseType.GetProperty("Object").SetValue(responseData, response, null);
responsePackage.DataType = responseDataType.AssemblyQualifiedName;
responseBody = responseData;
}
catch (Exception e)
{
responseBody = new TcpJsonResponse <string> {
Id = requestBody.Id, Object = "Handle Exception - " + e.ToString()
};
responsePackage.DataType = "ERROR";
}
finally
{
responsePackage.Data = JsonConvert.SerializeObject(responseBody);
SendPackage(responsePackage);
}
}
private void Recive(TcpJsonPackage package)
{
switch (package.Type)
{
case TcpJsonPackageType.Command:
DoReceiveCommand(package.Data);
break;
case TcpJsonPackageType.Json:
DoReceiveJson(package);
break;
case TcpJsonPackageType.Ping:
DoPing();
break;
case TcpJsonPackageType.NamedStream:
DoReceiveNamedStream(package);
break;
case TcpJsonPackageType.Bytes:
DoReceiveBytes(package);
break;
case TcpJsonPackageType.Request:
DoReceiveRequest(package);
break;
case TcpJsonPackageType.Response:
DoReceiveResponse(package);
break;
case TcpJsonPackageType.CookieSync:
Cookies.Sync(package);
break;
default:
break;
}
}
private void TryReadPackages()
{
TryNext:
if (readCache.Length < 5)
{
return;
}
var buffer = readCache.ToArray();
var type = (TcpJsonPackageType)buffer[0];
var size = BitConverter.ToInt32(buffer, 1);
if (buffer.Length >= size + 5)
{
var bodyBuffer = new byte[size];
Array.Copy(buffer, 5, bodyBuffer, 0, size);
using (var reader = new BinaryReader(new MemoryStream(bodyBuffer)))
{
var package = new TcpJsonPackage();
package.Type = type;
package.DataType = reader.ReadString();
if (package.Type == TcpJsonPackageType.NamedStream || package.Type == TcpJsonPackageType.Bytes)
{
var byteSize = reader.ReadInt32();
package.DataBytes = reader.ReadBytes(byteSize);
}
else
{
package.Data = reader.ReadString();
}
Recive(package);
}
readCache = new MemoryStream();
if (buffer.Length > size + 5)
{
readCache.Write(buffer, size + 5, buffer.Length - size - 5);
readCache.Position = 0;
}
goto TryNext;
}
}
internal void Sync(TcpJsonPackage package)
{
var sync = JsonConvert.DeserializeObject <TcpJsonCookieSync>(package.Data);
lock (this)
{
switch (sync.Action)
{
case TcpJsonCookieSyncAction.Clear:
mCookies.Clear();
break;
case TcpJsonCookieSyncAction.Add:
case TcpJsonCookieSyncAction.Update:
mCookies[sync.Name] = sync.Value;
break;
case TcpJsonCookieSyncAction.Remove:
mCookies.Remove(sync.Name);
break;
}
}
}
private void DoReceiveResponse(TcpJsonPackage package)
{
if (package.DataType == "ERROR")
{
var errorResponse = JsonConvert.DeserializeObject <TcpJsonResponse <string> >(package.Data);
var responseCxt = mWaitResponseContexts.FirstOrDefault(r => r.Id == errorResponse.Id);
if (responseCxt != null)
{
responseCxt.SetError(errorResponse.Object);
}
}
else
{
var responseType = typeof(TcpJsonResponse <>).MakeGenericType(Type.GetType(package.DataType));
var responseBody = JsonConvert.DeserializeObject(package.Data, responseType);
var id = (Guid)responseType.GetProperty("Id").GetValue(responseBody, null);
var responseCxt = mWaitResponseContexts.FirstOrDefault(r => r.Id == id);
if (responseCxt != null)
{
responseCxt.SetResponse(responseType.GetProperty("Object").GetValue(responseBody, null));
}
}
}
internal void SendPackage(TcpJsonPackage package)
{
sendPackageQueue.Enqueue(package);
}
private void DoReceiveNamedStream(TcpJsonPackage package)
{
var namedStream = GetNamedStream(package.DataType);
namedStream.OnDataReceive(package.DataBytes);
}
private void DoReceiveBytes(TcpJsonPackage package)
{
mBytesHandlers.ForEach(callback => callback(package.DataBytes, this));
}
