public SmtpClient()
{
Security = SecurityPolicies.None;
ResponseTimeout = TimeSpan.FromMinutes(5);
UpdateUploadProgressTriggerChunkSize = Size.FromBytes(500);
_uploadProgressChangedEventArgs = new UploadProgressChangedEventArgs(0, 1);
}
private void Programming_ProgressChanged(object sender, UploadProgressChangedEventArgs args)
{
Debug.WriteLine("");
Debug.WriteLine("[{0:D3}/{1:D3}] {2} ({3:N0}%)",
args.CurrentBlock,
args.TotalBlocks,
args.Filename,
args.ProgressPercentage*100);
Debug.WriteLine("");
}
private void Progresss3(object sender, UploadProgressChangedEventArgs e)
{
// the progress
progressBar4.Value = e.ProgressPercentage;
if (progressBar4.Value == 100)
{
progressBar4.Value = 0;
pictureBox3.Image = null;
img3 = null;
this.Enabled = true;
}
}
void _Client_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
double bytesIn = double.Parse(e.BytesSent.ToString());
double totalBytes = double.Parse(e.TotalBytesToSend.ToString());
double percentage = bytesIn / totalBytes * 100;
currentByte = bytesIn - currentByte;
if (ctrlAlbum != null)
{
ctrlAlbum.progressUpdate.Value = int.Parse(Math.Truncate(percentage).ToString());
}
//_ProgressBarWindow.ProgressValue( int.Parse(Math.Truncate(percentage).ToString()));
//_ProgressBarWindow.ProgrssStateDisplay(fileName, currentByte / 1000, totalBytes / 1000, bytesIn / 1000);
currentByte = bytesIn;
}
private void UploadProgressCallback(object sender, UploadProgressChangedEventArgs e)
{
// a clever way to handle cross-thread calls and avoid the dreaded
// "Cross-thread operation not valid: Control 'textBox1' accessed
// from a thread other than the thread it was created on." exception
// this will always be called from another thread,
// no need to check for InvokeRequired
BeginInvoke(
new MethodInvoker(() =>
{
textBox1.Text = (string)e.UserState + "\n\n"
+ "Uploaded " + e.BytesSent + "/" + e.TotalBytesToSend
+ "b (" + e.ProgressPercentage + "%)";
}));
}
public static void NotifyProgress(object itemsSyncRoot, IList <UploadableItem> items, UploadablePart part, ITelegramEventAggregator eventAggregator)
{
bool isComplete = false;
bool isCanceled;
var progress = 0.0;
lock (itemsSyncRoot)
{
part.Status = PartStatus.Processed;
isCanceled = part.ParentItem.Canceled;
if (!isCanceled)
{
isComplete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!isComplete)
{
double uploadedCount = part.ParentItem.Parts.Count(x => x.Status == PartStatus.Processed);
double totalCount = part.ParentItem.Parts.Count;
progress = uploadedCount / totalCount;
}
else
{
items.Remove(part.ParentItem);
}
}
}
if (!isCanceled)
{
if (isComplete)
{
SwitchIdleDetectionMode(true);
Execute.BeginOnThreadPool(() => eventAggregator.Publish(part.ParentItem));
}
else
{
if (part.ParentItem.FileNotFound)
{
return;
}
var args = new UploadProgressChangedEventArgs(part.ParentItem, progress);
Execute.BeginOnThreadPool(() => eventAggregator.Publish(args));
}
}
}
void UploadProgressHandler(object sender, UploadProgressChangedEventArgs e)
{
double sent = ((double)e.BytesSent / 1024 / 1024);
double total = ((double)e.TotalBytesToSend / 1024 / 1024);
int realProgress = e.ProgressPercentage != 100 ? e.ProgressPercentage * 2 : e.ProgressPercentage;
if (realProgress < 0 || realProgress > 100)
{
realProgress = 0;
}
string status = "Uploaded "
+ sent.ToString("F", CultureInfo.InvariantCulture) + " of "
+ total.ToString("F", CultureInfo.InvariantCulture) + "MB. "
+ " (" + realProgress + "%)";
toolStripStatusLabel.Text = status;
toolStripProgressBar.Value = realProgress;
}
void client_UploadProgressChanged4(object sender, UploadProgressChangedEventArgs e)
{
try
{
int value = e.ProgressPercentage; //(int)((decimal)e.BytesSent / (decimal)e.TotalBytesToSend * 100);
//update the progress on UI
label1.Invoke((Action) delegate { ReportProgress1(1, 3, e.BytesSent.ToString() + " bytes sent", value); });
//// get the elapsed time in milliseconds
//ctime4 = stopwatch.ElapsedMilliseconds;
//if (ctime4 - ptime4 > 300)
//{
// label2.Invoke((Action)delegate { ReportProgress2(1, 3, e.BytesSent.ToString() + " bytes sent", value); });
// ptime4 = ctime4;
//}
}
catch (Exception ee)
{ ltime4.Text = ee.Message; }
}
public void ShouldCreateAssetFromFolderWithUploadProgressChangedCallback()
{
var uploadResults = new ConcurrentDictionary <string, UploadProgressChangedEventArgs>();
Action <IAssetFile, UploadProgressChangedEventArgs> uploadProgressChangedCallback =
(af, e) =>
{
IAssetFile assetFile = af;
UploadProgressChangedEventArgs eventArgs = e;
Assert.IsNotNull(assetFile);
Assert.IsNotNull(eventArgs);
uploadResults.AddOrUpdate(assetFile.Name, eventArgs, (k, e2) => eventArgs);
};
var folderName = "Media";
this.asset = this.context.Assets.CreateFromFolder(folderName, AssetCreationOptions.None, uploadProgressChangedCallback);
var assetId = this.asset.Id;
Assert.IsNotNull(this.asset);
Assert.AreEqual(folderName, this.asset.Name);
Assert.AreEqual(3, uploadResults.Count);
AssertUploadedFile(folderName, @"Media\smallwmv1.wmv", uploadResults[@"Media\smallwmv1.wmv"]);
AssertUploadedFile(folderName, @"Media\smallwmv2.wmv", uploadResults[@"Media\smallwmv2.wmv"]);
AssertUploadedFile(folderName, @"Media\dummy.ism", uploadResults[@"Media\dummy.ism"]);
var assetFiles = this.asset.AssetFiles.ToList().OrderBy(a => a.Name);
Assert.AreEqual(3, assetFiles.Count());
Assert.AreEqual("dummy.ism", assetFiles.ElementAt(0).Name);
Assert.IsTrue(assetFiles.ElementAt(0).IsPrimary);
Assert.AreEqual("smallwmv1.wmv", assetFiles.ElementAt(1).Name);
Assert.IsFalse(assetFiles.ElementAt(1).IsPrimary);
Assert.AreEqual("smallwmv2.wmv", assetFiles.ElementAt(2).Name);
Assert.IsFalse(assetFiles.ElementAt(2).IsPrimary);
this.context = TestHelper.CreateContext();
Assert.AreEqual(0, this.context.Locators.Where(l => l.AssetId == assetId).Count());
}
private void Xbox_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
//Update progress
m_TotalSentBytes += e.BytesSent;
//Setup
TimeSpan elapsedTime = DateTime.Now - m_StartUploadTime;
m_AverageUploadRate = (float)(m_TotalSentBytes / elapsedTime.TotalSeconds);
//Invoke
if (IsHandleCreated)
{
Invoke(new MethodInvoker(delegate
{
Text = $"Uploading... ({GetSizeString((int)Math.Ceiling(m_AverageUploadRate))}/ s)";
fileProgressBar.Value = e.ProgressPercentage;
}));
}
}
private void OnRangeUploadProgressChanged(Object sender, System.Net.UploadProgressChangedEventArgs e)
{
lock (infoLock) {
if (!uploadInfos.ContainsKey((WebClient)sender))
{
return;
}
uploadInfos[(WebClient)sender].uploadedBytes = e.BytesSent;
Int64 bytesSent = this.uploadedBytes;
foreach (var kv in uploadInfos)
{
bytesSent += kv.Value.uploadedBytes;
}
UploadProgressChangedEventArgs ee = new UploadProgressChangedEventArgs();
ee.BytesSent = bytesSent;
ee.TotalBytesToSend = fileSize;
UploadProgressChanged(this, ee);
}
}
private void UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
if (e.ProgressPercentage % 10 == 0 && e.ProgressPercentage > _percentageUploaded)
{
_percentageUploaded = e.ProgressPercentage;
int p = e.ProgressPercentage;
this.InvokeEx(x =>
{
x.txtUploadLog.Text += System.Environment.NewLine + DateTime.Now.ToString("T") + " - " + p + "%";
});
}
if (_percentageUploaded == 100)
{
_percentageUploaded = 0;
this.InvokeEx(x =>
{
x.txtUploadLog.Text += System.Environment.NewLine + DateTime.Now.ToString("T") + " - " + "Calculating. Please wait ...";
});
}
}
void client_UploadProgressChanged5(object sender, UploadProgressChangedEventArgs e)
{
try
{
int value = e.ProgressPercentage; // (int)((decimal)e.BytesSent / (decimal)e.TotalBytesToSend * 100);
//update the progress on UI
label1.Invoke((Action) delegate { ReportProgress1(1, 4, e.BytesSent.ToString() + " bytes sent", value); });
//// get the elapsed time in milliseconds
//ctime5 = stopwatch.ElapsedMilliseconds;
//if (ctime5 - ptime5 > 125)
//{
// double dn = (double)e.BytesSent / 1024.0 / stopwatch.Elapsed.TotalSeconds; //(DateTime.Now - start).TotalSeconds;
// string sSpeed = (dn.ToString("n") + " KB/s) " + e.ProgressPercentage);
// label2.Invoke((Action)delegate { ReportProgress2(1, 4, e.BytesSent.ToString() + " bytes sent" + " | "+sSpeed, value); });
// ptime5 = ctime5;
//}
}
catch (Exception ee)
{ ltime5.Text = ee.Message; }
}
//下载进度事件处理程序
private static void WebUpload_ProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
log4net.WriteLogFile("数据正在处理中...");
}
private long uploadTotal = 0; // 当前一共上传的字节数
/// <summary>
/// Handles the UploadProgressChanged event of the webClient control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Net.UploadProgressChangedEventArgs"/> instance containing the event data.</param>
private void webClient_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
OnShellProgressBarChanged((int)((uploadTotal + e.BytesSent) / project.TotalSize * 100));
}
private void WebClientUploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
OnProgressChange(e.ProgressPercentage * 2);
}
void _client_CheckFileExistsCompleted(object sender, SMT.Saas.Tools.NewFileUploadWS.CheckFileExistsCompletedEventArgs e)
{
if (e.Error == null)
{
long lengthtemp = e.Result.BytesUploaded;
if (lengthtemp > 0)
{
MessageBoxResult result;
if (lengthtemp > 0)
{
result = MessageBox.Show(e.Result.FileName + "文件部分存在, 如果是相同文件名上传请先做删除处理，是否继续上传?", "续传?", MessageBoxButton.OKCancel);
if (result == MessageBoxResult.Cancel)
{
lengthtemp = 0;
this._file.BytesUploaded = 0;
_client.DeleteFileAsync(e.Result.SmtFileListId, e.Result.FileUrl);
this._file.State = Constants.FileStates.Pending;
return;
}
else
{
this._file.BytesUploaded = lengthtemp;
this._dataSent = lengthtemp;
int percent = (int)((this._file.BytesUploaded / this._file.FileSize) * 100);
_file.FileStream.Seek(lengthtemp, System.IO.SeekOrigin.Begin);
UploadProgressChangedEventArgs args = new UploadProgressChangedEventArgs(percent, lengthtemp, lengthtemp, this._file.FileSize, _file.FileName);
//this.Dispatcher.BeginInvoke(delegate()
//{
// UploadProgressChanged(this, args);
//});
OnProgressChanged();
}
}
}
StartUpload();
}
}
void upload_UploadProgressChanged(object sender, UploadProgressChangedEventArgs args)
{
FileUpload fu = sender as FileUpload;
try
{
callback.Invoke("onUploadProgress", fu.SessionId, args.TotalBytesUploaded, args.TotalBytes);
//HtmlPage.Window.Invoke("UploadProgressCallback", CallbackData, fu.SessionId, args.TotalBytesUploaded, args.TotalBytes);
}
catch (Exception) {}
}
void OnFileUploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
Debug.Log("Uploading Progreess: " + e.ProgressPercentage);
AddToOutputText(string.Format("Here is the FTP Upload path", FilePath));
}
void WebClientUploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
progressBar1.Value = e.ProgressPercentage;
}
private static void AssertUploadedFile(string originalFolderPath, string fileName, UploadProgressChangedEventArgs uploadProgressChangedEventArgs)
{
var expected = new FileInfo(Path.Combine(originalFolderPath, fileName));
Assert.AreEqual(expected.Length, uploadProgressChangedEventArgs.BytesUploaded);
Assert.AreEqual(expected.Length, uploadProgressChangedEventArgs.TotalBytes);
Assert.AreEqual(100, uploadProgressChangedEventArgs.Progress);
}
void client_UploadDataChanged(object sender, UploadProgressChangedEventArgs e)
{
int percent = e.ProgressPercentage;
progressBar1.Value = percent;
}
private void Webclient_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
Utils.InvokeOn(window.pbar_UploadProgress, () => window.pbar_UploadProgress.Value = e.ProgressPercentage);
}
void upload_UploadProgressChanged(object sender, UploadProgressChangedEventArgs args)
{
FileUpload fu = sender as FileUpload;
callJS("onProgress", fu.SessionId, args.TotalBytesUploaded, args.TotalBytes);
}
internal void SetProgress(UploadProgressChangedEventArgs e) => SetProgress(e.BytesSent, e.TotalBytesToSend);
private void OnFtpClientUploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
var progress = (e.BytesSent / (double)e.TotalBytesToSend) * 100;
EditAttachmentsProgressBar.Value = progress;
}
internal void _client_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
// Notify subscribers.
Document.OnUploadProgressChanged(sender, e);
}
/// <summary>
/// 进度条事件
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void userFile_UploadProgressChanged(object sender, UploadProgressChangedEventArgs args)
{
if (args.BytesUploaded == 0.0)
{
TotalUploaded += args.TotalBytesUploaded;
}
else
{
TotalUploaded += args.BytesUploaded;
}
// TotalUploaded += args.BytesUploaded;
progressBar.Value = TotalUploaded;//显示总进度条的值
if (TotalUploaded >= TotalUploadSize)
{
totalSizeTextBlock.Text = string.Format("{0} / {1}",
new ByteConverter().Convert(TotalUploadSize, this.GetType(), null, null).ToString(),
new ByteConverter().Convert(TotalUploadSize, this.GetType(), null, null).ToString());
}
else
{
totalSizeTextBlock.Text = string.Format("{0} / {1}",
new ByteConverter().Convert(TotalUploaded, this.GetType(), null, null).ToString(),
new ByteConverter().Convert(TotalUploadSize, this.GetType(), null, null).ToString());
}
double ByteProcessTime = 0;
double EstimatedTime = 0;
try
{
TimeSpan timeSpan = DateTime.Now - start;
ByteProcessTime = TotalUploaded / timeSpan.TotalSeconds;
Speed.Text = "速度:" + ((TotalUploaded / 1024) / timeSpan.TotalSeconds).ToString("F0") + "kb/秒";
EstimatedTime = (TotalUploadSize - TotalUploaded) / ByteProcessTime;
timeSpan = TimeSpan.FromSeconds(EstimatedTime);
timeLeftTextBlock.Text = string.Format("{0:00}:{1:00}:{2:00}", timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds);
}
catch { }
}
private void ZipFile_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
OnSynchronizeStepProgress(SynchonizeStep.SendFiles, e.BytesSent, e.TotalBytesToSend, DateTime.Now.Subtract(start));
}
static void client_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
m_status = HttpStatus.Sending;
m_progress = e.ProgressPercentage;
}
private void WebClient_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
TaskBytesSent = e.BytesSent;
}
void wc_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
pb.Value = e.ProgressPercentage;
}
private void UploadProgressChanged(Object sender, UploadProgressChangedEventArgs e)
{
textBox1.Text += e.ProgressPercentage + "%\r\n";
}
private void client_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
//Me.txtResult.Text = "Uploading.... " & e.ProgressPercentage & "%"
}
private void m_WebClient_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
long num = (e.BytesSent * 100L) / e.TotalBytesToSend;
this.InvokeIncrement((int)num);
}
private void SetFileStatus()
{
if (cancel)
{
Status = FileUploadStatus.Canceled;
}
else if (ErrorCode != Constants.NoError)
{
chunkRetries--;
if (chunkRetries > 0)
{
Status = FileUploadStatus.Retry;
}
else
{
Status = FileUploadStatus.Failed;
}
}
else
{
CalcNextChunkRanges();
if (UploadProgressChanged != null)
{
UploadProgressChangedEventArgs args = new UploadProgressChangedEventArgs(BytesUploaded, FileLength);
this.Dispatcher.BeginInvoke(delegate()
{
UploadProgressChanged(this, args);
});
}
if (BytesUploaded < FileLength)
{
new UserStorage().AddOrUpdateFileInfo(this);
chunkRetries = Constants.MaxChunkRetries;
Status = FileUploadStatus.Continue;
}
else
{
new UserStorage().DeleteFileInfo(this);
Status = FileUploadStatus.Complete;
}
}
}
/// <summary>
/// Вызывает событие <see cref="UploadProgressChanged"/>.
/// </summary>
/// <param name="e">Аргументы события.</param>
protected virtual void OnUploadProgressChanged(UploadProgressChangedEventArgs e)
{
EventHandler<UploadProgressChangedEventArgs> eventHandler = _uploadProgressChangedHandler;
if (eventHandler != null)
{
eventHandler(this, e);
}
}
private void UploadProgressCallback(object sender, UploadProgressChangedEventArgs e) => pBarUploadStatus.Value = e.ProgressPercentage;
