protected virtual void Dispose(bool disposing) { if (!IsDisposed) { Stop(); // Protect against recursion (eg linked disposables could create a cycle) _startableState = StartableState.Disposed; if (disposing) { // Dispose all the linked disposables foreach (var disposable in _linkedDisposables) { if (disposable != null) { try { disposable.Dispose(); } catch (ObjectDisposedException) {} // No need to log this catch (Exception exception) { var tracer = SetupTracerFactory.TracerFor(this); tracer.Error(exception, "Exception while disposing " + disposable + "."); } } } _linkedDisposables.Clear(); } } }
/// @inheritdoc public virtual void Start() { lock (this) { if (IsStarted || (_startableState == StartableState.Starting)) { // Do nothing if already started or starting. return; } if (_startableState >= StartableState.Disposing) { // Do nothing if already started. throw new ObjectDisposedException(this.ToString(), "Cannot be started; state is: " + _startableState); } if (!ReadyToStart) { throw new LogJamStartException(this + " cannot be started; state is: " + _startableState, this); } _startableState = StartableState.Starting; } try { InternalStart(); _startableState = StartableState.Started; } catch (LogJamStartException) { _startableState = StartableState.FailedToStart; throw; } catch (Exception exception) { _startableState = StartableState.FailedToStart; throw new LogJamStartException("Exception starting " + this, exception, this); } }
public void Stop() { lock (this) { var thread = _thread; if (thread != null) { _startableState = StartableState.Stopping; thread.Join(); } _startableState = StartableState.Stopped; } }
private void Run() { computationInfo.IsActive = true; State = StartableState.Running; try { var results = new List <GymResult <Exercisetype, Resulttype> >(); double runs = athlitis.Count * dataset.Count; computationInfo.Length = 1.0 / runs; double counter = 0; foreach (var athlit in athlitis) { athlit.ComputationInfo = ComputationInfo; var res = new GymResult <Exercisetype, Resulttype>(); res.Athlete = athlit; results.Add(res); foreach (var exercise in dataset) { if (State == StartableState.CancelRequested) { PublishResults.Enter(results); computationInfo.IsActive = false; State = StartableState.Online; return; } var startTime = DateTime.Now; var result = athlit.execute(exercise, ResultEvaluation); result.StartTime = startTime; result.EndTime = DateTime.Now; result.Challenge = exercise; res.ExerciseResults.Add(result); counter++; computationInfo.From = counter / runs; } } PublishResults.Enter(results); } catch (Exception e) { Log.Error(e); } finally { computationInfo.IsActive = false; State = StartableState.Online; } }
/// <summary> /// Stops this instance; closes all disposables. /// </summary> public void Stop() { if (IsStopped || (_startableState == StartableState.Unstarted) || (_startableState == StartableState.Stopping)) { return; } var tracer = SetupTracerFactory.TracerFor(this); string className = GetType().Name; tracer.Info("Stopping " + className + "..."); try { _startableState = StartableState.Stopping; InternalStop(); _startableState = StartableState.Stopped; } catch (Exception stopException) { _startException = stopException; tracer.Error(stopException, "Stop failed: Exception occurred."); _startableState = StartableState.FailedToStop; } foreach (var disposableRef in _disposeOnStop) { IDisposable disposable = disposableRef.Target as IDisposable; if (disposable != null) { try { disposable.Dispose(); } catch (ObjectDisposedException) {} // No need to log this catch (Exception exception) { tracer.Error(exception, "Exception while disposing " + disposable + "."); } } } _disposeOnStop.Clear(); tracer.Info(className + " stopped."); }
public void Start() { lock (this) { if (IsStarted) { return; } Debug.Assert(!IsThreadRunning); _startableState = StartableState.Starting; _thread = new Thread(BackgroundThreadProc) { Name = "BackgroundMultiLogWriter.BackgroundThread" }; _thread.Start(); } }
private void checkState() { if (State == StartableState.Running) { return; } var at = (athlitis.NotNullOrEmpty()); var ex = dataset.NotNullOrEmpty(); var res = ResultEvaluation != null; if (at && ex && res) { State = StartableState.Online; } else { State = StartableState.Offline; } }
/// @inheritdoc public void Stop() { lock (this) { if (!IsStarted) { return; } _startableState = StartableState.Stopping; } try { InternalStop(); _startableState = StartableState.Stopped; } catch (Exception exception) { _startableState = StartableState.FailedToStop; throw new LogJamException("Exception stopping " + this, exception, this); } }
/// <summary> /// Starts the manager whether or not <c>Start()</c> has already been called. /// </summary> /// <remarks>To avoid starting more than once, use <see cref="EnsureAutoStarted" />.</remarks> public void Start() { var tracer = SetupTracerFactory.TracerFor(this); string className = GetType().Name; if (IsDisposed) { tracer.Error(className + " cannot be started; it has been Dispose()ed."); return; } var state = _startableState; if ((state == StartableState.Starting) || (state == StartableState.Stopping)) { tracer.Error(className + " cannot be started; state is: " + state); return; } tracer.Debug("Starting " + className + "..."); lock (this) { try { _startableState = StartableState.Starting; InternalStart(); _startableState = StartableState.Started; tracer.Info(className + " started."); } catch (Exception startException) { _startException = startException; tracer.Error(startException, "Start failed: Exception occurred."); _startableState = StartableState.FailedToStart; } } }
/// <summary> /// ThreadProc for the background thread. At any one time, there should be 0 or 1 background threads for each /// <see cref="BackgroundMultiLogWriter" /> /// instance. /// </summary> private void BackgroundThreadProc() { _startableState = StartableState.Started; _tracer.Info("Started background thread."); SpinWait spinWait = new SpinWait(); while (true) { Action action; if (_backgroundActionQueue.TryDequeue(out action)) { try { action(); } catch (Exception excp) { _tracer.Error(excp, "Exception caught in background thread."); } spinWait.Reset(); } else if (spinWait.NextSpinWillYield && _startableState == StartableState.Stopping) { // No queued actions, and logwriter is stopped: Time to exit the background thread break; } else { spinWait.SpinOnce(); } } _tracer.Info("Exiting background thread."); _thread = null; }
protected Startable() { _startableState = StartableState.Unstarted; }
public void Stop() { State = StartableState.CancelRequested; }