public void GetWorkingLine()
{
try
{
using (ProxyBE p = new ProxyBE())
{
WorkingLine line = p.Client.GetWorkingLine(SenderUser, parm.WorkingLineID);
Response.Write(JSONHelper.Object2Json(line));
}
}
catch (Exception ex)
{
WriteError(ex.Message, ex);
}
}
private void ParallelCancellationTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
var q = wl.Queue;
var tasks = Enumerable.Range(0, 18).Select(i => new TestTask(i.ToString())).ToArray();
var taskMons = tasks.Select(t => new EventMonitor <TestTask>(t)).ToArray();
var cancelTask = tasks[9];
cancelTask.StateChanging += (s, e) =>
{
if (e.NewValue == TaskState.InProgress)
{
wl.Cancel();
}
};
wl.Enqueue(tasks);
Assert.IsTrue(wl.WaitForEnd(timeout: 4000));
AssertState(wl, isDisposed: false, busy: false);
Assert.AreEqual(0, wl.CurrentTasks.Length);
Assert.IsTrue(wl.Queue.IsEmpty);
Assert.AreEqual(TaskState.Succeeded, tasks.First().State);
Assert.AreEqual(TaskState.Obsolete, tasks.Last().State);
Assert.AreEqual(tasks.Length,
tasks.Where(t =>
t.State == TaskState.Succeeded ||
t.State == TaskState.Canceled ||
t.State == TaskState.Obsolete)
.Count());
wlMon.FilterHistory(ByEventName(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.Cancelled)))
.AssertEventNames(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.Cancelled),
nameof(WorkingLine.BusyChanged));
wlMon.FilterHistory(ByEventName(nameof(WorkingLine.BusyChanged)))
.AssertPropertyValues(true, false);
wlMon.FilterHistory(ByEventName(nameof(WorkingLine.BusyWorkerCountChanged)))
.AssertPropertyValues(1, 2, 3, 2, 1, 0);
}
public void newWorkingLine()
{
try
{
using (ProxyBE p = new ProxyBE())
{
WorkingLine line = new WorkingLine();
line.WorkingLineID = Guid.NewGuid();
line.WorkingLineName = "";
line.Remark = "";
Response.Write(JSONHelper.Object2Json(line));
}
}
catch (Exception ex)
{
WriteError(ex.Message, ex);
}
}
private void SingleWorkerSingleTaskTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
var q = wl.Queue;
var task = new TestTask("single");
var taskMon = new EventMonitor <TestTask>(task);
Assert.IsTrue(q.IsEmpty);
wl.Enqueue(task);
Assert.IsFalse(q.IsEmpty);
AssertState(wl, isDisposed: false, busy: false);
wl.Start();
wl.WaitForEnd(timeout: 10000);
Assert.IsTrue(q.IsEmpty);
AssertState(wl, isDisposed: false, busy: false);
wlMon.History.AssertSender(wl);
wlMon.FilterHistory(ByEventName(
nameof(WorkingLine.TaskBegin),
nameof(WorkingLine.TaskEnd)))
.AssertEventNames(
nameof(WorkingLine.TaskBegin),
nameof(WorkingLine.TaskEnd));
wlMon.FilterHistory(ByEventName(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.BusyWorkerCountChanged)))
.AssertEventNames(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.BusyWorkerCountChanged),
nameof(WorkingLine.BusyWorkerCountChanged),
nameof(WorkingLine.BusyChanged));
wlMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkingLine.Busy)))
.AssertPropertyValues(true, false);
wlMon.FilterHistory(ByPropertyChanges <int>(nameof(WorkingLine.BusyWorkerCount)))
.AssertPropertyValues(1, 0);
taskMon.History.AssertSender(task);
taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(ITask.State)))
.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded);
}
public void GetWorkingLines()
{
try
{
using (ProxyBE p = new ProxyBE())
{
List <WorkingLine> lines = p.Client.GetAllWorkingLines(SenderUser);
WorkingLine wf = new WorkingLine();
wf.WorkingLineName = "请选择";
wf.WorkingLineID = Guid.Empty;
lines.Insert(0, wf);
//lines.Sort((x, y) => x.WorkingLineName.CompareTo(y.WorkingLineName));
Response.Write(JSONHelper.Object2JSON(lines));
}
}
catch (Exception ex)
{
WriteError(ex.Message, ex);
}
}
private void SequentialCancellationTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
var q = wl.Queue;
var tasks = Enumerable.Range(0, 4).Select(i => new TestTask(i.ToString())).ToArray();
var cancelTask = tasks[1];
cancelTask.StateChanging += (s, e) =>
{
if (e.NewValue == TaskState.InProgress)
{
wl.Cancel();
}
};
wl.Enqueue(tasks);
Assert.IsTrue(wl.WaitForEnd(timeout: 4000));
AssertState(wl, isDisposed: false, busy: false);
Assert.AreEqual(0, wl.CurrentTasks.Length);
Assert.IsTrue(wl.Queue.IsEmpty);
Assert.AreEqual(TaskState.Succeeded, tasks[0].State);
Assert.AreEqual(TaskState.Canceled, tasks[1].State);
Assert.AreEqual(TaskState.Obsolete, tasks[2].State);
Assert.AreEqual(TaskState.Obsolete, tasks[3].State);
wlMon.History
.AssertSender(wl)
.AssertEventNames(
nameof(WorkingLine.TaskBegin),
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.BusyWorkerCountChanged),
nameof(WorkingLine.TaskEnd),
nameof(WorkingLine.TaskBegin),
nameof(WorkingLine.Cancelled),
nameof(WorkingLine.TaskEnd),
nameof(WorkingLine.BusyWorkerCountChanged),
nameof(WorkingLine.BusyChanged));
}
public bool WorkingLineIsDuplicated(Sender sender, WorkingLine WorkingLine)
{
try
{
using (ObjectProxy op = new ObjectProxy())
{
WorkingLine obj = new WorkingLine();
obj.WorkingLineName = WorkingLine.WorkingLineName;
if (op.LoadWorkingLineByWorkingLineName(obj) == 0)
{
return(false);
}
return(obj.WorkingLineID != WorkingLine.WorkingLineID);
}
}
catch (Exception ex)
{
PLogger.LogError(ex);
throw ex;
}
}
public WorkingLine GetWorkingLine(Sender sender, Guid WorkingLineID)
{
try
{
using (ObjectProxy op = new ObjectProxy())
{
WorkingLine obj = new WorkingLine();
obj.WorkingLineID = WorkingLineID;
if (op.LoadWorkingLineByWorkingLineID(obj) == 0)
{
return(null);
}
return(obj);
}
}
catch (Exception ex)
{
PLogger.LogError(ex);
throw ex;
}
}
private void LifeCycleTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
// nothing
}
public static void AssertState(WorkingLine wl,
bool isDisposed, bool busy)
{
Assert.AreEqual(isDisposed, wl.IsDisposed, $"The disposed state of the {nameof(WorkerThread)} is unexpected.");
Assert.AreEqual(busy, wl.Busy, $"The busy state of the {nameof(WorkingLine)} is unexpected.");
}
