public void Progress(int len)
{
if (isCompleted)
{
return;
}
if (TransferredLength == 0 && !isStarted)
{
isStarted = true;
Started?.Invoke(this);
}
TransferredLength += len;
Progressed?.Invoke(this, len);
if (TransferredLength == Length)
{
isCompleted = true;
Completed?.Invoke(this);
}
// else if (TransferredLength > Length)
// {
//#if DEBUG
// Env.Instance.ShowMessage("TransferredLength=" + TransferredLength + "> Length" + Length);
//#endif
// }
}
void IProgressable.Progress(int len)
{
//传送文件的时候，如果文件的状态已经变成了Confirm或者Completed, 再调用Progress是不对的。
if (IsTransferEnd())
{
return;
}
//即使len == 0, 只要用户有意调用这个函数，还是要更改TransferState,这对于空文件是有意义的。会在下面直接把文件变成Completed状态。
if (TransferredLength == 0)
{
TransferState = TransferState.Transferring;
}
TransferredLength += len;
Progressed?.Invoke(this, len);
if (TransferredLength >= Length)
{
TransferState = TransferState.Completed;
if (TransferredLength > Length)
{
var msg = "Transfered Lenght > Total Length. some time this does happens, and the transfer is success.";
Env.Logger.Log(msg);
}
}
((IProgressable)TopLevelDir)?.Progress(len);
TransferBundle?.Progress(len);
}
protected void OnProgress()
{
if (control.InvokeRequired)
{
control.Invoke(new VoidDelegate(OnProgress));
return;
}
if (Progressed != null)
{
Progressed.Invoke(this, EventArgs.Empty);
}
}
/// <summary>
/// Updated the component with the latest upload progress.
/// </summary>
/// <param name="fileEntry">Currently processed file entry.</param>
/// <param name="progressProgress">Progress value.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
internal async Task UpdateFileProgressAsync(IFileEntry fileEntry, long progressProgress)
{
ProgressProgress += progressProgress;
var progress = Math.Round((double)ProgressProgress / ProgressTotal, 3);
if (Math.Abs(progress - Progress) > double.Epsilon)
{
Progress = progress;
await Progressed.InvokeAsync(new FileProgressedEventArgs( fileEntry, Progress ));
}
}
void addOnProgress(Progressed value)
{
lock (_lock) {
if (progress < 1f)
{
_onProgressed += value;
}
else
{
value(progress);
}
}
}
public void Report(RunDetail <MulticlassClassificationMetrics> value)
{
Progressed?.Invoke(this, new ProgressEventArgs
{
Model = new AutomationExperiment
{
Trainer = value.TrainerName,
LogLoss = value.ValidationMetrics?.LogLoss,
LogLossReduction = value.ValidationMetrics?.LogLossReduction,
MicroAccuracy = value.ValidationMetrics?.MicroAccuracy,
MacroAccuracy = value.ValidationMetrics?.MacroAccuracy
}
});
}
public void Progress(int length)
{
if (TransferredLength == 0)
{
TransferState = TransferState.Transferring;
}
TransferredLength += length;
Progressed?.Invoke(this, length);
if (TransferredLength >= Length)
{
TransferState = TransferState.Completed;
}
}
internal protected override void OnInitRequest()
{
//TODO 先检查哪些Items已经存在。直接更新其状态。
receiver.SaveToPath = Path;
receiver.PutItems(Items);
GetItemsMessage message = new GetItemsMessage(Items);
message.Path = RemotePath;
message.BrowseId = BrowseConversionId;
PostMessage(message);
Items.ForEach(i => receiver.Length += i.Length);
receiver.Started += o => Started?.Invoke(this);
receiver.Completed += o => Completed?.Invoke(this);
receiver.Progressed += (o, v) => Progressed?.Invoke(this, v);
}
internal void ForceComplete(TransferState state)
{
//正常状况下，如果已经IsPostCompleted,就不会更新Length了。
//异常情况是，当对方通知文件已经存在时，这边不管已经传输多少，直接把状态修改成Confirmed。此时界面上需要直接把进度更新成１００％。
var tmp = TransferredLength;
TransferredLength = Length;
var delta = Length - tmp;
Progressed?.Invoke(this, delta);
if (Parent != null)
{
((IProgressable)Parent).Progress((int)delta);
}
//要放在最后，因为上面Progress会引起父状态变化，而这里会导致递归检查父状态。
TransferState = state;
}
public DoNothingJob(string name)
{
Name = name;
randomFailer_ = new Random();
Status = JobStatus.Pending;
var elapsedTime = new Random().Next(100, 1000);
//Console.Write("Initializing job {0} that takes {1:##.0}s to complete.\n", Name, elapsedTime * 100.0 / 1000);
timer_ = new Timer(elapsedTime)
{
AutoReset = true
};
timer_.Elapsed += (sender, eventargs) =>
{
var randomFailerValue = randomFailer_.Next(1, 300); // Fail 1 in 3.
//Console.WriteLine($"job:{Name}, randomFailerValue={randomFailerValue}");
var willFail = randomFailerValue == 1;
if (willFail)
{
timer_.Stop();
timer_.Close();
Status = JobStatus.Failed;
}
percentCounter_ += 1;
if (percentCounter_ == 100)
{
percentCounter_ = 0;
timer_.Stop();
timer_.Close();
Status = JobStatus.Completed;
Finished?.Invoke();
}
else
{
Progressed?.Invoke(percentCounter_);
}
};
}
void IProgressable.Progress(int len)
{
//传送文件的时候，如果文件的状态已经变成了Confirm或者Completed, 再调用Progress是不对的。
if (!ShouldProgress())
{
return;
}
if (TransferredLength == 0)
{
TransferState = TransferState.Transferring;
}
TransferredLength += len;
Progressed?.Invoke(this, len);
if (TransferredLength >= Length)
{
TransferState = TransferState.Completed;
if (TransferredLength > Length)
{
var msg = "Transfered Lenght > Total Length. some time this does happens, and the transfer is success.";
Env.Instance.Logger.Warn(msg);
}
}
//对于DirItem是怎么避免错误的Progress的？FileItem会导致父容器Progress。
//容器类的Progress被直接调用是错误的。应该定义一个ProgressableContainer。只有一个具体的Item才能驱动容器的进度。
//现在FileItem的Parent还不一定是DirItem,可以是ListSequencable。应该简化此处的结构，让Parent只有一种可能性。应该考虑让DirItem直接实现ListSequencable。
if (Parent != null)
{
((IProgressable)Parent).Progress(len);
}
}
private void request_Progress(long current, long total) => API.Schedule(() => Progressed?.Invoke(current, total));
public void InvokeProgress(ProgressEventArgs e)
{
Progressed?.Invoke(this, e);
}
void IGameObjectiveInformer.OnProgressed(int amount)
{
Progressed?.Invoke(amount);
}
