/// <summary>
/// Starting a delayed task.
/// </summary>
/// <param name="delayedAction">The delayed action.</param>
/// <param name="waitTime">The timespan before invoking the action. (Milliseconds.)</param>
/// <param name="repeat">The amount of times the action should be repeated.</param>
public static uint StartDelayedTask(ThreadAction delayedAction, int waitTime, int repeat = 0)
{
DelayedAction taskAction = new DelayedAction();
lock (SyncRoot)
{
taskAction.actionID = TaskID;
TaskID++;
}
taskAction.allowedTime = DateTime.Now.AddMilliseconds(waitTime);
taskAction.repeat = repeat;
taskAction.threadAction = new ThreadAction(() =>
{
if (DateTime.Now >= taskAction.allowedTime)
{
delayedAction.Invoke();
if (taskAction.repeated >= taskAction.repeat)
{
DelayedAction outDA;
taskObjects.TryRemove(taskAction.actionID, out outDA);
}
taskAction.repeated++;
}
});
taskObjects.TryAdd(taskAction.actionID, taskAction);
return taskAction.actionID;
}
/// <summary>
/// Starting a delayed task.
/// </summary>
/// <param name="delayedAction">The delayed action.</param>
/// <param name="waitTime">The timespan before invoking the action. (Milliseconds.)</param>
/// <param name="repeat">The amount of times the action should be repeated.</param>
public static uint StartDelayedTask(ThreadAction delayedAction, int waitTime, int repeat = 0)
{
DelayedAction taskAction = new DelayedAction();
lock (SyncRoot)
{
taskAction.actionID = TaskID;
TaskID++;
}
taskAction.allowedTime = DateTime.Now.AddMilliseconds(waitTime);
taskAction.repeat = repeat;
taskAction.threadAction = new ThreadAction(() =>
{
if (DateTime.Now >= taskAction.allowedTime)
{
delayedAction.Invoke();
if (taskAction.repeated >= taskAction.repeat)
{
DelayedAction outDA;
taskObjects.TryRemove(taskAction.actionID, out outDA);
}
taskAction.repeated++;
}
});
taskObjects.TryAdd(taskAction.actionID, taskAction);
return(taskAction.actionID);
}
protected void Execute(Action action, string groupName = "", float delay = 0f, bool stopOnTimeScale = false)
{
//Debug.Log("Added item to thread with delay: " + delay);
lock (Lock)
{
var neww = new ThreadAction
{
Action = action,
IsReady = false,
StopOnTimeScale = stopOnTimeScale,
GroupName = groupName
};
if (delay <= 0f)
{
neww.IsReady = true;
}
else
{
neww.Start(delay);
}
_actions.Add(neww);
}
}
/// <summary>
/// Creating a new instance of ConquerOnline.MultiThreading.BaseThread.
/// </summary>
/// <param name="Action">The thread action.</param>
/// <param name="Interval">The interval.</param>
/// <param name="ThreadName">The thread name.</param>
public BaseThread(ThreadAction Action, int Interval, string ThreadName)
{
this.Action = Action;
this.Interval = Interval;
running_thread = new Thread(ThreadRun);
running_thread.Name = ThreadName;
check_thread = new Thread(ThreadCheck);
}
/// <summary>
/// Creating a new instance of ConquerOnline.MultiThreading.BaseThread.
/// </summary>
/// <param name="Action">The thread action.</param>
/// <param name="Interval">The interval.</param>
/// <param name="ThreadName">The thread name.</param>
public BaseThread(ThreadAction Action, int Interval, string ThreadName)
{
this.Action = Action;
this.Interval = Interval;
running_thread = new Thread(ThreadRun);
running_thread.Name = ThreadName;
check_thread = new Thread(ThreadCheck);
}
public static bool CreateNewThread(ThreadAction action, IntPtr param)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(NativeMethods.create_new_thread(action.FunctionPointer, IntPtr.Zero));
}
public override void OnThreadFinished(ThreadAction threadAction)
{
if(isFinishing)
{
return;
}
ThreadAction action = new ThreadAction(threadAction.DoCallback);
action.SignalFinishedCallback = threadAction.SignalFinishedCallback;
action.Start();
}
public override void OnThreadFinished(ThreadAction threadAction)
{
if (isFinishing)
{
return;
}
ThreadAction action = new ThreadAction(threadAction.DoCallback);
action.SignalFinishedCallback = threadAction.SignalFinishedCallback;
action.Start();
}
public override void OnThreadFinished(ThreadAction threadAction)
{
lock (this.sync)
{
finishedThreadsCount++;
if (finishedThreadsCount == threadActions.Count)
{
allThreadsAreFinishedSignal.Set();
}
}
}
public override void OnThreadFinished(ThreadAction threadAction)
{
if (isFinishing || ThreadAction.AllCanceled)
{
return;
}
ThreadAction action = new ThreadAction(threadAction.DoCallback);
action.SignalFinishedCallback = threadAction.SignalFinishedCallback;
this.threadActions.Add(action);
action.Start();
}
public override void OnThreadFinished(ThreadAction threadAction)
{
lock (this.sync)
{
finishedThreadsCount++;
if (finishedThreadsCount == threadActions.Count)
{
allThreadsAreFinishedSignal.Set();
}
}
}
private void RunPoolThreads(int count, ThreadAction action)
{
// TODO: Run 'count' pool threads and execute 'action' in every one with appropriate range of data
// TODO: Use 'ManualResetEvent' to synchronize operations
var events = new List <ManualResetEvent>();
for (int i = 0; i < count; i++)
{
var i1 = i;
var resetEvent = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(_ => { action(i1 * _data.Length / count, (i1 + 1) * _data.Length / count); resetEvent.Set(); });
events.Add(resetEvent);
}
WaitHandle.WaitAll(events.ToArray <WaitHandle>());
}
/// <summary>
/// deserialize a file to be used in the scenario
/// </summary>
/// <param name="filename"></param>
public void Deserialize(string filename)
{
XmlSerializer xd = new XmlSerializer(typeof(Scenario));
using (StreamReader rd = new StreamReader(filename))
{
Scenario scenario = xd.Deserialize(rd) as Scenario;
Airports = scenario.Airports;
foreach (Airport airport in Airports)
{
airport.Reviver(this);
}
AirportNotifier();
ThreadAction.Start();
}
}
public ThreadAsync DoSomething(ThreadAction action, object obj = null)
{
ThreadAsync async = null;
Thread thread = new Thread(() => {
if (action != null)
{
ThreadAction temp = action;
action = null;
string error = temp.Invoke(obj);
async.SetError(error);
async.SetIsDone(true);
}
});
async = new ThreadAsync(thread);
thread.Start();
return(async);
}
private void RunStandaloneThreads(int count, ThreadAction action)
{
// TODO: Run 'count' threads and execute 'action' in every one with appropriate range of data
var t = new Thread[count];
for (var i = 0; i < count; i++)
{
var i1 = i;
t[i] = new Thread(() => action(i1 * _data.Length / count, (i1 + 1) * _data.Length / count));
}
foreach (var temp in t)
{
temp.Start();
}
foreach (var temp in t)
{
temp.Join();
}
}
internal override Action Clone(IDocumentEssential owner)
{
PDFDictionary dict = new PDFDictionary();
dict.AddItem("Type", new PDFName("Action"));
dict.AddItem("S", new PDFName("Thread"));
IPDFObject fs = m_dictionary["F"];
if (fs != null)
{
dict.AddItem("F", fs);
}
string[] keys = { "D", "B" };
for (int i = 0; i < keys.Length; ++i)
{
IPDFObject obj = m_dictionary[keys[i]];
if (obj != null)
{
dict.AddItem(keys[i], obj.Clone());
}
}
ThreadAction action = new ThreadAction(dict, owner);
IPDFObject next = m_dictionary["Next"];
if (next != null)
{
for (int i = 0; i < Next.Count; ++i)
{
action.Next.Add(Next[i]);
}
}
return(action);
}
public ThreadWorker(ThreadAction action)
{
this.mAction = action;
this.mWorkerLock = new object();
this.mThread = new Thread(new ThreadStart(Work));
}
private Task StartTask(ThreadAction action, CancellationToken cancellationToken)
{
var token = !cancellationToken.IsCancellationRequested ? cancellationToken : CancellationToken.None;
return Task.Factory.StartNew(() => action(token), token, TaskCreationOptions.None, _callbackThread);
}
public void InvokeOnUIThreadSync(ThreadAction action)
{
StartTask(action, _cancellationToken).Wait();
}
//=====================================================================
/// <summary>
/// This performs the requested task
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event arguments</param>
private void actionThread_DoWork(object sender, DoWorkEventArgs e)
{
ThreadAction action = (ThreadAction)e.Argument;
string arguments, contentSetupFile;
int errorCode;
runningThread = Thread.CurrentThread;
try
{
HelpLibraryManager hlm = new HelpLibraryManager(viewerVersion);
// Remove old content. We'll remove it if installing to be sure that
// the latest copy is installed.
if (action == ThreadAction.Install || action == ThreadAction.Remove)
{
if (action == ThreadAction.Install)
{
actionThread.ReportProgress(0, (int)ThreadState.RemovingOldContent);
}
else
{
actionThread.ReportProgress(0, (int)ThreadState.RemovingContent);
}
if (viewerVersion.Major == 1)
{
arguments = String.Format(CultureInfo.InvariantCulture,
"/product \"{0}\" /version \"{1}\" /locale {2} /uninstall /silent /vendor " +
"\"{3}\" /productName \"{4}\" /mediaBookList \"{5}\"",
project.CatalogProductId, project.CatalogVersion, project.Language.Name,
!String.IsNullOrEmpty(project.VendorName) ? project.VendorName : "Vendor Name",
!String.IsNullOrEmpty(project.ProductTitle) ? project.ProductTitle : project.HelpTitle,
project.HelpTitle);
}
else
{
arguments = String.Format(CultureInfo.InvariantCulture,
"/catalogName \"{0}\" /locale {1} /wait 0 /operation uninstall /vendor \"{2}\" " +
"/productName \"{3}\" /bookList \"{4}\" ",
project.CatalogName, project.Language.Name,
!String.IsNullOrEmpty(project.VendorName) ? project.VendorName : "Vendor Name",
!String.IsNullOrEmpty(project.ProductTitle) ? project.ProductTitle : project.HelpTitle,
project.HelpTitle);
}
// This doesn't have to run as an administrator
errorCode = hlm.RunAsNormalUser(arguments, ProcessWindowStyle.Minimized);
// Ignore it if not found and we are installing
if (errorCode != HelpLibraryManagerException.Success &&
(errorCode != HelpLibraryManagerException.NoBooksToInstall || action == ThreadAction.Remove))
{
throw new HelpLibraryManagerException(viewerVersion, errorCode);
}
}
if (action == ThreadAction.Install)
{
// Install the new content
actionThread.ReportProgress(0, (int)ThreadState.InstallingContent);
// Copy the MSHA file to the required name
contentSetupFile = Path.Combine(Path.GetDirectoryName(setupFile), "HelpContentSetup.msha");
File.Copy(setupFile, contentSetupFile, true);
if (viewerVersion.Major == 1)
{
arguments = String.Format(CultureInfo.InvariantCulture, "/product \"{0}\" " +
"/version \"{1}\" /locale {2} /sourceMedia \"{3}\"", project.CatalogProductId,
project.CatalogVersion, project.Language.Name, contentSetupFile);
}
else
{
arguments = String.Format(CultureInfo.InvariantCulture, "/catalogName \"{0}\" " +
"/locale {1} /wait 0 /operation install /sourceUri \"{2}\"", project.CatalogName,
project.Language.Name, contentSetupFile);
}
// Always interactive and must run as administrator. We can't run silently as we don't have
// a signed cabinet file.
errorCode = hlm.RunAsAdministrator(arguments, ProcessWindowStyle.Normal);
if (errorCode != HelpLibraryManagerException.Success)
{
throw new HelpLibraryManagerException(viewerVersion, errorCode);
}
// Open it if installed successfully
action = ThreadAction.OpenCurrent;
}
if (action == ThreadAction.OpenCurrent)
{
arguments = null;
if (msHelpViewer == null)
{
msHelpViewer = hlm.HelpViewerPath;
if (msHelpViewer == null)
{
msHelpViewer = "ms-xhelp:///?method=page&id=-1";
}
else
if (viewerVersion.Major == 2)
{
arguments = "/catalogname \"" + project.CatalogName + "\"";
}
}
actionThread.ReportProgress(0, (int)ThreadState.OpeningContent);
System.Diagnostics.Process.Start(msHelpViewer, arguments);
}
}
catch (ThreadAbortException)
{
// Ignore thread abort exceptions
}
}
public abstract void OnThreadFinished(ThreadAction threadAction);
public abstract void OnThreadFinished(ThreadAction threadAction);
private Task StartTask(ThreadAction action, CancellationToken cancellationToken)
{
var token = !cancellationToken.IsCancellationRequested ? cancellationToken : CancellationToken.None;
return(Task.Factory.StartNew(() => action(token), token, TaskCreationOptions.None, _callbackThread));
}
internal void AttachThread(NsScriptThread thread)
{
thread.Process = this;
PendingThreadActions.Enqueue(ThreadAction.Create(thread));
}
public void InvokeOnUIThreadAsync(ThreadAction action)
{
StartTask(action, _cancellationToken);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExtremeKit.Threads"/> class.
/// </summary>
/// <param name="action">Action.</param>
/// <param name="threadsCount">Threads count.</param>
public Threads(ThreadAction action, int threadsCount) : this() {
this.Action = action;
this.Count = threadsCount;
}
