| public PostOperationCompleted ( SendOrPostCallback d, object arg ) : void | ||
| d | SendOrPostCallback | |
| arg | object | |
| 리턴 | void | |
private void WorkerThreadStart(object argument)
{
Debug.Assert(_asyncOperation != null, "_asyncOperation not initialized");
object workerResult = null;
Exception error = null;
bool cancelled = false;
try
{
DoWorkEventArgs doWorkArgs = new DoWorkEventArgs(argument);
OnDoWork(doWorkArgs);
if (doWorkArgs.Cancel)
{
cancelled = true;
}
else
{
workerResult = doWorkArgs.Result;
}
}
catch (Exception exception)
{
error = exception;
}
var e = new RunWorkerCompletedEventArgs(workerResult, error, cancelled);
_asyncOperation.PostOperationCompleted(_operationCompleted, e);
}
private void CompleteWorkOnBackgroundThread(Exception error, object result, bool cancelled)
{
// Called on a background thread
RunWorkerCompletedEventArgs e = new RunWorkerCompletedEventArgs(result, error, cancelled);
_currentOperation.PostOperationCompleted(_ => RaiseOnRunWorkerCompleted(e), (object)null);
}
private void WorkerThreadStart(object argument)
{
object workerResult = null;
Exception error = null;
bool cancelled = false;
try
{
DoWorkEventArgs doWorkArgs = new DoWorkEventArgs(argument);
OnDoWork(doWorkArgs);
if (doWorkArgs.Cancel)
{
cancelled = true;
}
else
{
workerResult = doWorkArgs.Result;
}
}
catch (Exception exception)
{
error = exception;
}
RunWorkerCompletedEventArgs e =
new RunWorkerCompletedEventArgs(workerResult, error, cancelled);
asyncOperation.PostOperationCompleted(operationCompleted, e);
}
private void CompletionMethod(string output, Exception ex, bool cancelled, AsyncOperation asyncOp)
{
lock (userStateDictionary)
{
userStateDictionary.Remove(asyncOp.UserSuppliedState);
}
// results of the operation
asyncOp.PostOperationCompleted(onCompletedDelegate,
new LongTaskCompletedEventArgs(output, ex, cancelled, asyncOp.UserSuppliedState));
}
private void DispatchCompleting(MessageData responsemsg, Exception ex, bool canceled, AsyncOperation asyncOper)
{
if (!canceled)
{
lock (_userStateToLifetime.SyncRoot)
{
_userStateToLifetime.Remove(asyncOper.UserSuppliedState);
}
}
TransmitCompletedEventArgs eventArgs = new TransmitCompletedEventArgs(responsemsg, ex, canceled, asyncOper.UserSuppliedState);
asyncOper.PostOperationCompleted(onCompletedDelegate, eventArgs);
}
private void CompleteWorker(object state)
{
object[] array = (object[])state;
RunWorkerCompletedEventArgs arg = array[0] as RunWorkerCompletedEventArgs;
AsyncOperation asyncOperation = array[1] as AsyncOperation;
SendOrPostCallback d = delegate(object darg)
{
this.async = null;
this.OnRunWorkerCompleted(darg as RunWorkerCompletedEventArgs);
};
asyncOperation.PostOperationCompleted(d, arg);
this.cancel_pending = false;
}
void CompleteWorker(object state)
{
object [] args = (object [])state;
RunWorkerCompletedEventArgs e =
args [0] as RunWorkerCompletedEventArgs;
AsyncOperation async = args [1] as AsyncOperation;
SendOrPostCallback callback = delegate(object darg) {
OnRunWorkerCompleted(darg as RunWorkerCompletedEventArgs);
};
async.PostOperationCompleted(callback, e);
this.async = null;
}
public void CancelAsync()
{
if (!support_cancel)
{
throw new InvalidOperationException("This background worker does not support cancellation.");
}
if (!IsBusy)
{
return;
}
cancel_pending = true;
async.PostOperationCompleted(delegate(object darg) {
OnRunWorkerCompleted(
new RunWorkerCompletedEventArgs(
null, null, true));
this.async = null;
cancel_pending = false;
},
null);
}
private void WorkerThreadStart(AsyncOperation asyncOp, object userState, object argument)
{
Exception error = null;
bool cancelled = false;
DoWorkEventArgs e = new DoWorkEventArgs(userState, argument);
try
{
this.OnDoWork(e);
if (e.Cancel) cancelled = true;
}
catch (Exception ex)
{
error = ex;
}
lock (userStateToLifetime.SyncRoot)
{
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
WorkerCompletedEventArgs arg = new WorkerCompletedEventArgs(error, cancelled, asyncOp.UserSuppliedState, argument);
asyncOp.PostOperationCompleted(this.SendOrPostWorkerCompleted, arg);
}
private void ProcessWorker(Queue<KeyValuePair<string, string>> taskQueue, IEnumerable<IProcessingPlugin> processingPlugins, IOutputPlugin outputPlugin, AsyncOperation asyncOp)
{
var imageProcessingManagerTaskContext = new ImageProcessingManagerTaskContext(taskQueue, asyncOp.UserSuppliedState);
imageProcessingManagerTaskContext.TotalTaskCount = taskQueue.Count;
lock ((userStateToTaskContext as ICollection).SyncRoot)
{
userStateToTaskContext[asyncOp.UserSuppliedState] = imageProcessingManagerTaskContext;
}
while (imageProcessingManagerTaskContext.TaskQueue.Count > 0)
{
imageProcessingManagerTaskContext.Semaphore.WaitOne();
if (IsTaskCancelled(asyncOp.UserSuppliedState))
{
break;
}
else
{
var task = taskQueue.Dequeue();
asyncOp.Post(processAsyncStateChangedDelegate, new ProcessStateChangedEventArgs(asyncOp.UserSuppliedState, task.Key, "处理中"));
object userState = Guid.NewGuid();
lock ((imageProcessorUserStateToUserState as ICollection).SyncRoot)
{
imageProcessorUserStateToUserState[userState] = asyncOp.UserSuppliedState;
}
lock ((imageProcessorUserStateToInput as ICollection).SyncRoot)
{
imageProcessorUserStateToInput[userState] = task.Key;
}
lock (imageProcessingManagerTaskContext.CurrentProcessingPluginUserStates)
{
imageProcessingManagerTaskContext.CurrentProcessingPluginUserStates.Add(userState);
}
imageProcessor.ProcessAsync(task, processingPlugins, outputPlugin, userState);
}
}
while (imageProcessingManagerTaskContext.CurrentProcessingPluginUserStates.Count > 0)
{
imageProcessingManagerTaskContext.Semaphore.WaitOne();
}
bool cancelled = IsTaskCancelled(asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(processAsyncCompletedDelegate, new AsyncCompletedEventArgs(null, cancelled, asyncOp.UserSuppliedState));
}
protected void Generate(GenerationMode generationMode, AsyncOperation asyncOp)
{
System.DateTime time2;
System.TimeSpan span2;
this.IsBusy = true;
int num = 0;
logger.Info("Запущена операция формирования извещений");
System.Exception ex = null;
System.DateTime now = System.DateTime.Now;
if (generationMode != GenerationMode.GenerateOnly)
{
ObjectList<NoticeNoticeTemplate> list = new ObjectList<NoticeNoticeTemplate> {
this.Template
};
this.Templates = list;
}
this.InitNoticeRenderer();
this.m_RenderedNoticeQueue.IsClosed = false;
this.m_SaveRenderedNoticeQueue.IsClosed = false;
this.m_RenderingNoticeQueue.IsClosed = false;
this.m_ThreadExceptions.IsClosed = false;
this.m_GeneratedReport = null;
this.m_RenderingNoticeQueue.Clear();
this.m_RenderedNoticeQueue.Clear();
this.m_SaveRenderedNoticeQueue.Clear();
this.m_ThreadExceptions.Clear();
this.m_ProcessedNoticeCount = this.AccountListStatistics.RenderedCount;
this.m_RenderThreads = null;
this.m_ReportGenerationThreads = null;
logger.Info("Запуск потоков");
try
{
this.m_RenderThreads = new System.Threading.Thread[Constants.NoticeRenderThreads];
for (int i = 0; i < this.m_RenderThreads.Length; i = (int) (i + 1))
{
this.m_RenderThreads[i] = new System.Threading.Thread(new System.Threading.ThreadStart(this.RenderThread));
this.m_RenderThreads[i].Start();
logger.Info("Запуск потока рендера " + (i + 1));
}
if (generationMode != GenerationMode.GenerateOnly)
{
this.m_ReportGenerationThreads = new System.Threading.Thread[Constants.NoticeReportGenerationThreads];
for (int j = 0; j < this.m_ReportGenerationThreads.Length; j = (int) (j + 1))
{
this.m_ReportGenerationThreads[j] = new System.Threading.Thread(new System.Threading.ThreadStart(this.ReportGenerationThread));
this.m_ReportGenerationThreads[j].Start();
logger.Info("Запуск потока экспорта " + (j + 1));
}
}
}
catch (System.OutOfMemoryException exception2)
{
ex = new NoticeGenerationException("Недостаточно памяти для создания потоков.", exception2);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
catch (System.ApplicationException exception3)
{
ex = new NoticeGenerationException("Ошибка при выполнении запроса в базу данных для получения константы", exception3);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
catch (System.Data.SqlClient.SqlException exception4)
{
ex = new NoticeGenerationException("Ошибка при выполнении запроса в базу данных для получения константы", exception4);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
catch (System.Exception exception5)
{
ex = new NoticeGenerationException("Ошибка при создании потоков", exception5);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
if (Constants.MaxAccountsInGeneratingBlock > 0)
{
time2 = System.DateTime.Now;
logger.Info("AccountCount: " + ((long) this.AccountListStatistics.AccountCount));
for (int k = 0; k < System.Math.Ceiling((decimal) (this.AccountListStatistics.AccountCount / System.Convert.ToDecimal(Constants.MaxAccountsInGeneratingBlock))); k = (int) (k + 1))
{
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
foreach (NoticeNoticeTemplate template in this.Templates)
{
bool flag;
int indexPart = (int) (k + 1);
logger.Info("Получение блока извещений для пачки " + ((int) indexPart));
System.Data.DataTable table = null;
do
{
flag = false;
}
while (flag && (num <= 5));
this.ReportPercentage(asyncOp);
ObjectList<NoticeNotice> list2 = new ObjectList<NoticeNotice>();
logger.Info("Разбор полученного блока. Кол-во: " + ((int) table.Rows.get_Count()));
foreach (System.Data.DataRow row in table.Rows)
{
if (!row.IsNull("renderedNoticeId") && (generationMode != GenerationMode.GenerateOnly))
{
long id = (long) ((long) row.get_Item("renderedNoticeId"));
NoticeRenderedNotice item = null;
num = 0;
do
{
flag = false;
try
{
item = NoticeRenderedNotice.GetById(id);
this.m_RenderedNoticeQueue.Enqueue(item);
}
catch (System.ApplicationException exception9)
{
if (exception9.InnerException is System.Data.SqlClient.SqlException)
{
num = (int) (num + 1);
flag = true;
logger.Warn("Потеря соединения. Переподключение.");
}
else
{
ex = new NoticeGenerationException("Ошибка при получении сформированного извещения из базы данных", exception9);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
catch (System.Exception exception11)
{
ex = new NoticeGenerationException("Ошибка при получении сформированного извещения из базы данных", exception11);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
while (flag && (num <= 5));
}
else if (!row.IsNull("noticeId") && row.IsNull("renderedNoticeId"))
{
NoticeNotice notice2 = new NoticeNotice();
try
{
long num7 = (long) ((long) row.get_Item("noticeId"));
notice2.Id = num7;
notice2.Period = (System.DateTime) row.get_Item("period");
notice2.AccountId = (long) ((long) row.get_Item("accountId"));
notice2.HouseHolderId = row.IsNull("houseHolderId") ? NoticeNotice.Null.Id : ((long) ((long) row.get_Item("houseHolderId")));
notice2.Barcode = row.IsNull("barcode") ? string.Empty : ((string) ((string) row.get_Item("barcode")));
}
catch (System.Exception exception12)
{
ex = new NoticeGenerationException("Ошибка заполнении объекта извещения данными из БД", exception12);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
list2.Add(notice2);
}
}
table.Clear();
table.Dispose();
this.ReportPercentage(asyncOp);
if (list2.get_Count() > 0)
{
logger.Info("Получение данных для блока извещений из " + ((int) list2.get_Count()));
System.Data.DataTable table2 = null;
num = 0;
do
{
flag = false;
try
{
table2 = NoticeNotice.GetHeader(this.AreaId, this.Adapter.Filter.Period.Value, indexPart, template.Id);
}
catch (System.ApplicationException exception13)
{
if (exception13.InnerException is System.Data.SqlClient.SqlException)
{
num = (int) (num + 1);
flag = true;
logger.Warn("Потеря соединения. Переподключение.");
}
else
{
ex = new NoticeGenerationException("Ошибка при получении заголовков для блока извещений", exception13);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
catch (System.Exception exception15)
{
ex = new NoticeGenerationException("Ошибка при получении заголовков для блока извещений", exception15);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
while (flag && (num <= 5));
table2.set_TableName("header");
this.ReportPercentage(asyncOp);
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
System.Data.DataSet set = null;
num = 0;
do
{
flag = false;
try
{
set = NoticeNotice.GetReport(this.AreaId, this.Adapter.Filter.Period.Value, indexPart, template.Sql, template.Id);
if ((this.AdditionDataTable != null) && (set != null))
{
set.Tables.Add(this.AdditionDataTable);
}
}
catch (System.ApplicationException exception16)
{
if (exception16.InnerException is System.Data.SqlClient.SqlException)
{
num = (int) (num + 1);
flag = true;
logger.Warn("Потеря соединения. Переподключение.");
}
else
{
ex = new NoticeGenerationException("Ошибка при получении данных для блока извещений", exception16);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
catch (System.Exception exception18)
{
ex = new NoticeGenerationException("Ошибка при получении данных для блока извещений", exception18);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
while (flag && (num <= 5));
set.Tables.get_Item(0).set_TableName("pays");
set.Tables.get_Item(1).set_TableName("counter");
for (int m = 2; m < set.Tables.get_Count(); m = (int) (m + 1))
{
int num15 = (int) (m - 1);
set.Tables.get_Item(m).set_TableName("data" + ((int) num15).ToString());
}
if (template.IdentityName == "Счет на оплату Ульяновск вариант 3")
{
if (set.Tables.get_Count() > 2)
{
set.Tables.get_Item(2).set_TableName("organizations");
}
if (set.Tables.get_Count() > 3)
{
set.Tables.get_Item(3).set_TableName("rates");
}
}
logger.Info("Отправка группы извещений {0} на рендер", indexPart);
this.m_RenderingNoticeQueue.IsWaiting = true;
foreach (NoticeNotice notice3 in list2)
{
System.Data.DataTable headerTable = table2.Clone();
foreach (System.Data.DataRow row2 in table2.Rows)
{
bool flag2 = false;
foreach (System.Data.DataRow row3 in set.Tables.get_Item(0).Rows)
{
if (((long) row3.get_Item("id")) == notice3.Id)
{
flag2 = true;
break;
}
}
if (!flag2)
{
break;
}
if (((long) row2.get_Item("id")) == notice3.Id)
{
headerTable.ImportRow(row2);
break;
}
}
RenderingNotice notice4 = new RenderingNotice(notice3, headerTable, set.Copy(), template.Template, template.Id);
this.m_RenderingNoticeQueue.Enqueue(notice4);
logger.Info("Отправлено на рендер " + ((long) notice3.Id));
this.ReportPercentage(asyncOp);
}
table2.Clear();
table2.Dispose();
set.Clear();
set.Dispose();
this.m_RenderingNoticeQueue.IsWaiting = false;
this.m_RetreivedNoticeBlocksCount = (int) (this.m_RetreivedNoticeBlocksCount + 1);
}
this.ReportPercentage(asyncOp);
if (this.m_RetreivedNoticeBlocksCount >= Constants.MaxRenderingBlocks)
{
logger.Info("Достигнуто максимальное количество одновременно обрабатываемых блоков");
while (true)
{
if (((this.m_SaveRenderedNoticeQueue.Count == 0) && (this.m_RenderingNoticeQueue.Count == 0)) && (this.m_RenderingNoticeCount == 0))
{
logger.Info("Очереди обработаны.");
this.m_RetreivedNoticeBlocksCount = 0;
continue;
}
this.SaveRenderedNotices(asyncOp, now);
this.ReportPercentage(asyncOp);
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
System.Threading.Thread.Sleep(10);
}
}
this.SaveRenderedNotices(asyncOp, now);
this.ReportPercentage(asyncOp);
span2 = (System.TimeSpan) (System.DateTime.Now - time2);
if (span2.get_TotalMinutes() >= 3.0)
{
time2 = System.DateTime.Now;
logger.Info("Сборка мусора");
System.GC.Collect();
}
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
}
this.m_RenderingNoticeQueue.IsClosed = true;
logger.Info("Ожидание и обработка очереди оставшихся отрендеренных извещений");
while (!this.m_SaveRenderedNoticeQueue.IsClosed || (this.m_SaveRenderedNoticeQueue.Count != 0))
{
if (this.m_SaveRenderedNoticeQueue.Count == 0)
{
System.Threading.Thread.Sleep(10);
}
span2 = (System.TimeSpan) (System.DateTime.Now - time2);
if (span2.get_TotalMinutes() >= 3.0)
{
time2 = System.DateTime.Now;
logger.Info("Сборка мусора");
System.GC.Collect();
}
this.ReportPercentage(asyncOp);
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
this.SaveRenderedNotices(asyncOp, now);
}
}
else
{
ex = new NoticeGenerationException("Неверное значение константы MaxAccountsInGeneratingBlock");
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
this.m_RenderedNoticeQueue.IsClosed = true;
logger.Info("Ожидание завершения запущенных потоков рендеринга и экспорта");
while ((this.m_RenderingNoticeQueue.Count > 0) || (this.m_RenderingNoticeCount > 0))
{
System.Threading.Thread.Sleep(10);
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
this.ReportPercentage(asyncOp);
}
while ((this.m_RenderedNoticeQueue.Count > 0) || (this.m_ExportingNoticeCount > 0))
{
System.Threading.Thread.Sleep(10);
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
this.ReportPercentage(asyncOp);
}
span2 = (System.TimeSpan) (System.DateTime.Now - time2);
if (span2.get_TotalMinutes() >= 3.0)
{
time2 = System.DateTime.Now;
logger.Info("Сборка мусора");
System.GC.Collect();
}
NoticeReport report = null;
if (generationMode == GenerationMode.GenerateReport)
{
logger.Info("Объединение извещений в один отчёт для показа");
System.Collections.Generic.List<NoticeRenderedNotice> renderedNotices = new System.Collections.Generic.List<NoticeRenderedNotice>();
foreach (NoticeReport report2 in this.m_NoticeReports)
{
renderedNotices.AddRange(report2.RenderedNotices);
report2.Dispose();
}
report = new NoticeReport(renderedNotices);
this.m_GeneratedReport = report;
}
if ((this.m_ThreadExceptions.Count > 0) || this.m_IsCancelled)
{
ex = null;
this.m_ThreadExceptions.TryDequeue(out ex);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
}
else
{
if ((this.m_NoticeCache.get_Count() > 0) && (this.m_Exporter != null))
{
logger.Info("Экспорт по домам управляющих компаний");
int num9 = (int) ((this.m_Exporter.MaxPageCount * this.m_Template.AccountsInTemplate) / this.m_Template.PageCount);
CachedNoticeInfoComparer comparer = new CachedNoticeInfoComparer();
try
{
foreach (string str in this.m_NoticeCache.Keys)
{
this.m_NoticeCache[str].Sort(comparer);
logger.Info("Экспорт домов УК " + str);
for (int n = 0; n < this.m_NoticeCache[str].get_Count(); n = (int) (n + num9))
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
int num11 = this.m_NoticeCache[str].get_Count();
if (num11 != 0)
{
int maxPageCount = this.m_Exporter.MaxPageCount;
int num13 = (int) (num11 - (n + maxPageCount));
num13 = (num13 < 1) ? ((int) 0) : num13;
using (StiReport report3 = new StiReport())
{
report3.IsRendered = true;
report3.NeedsCompiling = false;
report3.RenderedPages.Clear();
System.IO.DirectoryInfo info = new System.IO.DirectoryInfo(System.IO.Path.Combine(this.m_Exporter.DestinationPath, str));
if (!info.get_Exists())
{
info.Create();
}
string file = System.IO.Path.Combine(info.get_FullName(), string.Format("{0}_{1}.pdf", str, n / num9));
for (int num14 = n; num14 < (num11 - num13); num14 = (int) (num14 + 1))
{
System.IO.FileInfo info2 = new System.IO.FileInfo(this.m_NoticeCache[str].get_Item(num14).CacheFilePath);
if (info2.get_Exists())
{
byte[] bytes = System.IO.File.ReadAllBytes(info2.get_FullName());
StiReport report4 = new StiReport();
report4.LoadPackedDocument(bytes);
report4.ReportUnit = report3.ReportUnit;
foreach (StiPage page in report4.RenderedPages)
{
page.Report = report3;
page.Guid = System.Guid.NewGuid().ToString().Replace("-", "");
report3.RenderedPages.Add(page);
}
if (this.m_Exporter.DualPageExportMode && ((report4.RenderedPages.get_Count() % 2) != 0))
{
StiPage page2 = new StiPage(report3) {
IsRendered = true,
Orientation = report4.RenderedPages[0].Orientation,
Guid = System.Guid.NewGuid().ToString().Replace("-", "")
};
report3.RenderedPages.Add(page2);
}
builder.AppendLine(this.m_NoticeCache[str].get_Item(num14).FullAddress);
}
}
report3.ExportDocument(StiExportFormat.Pdf, file);
System.IO.File.WriteAllText(file + ".txt", builder.ToString());
}
}
}
}
logger.Info("Очистка дискового кэша");
System.IO.Directory.Delete(System.IO.Path.Combine(this.m_Exporter.DestinationPath, this.m_ExportCacheDirectoryName), true);
}
catch (System.Exception exception19)
{
ex = new NoticeGenerationException("Ошибка при экспорте извещений, сгруппированных по УК", exception19);
this.AbortOperation(asyncOp, ex, (System.TimeSpan) (System.DateTime.Now - now));
return;
}
}
System.TimeSpan timeSpent = (System.TimeSpan) (System.DateTime.Now - now);
logger.Info("Операция успешно завершена. Время выполнения " + timeSpent.ToString());
logger.Info("Всего отрендерено: " + ((int) this.m_TotalRendered));
if (asyncOp != null)
{
GenerationCompletedEventArgs args = new GenerationCompletedEventArgs(timeSpent, null, false, asyncOp.get_UserSuppliedState()) {
GeneratedReport = report
};
asyncOp.PostOperationCompleted(this.onCompletedDelegate, args);
}
this.Reset();
}
}
public void SendAsync(MailMessage message, object userToken) {
if (disposed) {
throw new ObjectDisposedException(this.GetType().FullName);
}
if (Logging.On) Logging.Enter(Logging.Web, this, "SendAsync", "DeliveryMethod=" + DeliveryMethod.ToString());
GlobalLog.Enter("SmtpClient#" + ValidationHelper.HashString(this) + "::SendAsync Transport#" + ValidationHelper.HashString(transport));
try {
if (InCall) {
throw new InvalidOperationException(SR.GetString(SR.net_inasync));
}
if (message == null) {
throw new ArgumentNullException("message");
}
if (DeliveryMethod == SmtpDeliveryMethod.Network)
CheckHostAndPort();
recipients = new MailAddressCollection();
if (message.From == null) {
throw new InvalidOperationException(SR.GetString(SR.SmtpFromRequired));
}
if (message.To != null) {
foreach (MailAddress address in message.To) {
recipients.Add(address);
}
}
if (message.Bcc != null) {
foreach (MailAddress address in message.Bcc) {
recipients.Add(address);
}
}
if (message.CC != null) {
foreach (MailAddress address in message.CC) {
recipients.Add(address);
}
}
if (recipients.Count == 0) {
throw new InvalidOperationException(SR.GetString(SR.SmtpRecipientRequired));
}
try {
InCall = true;
cancelled = false;
this.message = message;
string pickupDirectory = PickupDirectoryLocation;
#if !FEATURE_PAL
CredentialCache cache;
// Skip token capturing if no credentials are used or they don't include a default one.
// Also do capture the token if ICredential is not of CredentialCache type so we don't know what the exact credential response will be.
transport.IdentityRequired = Credentials != null && (Credentials is SystemNetworkCredential || (cache = Credentials as CredentialCache) == null || cache.IsDefaultInCache);
#endif // !FEATURE_PAL
asyncOp = AsyncOperationManager.CreateOperation(userToken);
switch (DeliveryMethod) {
#if !FEATURE_PAL
case SmtpDeliveryMethod.PickupDirectoryFromIis:
pickupDirectory = IisPickupDirectory.GetPickupDirectory();
goto case SmtpDeliveryMethod.SpecifiedPickupDirectory;
#endif // !FEATURE_PAL
case SmtpDeliveryMethod.SpecifiedPickupDirectory:
{
if (EnableSsl)
throw new SmtpException(SR.GetString(SR.SmtpPickupDirectoryDoesnotSupportSsl));
writer = GetFileMailWriter(pickupDirectory);
bool allowUnicode = IsUnicodeSupported();
ValidateUnicodeRequirement(message, recipients, allowUnicode);
message.Send(writer, true, allowUnicode);
if (writer != null)
writer.Close();
transport.ReleaseConnection();
AsyncCompletedEventArgs eventArgs = new AsyncCompletedEventArgs(null, false, asyncOp.UserSuppliedState);
InCall = false;
asyncOp.PostOperationCompleted(onSendCompletedDelegate, eventArgs);
break;
}
case SmtpDeliveryMethod.Network:
default:
operationCompletedResult = new ContextAwareResult(transport.IdentityRequired, true, null, this, _ContextSafeCompleteCallback);
lock (operationCompletedResult.StartPostingAsyncOp())
{
GlobalLog.Print("SmtpClient#" + ValidationHelper.HashString(this) + "::SendAsync calling BeginConnect. Transport#" + ValidationHelper.HashString(transport));
transport.BeginGetConnection(ServicePoint, operationCompletedResult, ConnectCallback, operationCompletedResult);
operationCompletedResult.FinishPostingAsyncOp();
}
break;
}
}
catch (Exception e) {
InCall = false;
if (Logging.On) Logging.Exception(Logging.Web, this, "Send", e);
if (e is SmtpFailedRecipientException && !((SmtpFailedRecipientException)e).fatal) {
throw;
}
Abort();
if (timedOut) {
throw new SmtpException(SR.GetString(SR.net_timeout));
}
if (e is SecurityException ||
e is AuthenticationException ||
e is SmtpException)
{
throw;
}
throw new SmtpException(SR.GetString(SR.SmtpSendMailFailure), e);
}
} finally {
if (Logging.On) Logging.Exit(Logging.Web, this, "SendAsync", null);
GlobalLog.Leave("SmtpClient#" + ValidationHelper.HashString(this) + "::SendAsync");
}
}
protected void FinalizeOperation(AsyncOperation asyncOp, AsyncCompletedEventArgs e)
{
lock (m_userStateToLifetime.SyncRoot)
{
m_userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
asyncOp.PostOperationCompleted(m_onCompletedDelegate, e);
}
// This is the method that the underlying, free-threaded
// asynchronous behavior will invoke. This will happen on
// an arbitrary thread.
private void RefreshWeaveDataCompletionMethod(Exception error, bool cancelled, AsyncOperation asyncOperation)
{
// If the task was not previously canceled,
// remove the task from the lifetime collection.
if (!cancelled)
{
lock (this)
{
userStateToLifetime.Remove(asyncOperation.UserSuppliedState);
}
}
RefreshWeaveDataCompletedEventArgs e = new RefreshWeaveDataCompletedEventArgs(error, cancelled, asyncOperation.UserSuppliedState);
asyncOperation.PostOperationCompleted(state => OnRefreshWeaveDataCompleted((RefreshWeaveDataCompletedEventArgs)state), e);
}
private void JobActionWorker(AsyncOperation asyncOp, ActionType action, string reason, string label, bool suppressError)
{
Exception exception = null;
#pragma warning disable 56500
try
{
switch (action)
{
case ActionType.Start:
DoStartJobLogic(null);
break;
case ActionType.Stop:
DoStopJob();
break;
case ActionType.Suspend:
DoSuspendJob();
break;
case ActionType.Resume:
DoResumeJob(label);
break;
case ActionType.Abort:
DoAbortJob(reason);
break;
case ActionType.Terminate:
DoTerminateJob(reason, suppressError);
break;
}
}
catch (Exception e)
{
// Called on a background thread, need to include any exception in
// event arguments.
exception = e;
}
#pragma warning restore 56500
var eventArgs = new AsyncCompletedEventArgs(exception, false, asyncOp.UserSuppliedState);
var container = new AsyncCompleteContainer { EventArgs = eventArgs, Action = action };
// End the task. The asyncOp object is responsible
// for marshaling the call.
asyncOp.PostOperationCompleted(JobActionAsyncCompleted, container);
}
/// <summary>
/// 异步工作线程。
/// </summary>
/// <param name="task">输入路径到输出路径</param>
/// <param name="processingPlugins">处理插件</param>
/// <param name="outputPlugin">输出插件</param>
/// <param name="asyncOp">跟踪异步操作的生存期。</param>
private void ProcessWorker(KeyValuePair<string, string> task, IEnumerable<IProcessingPlugin> processingPlugins, IOutputPlugin outputPlugin, AsyncOperation asyncOp)
{
// 创建处理任务上下文对象。
ImageProcessorTaskContext imageProcessorTaskContext = new ImageProcessorTaskContext();
imageProcessorTaskContext.TotalProcedureCount = processingPlugins.Count() + 2;
// 为 ProcessingPlugin 添加事件处理方法。
foreach (var processingPlugin in processingPlugins)
{
// ! 重要，保证多任务处理事件唯一，也许以后可能有更好的方法。
lock (processingPlugin)
{
processingPlugin.ProcessProgressChanged -= processingPlugin_ProcessProgressChangedDelegate;
processingPlugin.ProcessCompleted -= getBitmapCompletedDelegate;
processingPlugin.ProcessProgressChanged += processingPlugin_ProcessProgressChangedDelegate;
processingPlugin.ProcessCompleted += getBitmapCompletedDelegate;
}
imageProcessorTaskContext.ProcessingPluginQueue.Enqueue(processingPlugin);
}
// 添加到对应关系中。
lock ((userStateToTaskContext as ICollection).SyncRoot)
{
userStateToTaskContext[asyncOp.UserSuppliedState] = imageProcessorTaskContext;
}
// 创建 UserState 对象。
object userState = Guid.NewGuid();
// 添加到对应关系中。
lock ((taskUserStateToUserState as ICollection).SyncRoot)
{
taskUserStateToUserState[userState] = asyncOp.UserSuppliedState;
}
// 开始获取 Bitmap。
getBitmapManager.GetBitmapAsync(task.Key, userState);
while (imageProcessorTaskContext.ProcessingPluginQueue.Count > 0)
{
// 等待上步操作完成。
imageProcessorTaskContext.AutoResetEvent.WaitOne();
if (IsTaskCancelled(asyncOp.UserSuppliedState) || imageProcessorTaskContext.Error != null)
{
break;
}
else
{
IProcessingPlugin processingPlugin = imageProcessorTaskContext.ProcessingPluginQueue.Dequeue();
userState = Guid.NewGuid();
imageProcessorTaskContext.CurrentProcessingPlugin = processingPlugin;
imageProcessorTaskContext.CurrentProcessingPluginUserState = userState;
lock ((taskUserStateToUserState as ICollection).SyncRoot)
{
taskUserStateToUserState[userState] = asyncOp.UserSuppliedState;
}
processingPlugin.ProcessAsync(imageProcessorTaskContext.Bitmap, userState);
}
}
if (!IsTaskCancelled(asyncOp.UserSuppliedState) && imageProcessorTaskContext.Error == null)
{
// 等待最后处理完成。
imageProcessorTaskContext.AutoResetEvent.WaitOne();
// 输出。
outputPlugin.Output(imageProcessorTaskContext.Bitmap, task.Value);
}
bool cancelled = IsTaskCancelled(asyncOp.UserSuppliedState);
lock ((userStateToLifetime as ICollection).SyncRoot)
{
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
asyncOp.PostOperationCompleted(processAsyncCompletedDelegate, new AsyncCompletedEventArgs(imageProcessorTaskContext.Error, cancelled, asyncOp.UserSuppliedState));
}
// This is the method that the underlying, free-threaded
// asynchronous behavior will invoke. This will happen on
// a worker thread
private void processCompletionMethod(
Task task,
Exception exception,
bool canceled,
AsyncOperation asyncOp)
{
// If the task was not previously canceled,
// remove the task from the lifetime collection.
if (!canceled)
{
lock (processJobs)
{
processJobs.Remove(asyncOp.UserSuppliedState);
}
}
// Package the results of the operation in EventArgs
TaskEventArgs e = new TaskEventArgs(task, exception, canceled, asyncOp.UserSuppliedState);
// End the task. The asyncOp object is responsible
// for marshaling the call.
asyncOp.PostOperationCompleted(onProcessingCompleteDelegate, e);
// Note that after the call to OperationCompleted,
// asyncOp is no longer usable, and any attempt to use it
// will cause an exception to be thrown.
}
private void CompletionMethod(Exception exception,bool canceled,AsyncOperation asyncOp)
{
if (!canceled)
{
lock (userStateToLifetime.SyncRoot)
{
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
}
GenerationCompletedEventArgs e = new GenerationCompletedEventArgs(
exception,
canceled,
asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(onCompletedDelegate, e);
}
protected virtual void TriggerCompletionEvent(Exception exception, bool cancelled, AsyncOperation asyncOp)
{
// If the task was not previously canceled,
// remove the task from the lifetime collection.
if (!cancelled)
{
lock (userStateToLifetime.SyncRoot)
{
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
}
AsyncCompletedEventArgs e =
new AsyncCompletedEventArgs(
exception,
cancelled,
asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(this.onCompletedDelegate, e);
}
// This is the method that the underlying, free-threaded
// asynchronous behavior will invoke. This will happen on
// an arbitrary thread.
private void CompletionMethod(
List<AirItinerary> airItineraries,
ISupplier supplier,
Exception exception,
bool canceled,
AsyncOperation asyncOp)
{
// If the task was not previously canceled,
// remove the task from the lifetime collection.
if (!canceled)
{
lock (_userStateToLifetime.SyncRoot)
{
_userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
}
// Package the results of the operation in a
// SearchCompletedEventArgs.
var e =
new SearchCompletedEventArgs(
airItineraries,
supplier,
exception,
canceled,
asyncOp.UserSuppliedState);
// End the task. The asyncOp object is responsible
// for marshaling the call.
asyncOp.PostOperationCompleted(_onCompletedDelegate, e);
// Note that after the call to OperationCompleted,
// asyncOp is no longer usable, and any attempt to use it
// will cause an exception to be thrown.
}
private void completionMethod(object data, Exception ex, bool cancelled, AsyncOperation asyncOp)
{
if (!cancelled) {
lock (userStateToLifetime) {
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
var e = new OperationCompletedEventArgs(data, ex, cancelled, asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(onCompletedCallback, e);
}
}
private void GetBitmapWorker(string path, AsyncOperation asyncOp)
{
Exception error = null;
bool cancelled = false;
Bitmap bitmap = null;
try
{
bitmap = GetBitmap(path);
}
catch (Exception ex)
{
error = ex;
}
cancelled = IsTaskCanceled(asyncOp.UserSuppliedState);
GetBitmapAsyncCancel(asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(getBitmapAsyncCompletedDelegate, new GetBitmapCompletedEventArgs(error, cancelled, asyncOp.UserSuppliedState, bitmap));
}
private void processFieldWorker(string filePath, IProcessingSettings settings,
AsyncOperation asyncOp)
{
Exception e = null;
Task task = new Task();
try
{
if (settings is TextFieldProcessingSettings)
{
task = _syncClient.ProcessTextField(filePath, settings as TextFieldProcessingSettings);
}
else if (settings is BarcodeFieldProcessingSettings)
{
task = _syncClient.ProcessBarcodeField(filePath, settings as BarcodeFieldProcessingSettings);
}
else if (settings is CheckmarkFieldProcessingSettings)
{
task = _syncClient.ProcessCheckmarkField(filePath, settings as CheckmarkFieldProcessingSettings);
}
else
{
throw new ArgumentException("Invalid type of processing settings");
}
// Notify that upload was completed
Task uploadedTask = new Task(task.Id, TaskStatus.Submitted);
UploadCompletedEventArgs uploadCompletedEventArgs = new UploadCompletedEventArgs(uploadedTask, asyncOp.UserSuppliedState);
asyncOp.Post(onUploadCompletedDelegate, uploadCompletedEventArgs);
// Wait until task finishes
startTaskMonitorIfNecessary();
_taskList.AddTask(task);
task = waitUntilTaskFinishes(task);
}
catch (Exception ex)
{
e = ex;
}
lock (processJobs)
{
processJobs.Remove(asyncOp.UserSuppliedState);
}
bool canceled = false;
// Package the results of the operation in EventArgs
TaskEventArgs ev = new TaskEventArgs(task, e, canceled, asyncOp.UserSuppliedState);
// End the task. The asyncOp object is responsible
// for marshaling the call.
asyncOp.PostOperationCompleted(onProcessingCompleteDelegate, ev);
}
void CompleteWorker (object state)
{
object [] args = (object []) state;
RunWorkerCompletedEventArgs e =
args [0] as RunWorkerCompletedEventArgs;
AsyncOperation async = args [1] as AsyncOperation;
SendOrPostCallback callback = delegate (object darg) {
this.async = null;
complete = true;
OnRunWorkerCompleted (darg as RunWorkerCompletedEventArgs);
};
async.PostOperationCompleted (callback, e);
cancel_pending = false;
}
private void listTasksWorker(AsyncOperation asyncOp)
{
Exception e = null;
Task[] tasks = null;
try
{
tasks = _syncClient.ListTasks();
}
catch (Exception ex)
{
e = ex;
}
lock (downloadJobs)
{
taskListJobs.Remove(asyncOp.UserSuppliedState);
}
ListTaskEventArgs args = new ListTaskEventArgs(tasks, e, false, asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(onListTasksCompletedDelegate, args);
}
internal void PrepareToRaiseCreateContactCompletedEvent(AsyncOperation asyncOP, CreateContactCompletedEventArgs args)
{
asyncOP.PostOperationCompleted(OnCreateContactCompletedDelegate, args);
}
private void downloadCompletionMethod(
Task task,
Exception exception,
bool canceled,
AsyncOperation asyncOp)
{
if (!canceled)
{
lock (downloadJobs)
{
downloadJobs.Remove(asyncOp.UserSuppliedState);
}
}
TaskEventArgs e = new TaskEventArgs(task, exception, canceled, asyncOp.UserSuppliedState);
asyncOp.PostOperationCompleted(onDownloadCompletedDelegate, e);
}
private void InvokeOperationCompeted(AsyncOperation asyncOp, SendOrPostCallback callback, UploadFileCompletedEventArgs eventArgs)
{
if (this.m_IsExpired)
eventArgs = new UploadFileCompletedEventArgs("", new Exception(Properties.Settings.Default.UploadExpired), false, this.m_AsyncOperation.UserSuppliedState);
if (Interlocked.CompareExchange<AsyncOperation>(ref this.m_AsyncOperation, null, asyncOp) == asyncOp)
{
var _originalWebResponse = Interlocked.Exchange<WebResponse>(ref this.m_WebResponse, null);
closeResponse(_originalWebResponse);
this.completeUploadClientState();
asyncOp.PostOperationCompleted(callback, eventArgs);
}
}
private void loading(object obj, AsyncOperation asyncOperation)
{
string[] flist = (string[])obj;
//loading
string res = "ok";
asyncOperation.PostOperationCompleted(new SendOrPostCallback(OnComplete), res);
}
private void DoProcessAsyncCompleted(AsyncOperation asyncOp, GetBitmapCompletedEventArgs e)
{
asyncOp.PostOperationCompleted(processAsyncCompletedDelegate, e);
}
public void UploadInternal(string path, string token, string message, AsyncOperation asyncOp)
{
//送信先のURL
string url = "http://img.ly/api/2/upload.xml";
//区切り文字列
string boundary = System.Environment.TickCount.ToString();
//WebRequestの作成
var req = (HttpWebRequest)WebRequest.Create(url);
if (MiniTwitter.Properties.Settings.Default.UseProxy)
{
if (MiniTwitter.Properties.Settings.Default.UseIEProxy)
{
req.Proxy = System.Net.WebRequest.GetSystemWebProxy();
}
else
{
int pn = 0;
if (!(int.TryParse(MiniTwitter.Properties.Settings.Default.ProxyPortNumber, out pn)))
{
var p = new System.Net.WebProxy(MiniTwitter.Properties.Settings.Default.ProxyAddress, pn);
if (!(string.IsNullOrEmpty(MiniTwitter.Properties.Settings.Default.ProxyUsername) || string.IsNullOrEmpty(MiniTwitter.Properties.Settings.Default.ProxyPassword)))
{
p.Credentials = new System.Net.NetworkCredential(MiniTwitter.Properties.Settings.Default.ProxyUsername, MiniTwitter.Properties.Settings.Default.ProxyPassword);
}
req.Proxy = p;
}
}
}
//メソッドにPOSTを指定
req.Method = "POST";
//ContentTypeを設定
req.ContentType = "multipart/form-data; boundary=" + boundary;
req.Headers["X-Verify-Credentials-Authorization"] = token;
req.Headers["X-Auth-Service-Provider"] = "https://api.twitter.com/1/account/verify_credentials.json";
//POST送信するデータを作成
string postData = "";
postData = "--" + boundary + "\r\n" +
"Content-Disposition: form-data; name=\"message\"\r\n\r\n" + message + "\r\n" +
"--" + boundary + "\r\n" +
"Content-Disposition: form-data; name=\"media\"; filename=\"" + Path.GetFileName(path) + "\"\r\n" +
"Content-Type: application/octet-stream\r\n" +
"Content-Transfer-Encoding: binary\r\n\r\n";
//バイト型配列に変換
var enc = Encoding.UTF8;
byte[] startData = enc.GetBytes(postData);
postData = "\r\n--" + boundary + "--\r\n";
byte[] endData = enc.GetBytes(postData);
FileStream fs = null;
try
{
//送信するファイルを開く
fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
//POST送信するデータの長さを指定
req.ContentLength = startData.Length + endData.Length + fs.Length;
//データをPOST送信するためのStreamを取得
var reqStream = req.GetRequestStream();
//送信するデータを書き込む
reqStream.Write(startData, 0, startData.Length);
//ファイルの内容を送信
byte[] readData = new byte[0x10000];
int readSize = 0;
while (true)
{
readSize = fs.Read(readData, 0, readData.Length);
if (readSize == 0)
{
break;
}
reqStream.Write(readData, 0, readSize);
}
fs.Close();
reqStream.Write(endData, 0, endData.Length);
reqStream.Close();
}
catch (Exception)
{
throw;
}
finally
{
if (fs != null)
fs.Dispose();
}
//サーバーからの応答を受信するためのWebResponseを取得
var res = (HttpWebResponse)req.GetResponse();
//応答データを受信するためのStreamを取得
using (var resStream = res.GetResponseStream())
{
var xd = XDocument.Load(new XmlTextReader(resStream));
try
{
var imgurl = xd.Root.Element("url").Value;
asyncOp.PostOperationCompleted(p => UploadCompleted(this, new imglyUploadCompletedEventArgs(imgurl, null, false, null)), null);
}
catch (Exception e)
{
asyncOp.PostOperationCompleted(p => UploadCompleted(this, new imglyUploadCompletedEventArgs(null, e, false, null)), null);
}
}
}
private void CompletionMethod(
byte[] responseData,
Exception exception,
bool canceled,
AsyncOperation asyncOp)
{
// If the task was not previously canceled,
// remove the task from the lifetime collection.
if (!canceled)
{
lock (userStateToLifetime.SyncRoot)
{
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
}
RequestDataCompletedEventArgs e =
new RequestDataCompletedEventArgs(
responseData,
exception,
canceled,
asyncOp.UserSuppliedState);
// End the task. The asyncOp object is responsible
// for marshaling the call.
asyncOp.PostOperationCompleted(onRequestDataCompletedDelegate, e);
// Note that after the call to OperationCompleted,
// asyncOp is no longer usable, and any attempt to use it
// will cause an exception to be thrown.
}
// This is the method that the underlying, free-threaded
// asynchronous behavior will invoke. This will happen on
// an arbitrary thread.
private void CompletionMethod(
List<ProxyInfo> proxylistOk,
Exception exception,
bool canceled,
AsyncOperation asyncOp)
{
// If the task was not previously canceled,
// remove the task from the lifetime collection.
if (!canceled)
{
lock (userStateToLifetime.SyncRoot)
{
userStateToLifetime.Remove(asyncOp.UserSuppliedState);
}
}
// Package the results of the operation in a
// CalculatePrimeCompletedEventArgs.
CompletedEventArgs e =
new CompletedEventArgs(
proxylistOk,
exception,
canceled,
asyncOp.UserSuppliedState);
// End the task. The asyncOp object is responsible
// for marshaling the call.
asyncOp.PostOperationCompleted(onCompletedDelegate, e);
// Note that after the call to OperationCompleted,
// asyncOp is no longer usable, and any attempt to use it
// will cause an exception to be thrown.
}
private void PostCompleted(Exception error, bool cancelled)
{
AsyncOperation currentAsyncLoadOperation = this.currentAsyncLoadOperation;
this.currentAsyncLoadOperation = null;
if (currentAsyncLoadOperation != null)
{
currentAsyncLoadOperation.PostOperationCompleted(this.loadCompletedDelegate, new AsyncCompletedEventArgs(error, cancelled, null));
}
}
public void SendAsync(MailMessage message, object userToken)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Web, this, "SendAsync", "DeliveryMethod=" + DeliveryMethod.ToString());
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Enter("SmtpClient#" + LoggingHash.HashString(this) + "::SendAsync Transport#" + LoggingHash.HashString(_transport));
}
try
{
if (InCall)
{
throw new InvalidOperationException(SR.net_inasync);
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (DeliveryMethod == SmtpDeliveryMethod.Network)
CheckHostAndPort();
_recipients = new MailAddressCollection();
if (message.From == null)
{
throw new InvalidOperationException(SR.SmtpFromRequired);
}
if (message.To != null)
{
foreach (MailAddress address in message.To)
{
_recipients.Add(address);
}
}
if (message.Bcc != null)
{
foreach (MailAddress address in message.Bcc)
{
_recipients.Add(address);
}
}
if (message.CC != null)
{
foreach (MailAddress address in message.CC)
{
_recipients.Add(address);
}
}
if (_recipients.Count == 0)
{
throw new InvalidOperationException(SR.SmtpRecipientRequired);
}
try
{
InCall = true;
_cancelled = false;
_message = message;
string pickupDirectory = PickupDirectoryLocation;
CredentialCache cache;
// Skip token capturing if no credentials are used or they don't include a default one.
// Also do capture the token if ICredential is not of CredentialCache type so we don't know what the exact credential response will be.
_transport.IdentityRequired = Credentials != null && (ReferenceEquals(Credentials, CredentialCache.DefaultNetworkCredentials) || (cache = Credentials as CredentialCache) == null);
_asyncOp = AsyncOperationManager.CreateOperation(userToken);
switch (DeliveryMethod)
{
case SmtpDeliveryMethod.PickupDirectoryFromIis:
throw new NotSupportedException(SR.SmtpGetIisPickupDirectoryNotSupported);
case SmtpDeliveryMethod.SpecifiedPickupDirectory:
{
if (EnableSsl)
{
throw new SmtpException(SR.SmtpPickupDirectoryDoesnotSupportSsl);
}
_writer = GetFileMailWriter(pickupDirectory);
bool allowUnicode = IsUnicodeSupported();
ValidateUnicodeRequirement(message, _recipients, allowUnicode);
message.Send(_writer, true, allowUnicode);
if (_writer != null)
_writer.Close();
_transport.ReleaseConnection();
AsyncCompletedEventArgs eventArgs = new AsyncCompletedEventArgs(null, false, _asyncOp.UserSuppliedState);
InCall = false;
_asyncOp.PostOperationCompleted(_onSendCompletedDelegate, eventArgs);
break;
}
case SmtpDeliveryMethod.Network:
default:
_operationCompletedResult = new ContextAwareResult(_transport.IdentityRequired, true, null, this, s_contextSafeCompleteCallback);
lock (_operationCompletedResult.StartPostingAsyncOp())
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("SmtpClient#" + LoggingHash.HashString(this) + "::SendAsync calling BeginConnect. Transport#" + LoggingHash.HashString(_transport));
}
_transport.BeginGetConnection(_operationCompletedResult, ConnectCallback, _operationCompletedResult, Host, Port);
_operationCompletedResult.FinishPostingAsyncOp();
}
break;
}
}
catch (Exception e)
{
InCall = false;
if (NetEventSource.Log.IsEnabled()) NetEventSource.Exception(NetEventSource.ComponentType.Web, this, "Send", e);
if (e is SmtpFailedRecipientException && !((SmtpFailedRecipientException)e).fatal)
{
throw;
}
Abort();
if (_timedOut)
{
throw new SmtpException(SR.net_timeout);
}
if (e is SecurityException ||
e is AuthenticationException ||
e is SmtpException)
{
throw;
}
throw new SmtpException(SR.SmtpSendMailFailure, e);
}
}
finally
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Web, this, "SendAsync", null);
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Leave("SmtpClient#" + LoggingHash.HashString(this) + "::SendAsync");
}
}
}
internal void PrepareToRaiseCompletedEvent(AsyncOperation asyncOP, ResolveCompletedEventArgs args)
{
asyncOP.PostOperationCompleted(OnResolveCompletedDelegate, args);
lock (m_PeerNameResolverHelperListLock)
{
PeerNameResolverHelper helper = m_PeerNameResolverHelperList[args.UserState];
if (helper == null)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Critical, 0, "userState for which we are about to call Completed event does not exist in the pending async list");
}
else
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, helper.TraceEventId,
"userState {0} is being removed from the pending async list", args.UserState.GetHashCode());
m_PeerNameResolverHelperList.Remove(args.UserState);
}
}
}
