/// <summary> /// Send an Object /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="obj">Object</param> /// <param name="callback">Post-Send callback</param> public void SendObject <T>(T obj, Action callback = null) { SendPackage(new TcpBsonPackage { Type = TcpBsonPackageType.Bson, DataType = GetDataType(typeof(T)), DataBytes = BsonConvert.SerializeObject(obj), Callback = callback }); }
private void DoReceiveBson(TcpBsonPackage package) { var dataType = Type.GetType(package.DataType); lock (mJsonHandlers) { foreach (var handler in mJsonHandlers) { if (handler.Type == dataType) { handler.Callback.DynamicInvoke(BsonConvert.DeserializeObject(package.DataBytes, dataType), this); } } } }
private void DoReceiveRequest(TcpBsonPackage package) { var requestType = Type.GetType(package.DataType); var dataType = typeof(TcpBsonRequest <>).MakeGenericType(requestType); var requestBody = BsonConvert.DeserializeObject(package.DataBytes, dataType) as TcpBsonRequest; var handler = mReceiveRequestCallbacks.FirstOrDefault(c => c.URI.Equals(requestBody.URI, StringComparison.OrdinalIgnoreCase) && (c.RequestType == requestType || c.RequestType.IsAssignableFrom(requestType))); var responsePackage = new TcpBsonPackage { Type = TcpBsonPackageType.Response }; object responseBody = null; if (handler == null) { responseBody = new TcpBsonResponse <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(TcpBsonResponse <>).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 TcpBsonResponse <string> { Id = requestBody.Id, Object = "Handle Exception - " + e.ToString() }; responsePackage.DataType = "ERROR"; } finally { responsePackage.DataBytes = BsonConvert.SerializeObject(responseBody); SendPackage(responsePackage); } }
internal void Sync(TcpBsonPackage package) { var sync = BsonConvert.DeserializeObject <TcpBsonCookieSync>(package.DataBytes); lock (this) { switch (sync.Action) { case TcpBsonCookieSyncAction.Clear: mCookies.Clear(); break; case TcpBsonCookieSyncAction.Add: case TcpBsonCookieSyncAction.Update: mCookies[sync.Name] = sync.Value; break; case TcpBsonCookieSyncAction.Remove: mCookies.Remove(sync.Name); break; } } }
private void DoReceiveResponse(TcpBsonPackage package) { if (package.DataType == "ERROR") { var errorResponse = BsonConvert.DeserializeObject <TcpBsonResponse <string> >(package.DataBytes); var responseCxt = mWaitResponseContexts.FirstOrDefault(r => r.Id == errorResponse.Id); if (responseCxt != null) { responseCxt.SetError(errorResponse.Object); } } else { var responseType = typeof(TcpBsonResponse <>).MakeGenericType(Type.GetType(package.DataType)); var responseBody = BsonConvert.DeserializeObject(package.DataBytes, 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)); } } }
/// <summary> /// Sync Send an Request and wait Response /// </summary> /// <typeparam name="TRequest">Response Object Type</typeparam> /// <param name="uri">A request uri</param> /// <param name="obj">Request object</param> /// <param name="millisecondsTimeout">Response timeout milliseconds, Default is one Minute.</param> /// <returns>Response object</returns> public object SendRequest <TRequest>(string uri, TRequest obj, int millisecondsTimeout = 60000) { var data = new TcpBsonRequest <TRequest> { Id = Guid.NewGuid(), URI = uri, Object = obj }; TcpBsonRequestContext cxt = new TcpBsonRequestContext(this, data.Id); SendPackage(new TcpBsonPackage { Type = TcpBsonPackageType.Request, DataType = typeof(TRequest).AssemblyQualifiedName, DataBytes = BsonConvert.SerializeObject(data) }); mWaitResponseContexts.Add(cxt); try { if (cxt.WaitHandler.WaitOne(millisecondsTimeout)) { if (cxt.IsError) { throw new Exception(cxt.ErrorMessage); } return(cxt.Response); } else { throw new TimeoutException("Response is Timeout!"); } } finally { mWaitResponseContexts.Remove(cxt); } }
/// <summary> /// End a init, This will restore cookie sync. /// </summary> public void EndInit() { mInInitMode = false; if (mInitSyncs.Any()) { lock (mInitSyncs) { foreach (var sync in mInitSyncs) { mClient.SendPackage(new TcpBsonPackage { Type = TcpBsonPackageType.CookieSync, DataType = typeof(TcpBsonCookieSync).AssemblyQualifiedName, DataBytes = BsonConvert.SerializeObject(sync) }); } mInitSyncs.Clear(); } } }
private void SendSync(TcpBsonCookieSync sync) { if (mInInitMode) { lock (mInitSyncs) { mInitSyncs.Add(sync); } } else { mClient.SendPackage(new TcpBsonPackage { Type = TcpBsonPackageType.CookieSync, DataType = typeof(TcpBsonCookieSync).AssemblyQualifiedName, DataBytes = BsonConvert.SerializeObject(sync) }); } }