public NetMqSnapshotServer(string address, Func <string, byte[]> snapshotFactory)
{
//todo: check null
_snapshotFactory = snapshotFactory;
Address = address;
_worker = new TaskWorker(RouterAction);
}
public void Task_MustCompleteWork()
{
// Arrange
var watch = System.Diagnostics.Stopwatch.StartNew();
var task = new TaskWorker(this);
var workDone = false;
var completed = false;
var manualResetEvent = new ManualResetEvent(false);
// Act
task.QueueWorker(this.workerQueue, null, (x, e) =>
{
workDone = true;
}, (x, e) => {
completed = true;
manualResetEvent.Set(); // continue wait
}, (e) => {
}, (x, e) => {
});
manualResetEvent.WaitOne(1000); // pause until set
// Assert
watch.Stop();
Assert.InRange(watch.ElapsedMilliseconds, 0, 500); //should be more than enough
if (!workDone)
{
throw new Exception("Task has not done any work.");
}
if (!completed)
{
throw new Exception("Task has not completed.");
}
}
private static void SpawnWorker(string i)
{
var task = new TaskWorker(null);
task.QueueWorker(
_workerQueue,
null,
(x, e) =>
{
//// some custom do work logic.
while (_runWorkers)
{
var dataString = task.Id + " Key " + DateTime.Now.Ticks.ToString();
_mainSocket.Emit("hi", dataString);
System.Console.WriteLine("Emitted " + dataString);
System.Threading.Thread.Sleep(50);
}
},
(x, e) =>
{
//// some custom completed logic.
},
(e) =>
{
//// some custom display error logic.
},
(x, e) =>
{
//// Progress change logic.
});
}
/// <summary>
/// Starts listening for incoming messages from a pipe client.
/// </summary>
public void Start()
{
TaskWorker tWorker = new TaskWorker();
tWorker.WorkException += ThrowException;
tWorker.DoWork(Listen);
}
public void CancelAll_ShouldStopAllTasks()
{
// Arrange
var watch = System.Diagnostics.Stopwatch.StartNew();
var task = new TaskWorker(this);
var workDone = false;
task.QueueWorkerWithDelay(this.workerQueue, null, (x, e) =>
{
// some custom do work logic.
workDone = true;
throw new Exception("Thread not cancelled. Expected to never reach here.");
}, (x, e) => {
}, (e) => { }, (x, e) => {
}, 5000);
// Act
task.CancelAll(workerQueue);
watch.Stop();
// Assert
Assert.InRange(watch.ElapsedMilliseconds, 0, 500); //should be more than enough
if (workDone)
{
throw new Exception("Task not cancelled on time.");
}
}
public TelecomTask(XPathNavigator nav, TaskWorker worker) : base(nav, worker)
{
_LOG = worker._LOG;
OnStart += (t) => _LOG.Trace("Start: " + t);
OnStop += (t) => _LOG.Trace("Stop: " + t);
OnList += (t) => _LOG.Trace("List: " + t);
OnListError += (t, e) => _LOG.HandleException(e, "List: " + t);
OnRead += (t, m, msg, ti) => _LOG.Trace("Read: " + t + m + " msgCount=" + (msg == null ? 0 : msg.Count));
OnReadError += (t, m, msg, ti, e) => _LOG.HandleException(e, "Read: '" + ti.Status + "' " + t + m);
OnWrite += (t1, m1, m2, msg, ti) => _LOG.Trace("Write: " + t1 + m1 + " >> " + m2); //msg
OnWriteError += (t1, m1, m2, msg, ti, e) => _LOG.HandleException(e, "Write: '" + ti.Status + "' " + t1 + m1 + " >> " + m2); //msg
OnDelete += (t, m, ti) => _LOG.Trace("Delete: " + t + m);
OnDeleteError += (t, m, ti, e) => _LOG.HandleException(e, "Delete: " + t + m);
TaskQueuePath = Path.Combine(AppContext.AppDir, TaskInfo["Name"] + "TaskQueue.dat");
var v = nav.GetAllChildAttributes();
foreach (var x in v["read"])
{
readTask[x.Key] = x.Value;
}
foreach (var x in v["write"])
{
writeTask[x.Key] = x.Value;
}
}
private void TaskWorkerOnFinished(int errorCode)
{
Thread.Sleep((int)((Stopwatch.ElapsedMilliseconds > 1000) ? 0 : 1000 - Stopwatch.ElapsedMilliseconds));
Stopwatch.Restart();
Dispatcher.BeginInvoke(new System.Action(() => {
if (ActionIndex < ReadActions.Count)
{
Action action = ReadActions[ActionIndex];
PastStatus = CurrentStatus + " - " + ((errorCode == 0) ? "Successful." : "Failed.");
CurrentStatus = action.Text;
ProgressBar.Value = ActionIndex;
TaskWorker taskWorker = new TaskWorker(action.Program);
taskWorker.Finished += TaskWorkerOnFinished;
taskWorker.Start();
ActionIndex++;
}
else
{
ProgressBar.Value = ActionIndex;
PastStatusLabel.Content = CurrentStatus + " - " + ((errorCode == 0) ? "Successful." : "Failed.");
CurrentStatus = "Completed Actions";
Timer timer = new Timer(1500);
timer.Elapsed += Close;
timer.Start();
}
}));
}
/// <summary>
/// Sends a message to the pipe server.
/// </summary>
/// <param name="message">The message to send to the pipe server.</param>
public void SendMessage(string message)
{
TaskWorker tWorker = new TaskWorker();
tWorker.WorkException += ThrowException;
tWorker.DoWork(Send, message);
}
private void RollBackOp()
{
if ((!string.IsNullOrEmpty(this.RollBackMark)) && this.RollBackMark != "-1")
{
DBLog dbl = new DBLog();
DataTable DT = dbl.GetBakUps(this.RollBackMark);
string sitename = string.Empty;
if (DT != null && DT.Rows.Count > 0)
{
sitename = DT.Rows[0]["RBSiteName"].ToString();
}
TaskInfo SiteObj = new TaskInfo();
if (Convert.ToInt32(DT.Rows[0]["IsUsed"]) == 0)
{
string msg = "";
TaskWorker SyncAction = new TaskWorker(SiteObj, dbl);
if (SyncAction.RollBackSite())
{
new DBLog().UpdateBakUsedMark(this.RollBackMark);
Response.Write("<script>alert('回滚成功');</script>");
}
else
{
Response.Write("<script>alert('回滚失败!\\r\\n\\r\\n" + msg + "');</script>");
}
}
else
{
this.Data_Bind();
Response.End();
}
}
}
public void TestMethod1()
{
TaskWorker worker = new TaskWorker();
worker.Run();
Console.Read();
}
static void Main(string[] args)
{
// Create the Ventilator object.
var ventilator = new TaskVentilator("tcp://localhost:5557", "tcp://localhost:9001");
Thread ventilatorThread = new Thread(ventilator.DoWork);
var taskWorkers = new List <TaskWorker>();
var workerThreads = new List <Thread>();
// Create some worker objects.
for (int i = 0; i < 4; i++)
{
var worker = new TaskWorker("tcp://localhost:5557", "tcp://localhost:5558");
Thread workerThread = new Thread(worker.DoWork);
taskWorkers.Add(worker);
workerThreads.Add(workerThread);
}
// Create the Sink object.
var sink = new TaskSink("tcp://localhost:5558", "tcp://localhost:9001");
Thread sinkThread = new Thread(sink.DoWork);
// Start the Worker threads.
int workerCount = 0;
foreach (var workerThread in workerThreads)
{
workerThread.Start();
Console.WriteLine("Main thread: Starting Working thread #{0}.", workerCount);
workerCount++;
}
// Start the Sink thread.
sinkThread.Start();
Console.WriteLine("Main thread: Starting Sink thread.");
// Start the Ventilator thread.
ventilatorThread.Start();
Console.WriteLine("Main thread: Starting Ventilator thread.");
while (ventilator.IsWorking)
{
Thread.Sleep(1000);
}
Console.WriteLine("Waiting for disk!");
while (sink.WaitingOnWork)
{
Thread.Sleep(1000);
}
Console.WriteLine("We're all done!");
Console.ReadLine();
}
/// <summary>
/// 暂停
/// </summary>
public void Pause()
{
lock (this)
{
ChangeStatus(TaskRunStatus.Pausing);
TaskWorker.Change(Timeout.Infinite, Timeout.Infinite); //禁止再次回调
ChangeStatus(TaskRunStatus.Paused);
Logger.Debug("[{0}]暂停，计时器已暂停。(最后一次回调的任务可能还在执行)", this);
}
}
public void TestMethod1()
{
TaskWorker manager = new TaskWorker();
//manager.Start();
// var task = new EchoActivity("ASDFFDSA");
// manager.AddTaskActivities(task);
//manager.Stop();
}
private void StopTask()
{
lock (this)
{
ChangeStatus(TaskRunStatus.Stoping);
TaskWorker.Change(Timeout.Infinite, Timeout.Infinite); //禁止再次回调
Task.Execution.RunStatus = TaskRunStatus.Stoped;
ChangeStatus(TaskRunStatus.Stoped);
Logger.Debug("[{0}] 停止，计时器已释放。", this);
}
}
/// <summary>
/// 暂停
/// </summary>
public void Pause()
{
lock (this)
{
ChangeStatus(TaskRunStatusType.Pausing);
//SaveExecution(); //先保存一次状态
TaskWorker.Change(Timeout.Infinite, Timeout.Infinite); //禁止再次回调
ChangeStatus(TaskRunStatusType.Paused);
Log.Debug($"[{this}]暂停，计时器已暂停。(最后一次回调的任务可能还在执行)");
}
}
/// <summary>
/// Run the task that is selected
/// </summary>
protected virtual void RunTask()
{
TaskWorker task = CurrentTask;
if (AutoResetTasks && !isRecovering)
{
CurrentTask.Reset();
}
isRecovering = false;
task.StateChanged += Task_StateChanged;
task.Start();
}
private async void Window_Loaded(object sender, RoutedEventArgs e)
{
this.Title = "Home - Feed";
DisableButtons();
var _user = await Api.GetCurrentUserAsync();
if (_user.Succeeded)
{
this.CurrentUser = _user.Value;
using (var context = new InstaContext())
{
if (!context.Users.Any(u => u.PK == this.CurrentUser.Pk))
{
var user = new UserModel
{
PK = this.CurrentUser.Pk,
LastLogin = DateTime.Now
};
context.Users.Add(user);
context.SaveChanges();
}
this.UserModel = context.Users.Include("Schedules").Include("Searches").Include("Tasks").First(u => this.CurrentUser.Pk == u.PK);
this.UserModel.LastLogin = DateTime.Now;
context.SaveChanges();
}
try
{
TaskWorker.StartBackgroundWorker(this.UserModel.Id, this.Api);
}
catch (Exception ex)
{
MessageBox.Show("TaskWorker.StartBackgroundWorker" + Environment.NewLine + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
EnableButtons();
profileImage.Fill = new ImageBrush(new BitmapImage(new Uri(this.CurrentUser.ProfilePicture)));
lblUsername.Content = this.CurrentUser.UserName;
progressBar.Visibility = Visibility.Hidden;
}
else
{
MessageBox.Show(_user.Info.Message);
this.Close();
}
pnlMainContent.Children.Clear();
pnlMainContent.Children.Add(new FeedView(this.Api));
}
private void StopTask()
{
lock (this)
{
ChangeStatus(TaskRunStatusType.Stoping);
TaskWorker.Change(Timeout.Infinite, Timeout.Infinite); //禁止再次回调
//SaveExecution(); //先保存一次状态
Task.Execution.RunStatus = TaskRunStatusType.Stoped;
ChangeStatus(TaskRunStatusType.Stoped);
Log.Debug($"[{this}] 停止，计时器已释放。");
}
}
private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
{
Stopwatch.Start();
ReadActions = ActionHelper.ReadActions(Assembly.GetExecutingAssembly().GetManifestResourceStream("SlightNetRepairer." + "Actions.txt"));
ProgressBar.Maximum = ReadActions.Count;
ExtractFiles();
TaskWorker taskWorker = new TaskWorker("");
taskWorker.Finished += TaskWorkerOnFinished;
taskWorker.Start();
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
try
{
Stop();
TaskWorker.Dispose();
TaskWorker = null; //干掉引用
}
catch (Exception ex)
{
Logger.Error("释放资源时发生异常。", ex);
}
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
try
{
Stop();
TaskWorker.Dispose();
TaskWorker = null; //干掉引用
}
catch (Exception ex)
{
Log.Error(ex, "释放资源时发生异常。");
//throw;
}
}
public SocketEngine Open()
{
string transportName;
if (RememberUpgrade && PriorWebsocketSuccess && Transports.Contains(WebSocket.NAME))
{
transportName = WebSocket.NAME;
}
else
{
transportName = Transports[0];
}
transportName = WebSocket.NAME;
ReadyState = ReadyStateEnum.OPENING;
var transport = CreateTransport(transportName);
SetTransport(transport);
//EasyTimer.TaskRunNoWait(() =>
//{
// var log2 = LogManager.GetLogger(GlobalHelper.CallerName());
// log2.Info("Task.Run Open start");
// transport.Open();
// log2.Info("Task.Run Open finish");
//});
if (TasksQueue == null)
{
TasksQueue = new Queue <TaskWorker>();
}
var task = new TaskWorker(null);
task.QueueWorker(
TasksQueue,
null,
(x, e) => {
var log2 = LogManager.GetLogger(GlobalHelper.CallerName());
log2.Info("Task.Run Open start");
transport.Open();
log2.Info("Task.Run Open finish");
},
null,
null,
null
);
return(this);
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="args">Details about the launch request and process.</param>
protected override async void OnLaunched(LaunchActivatedEventArgs args)
{
#if DEBUG
if (Debugger.IsAttached)
{
this.DebugSettings.EnableFrameRateCounter = false;
this.DebugSettings.IsBindingTracingEnabled = true;
this.DebugSettings.BindingFailed += (s, e) =>
{
Debug.WriteLine("binding failed");
};
}
#endif
switch (args.PreviousExecutionState)
{
case ApplicationExecutionState.Terminated:
case ApplicationExecutionState.ClosedByUser:
break; // load saved application data and refresh content
case ApplicationExecutionState.NotRunning: // normal launch
await TaskHelper.RegisterAll();
InitializeUi();
if (IsFirstLaunch())
{
OnFirstLaunch(args);
}
else
{
OnNormalLaunch(args);
}
break;
case ApplicationExecutionState.Running:
// activated through secondary tile or activiation contracts and extensions
case ApplicationExecutionState.Suspended:
// activated through secondary tile of activation contracts and extensions after has been suspended
break;
default:
Log.Warn("Unexpected PreviousExecutionState");
break;
}
Worker = new TaskWorker();
Worker.Start();
}
public Socket Open()
{
//Task.Factory.StartNew(() =>
//{
// if (!Connected)
// {
// _io.Open();
// if (_io.ReadyState == Manager.ReadyStateEnum.OPEN)
// {
// OnOpen();
// }
// }
//},
//CancellationToken.None,
//TaskCreationOptions.None,
//TaskScheduler.Default);
if (Subs.Count == 0)
{
// Registers the "sub" events if they are not
// used in a Connect-Disconnect-Connect cycle
SubEvents();
}
var task = new TaskWorker(null);
task.QueueWorker(
TasksQueue,
null,
(x, e) => {
if (!Connected)
{
_io.Open();
if (_io.ReadyState == Manager.ReadyStateEnum.OPEN)
{
OnOpen();
}
}
},
null,
null,
null
);
return(this);
}
/// <summary>
/// Handles the StateChanged event of the task control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected virtual void Task_StateChanged(object sender, EventArgs e)
{
TaskWorker task = (TaskWorker)sender;
if (task.IsFinished)
{
CurrentTask.StateChanged -= Task_StateChanged;
if (task.State == TaskWorker.WorkerState.Completed)
{
OnTaskCompleted();
}
else if (task.State == TaskWorker.WorkerState.Cancelled)
{
OnTasksCancelled();
}
else if (task.State == TaskWorker.WorkerState.Failed)
{
if (AutoTryRecover)
{
if (task.IsRecoverable)
{
bool moveNext;
IsRecovering = true;
if (task.TryRecover(out moveNext))
{
IsRecovering = false;
if (stop)
{
OnTasksCancelled();
return;
}
Resume(moveNext);
return;
}
IsRecovering = false;
if (stop)
{
OnTasksCancelled();
return;
}
}
}
OnTasksFailed();
}
}
}
public virtual void Initialize(bool initAsync = false)
{
if (isInitializing || isInitialized)
{
return;
}
isInitializing = true;
if (this.initAsync = initAsync)
{
(initWorker = TaskWorker.Create(Initializer)).Start();
}
else
{
Initializer();
}
}
/// <summary>
/// 恢复
/// </summary>
public void Resume()
{
lock (this)
{
ChangeStatus(TaskRunStatus.Running);
var now = SystemTime.Now();
var nextRun = Task.GetNextRunTime(now);
if (nextRun == null)
{
Logger.Warn("[{0}] 无法恢复，因为下次执行时间为null", this);
return;
}
var dueTime = nextRun.Value.Subtract(now);
TaskWorker.Change(dueTime /*第一次延时调用*/, TimeSpan.FromMilliseconds(-1) /*Note:回调时会更改调用延时，此周期设为无限*/); //重启计时器
Logger.Debug("[{0}] 暂停，计时器已恢复。(最后一次回调的任务可能还在执行)", this);
}
}
/// <summary>
/// 恢复
/// </summary>
public void Resume()
{
lock (this)
{
ChangeStatus(TaskRunStatusType.Running);
var now = SystemTime.Now();
var nextRun = Task.GetNextRunTime(now);
if (nextRun == null)
{
Log.Warn($"[{this}] 无法恢复，因为下次执行时间为null");
return;
}
var dueTime = nextRun.Value.Subtract(now);
TaskWorker.Change(dueTime /*第一次延时调用*/, TimeSpan.MaxValue); //重启计时器
Log.Debug($"[{this}] 暂停，计时器已恢复。(最后一次回调的任务可能还在执行)");
}
}
public RAlgSolver(TaskWorker tw, RKResults res, List <List <double> > startParameters, Vector startP, int method)
: this(tw, res, startParameters)
{
this.startP = startP;
if (this.startP.Count == 1)
{
calcFunct += CalcFunct1;
}
else
{
if (method == 0)
{
calcFunct += CalcFunct2;
}
else
{
calcFunct += CalcFunct2_1;
}
}
}
private RAlgSolver(TaskWorker tw, RKResults res, List <List <double> > startParameters)
{
this.tw = tw;
this.res = res;
itab = new int[res.Count - 1];
if (res[0].Y.Count == 2)
{
var dz1 = new double[res.Count - 1];
for (int i = 1; i < res.Count; i++)
{
dz1[i - 1] = (res[i].Y[0] - res[i - 1].Y[0]) / (res[i].X - res[i - 1].X);
}
var dz2 = new double[res.Count - 2];
for (int i = 1; i < dz1.Length; i++)
{
dz2[i - 1] = (dz1[i] - dz1[i - 1]) / (res[i].X - res[i - 1].X);
}
dz = dz2;
}
var list = new List <TaskParameter>();
int k = 0;
for (int i = 0; i < startParameters.Count; i++)
{
var tp1 = new TaskParameter(startParameters[i].Count);
for (int j = 0; j < startParameters[i].Count; j++)
{
x[k] = startParameters[i][j];
tp1.Param[j] = x[k];
k++;
}
list.Add(tp1);
}
c = k;
tp = new TaskParameters(list, double.MinValue);
}
private void btnSolveRK_Click(object sender, EventArgs e)
{
this.rtbResult1.Text = this.rtbResult2.Text = string.Empty;
this.dgvTabRes.DataSource = null;
this.n = int.Parse(this.txtN.Text);
this.setCount = this.rbN1.Checked ? 1 : 2;
//this.gamma = double.Parse(txtGamma.Text);
ZedGraph.GraphPane gp = this.zgcMainChart2.GraphPane;
gp.CurveList.Clear();
this.curves.Clear();
this.curves.Add(this.curveName, new PointPairList());
gp.AddCurve(this.curveName, this.curves[curveName], Color.Black, SymbolType.None);
List<double> gammaList = new List<double>();
List<double> p = new List<double>();
for (int i = 0; i < dgvGama.ColumnCount; i++)
{
gammaList.Add(Convert.ToDouble(dgvGama.Rows[0].Cells[i].Value));
}
List<TaskParameter> list = new List<TaskParameter>();
for (int i = 0; i < dgvParameters.RowCount; i++)
{
TaskParameter tp = new TaskParameter(dgvParameters.ColumnCount);
for (int j = 0; j < dgvParameters.ColumnCount; j++)
{
double val = Convert.ToDouble(dgvParameters.Rows[i].Cells[j].Value);
tp.Param[j] = val;
}
list.Add(tp);
}
this.tps = new TaskParameters(list, gammaList);
string mfName = this.setCount == 1 ? "MF1" : "MF2";
this.funcDescr = new Functions_2_2(mfName, this.fnames[(sfList.SelectedItem as string).ToUpper()]);
this.tw = new TaskWorker(tps, funcDescr.GetType(), funcDescr.MainFuncName, funcDescr.SecFuncName, funcDescr);
this.startVector = this.setCount == 1 ? new Vector(1, double.Parse(this.txtY0.Text)) :
new Vector(2, double.Parse(this.txtY00.Text), double.Parse(this.txtY01.Text));
RKVectorForm rk = new RKVectorForm(tw, curveName, double.Parse(this.txtT0.Text), double.Parse(this.txtT1.Text), startVector);
this.res = rk.SolveWithConstH(n, RKMetodType.RK4_1);
if (this.rbN1.Checked)
{
res.ForEach(r => this.curves[curveName].Add(r.X, r.Y[0]));
}
else
{
res.ForEach(r => this.curves[curveName].Add(r.Y[0], r.Y[1]));
}
this.zgcMainChart2.AxisChange();
this.zgcMainChart2.Refresh();
if (this.setCount == 1)
{
this.tblResList = new List<ResPointViewType1>();
for (int i = 0; i < res.Count - 1; i++)
(this.tblResList as List<ResPointViewType1>).Add(new ResPointViewType1(res[i].X, res[i].Y[0], -1, -1));
this.dgvTabRes.DataSource = null;
this.dgvTabRes.DataSource = tblResList;
}
else
{
this.tblResList = new List<ResPointViewType2>();
for (int i = 0; i < res.Count - 2; i++)
(this.tblResList as List<ResPointViewType2>).Add(new ResPointViewType2(res[i].X, res[i].Y[0], res[i].Y[1], -1, -1));
this.dgvTabRes.DataSource = null;
this.dgvTabRes.DataSource = tblResList;
}
this.dgvTabRes.RefreshDataSource();
this.randomStartParameters = this.GetRandomStartParam();
}
private void btnSolveRAlg2_Click(object sender, EventArgs e)
{
try
{
this.btnSolveRAlg2.Enabled = false;
int tick = Environment.TickCount;
this.inf2 = null;
//List<List<double>> sp = this.GetRandomStartParam();
List<List<double>> sp = this.randomStartParameters;
RAlgSolver ra = new RAlgSolver(this.tw, this.res, sp, this.startVector);
ra.FUNCT = new RAlgSolver.FUNCTDelegate(ra.FUNCT4);
ra.R_Algorithm();
for (int i = 0; i < res.Count - this.setCount; i++)
{
if (this.setCount == 1)
{
(this.tblResList as List<ResPointViewType1>)[i].M2 = ra.itab[i];
}
else
{
(this.tblResList as List<ResPointViewType2>)[i].M2 = ra.itab[i];
}
}
this.dgvTabRes.RefreshDataSource();
Dictionary<double, int> tt = this.GetTT(this.res, ra.itab);
StringBuilder sb = new StringBuilder();
//-- draw res ---
if (!this.curves.ContainsKey(this.curveName2))
{
this.curves.Add(this.curveName2, new PointPairList());
LineItem curve = new LineItem(this.curveName2, this.curves[curveName2], Color.Blue, SymbolType.None);
curve.Line.Style = System.Drawing.Drawing2D.DashStyle.DashDot;
curve.Line.Width = 2;
this.zgcMainChart2.GraphPane.CurveList.Add(curve);
}
else
{
this.curves[this.curveName2].Clear();
}
int k = 0;
List<TaskParameter> listDraw = new List<TaskParameter>();
for (int i = 0; i < tps.Count; i++)
{
TaskParameter tpDraw = new TaskParameter(tps[i].Param.Length);
string line = string.Format("{0}) ", i);
for (int j = 0; j < tps[0].Param.Length; j++)
{
tpDraw.Param[j] = ra.x[k];
line += string.Format("a{0}={1:f6} ", j, ra.x[k]);
k++;
}
sb.AppendLine(line);
listDraw.Add(tpDraw);
}
sb.AppendLine("-----");
sb.Append(string.Format("f={0}", ra.f));
rtbResult2.Text = sb.ToString();
TaskParameters tps1 = new TaskParameters(listDraw, tt);
TaskWorker tw1 = new TaskWorker(tps1, this.funcDescr.GetType(), this.funcDescr.MainFuncName, this.funcDescr.SecFuncName, this.funcDescr);
RKVectorForm rk1 = new RKVectorForm(tw1, curveName2, double.Parse(this.txtT0.Text), double.Parse(this.txtT1.Text), this.startVector);
RKResults res1 = rk1.SolveWithConstH(n, RKMetodType.RK2_1);
//if (this.setCount == 1)
//{
// res1.ForEach(r => this.curves[this.curveName2].Add(r.X, r.Y[0]));
//}
//else
//{
// res1.ForEach(r => this.curves[this.curveName2].Add(r.Y[0], r.Y[1]));
//}
int nn = this.setCount == 1 ? 1 : 2;
for (int i = 0; i < res1.Count - nn; i++)
{
if (nn == 1)
{
this.curves[curveName2].Add(res1[i].X, res1[i].Y[0]);
}
else
{
this.curves[curveName2].Add(res1[i].Y[0], res1[i].Y[1]);
}
}
this.zgcMainChart2.AxisChange();
this.zgcMainChart2.Refresh();
this.ra2 = ra;
double t = ((Environment.TickCount - tick) / (double)1000);
this.rtbResult2.Text += string.Format("\r\n-----\r\ntime = {0} sec", t);
this.inf2 = string.Format("Result: f = {0:f6} time = {1} sec", ra.f, t);
}
finally
{
this.btnSolveRAlg2.Enabled = true;
}
}
protected static void Build()
{
worker = new TaskWorker<IMessagingChannel>(mockChannel.Object, tokenSource.Token, minWorkers, maxWorkers);
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskWorkerItem"/> class.
/// </summary>
/// <param name="task">The task to represent.</param>
public TaskWorkerItem(TaskWorker task)
: this()
{
this.Task = task;
}
protected override void Start(TaskWorker tw) {
try {
LocalNode.EnqueueAction(tw);
}
catch {
/*
* We could get an exception if queue in LocalNode is closed
*/
tw.Start();
}
}
