//private MultiThreadingProcessForm progressWindow = null;
///// <summary>
///// Show or hide the progress bar
///// </summary>
///// <param name="flag"></param>
//public void ShowProgress(bool flag)
//{
// if (flag)
// {
// progressWindow = new MultiThreadingProcessForm(this);
// progressWindow.ConfirmExit = true;
// StopEventHandler += delegate(object sender, EventArgs e)
// {
// ShowProgress(false);
// };
// progressWindow.Show();
// //this.workStatusEvent += new WorkStatusEventHandler(MultiThreadingManager_workStatusEvent);
// this.RaiseStatusInterval = 1;
// }
// else
// {
// progressWindow.ConfirmExit = false;
// progressWindow.Close();
// progressWindow.Dispose();
// }
//}
//void MultiThreadingManager_workStatusEvent(object sender, WorkStatusEventArgs e)
//{
// try
// {
// progressWindow.Percentage = e.Percentage;
// progressWindow.Detail = e.ToString();
// }
// catch (Exception ex)
// {
// Debug.WriteLine(ex.Message);
// throw;
// }
//}
#endregion ShowProgress Window
#region mtObjects Configuration
/// <summary>
/// add a MTObject-derived instance to the list.
/// </summary>
/// <param name="mtObject"></param>
public void Add(MultiThreadingBase <T, U> mtObject)
{
#region Sanity Checks
if (mtObject == null)
{
throw new ArgumentNullException("myObject");
}
if (this.mtObjects.Count >= MAX_THREADS)
{
throw new ArgumentOutOfRangeException("Maximum thread occurred");
}
if (this.mtObjects.Count > 0)
{
// for consistency purpose: all MultiThreading objects
// must be of the same type.
if (this.mtObjects[0].GetType() != mtObject.GetType())
{
throw new ArgumentException("All mtObjects must be of same type for consistency");
}
}
if (this.mtObjects.Contains(mtObject))
{
throw new ArgumentException("myObject already added.");
}
#endregion Sanity Checks
this.mtObjects.Add(mtObject);
}
/// <summary>
/// remove a MTObject-derived instance from the list.
/// </summary>
/// <param name="mtObject"></param>
public void Remove(MultiThreadingBase <T, U> mtObject)
{
#region Sanity Checks
if (mtObject == null)
{
throw new ArgumentNullException("myObject");
}
//// TODO: do i want to throw exception for object that does not exist?
//if (!this.mtObjects.Contains(mtObject))
// throw new ArgumentOutOfRangeException("mtObject not found");
#endregion Sanity Checks
if (this.mtObjects.Contains(mtObject))
{
this.mtObjects.Remove(mtObject);
}
}
/// <summary>
/// Create a number of given type
/// </summary>
/// <param name="numberThreads"></param>
/// <param name="type"></param>
/// <param name="args"></param>
public void InitializeThread(int numberThreads, Type type, params object[] args)
{
try
{
Clear();
for (int i = 0; i < numberThreads; i++)
{
MultiThreadingBase <T, U> mtObject = (MultiThreadingBase <T, U>)Activator.CreateInstance(type, args);
Add(mtObject);
}
}
catch (Exception ex)
{
DebuggerTool.AddData(ex, "numberThreads", numberThreads);
DebuggerTool.AddData(ex, "type", type.GetType());
DebuggerTool.AddData(ex, "args", args);
throw;
}
}
/// <summary>
/// TEST PURPOSE ONLY: start the process in a single thread and merge output.
/// </summary>
public void Start()
{
#region Sanity Checks
if ((this.mtObjects == null) || (this.mtObjects.Count == 0))
{
throw new ArgumentNullException("mtObjects is null or empty");
}
#endregion Sanity Checks
if (!inputDistributed)
{
DistributeInput();
//throw new ApplicationException("input not distributed.");
}
InitializeMTContainers();
RaiseMasterWorkStatus("Starting Process", THREADNAME, 0, 0);
DateTime start = DateTime.Now;
for (int i = 0; i < this.mtObjects.Count; i++)
{
string threadName = ThreadNamePrefix + i;
MultiThreadingBase <T, U> thread = this.mtObjects[i];
#if !SILVERLIGHT
Trace.WriteLine("Starting", "Start");
#endif
thread.Start();
#if !SILVERLIGHT
Trace.WriteLine("Completed", "Start");
#endif
MergeLog(thread);
}
RaiseMasterWorkStatus("Merging Output", THREADNAME, 0, 0);
MergeOutput();
elapsedTime = new TimeSpan(DateTime.Now.Ticks - start.Ticks);
RaiseMasterWorkStatus("Stopped", THREADNAME, 0, 0);
}
private void MergeLog(MultiThreadingBase <T, U> thread)
{
this.log.AddRange(thread.ErrorLog);
}
/// <summary>
/// start the process in multiple threads, wait for completion, and merge output.
/// </summary>
public void StartAsync()
{
// make local copy for thread-safe
List <MultiThreadingBase <T, U> > mtObjects = this.mtObjects;
DateTime start = DateTime.Now;
RaiseMasterWorkStatus("Task Start : " + start.ToString("s"), THREADNAME, 0, 100);
#region Sanity Checks
if ((mtObjects == null) || (mtObjects.Count == 0))
{
throw new ArgumentNullException("mtObjects is null or empty");
}
#endregion Sanity Checks
if (!inputDistributed)
{
DistributeInput();
}
InitializeMTContainers();
#region Start Threads
MultiThreadingBase <T, U>[] threads = new MultiThreadingBase <T, U> [mtObjects.Count];
try
{
for (int i = 0; i < mtObjects.Count; i++)
//for (int i = mtObjects.Count - 1; i >= 0; i--)
{
string threadName = ThreadNamePrefix + i;
threads[i] = mtObjects[i];
string s = String.Format("Starting thread {0} with {1} records.",
threadName,
mtObjects[i].InputList.Count);
RaiseMasterWorkStatus(s, THREADNAME, 0, 0);
#if !SILVERLIGHT
threads[i].StartAsync(threadName, ThreadPriority);
#else
threads[i].StartAsync(threadName);
#endif
}
WaitForProcess(WaitInterval);
MergeOutput();
}
catch (Exception ex)
{
Debug.WriteLine("Thread Execution Failed: " + ex.ToString());
// abort all threads
for (int i = 0; i < threads.Length; i++)
{
threads[i].Abort();
}
}
#endregion Start Threads
// *********************************************************************
// all threads should be completed (or aborted) with at this point
// *********************************************************************
MergeLog(threads);
ElapsedTime = new TimeSpan(DateTime.Now.Ticks - start.Ticks);
RaiseMasterWorkStatus("Task Completed : " + DateTime.Now.ToString("s") + " Elapsed: " + ElapsedTime.ToString(), THREADNAME, 0, 100);
RaiseStopEvent();
}