/// <summary>
/// Stop all writing to this class.
/// Once stopped, it cannot be resumed.
/// All data is then immediately flushed to the output.
/// This method calls Dispose()
/// </summary>
/// <returns>the transaction number of the last point that written</returns>
public long Stop()
{
Log.Publish(MessageLevel.Info, "Stop() called", "Write is stopping");
lock (m_syncRoot)
{
m_stopped = true;
}
m_rolloverTask.Dispose(); //This method block until the worker runs one last time
Dispose();
return(m_latestTransactionId);
}
/// <summary>
/// Stop all writing to this class.
/// Once stopped, it cannot be resumed.
/// All data is then immediately flushed to the output.
/// This method calls Dispose()
/// </summary>
/// <returns></returns>
public long Stop()
{
Log.Publish(MessageLevel.Info, "Stop() called", "Write is stopping");
lock (m_syncRoot)
{
m_stopped = true;
}
m_rolloverTask.Dispose();
Dispose();
return(m_lastCommitedSequenceNumber);
}
/// <summary>
/// Attempts to disconnect from data input source.
/// </summary>
protected override void AttemptDisconnection()
{
if ((object)m_timer != null)
{
m_timer.Dispose();
m_timer = null;
}
if ((object)m_statusUpdate != null)
{
m_statusUpdate.Dispose();
m_statusUpdate = null;
}
}
public void Dispose_Success()
{
DateTimeOffset now = new DateTimeOffset(2013, 6, 1, 12, 0, 0, 0, TimeSpan.Zero);
DateTimeOffset now2 = new DateTimeOffset(2013, 6, 1, 12, 0, 1, 0, TimeSpan.Zero);
ScheduledTask <FailableScheduledAction> task = new ScheduledTask <FailableScheduledAction>(Schedule.CreateOneTime(now), new FailableScheduledAction(FailableScheduledAction.DummyAction.Run), true, now, now2);
task.Dispose();
CustomAssert.ThrowsException <ObjectDisposedException>(() =>
{
FailableScheduledAction action = task.Action;
});
task.Dispose();
}
public void Dispose()
{
m_disposing = true;
Thread.MemoryBarrier();
m_syncEvent.Dispose();
m_async.Dispose();
}
/// <summary>
/// Gracefully terminate all message routing. Function blocks until all termination is successful.
/// </summary>
public void Dispose()
{
if (m_disposing)
{
return;
}
lock (m_syncRoot)
{
//Ensure that setting disposing is in a synchronized context.
m_disposing = true;
}
//These scheduled tasks block when dispose is called. Therefore do not put these in a lock on the base class.
m_calculateRoutingTable.Dispose();
m_routingTask.Dispose();
lock (m_syncRoot)
{
m_allPublishers.Clear();
foreach (var sub in m_subscribers)
{
(sub.Target as LogSubscriberInternal)?.Dispose();
}
m_subscribers.Clear();
}
}
public void TestMethod1()
{
m_task = new ScheduledTask(ThreadingMode.DedicatedBackground, ThreadPriority.Highest);
m_task.Running += task_Running;
m_task.Start(10);
Thread.Sleep(1000);
m_task.Dispose();
System.Console.WriteLine("Disposed");
}
/// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
m_flushTask.Dispose();
lock (m_syncRoot)
{
if (m_writer != null)
{
string fileName = m_writer.FileName;
m_writer.Dispose();
m_writer = null;
OnNewFileComplete(fileName);
}
}
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="LogSourceBase"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
m_disposed = true;
if (disposing)
{
if (m_rolloverTask != null)
{
m_rolloverTask.Dispose();
}
m_rolloverTask = null;
}
}
base.Dispose(disposing);
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="LogSourceBase"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!m_disposed && disposing)
{
ReleaseClientResources();
m_processRemovals.Dispose();
m_listLog.Dispose();
lock (m_syncRoot)
{
foreach (ArchiveTableSummary <TKey, TValue> f in m_fileSummaries.Values)
{
f.SortedTreeTable.BaseFile.Dispose();
}
}
m_disposed = true;
}
base.Dispose(disposing);
}
public void IsTaskDue_False_Success()
{
ScheduledTask <FailableScheduledAction> task = new ScheduledTask <FailableScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now.AddMinutes(-1.0)), new FailableScheduledAction(FailableScheduledAction.DummyAction.ThrowException), true, null, null);
task.IsEnabled = false;
Assert.IsFalse(task.IsTaskDue);
task.IsEnabled = true;
task.IsScheduled = true;
Assert.IsFalse(task.IsTaskDue);
task.IsScheduled = false;
task.Dispose();
Assert.IsFalse(task.IsTaskDue);
task = new ScheduledTask <FailableScheduledAction>();
Assert.IsFalse(task.IsTaskDue);
}
public void Dispose()
{
m_worker.Dispose();
}