private TraceError ( |
||
ex | ||
message | string | |
reportIt | bool | |
filePath | [ | |
lineNumber | [ | |
method | [ | |
리턴 | void |
//------------------------------------------------------------------------------------------------------------------------ #endregion #region Constructors //------------------------------------------------------------------------------------------------------------------------ static TypeCache() { #if NETFX //add entry assembly var EntryAssembly = Assembly.GetEntryAssembly(); if (EntryAssembly != null) { EntryAssemblies.Add(EntryAssembly); } //Add as many assemblies as we can //add from stack try { var frameAssemblies = new System.Diagnostics.StackTrace().GetFrames().Select(t => t.GetMethod().Module.Assembly).ToHashSet(); foreach (var entry in frameAssemblies) { EntryAssemblies.Add(entry); } } catch (Exception ex) { DebugEx.TraceError(ex, "Unhandled exception during Stack Frame assembly examination"); } //add from domain try { EntryAssemblies.AddFromSource(AppDomain.CurrentDomain.GetAssemblies()); } catch (Exception ex) { DebugEx.TraceError(ex, "Unhandled exception during AppDomain assembly examination"); } #elif UNIVERSAL EntryAssemblies.Add(Windows.UI.Xaml.Application.Current.GetType().GetTypeInfo().Assembly); #endif }
//------------------------------------------------------------------------------------------------------------------------ public void Dispose() { if (_IsDisposed) { return; } //dispose try { lock (locker) { if (_IsDisposed) { return; } else { _IsDisposed = true; } //stop it if (isRunning) { Stop(); } } } catch (Exception ex) { DebugEx.TraceError(ex, "FutureCallbackQueue dispose failed"); } }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing && !LeaveOpen) { GC.SuppressFinalize(this); try { BaseStream.Dispose(); } catch (Exception ex) { DebugEx.TraceError(ex, "Exception while closing underlying stream", reportIt: false); } } }
//------------------------------------------------------------------------------------------------------------------------ #if NETFX public override void Close() { base.Close(); if (!LeaveOpen) { try { BaseStream.Close(); BaseStream.Dispose(); } catch (Exception ex) { DebugEx.TraceError(ex, "Exception while closing underlying stream", reportIt: false); } } }
//------------------------------------------------------------------------------------------------------------------------ public virtual bool SendResponse(T wrapper_msg, object response, int syncId) { if (wrapper_msg == null || response == null) { return(false); } try { wrapper_msg.IsResponse = true; wrapper_msg.SyncId = syncId; wrapper_msg.Payload = response.ToJSON(); return(PublishFunc?.Invoke(wrapper_msg, response) == true); } catch (Exception ex) { DebugEx.TraceError(ex, "Could not send MsgSync response message"); return(false); } }
//------------------------------------------------------------------------------------------------------------------------ public void Stop() { try { #if UNIVERSAL Task _heartbeat = null; #else Thread _heartbeat = null; #endif lock (RequestQueue) { if (!_IsAlive) { return; } _IsAlive = false; RequestQueue.Clear(); Monitor.Pulse(RequestQueue); //wait for heartbeat stop _heartbeat = heartbeat; heartbeat = null; } try { //wait for finish if (_heartbeat != null) { #if UNIVERSAL _heartbeat.Wait(5000); #else _heartbeat.Join(5000); #endif } } catch { } } catch (Exception ex) { DebugEx.TraceError(ex, "Unhandled exception in RQC Stop()"); } }
//------------------------------------------------------------------------------------------------------------------------ public bool OnMessageReceived(T wrapper_msg, object payload) { //check if this is a response, in which case unblock pending request if (wrapper_msg.IsResponse) { int syncId = wrapper_msg.SyncId; DebugEx.Assert(syncId != 0, "IsResponse flag without valid syncId not allowed"); if (syncId == 0) { return(false); } DebugEx.TraceLog("MsgSync: got " + payload.GetType() + ", syncid: " + wrapper_msg.SyncId); //find waiter RpcWaiter w = null; lock (RpcPending) if (RpcPending.TryGetValue(syncId, out w)) { RpcPending.Remove(syncId); } //remove if found //set result and wake if (w != null) { lock (w) { w.Response = payload; Monitor.Pulse(w); return(true); } } else { DebugEx.TraceError("Could not find MsgSync waiter from " + payload.GetType() + " with syncId=" + syncId); } } return(false); }
//------------------------------------------------------------------------------------------------------------------------ #endregion #region Functions //------------------------------------------------------------------------------------------------------------------------ void HeartBeatEntryPoint() { try { //declares TimeSpan?timeout = null; //spin while (isRunning) { lock (locker) { //check pending requests.. if none the sleep the good sleep if (RequestQueue.Count == 0) { timeout = TimeSpan.MaxValue; //infinite } else { //get first pending request (has smallest wake timestamp) var req = RequestQueue.First(); //get remaining time var rem = req.WakeupTimestamp - DateTime.UtcNow; if (rem.TotalMilliseconds > 0.5d) { timeout = rem; } else { //consume event RequestQueue.Dequeue(); RequestLookup.Remove(req.RequestID); //callback if (req.AsyncCallback) { Task.Run(() => { try { //fire event if (req.Callback != null) { req.Callback(req.UserData); } else if (req.WeakCallback != null) { req.WeakCallback.Invoke(req.UserData); } else { DebugEx.Assert("FutureCallbackQueue reqId:" + req.RequestID + " has no callback to invoke"); } } catch (Exception ex) { DebugEx.Assert(ex, "Unhandled exception in callback caught by FutureCallbackQueue"); } }); } else { //exit lock to fire event Monitor.Exit(locker); try { //fire event if (req.Callback != null) { req.Callback(req.UserData); } else if (req.WeakCallback != null) { req.WeakCallback.Invoke(req.UserData); } else { DebugEx.Assert("FutureCallbackQueue reqId:" + req.RequestID + " has no callback to invoke"); } } catch (Exception ex) { DebugEx.Assert(ex, "Unhandled exception in callback caught by FutureCallbackQueue"); } finally { Monitor.Enter(locker); } } //no timeout..keep spinning timeout = null; } } //sleep/wait manager if (timeout.HasValue) { int _clampedTimeout = (int)timeout.Value.TotalMilliseconds.ClampCeil(MaxSleepMilisecondsD); Monitor.Wait(locker, _clampedTimeout); if (!isRunning) { break; } } } } } catch (Exception ex) { DebugEx.TraceError(ex, "FutureCallbackQueue heartbeat failed"); } }