public void ProcessWorkerThrowingExceptionInIntMethod()
{
Assert.Throws <ProcessWorkerRemoteException>(() =>
{
ProcessWorker.RunAndWait(IntMethodWhichThrows);
});
}
/// <summary>
/// Processes content, first checking if content is valid, then running processing on background thread
/// </summary>
/// <param name="content"></param>
public void Process(List <IContent> content)
{
// process each content item
content.ForEach(singleContentItem =>
{
// check that the item can be processed by this processor
if (CanProcess(singleContentItem.GetType()))
{
// check if processor is already running a diff item
if (ProcessWorker.IsBusy)
{
// lock queue and add item
lock (QueueLock)
{
ContentQueue.Enqueue(singleContentItem);
}
}
else
{
// process item on background thread
ProcessWorker.RunWorkerAsync(singleContentItem);
}
}
});
}
public void PassEnumValueTwo()
{
Assert.DoesNotThrow(() =>
{
ProcessWorker.RunAndWait(AssertGivenEnumValue, TestTheEnums.TestValueOne);
});
}
public void PassEnumValueOne()
{
Assert.Throws <ProcessWorkerRemoteException>(() =>
{
ProcessWorker.RunAndWait(AssertGivenEnumValue, TestTheEnums.TestValueTwo);
});
}
public void ProcessWorkerWithIntParameterTest()
{
const int i1 = 1337;
var data0 = ProcessWorker.RunAndWait(RemoteExecuteInt1, i1);
Assert.AreEqual(i1 * 2, data0);
}
private static bool handleArguments(string[] args)
{
switch (args[0])
{
case "update":
if (args.Length < 3)
{
return(false);
}
setupLogging(Path.Combine(args[1], DefaultLogPath), "update.log");
Updater.Update(args[1], new Version(args[2]));
return(true);
case "build":
setupLogging(null, "build.log");
Builder.Build();
return(true);
case "worker":
if (args.Length < 2)
{
return(false);
}
setupLogging(null, $"worker-{DateTime.UtcNow:yyyyMMddHHmmssfff}.log");
enableScheduling();
ProcessWorker.Run(args[1]);
return(true);
}
return(false);
}
public void ProcessWorkerRemoteAssertion()
{
var result = ProcessWorker.RunAndWait(RemoteAssertion, 42);
Assert.AreEqual(42, result);
Assert.Throws <ProcessWorkerRemoteException>(() => ProcessWorker.RunAndWait(RemoteAssertion, 32));
}
public void ConverterTest()
{
var enumResult = ProcessWorker.RunAndWait(RemoteEnum);
Assert.AreEqual(TestEnum.Leet, enumResult);
var intResult = ProcessWorker.RunAndWait(RemoteInt);
Assert.AreEqual(12345, intResult);
}
private void binApplyBtn_Click(object sender, EventArgs e)
{
label4.Text = "Status : Processing!";
if (!ProcessWorker.IsBusy)
{
ProcessWorker.RunWorkerAsync();
}
{
MessageBox.Show("Kindly Wait!");
}
}
void ProcessWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
OnCompleted(e);
lock (QueueLock)
{
if (ContentQueue.Count > 0)
{
ProcessWorker.RunWorkerAsync(ContentQueue.Dequeue());
}
}
}
public void ProcessWorkerWithParametersOkTest()
{
const string p1 = "1";
var data1 = ProcessWorker.RunAndWait(RemoteExeute1, p1);
Assert.AreEqual(TestData + p1, data1);
const string p2 = "2";
var data2 = ProcessWorker.RunAndWait(RemoteExeute2, p1, p2);
Assert.AreEqual(TestData + p1 + p2, data2);
const string p3 = "3";
var data3 = ProcessWorker.RunAndWait(RemoteExeute3, p1, p2, p3);
Assert.AreEqual(TestData + p1 + p2 + p3, data3);
const string p4 = "4";
var data4 = ProcessWorker.RunAndWait(RemoteExeute4, p1, p2, p3, p4);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4, data4);
const string p5 = "5";
var data5 = ProcessWorker.RunAndWait(RemoteExeute5, p1, p2, p3, p4, p5);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4 + p5, data5);
const string p6 = "6";
var data6 = ProcessWorker.RunAndWait(RemoteExeute6, p1, p2, p3, p4, p5, p6);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4 + p5 + p6, data6);
const string p7 = "7";
var data7 = ProcessWorker.RunAndWait(RemoteExeute7, p1, p2, p3, p4, p5, p6, p7);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4 + p5 + p6 + p7, data7);
const string p8 = "8";
var data8 = ProcessWorker.RunAndWait(RemoteExeute8, p1, p2, p3, p4, p5, p6, p7, p8);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8, data8);
const string p9 = "9";
var data9 = ProcessWorker.RunAndWait(RemoteExeute9, p1, p2, p3, p4, p5, p6, p7, p8, p9);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9, data9);
const string p10 = "A";
var data10 = ProcessWorker.RunAndWait(RemoteExeute10, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
Assert.AreEqual(TestData + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10, data10);
}
private void numericUpDown1_ValueChanged(object sender, EventArgs e)
{
holderTb_1.Text = numericUpDown1.Value.ToString();
if (!ProcessWorker.IsBusy)
{
label4.Text = "Status : Processing!";
ProcessWorker.RunWorkerAsync();
}
else
{
MessageBox.Show("Kindly Wait!");
}
}
/// <summary>
/// Handles completion of background processing of an item
/// </summary>
/// <param name="sender">The worker that has completed</param>
/// <param name="e">The completion event args</param>
void ProcessWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
// allow derived processing of completion of an item
OnCompleted(e);
// get th next item on the queue, if any
lock (QueueLock)
{
if (ContentQueue.Count > 0)
{
ProcessWorker.RunWorkerAsync(ContentQueue.Dequeue());
}
}
}
private void FFmpeg_Completed(object sender, ProcessCompletedEventArgs e)
{
Dispatcher.Invoke(() => {
ProcessWorker Proc = sender as ProcessWorker;
if (e.Status == CompletionStatus.Failed && !Proc.WorkProcess.StartInfo.FileName.EndsWith("avs2pipemod.exe"))
{
FFmpegErrorWindow.Instance(Owner, Proc);
}
if (autoClose)
{
this.Close();
}
});
}
private void WaitingForm_FormClosing(object sender, FormClosingEventArgs e)
{
if (e.CloseReason == CloseReason.UserClosing && !isClosing)
{
ProcessWorker.CancelAsync();
if (onCancel != null)
{
MessageLbl.Text = "Cancelling...";
e.Cancel = !onCancel();
}
else
{
e.Cancel = true;
}
}
}
private void OnActionButtonClicked(object sender, EventArgs e)
{
switch (ActionButton.Text)
{
case "Start":
SourceGroupBox.Enabled = false;
PreferenceGroupBox.Enabled = false;
ActionButton.Text = "Cancel";
ProcessWorker.RunWorkerAsync(GetTask());
break;
case "Cancel":
Application.Exit();
break;
case "Close":
this.Close();
break;
}
}
public void DisplayTask(IProcessWorker taskArg)
{
Dispatcher.Invoke(() => {
if (taskArg.Options.IsMainTask)
{
host = taskArg;
hostFFmpeg = host as IProcessWorkerEncoder;
if (hostFFmpeg != null)
{
hostFFmpeg.FileInfoUpdated += FFmpeg_InfoUpdated;
hostFFmpeg.ProgressReceived += FFmpeg_StatusUpdated;
}
host.ProcessCompleted += FFmpeg_Completed;
PercentText.Text = 0.ToString("p1");
SetPageTitle(PercentText.Text);
}
else
{
task = taskArg;
TaskStatusText.Text = task.Options.Title;
task.ProcessCompleted += (sender, e) => {
ProcessWorker Proc = (ProcessWorker)sender;
Dispatcher.Invoke(() => {
if (e.Status == CompletionStatus.Failed && !Proc.WorkProcess.StartInfo.FileName.EndsWith("avs2pipemod.exe"))
{
FFmpegErrorWindow.Instance(Owner, Proc);
}
TaskStatusText.Text = "";
task = null;
if (autoClose)
{
this.Close();
}
});
};
}
});
}
public static void Main(string[] args)
{
Console.WriteLine("Start MultiProcessWorkerClient Demo");
using (var processWorker = ProcessWorker.Create())
{
var resultGuid = processWorker.Execute(ExecuteThisNow);
Console.WriteLine("key to send");
Console.ReadKey();
var result = processWorker.ExecuteWait(ExecuteMeNow);
Console.WriteLine(result);
Console.WriteLine("key to send");
Console.ReadKey();
if (processWorker.IsDataReady(resultGuid))
{
var result2 = processWorker.GetResult <string>(resultGuid);
Console.WriteLine(result2);
}
Console.WriteLine("key to exit");
Console.ReadKey();
}
try
{
ProcessWorker.RunAndWait(ExecuteFuckedUp);
}
catch (ProcessWorkerRemoteException e)
{
Console.WriteLine(e);
}
}
public void ProcessWorkerOkTest()
{
var data = ProcessWorker.RunAndWait(RemoteExecute);
Assert.AreEqual(TestData, data);
}
public void ProcessWorkerFailTest()
{
Assert.Throws <ArgumentException>(() => ProcessWorker.RunAndWait(RemoteFailExecute));
}
public void ProcessWorkerRemoteExceptionTest()
{
Assert.Throws <ProcessWorkerRemoteException>(() => ProcessWorker.RunAndWait(RemoteExceptionExecute));
}
private void WaitingForm_Load(object sender, EventArgs e)
{
Theme.ChangeFormTheme(this);
Icon = Properties.Resources.Revision_Program;
ProcessWorker.RunWorkerAsync();
}
public void ProcessWorkerWithReturnTest()
{
ProcessWorker.RunAndWait(RemoteExecuteNoReturn, 1000);
}
