private static void SendToCollectionCompleted(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
SendMailAsyncResult thisPtr = (SendMailAsyncResult)result.AsyncState !;
try
{
string response;
if (!RecipientCommand.EndSend(result, out response))
{
thisPtr._failedRecipientExceptions.Add(
new SmtpFailedRecipientException(thisPtr._connection.Reader !.StatusCode,
thisPtr._toCollection[thisPtr._toIndex - 1].GetSmtpAddress(thisPtr._allowUnicode),
response));
if (thisPtr._failedRecipientExceptions.Count == thisPtr._toCollection.Count)
{
SmtpFailedRecipientException exception = thisPtr._toCollection.Count == 1 ?
(SmtpFailedRecipientException)thisPtr._failedRecipientExceptions[0] :
new SmtpFailedRecipientsException(thisPtr._failedRecipientExceptions, true);
exception.fatal = true;
thisPtr.InvokeCallback(exception);
return;
}
}
thisPtr.SendToCollection();
}
catch (Exception e)
{
thisPtr.InvokeCallback(e);
}
}
}
internal MailWriter SendMail(MailAddress sender, MailAddressCollection recipients, string deliveryNotify,
bool allowUnicode, out SmtpFailedRecipientException exception)
{
if (sender == null)
{
throw new ArgumentNullException(nameof(sender));
}
if (recipients == null)
{
throw new ArgumentNullException(nameof(recipients));
}
if (GlobalLog.IsEnabled && recipients.Count > 0)
{
GlobalLog.Assert("SmtpTransport::SendMail()|recepients.Count <= 0");
}
MailCommand.Send(_connection, SmtpCommands.Mail, sender, allowUnicode);
_failedRecipientExceptions.Clear();
exception = null;
string response;
foreach (MailAddress address in recipients)
{
string smtpAddress = address.GetSmtpAddress(allowUnicode);
string to = smtpAddress + (_connection.DSNEnabled ? deliveryNotify : string.Empty);
if (!RecipientCommand.Send(_connection, to, out response))
{
_failedRecipientExceptions.Add(
new SmtpFailedRecipientException(_connection.Reader.StatusCode, smtpAddress, response));
}
}
if (_failedRecipientExceptions.Count > 0)
{
if (_failedRecipientExceptions.Count == 1)
{
exception = _failedRecipientExceptions[0];
}
else
{
exception = new SmtpFailedRecipientsException(_failedRecipientExceptions, _failedRecipientExceptions.Count == recipients.Count);
}
if (_failedRecipientExceptions.Count == recipients.Count)
{
exception.fatal = true;
throw exception;
}
}
DataCommand.Send(_connection);
return(new MailWriter(_connection.GetClosableStream()));
}
private bool SendToCollection()
{
while (this.toIndex < this.toCollection.Count)
{
string str;
MultiAsyncResult result = (MultiAsyncResult)RecipientCommand.BeginSend(this.connection, this.toCollection[this.toIndex++].SmtpAddress + this.deliveryNotify, sendToCollectionCompleted, this);
if (!result.CompletedSynchronously)
{
return(false);
}
if (!RecipientCommand.EndSend(result, out str))
{
this.failedRecipientExceptions.Add(new SmtpFailedRecipientException(this.connection.Reader.StatusCode, this.toCollection[this.toIndex - 1].SmtpAddress, str));
}
}
return(true);
}
internal MailWriter SendMail(MailAddress sender, MailAddressCollection recipients, string deliveryNotify,
bool allowUnicode, out SmtpFailedRecipientException?exception)
{
ArgumentNullException.ThrowIfNull(sender);
ArgumentNullException.ThrowIfNull(recipients);
MailCommand.Send(_connection !, SmtpCommands.Mail, sender, allowUnicode);
_failedRecipientExceptions.Clear();
exception = null;
string response;
foreach (MailAddress address in recipients)
{
string smtpAddress = address.GetSmtpAddress(allowUnicode);
string to = smtpAddress + (_connection !.DSNEnabled ? deliveryNotify : string.Empty);
if (!RecipientCommand.Send(_connection, to, out response))
{
_failedRecipientExceptions.Add(
new SmtpFailedRecipientException(_connection.Reader !.StatusCode, smtpAddress, response));
}
}
if (_failedRecipientExceptions.Count > 0)
{
if (_failedRecipientExceptions.Count == 1)
{
exception = _failedRecipientExceptions[0];
}
else
{
exception = new SmtpFailedRecipientsException(_failedRecipientExceptions, _failedRecipientExceptions.Count == recipients.Count);
}
if (_failedRecipientExceptions.Count == recipients.Count)
{
exception.fatal = true;
throw exception;
}
}
DataCommand.Send(_connection !);
return(new MailWriter(_connection !.GetClosableStream(), encodeForTransport: true));
}
private void SendToCollection()
{
while (_toIndex < _toCollection.Count)
{
MultiAsyncResult result = (MultiAsyncResult)RecipientCommand.BeginSend(_connection,
_toCollection[_toIndex++].GetSmtpAddress(_allowUnicode) + _deliveryNotify,
s_sendToCollectionCompleted, this);
if (!result.CompletedSynchronously)
{
return;
}
string response;
if (!RecipientCommand.EndSend(result, out response))
{
_failedRecipientExceptions.Add(new SmtpFailedRecipientException(_connection.Reader.StatusCode,
_toCollection[_toIndex - 1].GetSmtpAddress(_allowUnicode), response));
}
}
SendData();
}
private void SendTo()
{
if (this.to != null)
{
IAsyncResult result = RecipientCommand.BeginSend(this.connection, (this.deliveryNotify != null) ? (this.to + this.deliveryNotify) : this.to, sendToCompleted, this);
if (result.CompletedSynchronously)
{
string str;
if (!RecipientCommand.EndSend(result, out str))
{
throw new SmtpFailedRecipientException(this.connection.Reader.StatusCode, this.to, str);
}
this.SendData();
}
}
else if (this.SendToCollection())
{
this.SendData();
}
}
internal MailWriter SendMail(MailAddress sender, MailAddressCollection recipients, string deliveryNotify, out SmtpFailedRecipientException exception)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (recipients == null)
{
throw new ArgumentNullException("recipients");
}
MailCommand.Send(this.connection, SmtpCommands.Mail, sender.SmtpAddress);
this.failedRecipientExceptions.Clear();
exception = null;
foreach (MailAddress address in recipients)
{
string str;
if (!RecipientCommand.Send(this.connection, this.connection.DSNEnabled ? (address.SmtpAddress + deliveryNotify) : address.SmtpAddress, out str))
{
this.failedRecipientExceptions.Add(new SmtpFailedRecipientException(this.connection.Reader.StatusCode, address.SmtpAddress, str));
}
}
if (this.failedRecipientExceptions.Count > 0)
{
if (this.failedRecipientExceptions.Count == 1)
{
exception = (SmtpFailedRecipientException)this.failedRecipientExceptions[0];
}
else
{
exception = new SmtpFailedRecipientsException(this.failedRecipientExceptions, this.failedRecipientExceptions.Count == recipients.Count);
}
if (this.failedRecipientExceptions.Count == recipients.Count)
{
exception.fatal = true;
throw exception;
}
}
DataCommand.Send(this.connection);
return(new MailWriter(this.connection.GetClosableStream()));
}
private static void SendToCollectionCompleted(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
SendMailAsyncResult asyncState = (SendMailAsyncResult)result.AsyncState;
try
{
string str;
if (!RecipientCommand.EndSend(result, out str))
{
asyncState.failedRecipientExceptions.Add(new SmtpFailedRecipientException(asyncState.connection.Reader.StatusCode, asyncState.toCollection[asyncState.toIndex - 1].SmtpAddress, str));
if (asyncState.failedRecipientExceptions.Count == asyncState.toCollection.Count)
{
SmtpFailedRecipientException exception = null;
if (asyncState.toCollection.Count == 1)
{
exception = (SmtpFailedRecipientException)asyncState.failedRecipientExceptions[0];
}
else
{
exception = new SmtpFailedRecipientsException(asyncState.failedRecipientExceptions, true);
}
exception.fatal = true;
asyncState.InvokeCallback(exception);
return;
}
}
if (asyncState.SendToCollection())
{
asyncState.SendData();
}
}
catch (Exception exception2)
{
asyncState.InvokeCallback(exception2);
}
}
}
private static void SendToCompleted(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
SendMailAsyncResult asyncState = (SendMailAsyncResult)result.AsyncState;
try
{
string str;
if (RecipientCommand.EndSend(result, out str))
{
asyncState.SendData();
}
else
{
asyncState.InvokeCallback(new SmtpFailedRecipientException(asyncState.connection.Reader.StatusCode, asyncState.to, str));
}
}
catch (Exception exception)
{
asyncState.InvokeCallback(exception);
}
}
}
