public void OnTaskFinished(long time, Dictionary <int, List <AlarmDataModel> > alarmsMemory)
{
TaskFinished?.Invoke(null, new TaskFinishedEventArgs()
{
ScanTimeMiliseconds = time, AlarmsMemory = alarmsMemory
});
}
private void IterateWorkflow(WorkflowRun <TWfContext> run)
{
if (_finish.Exists(precondition => precondition.Met(run.FinishedTasks)))
{
WorkflowFinished?.Invoke(this, new WorkflowEventArgs <TWfContext>(run.RunId, run.Context));
return;
}
var tasksToExecute = _tasks.Where(kv => kv.Value.Met(run.FinishedTasks) && !run.HasFinished(kv.Key))
.Select(kv => kv.Key).ToList();
var anythingFinished = false;
foreach (var task in tasksToExecute)
{
task.Action(run.Context);
run.StartTask(task);
TaskStarted?.Invoke(this, new WorkflowTaskEventArgs <TWfContext>(run.RunId, task.TaskId, run.Context));
if (task.Autocomplete)
{
TaskFinished?.Invoke(this,
new WorkflowTaskEventArgs <TWfContext>(run.RunId, task.TaskId, run.Context));
run.FinishTask(task);
anythingFinished = true;
}
}
if (anythingFinished)
{
IterateWorkflow(run);
}
}
static void GetFiles(string folder)
{
Mediator.AsyncThread = Thread.CurrentThread;
Mediator.FilesList = new List <string>();
GetFilesRecurs(folder);
TaskFinished?.Invoke(CurrentTask.SearchFiles);
}
public void ConsumeMessage <TMessage>(TMessage message)
{
if (_startsOn.ContainsKey(typeof(TMessage)))
{
var run = new WorkflowRun <TWfContext>(
((Func <TMessage, TWfContext>)_startsOn[typeof(TMessage)])(message));
_runs.Add(run);
WorkflowStarted?.Invoke(this, new WorkflowEventArgs <TWfContext>(run.RunId, run.Context));
IterateWorkflow(run);
return;
}
var runs = _runs.ToArray();
var tasksToFinish = _continuesOn.Where(kv => kv.Value == typeof(TMessage)).Select(kv => kv.Key);
foreach (var workflowTask in tasksToFinish)
{
var messageBasedTask = (WorkflowTask <TWfContext, TMessage>)workflowTask;
var runsToProcess = runs.Where(r =>
(messageBasedTask).WorkflowRunSelector(r.Context, message))
.Where(r => r.HasStarted(workflowTask));
foreach (var run in runsToProcess)
{
messageBasedTask.AfterMessageReceived?.Invoke(run.Context, message);
TaskFinished?.Invoke(this,
new WorkflowTaskEventArgs <TWfContext>(run.RunId, workflowTask.TaskId, run.Context));
run.FinishTask(workflowTask);
IterateWorkflow(run);
}
}
}
public void DoDetectedTask()
{
while (_taskList.Count > 0 && _startTime.AddMinutes(_taskList.ElementAt(0)._delay) <= FastClock.Instance.Time)
{
Task task = _taskList.ElementAt(0);
string message = "";
switch (task._orderType)
{
case OrderType.Order:
task._guest.AddArticle(task._article);
Task deliverTask = new Task(task._delay + task._article.TimeToBuild, task._guest, OrderType.Ready, task._article);
_taskList.Add(deliverTask);
_taskList.Sort();
message = task.ToString();
break;
case OrderType.Ready:
message = task.ToString();
break;
case OrderType.ToPay:
message = $"{task._guest.Name} pays {task._guest.Tab:f2}";
_guestList.Remove(task._guest.Name);
break;
}
_taskList.RemoveAt(0);
TaskFinished?.Invoke(this, message);
}
}
private void Task()
{
var tool = new ToolHelp32();
var processes = tool.GetProcesses().ToList();
ContextProvider.Send(obj => TaskFinished?.Invoke(processes), null);
}
public void FinishTask()
{
evt_taskFinished.Invoke(this);
if (disablePlayerMovement)
{
GameManager.instance.EnablePlayerControl(true);
}
}
protected void OnTaskFinished(ITask task)
{
var eventArgs = new TaskFinishedEventArgs(
task
);
TaskFinished?.Invoke(this, eventArgs);
}
/// <summary>
/// Executes the task.
/// </summary>
/// <param name="task">The task.</param>
/// <exception cref="NotImplementedException"></exception>
public void ExecuteTask(IEngineTask task)
{
// Check if task can be executed
if (!task.CanBeExecuted())
{
task.AddMessage($"The task cannot be executed.", MessageSeverity.Error);
if (task.ParentJob.FailIfAnyTaskHasError)
{
throw new EngineException(logger, $"The task cannot be executed. This job was aborted.");
}
else
{
return;
}
}
// Execute task
if (TaskStarted != null)
{
TaskStarted.Invoke((Guid)task.EntityId, (Guid)task.InstanceID);
}
task.Start();
// Stop task
task.Stop();
if (task.HasErrors)
{
task.AddMessage($"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs.", MessageSeverity.Error);
if (task.ParentJob.FailIfAnyTaskHasError)
{
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false);
}
throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs. This job was aborted.");
}
}
else if (task.HasWarnings)
{
task.AddMessage($"The task (instance: {task.InstanceID}) was executed but one or more warning occurs.", MessageSeverity.Warning);
if (task.ParentJob.FailIfAnyTaskHasWarning)
{
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false);
}
throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was executed but one or more warning occurs. This job was aborted.");
}
}
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, true);
}
}
private static void ManagerDB_ProcDoneHandler()
{
_report = DbNotification.GetResultFromDb();
ReportUpdated?.Invoke(_report);
if (QMediator.IsAuto)
{
TaskFinished?.Invoke(QMediator.CurrentTaskName);
}
}
private void OnCurrentTaskFinished(AIBackupUnitTask task, bool aborted)
{
if (currentTask != null)
{
currentTask.Finished -= OnCurrentTaskFinished;
TaskFinished?.Invoke(currentTask);
currentTask = null;
}
}
/// <summary>
/// Raise one of the events that is appropriate for the type of the BuildEventArgs
/// </summary>
public void Dispatch(BuildEventArgs buildEvent)
{
if (buildEvent is BuildMessageEventArgs)
{
MessageRaised?.Invoke(null, (BuildMessageEventArgs)buildEvent);
}
else if (buildEvent is TaskStartedEventArgs)
{
TaskStarted?.Invoke(null, (TaskStartedEventArgs)buildEvent);
}
else if (buildEvent is TaskFinishedEventArgs)
{
TaskFinished?.Invoke(null, (TaskFinishedEventArgs)buildEvent);
}
else if (buildEvent is TargetStartedEventArgs)
{
TargetStarted?.Invoke(null, (TargetStartedEventArgs)buildEvent);
}
else if (buildEvent is TargetFinishedEventArgs)
{
TargetFinished?.Invoke(null, (TargetFinishedEventArgs)buildEvent);
}
else if (buildEvent is ProjectStartedEventArgs)
{
ProjectStarted?.Invoke(null, (ProjectStartedEventArgs)buildEvent);
}
else if (buildEvent is ProjectFinishedEventArgs)
{
ProjectFinished?.Invoke(null, (ProjectFinishedEventArgs)buildEvent);
}
else if (buildEvent is BuildStartedEventArgs)
{
BuildStarted?.Invoke(null, (BuildStartedEventArgs)buildEvent);
}
else if (buildEvent is BuildFinishedEventArgs)
{
BuildFinished?.Invoke(null, (BuildFinishedEventArgs)buildEvent);
}
else if (buildEvent is CustomBuildEventArgs)
{
CustomEventRaised?.Invoke(null, (CustomBuildEventArgs)buildEvent);
}
else if (buildEvent is BuildStatusEventArgs)
{
StatusEventRaised?.Invoke(null, (BuildStatusEventArgs)buildEvent);
}
else if (buildEvent is BuildWarningEventArgs)
{
WarningRaised?.Invoke(null, (BuildWarningEventArgs)buildEvent);
}
else if (buildEvent is BuildErrorEventArgs)
{
ErrorRaised?.Invoke(null, (BuildErrorEventArgs)buildEvent);
}
AnyEventRaised?.Invoke(null, buildEvent);
}
private TResult EventWrapper()
{
var result = _func?.Invoke();
TaskFinished?.Invoke(this, new TaskWrapperEventArgs <TResult>()
{
Result = result
});
return(result);
}
public void OnTaskFinished(EventArgs args)
{
groupBoxReadMode.Enabled = true;
groupBoxSettings.Enabled = true;
groupBoxTemp.Enabled = true;
buttonAbort.Enabled = false;
buttonPause.Enabled = false;
buttonSave.Enabled = true;
TaskFinished?.Invoke(this, args);
}
private static void UpdateReport()
{
try
{
_report = ReadLog();
ReportUpdated?.Invoke(_report);
TaskFinished?.Invoke(TaskName.AdrSplit);
}
catch (Exception ex)
{
ExceptionHandler("UpdateReport()", ex.Message);
}
}
private StatusCode doExec(string parameter)
{
StatusCode retVal;
try
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Suppress))
{
retVal = OnExec(parameter ?? TaskDataParameter);
}
if (retVal.IsSucceeded)
{
Notify("[Task] " + this.CurrentTaskInfo.description + " Done");
}
}
catch (Exception ex)
{
retVal =
new CommonStatusCode(CommonStatusCode.TASK_EXECUTION_FAILED, new object[] { ApplicationID, TaskInfoID, TaskDataParameter, TaskDataID }, ex, Config, ApplicationID);
}
//Create new Instance
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
if (!retVal.IsSucceeded)
{
StatusCode retVal2 = createNewInstance(parameter, STATUS_FAIL, null, retVal, null);
if (retVal2.IsSucceeded)
{
retVal = retVal2;
}
}
else
{
retVal =
createNewInstance(parameter, STATUS_COMPLETE,
null, null, null);
}
scope.Complete();
}
}
catch (Exception ex2)
{
retVal =
new CommonStatusCode(CommonStatusCode.TASK_LIBRARY_INTERNAL_ERROR, new object[] { ApplicationID, TaskInfoID, TaskDataParameter, TaskDataID }, ex2, Config, ApplicationID);
}
TaskFinished?.Invoke(this, null);
return(retVal);
}
private void _on_task_finished(object sender, EventArgs e)
{
lock (_external_lock)
{
if (_auto_start && _queue_data.Count > _pool_size)
{
_queue_data.ElementAt(_pool_size).Value.Start();
}
_queue_data.Remove((int)((Downloader)sender).Tag);
_set_speed();
}
try { TaskFinished?.Invoke(sender, e); }
catch { }
}
static void ReplaceText()
{
int count = 0;
foreach (var item in Mediator.FilesList)
{
string oldText = File.ReadAllText(item, Encoding.Default);
if (oldText.Contains(Mediator.Search))
{
string newText = oldText.Replace(Mediator.Search, Mediator.Replace);
File.WriteAllText(item, newText, Encoding.Default);
count++;
}
}
Mediator.UpdatedFiles = count;
TaskFinished?.Invoke(CurrentTask.ReplaceText);
}
private void _on_task_finished(object sender, EventArgs e)
{
lock (_external_lock)
{
if (_auto_start && _queue_data.Count > _pool_size)
{
_queue_data.ElementAt(_pool_size).Value.Start();
}
_queue_data.Remove((int)((Uploader)sender).Tag);
//System.Threading.ThreadPool.QueueUserWorkItem(delegate
//{
// ((Uploader)sender).Dispose();
//});
_set_speed();
}
try { TaskFinished?.Invoke(sender, e); }
catch { }
}
void CreateBackUp()
{
string str = ManagerDB.CreateBackUp(BackUpName);
if (str.Length < 1)
{
BackUpReport = "Таблица не создана.";
}
else
{
BackUpReport = "Таблица успешно создана. Количество записей - " + str;
}
QLoger.AddRecordToLog(BackUpName + "\t" + BackUpReport);
if (QMediator.IsAuto)
{
TaskFinished?.Invoke(TaskName.BackUp);
}
}
/// <summary>
/// Kellner führt Task aus, falls etwas zu tun ist.
/// </summary>
public void DoTasks()
{
//Gibt es was zu tun?
while (_tasks.Count > 0 &&
_startTime.AddMinutes(_tasks.ElementAt(0).Delay) <= FastClock.Instance.Time)
{
Task task = _tasks.ElementAt(0);
//Tasks ausführen
_tasks.RemoveAt(0);
string message = "";
switch (task.TaskType)
{
case TaskType.Order:
task.Guest.OrderArticle(task.Article);
Task deliverTask = new Task(TaskType.Deliver, task.Delay + task.Article.TimeToBuild,
task.Guest, task.Article);
_tasks.Add(deliverTask);
_tasks.Sort(); // damit die Auslieferung entsprechend der Zeit eingefügt wird
Debug.WriteLine(task);
message = task.ToString();
break;
case TaskType.Deliver:
Debug.WriteLine(task);
message = task.ToString();
break;
case TaskType.Pay:
double sum = task.Guest.CalculateSumOfOrders();
message = $"Pay\t{task.Guest.Name} \t {sum:f2}";
Debug.WriteLine(message);
_guests.Remove(task.Guest.Name);
break;
}
TaskFinished?.Invoke(this, message);
}
//// Rekursiver Aufruf der Taskbearbeitung bis in dieser Minute keine Aufträge anstehen.
//DoTasks();
}
public virtual void Update(GameTime gameTime)
{
if (!Stopped)
{
timespan++;
if (timespan >= interval)
{
timespan = 0;
if (index + 1 >= length)
{
Finished = true;
}
else
{
index++;
}
}
}
if (Finished)
{
TaskFinished?.Invoke(this);
}
}
private void CheckRefreshResult(JRCtler.JsonRpcRes e)//检查Refresh方法中异步返回的结果
{
foreach (dynamic s in e.Result)
{
JRCtler.JsonRpcRes a = new JRCtler.JsonRpcRes
{
Result = s
};
string g = a.Result.gid;
if (GidList.Contains(g) != true)
{
GidList.Add(g);
string Status = a.Result.status;
if (Status != "complete")
{
Add(new TaskLite(a));
}
else
{
TaskFinished?.Invoke(new TaskLite(a));
}
}
}
}
private void FireTaskFinished()
{
TaskFinished?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Use this method to finish effect, rather than turning <see cref="Finished"/> variable to true.
/// </summary>
public virtual void Finish()
{
Finished = true; TaskFinished?.Invoke(this);
}
private void OnTaskFinished()
{
this.IsComplete = true;
TaskFinished?.Invoke(this, null);
}
private void InformationRefresh(JRCtler.JsonRpcRes e)
{
//计算当前下载速度
double SpeedLong = e.Result.downloadSpeed;
if (SpeedLong / 1024 == 0)
{
Speed = Math.Round(SpeedLong, 2).ToString() + "B/S";
}
else if (SpeedLong / 1048576 == 0)
{
Speed = Math.Round((SpeedLong / 1024), 2).ToString() + "KB/S";
}
else
{
Speed = Math.Round((SpeedLong / 1048578), 2).ToString() + "MB/S";
}
OnPropertyChanged("Speed");
//更新状态
string NewStatus = e.Result.status;
if (Status != NewStatus)
{
Status = NewStatus;
switch (Status)
{
case "active":
State = "none";
break;
case "waiting":
State = "wait";
OughtToRefresh = 5;
break;
case "paused":
State = "wait";
OughtToRefresh = 5;
break;
case "error":
State = "error";
OughtToRefresh = 10;
break;
case "complete":
State = "none";
TaskFinished?.Invoke(this);
OughtToRefresh = 10;
break;
case "removed":
State = "error";
OughtToRefresh = 10;
break;
default:
State = "wait";
OughtToRefresh = 5;
break;
}
OnPropertyChanged("State");
}
//更新进度
string CompletedNew = e.Result.completedLength;
Total = e.Result.totalLength;
if (CompletedNew != Completed)
{
Completed = CompletedNew;
OnPropertyChanged("Progress");
}
else if (CompletedNew == "0")
{
State = "wait";
OnPropertyChanged("State");
}
Gid = e.Result.gid;
if (FileName == null || FileNameSource != FileNameSources.Path)
{
GetFileInfo();
}
e = null;
}
public static void ProgsToExec(ExecProgsType taskName)
{
try
{
_report = "Выполнение программ...\n\n";
ReportUpdated?.Invoke(_report);
if (QMediator.PathToProgDest != null)
{
string str;
if (taskName == ExecProgsType.Oktel)
{
str = "\\post!\\oktel";
QMediator.CurrentTaskName = TaskName.Oktel;
DbNotification.ResultWaiter();
}
else
{
str = taskName == ExecProgsType.PredProgs ? "\\!pred" : "\\post!";
}
string path = QMediator.PathToProgDest + str;
if (!new DirectoryInfo(path).Exists)
{
Directory.CreateDirectory(path);
_report = "Нет программ для выполнения.";
}
else
{
List <string> filePathList = GetFilesForExec(path);
if (filePathList.Count < 1)
{
_report = "Нет программ для выполнения.";
ReportUpdated?.Invoke(_report);
if (taskName == ExecProgsType.PredProgs)
{
TaskFinished?.Invoke(TaskName.PredProgs);
}
else if (taskName == ExecProgsType.PostProgs)
{
TaskFinished?.Invoke(TaskName.PostProgs);
}
else
{
TaskFinished?.Invoke(TaskName.Oktel);
}
return;
}
foreach (var item in filePathList)
{
_report += Environment.NewLine + "Файл:\t\t" + item;
bool isOk = true;
string fileText = File.ReadAllText(item, Encoding.Default);
try
{
if (fileText.ToLower().Contains("begin"))
{
ManagerDB.ExecCommand(fileText);
}
else
{
isOk = SplitAndExec(fileText);
}
}
catch (Exception ex)
{
isOk = false;
ExceptionHandler("ProgsToExec()", ex.Message);
}
_report += ("\t" + (isOk == true ? "отработал нормально." : "отработал с ошибками.") + Environment.NewLine);
}
}
}
else
{
_report = "Не определен путь к программам.";
}
ReportUpdated?.Invoke(_report);
if (taskName == ExecProgsType.PredProgs)
{
TaskFinished?.Invoke(TaskName.PredProgs);
}
else if (taskName == ExecProgsType.PostProgs)
{
TaskFinished?.Invoke(TaskName.PostProgs);
}
else
{
TaskFinished?.Invoke(TaskName.Oktel);
}
}
catch (Exception ex)
{
ExceptionHandler("ProgsToExec()", ex.Message);
}
}
// ReSharper disable once UnusedMember.Local
private void OnTaskFinished(TaskFinishedEventArgs e)
{
TaskFinished?.Invoke(this, e);
}
//RAM stream -> File stream
private void _monitor_thread_callback()
{
//设置线程启动相关变量
_monitor_thread_created.Set();
_start_time = DateTime.Now;
//管理任务状态
bool pause_to_start = false;
lock (_thread_flag_lock)
{
pause_to_start = ((_download_thread_flag & 0xffffff) & (_DOWNLOAD_THREAD_FLAG_PAUSED | _DOWNLOAD_THREAD_FLAG_PAUSE_REQUESTED)) != 0;
_download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_STARTED) & ~_DOWNLOAD_THREAD_FLAG_START_REQUESTED;
if (pause_to_start)
{
_download_thread_flag = (_download_thread_flag & ~_DOWNLOAD_THREAD_FLAG_PAUSED);
}
}
//缓存最大线程数，避免中途更改
var max_thread = _max_thread;
//预分配空间（todo：改为set-length，提高效率）
_downloaded_size = 0;
try { PreAllocBlockStarted?.Invoke(this, new EventArgs()); } catch { }
if (_file_stream.Length != (long)_data.Size)
{
if (_file_stream.Length > (long)_data.Size)
{
_file_stream.SetLength((long)_data.Size); //文件长度大于预分配长度，直接截断
}
else
{
//从当前长度开始按0填充
_file_stream.Seek(0, SeekOrigin.End);
_downloaded_size = _file_stream.Length;
var blank_buffer = new byte[_MIN_IO_FLUSH_DATA_LENGTH];
long write_length = 0;
do
{
write_length = (long)_data.Size - _file_stream.Length;
int len = (int)Math.Min(_MIN_IO_FLUSH_DATA_LENGTH, write_length);
_file_stream.Write(blank_buffer, 0, len);
_downloaded_size += len;
} while (write_length > 0 && ((_download_thread_flag & 0xffffff) & (_DOWNLOAD_THREAD_FLAG_PAUSE_REQUESTED | _DOWNLOAD_THREAD_FLAG_STOP_REQUESTED)) == 0);
}
_file_stream.Seek(0, SeekOrigin.Begin);
}
try { PreAllocBlockFinished?.Invoke(this, new EventArgs()); } catch { }
_downloaded_size = 0;
//分配多线程的变量数组
_guid_list = new Guid[max_thread];
_last_receive = new DateTime[max_thread];
_buffer_stream = new QueueStream[max_thread];
_thread_data_lock = new object[max_thread];
_request = new NetStream[max_thread];
_position = new ulong[max_thread];
_io_position = new long[max_thread];
for (int i = 0; i < max_thread; i++)
{
_buffer_stream[i] = new QueueStream();
_thread_data_lock[i] = new object();
_request[i] = new NetStream();
_request[i].CookieKey = _cookie_key;
}
var buffer = new byte[_MIN_IO_FLUSH_DATA_LENGTH];
var next_loop_time = DateTime.Now.AddSeconds(1);
//监控循环
#region monitor loop
while (true)
{
//当url的有效时间已过时，刷新url
if (_url_expire_time < DateTime.Now)
{
_url_expire_time = _url_expire_time.AddSeconds(30);
_url_fail_to_fetch_count = 0;
_api.GetAccount(_data.AccountID).GetLocateDownloadLinkAsync(_data.Path, _main_url_refresh_callback);
}
//管理任务标识
#region thread flag handling
bool ispause = false, iscancel = false;
if (((_download_thread_flag & 0xffffff) & _DOWNLOAD_THREAD_FLAG_PAUSE_REQUESTED) != 0)
{
ispause = true;
}
if (((_download_thread_flag & 0xffffff) & _DOWNLOAD_THREAD_FLAG_STOP_REQUESTED) != 0)
{
iscancel = true;
}
if (ispause)
{
//pause event
for (int i = 0; i < _request.Length; i++)
{
lock (_thread_data_lock[i])
{
_request[i].Close();
if (_guid_list[i] != Guid.Empty)
{
_dispatcher.ReleaseTask(_guid_list[i]);
_guid_list[i] = Guid.Empty;
}
//flushing buffer stream
if ((_guid_list[i] == Guid.Empty && _buffer_stream[i].Length > 0) || (_buffer_stream[i].Length > _MIN_IO_FLUSH_DATA_LENGTH))
{
_file_stream.Seek(_io_position[i], SeekOrigin.Begin);
while ((_guid_list[i] == Guid.Empty && _buffer_stream[i].Length > 0) || (_buffer_stream[i].Length > _MIN_IO_FLUSH_DATA_LENGTH))
{
int rc = _buffer_stream[i].Read(buffer, 0, _MIN_IO_FLUSH_DATA_LENGTH);
_file_stream.Write(buffer, 0, rc);
_io_position[i] += rc;
}
}
}
_file_stream.Flush();
}
_request = null;
_urls = null;
_guid_list = null;
_last_receive = null;
_position = null;
_thread_data_lock = null;
_monitor_thread = null;
_end_time = DateTime.Now;
_download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_PAUSED) & ~(_DOWNLOAD_THREAD_FLAG_PAUSE_REQUESTED | _DOWNLOAD_THREAD_FLAG_STARTED);
return;
}
if (iscancel)
{
//cancel event
_file_stream.Close();
for (int i = 0; i < _request.Length; i++)
{
lock (_thread_data_lock[i])
{
_request[i].Close();
if (_guid_list[i] != Guid.Empty)
{
_dispatcher.ReleaseTask(_guid_list[i]);
_guid_list[i] = Guid.Empty;
}
}
}
_request = null;
_urls = null;
_guid_list = null;
_last_receive = null;
_position = null;
_thread_data_lock = null;
_file_stream.Dispose();
_file_stream = null;
_monitor_thread = null;
_end_time = DateTime.Now;
_download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_STOPPED) & ~(_DOWNLOAD_THREAD_FLAG_STOP_REQUESTED | _DOWNLOAD_THREAD_FLAG_STARTED);
return;
}
#endregion
//url合理检测
if (_urls == null || _urls.Length == 0)
{
Thread.Sleep(100);
continue;
}
int started_tasks = 0;
for (int i = 0; i < _request.Length; i++)
{
lock (_thread_data_lock[i])
{
//将内存的缓存数据流写入到硬盘中
if ((_guid_list[i] == Guid.Empty && _buffer_stream[i].Length > 0) || (_buffer_stream[i].Length > _MIN_IO_FLUSH_DATA_LENGTH))
{
_file_stream.Seek(_io_position[i], SeekOrigin.Begin);
while ((_guid_list[i] == Guid.Empty && _buffer_stream[i].Length > 0) || (_buffer_stream[i].Length > _MIN_IO_FLUSH_DATA_LENGTH))
{
int rc = _buffer_stream[i].Read(buffer, 0, _MIN_IO_FLUSH_DATA_LENGTH);
_file_stream.Write(buffer, 0, rc);
_io_position[i] += rc;
}
}
//检测任务分配状态，自动开始新的分段下载
if (_guid_list[i] == Guid.Empty && (DateTime.Now - _last_receive[i]).TotalSeconds > 3.0)
{
if (started_tasks < _PARALLEL_START_REQUEST_COUNT)
{
_guid_list[i] = _dispatcher.AllocateNewTask(out _position[i]);
if (_guid_list[i] != Guid.Empty)
{
_last_receive[i] = DateTime.Now;
try
{
_request[i].UserAgent = "netdisk;5.7.2.3;PC;PC-Windows;10.0.16299;WindowsBaiduYunGuanJia";
_request[i].HttpGetAsync(_urls[i % _urls.Length], _data_transfer_callback, new _temp_strcut {
id = _guid_list[i], index = i
}, range: (long)_position[i]);
_io_position[i] = (long)_position[i];
}
catch { }
started_tasks++;
}
}
}
//自动中断超时的请求
else if (_guid_list[i] != Guid.Empty && (DateTime.Now - _last_receive[i]).TotalSeconds > 35.0)
{
_request[i].Close();
_request[i] = new NetStream();
_dispatcher.ReleaseTask(_guid_list[i]);
_guid_list[i] = Guid.Empty;
}
}
}
_current_bytes = 0;
//更新速度
var cur_len = _dispatcher.CompletedLength;
_last_5s_length.RemoveFirst();
_last_5s_length.AddLast(cur_len);
_average_speed_total = cur_len / (DateTime.Now - _start_time).TotalSeconds;
_average_speed_5s = (_last_5s_length.Last.Value - _last_5s_length.First.Value) / 5.0;
_downloaded_size = (long)cur_len;
Tracer.GlobalTracer.TraceInfo("Downloading: " + cur_len + "/" + _data.Size + " [" + (_average_speed_5s / 1024).ToString("0.00") + "KB/s]");
if (cur_len == _data.Size)
{
break;
}
//时钟控制（1s）
var ts = (next_loop_time - DateTime.Now).TotalMilliseconds;
next_loop_time = next_loop_time.AddSeconds(1);
if (ts >= 1.0)
{
Thread.Sleep((int)ts);
}
}
#endregion
//下载完成
_file_stream.Close();
for (int i = 0; i < _request.Length; i++)
{
lock (_thread_data_lock[i])
{
_request[i].Close();
}
}
_request = null;
_urls = null;
_guid_list = null;
_last_receive = null;
_position = null;
_thread_data_lock = null;
_file_stream.Dispose();
_file_stream = null;
_monitor_thread = null;
_end_time = DateTime.Now;
//文件解密
if (_data.Path.EndsWith(".bcsd"))
{
_download_thread_flag |= _DOWNLOAD_THREAD_FLAG_DECRYPTING;
try { DecryptStarted?.Invoke(this, new EventArgs()); } catch { }
_decrypt_file();
_download_thread_flag = _download_thread_flag & ~_DOWNLOAD_THREAD_FLAG_DECRYPTING;
try { DecryptFinished?.Invoke(this, new EventArgs()); } catch { }
}
_download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_FINISHED) & ~_DOWNLOAD_THREAD_FLAG_STARTED;
try { TaskFinished?.Invoke(this, new EventArgs()); }
catch { }
}
