public override void Dispose() { lockResetEvent?.Close(); connectionResetEvent?.Close(); base.Dispose(); }
/// <summary> /// Stop serial handler /// </summary> /// <returns></returns> public bool Stop() { _runingEvent?.Reset(); if (_thrdRead != null && _thrdRead.IsAlive) { _thrdRead.Join(); _thrdRead = null; } if (_thrdHandle != null && _thrdRead.IsAlive) { _thrdHandle.Join(); _thrdHandle = null; } if (this._serialPort != null && this._serialPort.IsOpen) { this._serialPort.Close(); } _cmdResponseReset?.Close(); _cmdResponseReset = null; _runingEvent?.Close(); _runingEvent = null; _quCmdRespone?.Clear(); _quCmdRespone = null; _quReceiveBuff?.Clear(); _quReceiveBuff = null; return(true); }
protected virtual void Dispose(bool disposing) { if (disposing) { // dispose managed resources _autoResetEvent?.Close(); } // free native resources }
protected virtual void Dispose(bool disposing) { ReleaseUnmanagedResources(); if (disposing) { _autoEvent?.Dispose(); _autoEvent?.Close(); } }
public void Clear() { Socket?.Close(); Unpacker?.Clear(); _autoResetEvent?.Close(); ReadArgs = null; WriteArgs = null; Socket = null; }
public void Dispose() { #if NETSTANDARD2_0 _sendCompleted?.Dispose(); #endif #if NETFX _sendCompleted?.Close(); _sendThread?.Abort(); _sendThread = null; #endif _sendCompleted = null; }
public void CleanupForTimeOutSpecs() { if (_debugWriterSubscriptionService != null) { _debugWriterSubscriptionService.Unsubscribe(); _debugWriterSubscriptionService.Dispose(); } _resetEvt?.Close(); var environmentModel = _scenarioContext.Get <IServer>("server"); var resourceModel = _scenarioContext.Get <ResourceModel>("resourceModel"); environmentModel?.ResourceRepository?.DeleteResource(resourceModel); }
protected override void Dispose(bool disposing) { if (disposing) { eventObject?.WaitOne(); eventObject?.Close(); eventObject = null; wasapi.Dispose(); captureClient.Dispose(); } base.Dispose(disposing); }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing) { eventObject?.WaitOne(); eventObject?.Close(); eventObject = null; wasapi.Dispose(); renderClient.Dispose(); } }
protected virtual void Dispose(bool disposing) { if (_isDisposed) { return; } if (disposing) { Cache?.Dispose(); _cacheLock?.Close(); } _isDisposed = true; }
void CommandsManager_CommandWorker() { try { while (true) { if (CommandQueue.Count == 0) { CommandQueued.WaitOne(); } KeyValuePair <string, ThreadStart> todo; lock (CommandQueue) { if (CommandQueue.Count == 0) { continue; } todo = CommandQueue.Dequeue(); } try { todo.Value(); } catch (ThreadAbortException) { break; } catch (Exception ex) { instance.TabConsole.DisplayNotificationInChat( string.Format("Command error: {0} \n{1} {2} ", todo.Key, ex.Message, ex.StackTrace)); } } } finally { CommandQueue.Clear(); try { CommandQueued?.Close(); } catch (Exception) { } } }
protected virtual void Dispose(bool disposing) { Debug.WriteLine("DISPOSE"); if (_disposed) { return; } if (disposing) { _mediaPlayer?.Dispose(); _libVLC?.Dispose(); _imageData?.Free(); _stopped?.Close(); } // Free any unmanaged objects here. // _disposed = true; }
void DoWatch(object parameter) { AutoResetEvent exitEvent = (AutoResetEvent)parameter; try { using (GroupPolicyNotificationRegistration registration = registrationBuilder.CreateRegistration()) { AutoResetEvent[] policyEvents = new AutoResetEvent[] { exitEvent, registration.MachinePolicyEvent, registration.UserPolicyEvent }; bool listening = true; while (listening) { int result = WaitHandle.WaitAny(policyEvents); // 0 == exit, 1 == machine, 2 == user if (result != 0) { // notification from policy handles, not from exit // fire the change notification mechanism if (GroupPolicyUpdated != null) { GroupPolicyUpdated(result == 1); } } else { // notification from exit listening = false; } } } } finally { // release the thread's exit event. exitEvent.Close(); } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public virtual void Dispose() { object exit = Interlocked.Exchange(ref _sync, null); if (_event != null) { _event.Close(); } if (exit == null) { return; } using (new SafeLock <InvalidOperationException>(exit, 0)) { if (_readersCount > 0) { throw new InvalidOperationException(); } } }
protected override void DoWaitForCompleteStop() { s_Servers.Unregister(this); if (m_AcceptThread != null) { m_AcceptThread.Join(); m_AcceptThread = null; } if (m_InstrumentationThread != null) { m_InstrumentationThread.Join(); m_InstrumentationThread = null; m_InstrumentationThreadWaiter.Close(); } closeListener(); try { m_Dispatcher.WaitForCompleteStop(); if (m_Gate != null) { if (m_Gate is Service) { ((Service)m_Gate).WaitForCompleteStop(); } } } finally { m_AcceptSemaphore.Dispose(); m_AcceptSemaphore = null; m_WorkSemaphore.Dispose(); m_WorkSemaphore = null; } }
private void Free( ) { if (imageProcessingThread != null) { nestedVideoSource.NewFrame -= new NewFrameEventHandler(nestedVideoSource_NewFrame); // make sure processing thread does nothing isProcessingThreadAvailable.WaitOne( ); // signal worker thread to stop and wait for it lastVideoFrame = null; isNewFrameAvailable.Set( ); imageProcessingThread.Join( ); imageProcessingThread = null; // release events isNewFrameAvailable.Close( ); isNewFrameAvailable = null; isProcessingThreadAvailable.Close( ); isProcessingThreadAvailable = null; } }
public bool HandleKey(Atk.KeyEventStruct evnt) { if (KeyListenerList.Count == 0) { return(false); } foreach (KeyValuePair <uint, KeyListenerInfo> kvp in KeyListenerList) { int result = 0; AutoResetEvent sync = GLibHacks.Invoke(delegate(object sender, EventArgs args) { result = kvp.Value.listener(evnt); }); sync.WaitOne(); sync.Close(); sync = null; if (result != 0) { return(true); } } return(false); }
protected virtual void Dispose(bool disposing) { if (!disposed) { if (disposing) { if (autoEvent != null) { timer.Stop(); autoEvent.WaitOne(); timer.Dispose(); timer = null; autoEvent.Close(); autoEvent = null; } } disposed = true; } }
private void _BufferPopulationThread() { IsRunning = true; IEnumerator <IEffectNode> dataEnumerator = EffectNodeSource.GetEnumerator(); try { while (IsRunning) { while (_IsBufferInadequate() && IsRunning && dataEnumerator.MoveNext()) { _AddToQueue(dataEnumerator.Current); } _bufferReadSignal.WaitOne(); } } finally { dataEnumerator.Dispose(); _bufferReadSignal.Close(); _bufferReadSignal.Dispose(); } }
/// <summary> /// Closes the broker. All pending <see cref="Dequeue" /> /// calls will return <c>null</c>. /// </summary> public void Close() { lock (syncLock) { if (!isOpen) { return; } queue = null; isOpen = false; if (cDequeue == 0) { wait.Close(); } else { wait.Set(); } } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { lock (this) { if (!Disposed) { Disposed = true; GC.SuppressFinalize(this); _onDelayEventEndHandler = null; Stop(); _autoEventBegin?.Close(); _autoEventBegin?.Dispose(); _autoEventBegin = null; _autoEventEnd?.Close(); _autoEventEnd?.Dispose(); _autoEventEnd = null; } } }
protected override void Dispose(bool disposing) { if (disposing) { HTTPManager.Logger.Information("UploadStream", string.Format("{0} - Dispose", this.Name)); ReadBuffer.Dispose(); ReadBuffer = null; WriteBuffer.Dispose(); WriteBuffer = null; #if NETFX_CORE ARE.Dispose(); #else ARE.Close(); #endif ARE = null; } base.Dispose(disposing); }
/** Atomically interact with the RE, return true if it was closed BEFORE * @param set if true, try to Set the RE * @param close if true, try to Close the RE * @return true if the RE was already closed. * both arguments should not be true */ private bool SetOrCloseRE(bool set, bool close) { lock ( _re_sync ) { if (_re == null) { return(true); } //Looks like we can actually try to work now: if (set) { //This is the more common case, so put it first _re.Set(); } else if (close) { _re.Close(); _re = null; } } //If we got here, it wasn't already closed return(false); }
public void Dispose() { try { if (m_Header.lpData != IntPtr.Zero) { WaveNative.waveInUnprepareHeader(m_WaveIn, ref m_Header, Marshal.SizeOf(m_Header)); m_HeaderHandle.Free(); m_Header.lpData = IntPtr.Zero; } m_RecordEvent.Close(); if (m_HeaderDataHandle.IsAllocated) { m_HeaderDataHandle.Free(); } GC.SuppressFinalize(this); } catch (Exception ex) { LogManage.WriteLog(this.GetType(), ex); } }
public void Kill() { //Kill is called on client thread - must use cached thread object Debug.Assert(m_ThreadObj != null); if (m_ThreadObj.IsAlive == false) { return; } EndLoop = true; m_ItemAdded.Set(); //Wait for thread to die m_ThreadObj.Join(); if (m_EndLoopMutex != null) { m_EndLoopMutex.Close(); } if (m_ItemAdded != null) { m_ItemAdded.Close(); } }
public void Dispose(WebSocketCloseStatus status, string errorMessage) { if (disposedFlag.Set()) { switch (webSocket.State) { case WebSocketState.Connecting: case WebSocketState.Open: case WebSocketState.CloseReceived: MiscHelpers.Try(() => webSocket.CloseOutputAsync(status, errorMessage, CancellationToken.None)); break; } var tempQueueWaitHandle = queueWaitHandle; if (tempQueueWaitHandle != null) { tempQueueWaitHandle.Unregister(null); } queueEvent.Close(); } }
public static TimedRunnerResult <TR> RunWithTimeout <TR>(Func <TR> proc, TimeSpan timeout) { using (var waitHandle = new AutoResetEvent(false)) { var ret = default(TR); var thread = new Thread(() => { ret = proc(); waitHandle.Set(); }) { IsBackground = true }; thread.Start(); var timedOut = !waitHandle.WaitOne(timeout, false); waitHandle.Close(); if (timedOut) { try { thread.Abort(); } catch { } return(new TimedRunnerResult <TR> { Result = default(TR), IsTimedOut = true }); } return(new TimedRunnerResult <TR> { Result = ret, IsTimedOut = false }); } }
public void NotifyAsync_ShouldSetRequestStatusToSuccessOnlyIfStatusCodeCreated(bool isStatusCodeCreated) { var config = new AirbrakeConfig { ProjectId = "127348", ProjectKey = "e2046ca6e4e9214b24ad252e3c99a0f6" }; using (var requestHandler = new FakeHttpRequestHandler()) { requestHandler.HttpResponse.StatusCode = isStatusCodeCreated ? HttpStatusCode.Created : HttpStatusCode.BadRequest; requestHandler.HttpResponse.ResponseJson = "{\"Id\":\"12345\",\"Url\":\"https://airbrake.io/\"}"; var notifier = new AirbrakeNotifier(config, new FakeLogger(), requestHandler); var resetEvent = new AutoResetEvent(false); AirbrakeResponse airbrakeResponse = null; notifier.NotifyCompleted += (sender, eventArgs) => { airbrakeResponse = eventArgs.Result; resetEvent.Set(); }; notifier.NotifyAsync(new Exception()); Assert.Equal(resetEvent.WaitOne(2000), true); resetEvent.Close(); if (isStatusCodeCreated) { Assert.True(airbrakeResponse.Status == RequestStatus.Success); } else { Assert.True(airbrakeResponse.Status == RequestStatus.RequestError); } } }
/// <summary>准备好定时器列表</summary> /// <returns></returns> static TimerX[] Prepare() { if (timers == null || timers.Count < 1) { // 没有计时器,设置一个较大的休眠时间 //period = 60000; // 使用事件量来控制线程 if (waitForTimer != null) { waitForTimer.Close(); } waitForTimer = new AutoResetEvent(false); waitForTimer.WaitOne(Timeout.Infinite, false); } lock (timers) { return(timers.ToArray()); } }
public void Dispose() { try { Close(); } catch { } if (!IsDisposed()) { Marshal.ReleaseComObject(m_pReader); m_pReader = null; m_pHeaderInfo = null; } if (IntPtr.Zero != m_hWaveOut) { waveOut.Close(m_hWaveOut); // Ignore return m_hWaveOut = IntPtr.Zero; } if (IntPtr.Zero != m_hMixer) { Mixer.Close(m_hMixer); m_hMixer = IntPtr.Zero; } if (null != m_hAsyncEvent) { m_hAsyncEvent.Close(); m_hAsyncEvent = null; } m_pWfx = null; #if SUPPORT_DRM objDRM.Dispose(); m_pwszURL = null; #endif }