Send() private method

private Send ( System.Net.Mime.BaseWriter writer, bool sendEnvelope, bool allowUnicode ) : void
writer System.Net.Mime.BaseWriter
sendEnvelope bool
allowUnicode bool
return void
        public void Send()
        {
            // Type
            var @this = new MailMessage("[email protected]", "[email protected]", "Fizz", "Buzz");

            // Examples
            @this.Send(); // Send a mail
        }
        public static Status<bool> SendMessage(this MailerBase mailer, MailMessage message)
        {
            try
            {
                message.Send();
            }
            catch(Exception exc)
            {
                return Status.Error(exc.Message, false);
            }

            return Status.OK(true);
        }
 public override void OnGameEnded(GameSession game)
 {
     if (!game.IsDraw)
     {
         var mailMessage = new MailMessage
         {
             Subject = "You won in Tic Tac Toe Online",
             Body = "Congratulations you won in Tic Tac Toe against" + game.Looser.NickName
         };
         mailMessage.To.Add(game.Winner.Email);
         mailMessage.Send(); //uncomment to really send mails
     }
 }
Example #4
0
        /// <summary>
        /// Calls SetMailDefaults first.
        /// </summary>
        /// <param name="mail"></param>
        /// <param name="subject"></param>
        /// <param name="to"></param>
        public void Send(MailMessage mail, string subject = "",  string to = "")
        {
            mail = SetMailDefaults(mail);
            if (subject != null && subject == "") {
                mail.Subject = subject;
            }

            if (to != null && to != "") {
                mail.To.Add(to);
            }

            try {
                new Thread(() => {
                    if (SEND_ASY)
                        mail.SendAsync();
                    else
                        mail.Send();
                }).Start();
            } catch (Exception) {

            }
        }
        public void SendAsync(MailMessage message, object userToken)
        {
            if (this.disposed)
            {
                throw new ObjectDisposedException(base.GetType().FullName);
            }
            if (Logging.On)
            {
                Logging.Enter(Logging.Web, this, "SendAsync", "DeliveryMethod=" + this.DeliveryMethod.ToString());
            }
            try
            {
                if (this.InCall)
                {
                    throw new InvalidOperationException(SR.GetString("net_inasync"));
                }
                if (message == null)
                {
                    throw new ArgumentNullException("message");
                }
                if (this.DeliveryMethod == SmtpDeliveryMethod.Network)
                {
                    this.CheckHostAndPort();
                }
                this.recipients = new MailAddressCollection();
                if (message.From == null)
                {
                    throw new InvalidOperationException(SR.GetString("SmtpFromRequired"));
                }
                if (message.To != null)
                {
                    foreach (MailAddress address in message.To)
                    {
                        this.recipients.Add(address);
                    }
                }
                if (message.Bcc != null)
                {
                    foreach (MailAddress address2 in message.Bcc)
                    {
                        this.recipients.Add(address2);
                    }
                }
                if (message.CC != null)
                {
                    foreach (MailAddress address3 in message.CC)
                    {
                        this.recipients.Add(address3);
                    }
                }
                if (this.recipients.Count == 0)
                {
                    throw new InvalidOperationException(SR.GetString("SmtpRecipientRequired"));
                }
                try
                {
                    CredentialCache cache;
                    this.InCall = true;
                    this.cancelled = false;
                    this.message = message;
                    this.transport.IdentityRequired = ((this.Credentials != null) && ComNetOS.IsWinNt) && (((this.Credentials is SystemNetworkCredential) || ((cache = this.Credentials as CredentialCache) == null)) || cache.IsDefaultInCache);
                    this.asyncOp = AsyncOperationManager.CreateOperation(userToken);
                    switch (this.DeliveryMethod)
                    {
                        case SmtpDeliveryMethod.SpecifiedPickupDirectory:
                            if (this.EnableSsl)
                            {
                                throw new SmtpException(SR.GetString("SmtpPickupDirectoryDoesnotSupportSsl"));
                            }
                            break;

                        case SmtpDeliveryMethod.PickupDirectoryFromIis:
                            if (this.EnableSsl)
                            {
                                throw new SmtpException(SR.GetString("SmtpPickupDirectoryDoesnotSupportSsl"));
                            }
                            goto Label_02B2;

                        default:
                            goto Label_0329;
                    }
                    this.writer = this.GetFileMailWriter(this.PickupDirectoryLocation);
                    message.Send(this.writer, this.DeliveryMethod != SmtpDeliveryMethod.Network);
                    if (this.writer != null)
                    {
                        this.writer.Close();
                    }
                    this.transport.ReleaseConnection();
                    AsyncCompletedEventArgs arg = new AsyncCompletedEventArgs(null, false, this.asyncOp.UserSuppliedState);
                    this.InCall = false;
                    this.asyncOp.PostOperationCompleted(this.onSendCompletedDelegate, arg);
                    return;
                Label_02B2:
                    this.writer = this.GetFileMailWriter(IisPickupDirectory.GetPickupDirectory());
                    message.Send(this.writer, this.DeliveryMethod != SmtpDeliveryMethod.Network);
                    if (this.writer != null)
                    {
                        this.writer.Close();
                    }
                    this.transport.ReleaseConnection();
                    AsyncCompletedEventArgs args2 = new AsyncCompletedEventArgs(null, false, this.asyncOp.UserSuppliedState);
                    this.InCall = false;
                    this.asyncOp.PostOperationCompleted(this.onSendCompletedDelegate, args2);
                    return;
                Label_0329:
                    this.operationCompletedResult = new ContextAwareResult(this.transport.IdentityRequired, true, null, this, _ContextSafeCompleteCallback);
                    lock (this.operationCompletedResult.StartPostingAsyncOp())
                    {
                        this.transport.BeginGetConnection(this.ServicePoint, this.operationCompletedResult, new AsyncCallback(this.ConnectCallback), this.operationCompletedResult);
                        this.operationCompletedResult.FinishPostingAsyncOp();
                    }
                }
                catch (Exception exception)
                {
                    this.InCall = false;
                    if (Logging.On)
                    {
                        Logging.Exception(Logging.Web, this, "Send", exception);
                    }
                    if ((exception is SmtpFailedRecipientException) && !((SmtpFailedRecipientException) exception).fatal)
                    {
                        throw;
                    }
                    this.Abort();
                    if (this.timedOut)
                    {
                        throw new SmtpException(SR.GetString("net_timeout"));
                    }
                    if (((exception is SecurityException) || (exception is AuthenticationException)) || (exception is SmtpException))
                    {
                        throw;
                    }
                    throw new SmtpException(SR.GetString("SmtpSendMailFailure"), exception);
                }
            }
            finally
            {
                if (Logging.On)
                {
                    Logging.Exit(Logging.Web, this, "SendAsync", (string) null);
                }
            }
        }
        public void Send(MailMessage message)
        {
            if (Logging.On)
            {
                Logging.Enter(Logging.Web, this, "Send", message);
            }
            if (this.disposed)
            {
                throw new ObjectDisposedException(base.GetType().FullName);
            }
            try
            {
                if (Logging.On)
                {
                    Logging.PrintInfo(Logging.Web, this, "Send", "DeliveryMethod=" + this.DeliveryMethod.ToString());
                }
                if (Logging.On)
                {
                    Logging.Associate(Logging.Web, this, message);
                }
                SmtpFailedRecipientException exception = null;
                if (this.InCall)
                {
                    throw new InvalidOperationException(SR.GetString("net_inasync"));
                }
                if (message == null)
                {
                    throw new ArgumentNullException("message");
                }
                if (this.DeliveryMethod == SmtpDeliveryMethod.Network)
                {
                    this.CheckHostAndPort();
                }
                MailAddressCollection recipients = new MailAddressCollection();
                if (message.From == null)
                {
                    throw new InvalidOperationException(SR.GetString("SmtpFromRequired"));
                }
                if (message.To != null)
                {
                    foreach (MailAddress address in message.To)
                    {
                        recipients.Add(address);
                    }
                }
                if (message.Bcc != null)
                {
                    foreach (MailAddress address2 in message.Bcc)
                    {
                        recipients.Add(address2);
                    }
                }
                if (message.CC != null)
                {
                    foreach (MailAddress address3 in message.CC)
                    {
                        recipients.Add(address3);
                    }
                }
                if (recipients.Count == 0)
                {
                    throw new InvalidOperationException(SR.GetString("SmtpRecipientRequired"));
                }
                this.transport.IdentityRequired = false;
                try
                {
                    this.InCall = true;
                    this.timedOut = false;
                    this.timer = new System.Threading.Timer(new TimerCallback(this.TimeOutCallback), null, this.Timeout, this.Timeout);
                    switch (this.DeliveryMethod)
                    {
                        case SmtpDeliveryMethod.SpecifiedPickupDirectory:
                            if (this.EnableSsl)
                            {
                                throw new SmtpException(SR.GetString("SmtpPickupDirectoryDoesnotSupportSsl"));
                            }
                            break;

                        case SmtpDeliveryMethod.PickupDirectoryFromIis:
                            if (this.EnableSsl)
                            {
                                throw new SmtpException(SR.GetString("SmtpPickupDirectoryDoesnotSupportSsl"));
                            }
                            goto Label_0235;

                        default:
                            goto Label_0244;
                    }
                    MailWriter fileMailWriter = this.GetFileMailWriter(this.PickupDirectoryLocation);
                    goto Label_0276;
                Label_0235:
                    fileMailWriter = this.GetFileMailWriter(IisPickupDirectory.GetPickupDirectory());
                    goto Label_0276;
                Label_0244:
                    this.GetConnection();
                    fileMailWriter = this.transport.SendMail((message.Sender != null) ? message.Sender : message.From, recipients, message.BuildDeliveryStatusNotificationString(), out exception);
                Label_0276:
                    this.message = message;
                    message.Send(fileMailWriter, this.DeliveryMethod != SmtpDeliveryMethod.Network);
                    fileMailWriter.Close();
                    this.transport.ReleaseConnection();
                    if ((this.DeliveryMethod == SmtpDeliveryMethod.Network) && (exception != null))
                    {
                        throw exception;
                    }
                }
                catch (Exception exception2)
                {
                    if (Logging.On)
                    {
                        Logging.Exception(Logging.Web, this, "Send", exception2);
                    }
                    if ((exception2 is SmtpFailedRecipientException) && !((SmtpFailedRecipientException) exception2).fatal)
                    {
                        throw;
                    }
                    this.Abort();
                    if (this.timedOut)
                    {
                        throw new SmtpException(SR.GetString("net_timeout"));
                    }
                    if (((exception2 is SecurityException) || (exception2 is AuthenticationException)) || (exception2 is SmtpException))
                    {
                        throw;
                    }
                    throw new SmtpException(SR.GetString("SmtpSendMailFailure"), exception2);
                }
                finally
                {
                    this.InCall = false;
                    if (this.timer != null)
                    {
                        this.timer.Dispose();
                    }
                }
            }
            finally
            {
                if (Logging.On)
                {
                    Logging.Exit(Logging.Web, this, "Send", (string) null);
                }
            }
        }
Example #7
0
        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");
                }
            }
        }
Example #8
0
        public void Send(MailMessage message)
        {
            if (NetEventSource.Log.IsEnabled())
            {
                NetEventSource.Enter(NetEventSource.ComponentType.Web, this, nameof(Send), message);
            }

            if (_disposed)
            {
                throw new ObjectDisposedException(GetType().FullName);
            }
            try
            {
                if (MailEventSource.Log.IsEnabled())
                {
                    MailEventSource.Log.Send(nameof(DeliveryMethod), DeliveryMethod.ToString());
                    MailEventSource.Log.Associate(this, message);
                }

                SmtpFailedRecipientException recipientException = null;

                if (InCall)
                {
                    throw new InvalidOperationException(SR.net_inasync);
                }

                if (message == null)
                {
                    throw new ArgumentNullException(nameof(message));
                }

                if (DeliveryMethod == SmtpDeliveryMethod.Network)
                    CheckHostAndPort();

                MailAddressCollection 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);
                }

                _transport.IdentityRequired = false;  // everything completes on the same thread.

                try
                {
                    InCall = true;
                    _timedOut = false;
                    _timer = new Timer(new TimerCallback(TimeOutCallback), null, Timeout, Timeout);
                    bool allowUnicode = false;
                    string pickupDirectory = PickupDirectoryLocation;

                    MailWriter writer;
                    switch (DeliveryMethod)
                    {
                        case SmtpDeliveryMethod.PickupDirectoryFromIis:
                            throw new NotSupportedException(SR.SmtpGetIisPickupDirectoryNotSupported);

                        case SmtpDeliveryMethod.SpecifiedPickupDirectory:
                            if (EnableSsl)
                            {
                                throw new SmtpException(SR.SmtpPickupDirectoryDoesnotSupportSsl);
                            }

                            allowUnicode = IsUnicodeSupported(); // Determend by the DeliveryFormat paramiter
                            ValidateUnicodeRequirement(message, recipients, allowUnicode);
                            writer = GetFileMailWriter(pickupDirectory);
                            break;

                        case SmtpDeliveryMethod.Network:
                        default:
                            GetConnection();
                            // Detected durring GetConnection(), restrictable using the DeliveryFormat paramiter
                            allowUnicode = IsUnicodeSupported();
                            ValidateUnicodeRequirement(message, recipients, allowUnicode);
                            writer = _transport.SendMail(message.Sender ?? message.From, recipients,
                                message.BuildDeliveryStatusNotificationString(), allowUnicode, out recipientException);
                            break;
                    }
                    _message = message;
                    message.Send(writer, DeliveryMethod != SmtpDeliveryMethod.Network, allowUnicode);
                    writer.Close();
                    _transport.ReleaseConnection();

                    //throw if we couldn't send to any of the recipients
                    if (DeliveryMethod == SmtpDeliveryMethod.Network && recipientException != null)
                    {
                        throw recipientException;
                    }
                }
                catch (Exception e)
                {
                    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
                {
                    InCall = false;
                    if (_timer != null)
                    {
                        _timer.Dispose();
                    }
                }
            }
            finally
            {
                if (NetEventSource.Log.IsEnabled()) NetEventSource.Exit(NetEventSource.ComponentType.Web, this, "Send", null);
            }
        }
Example #9
0
        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");
            }
        }
Example #10
0
        public void should_send()
        {
            var message = new MailMessage("[email protected]", "[email protected]", "subject", "body");

            message.Send();
        }
Example #11
0
 public void SendAsync(MailMessage message, object userToken)
 {
     if (this.disposed)
     throw new ObjectDisposedException(this.GetType().FullName);
       if (Logging.On)
     Logging.Enter(Logging.Web, (object) this, "SendAsync", "DeliveryMethod=" + ((object) this.DeliveryMethod).ToString());
       try
       {
     if (this.InCall)
       throw new InvalidOperationException(SR.GetString("net_inasync"));
     if (message == null)
       throw new ArgumentNullException("message");
     if (this.DeliveryMethod == SmtpDeliveryMethod.Network)
       this.CheckHostAndPort();
     this.recipients = new MailAddressCollection();
     if (message.From == null)
       throw new InvalidOperationException(SR.GetString("SmtpFromRequired"));
     if (message.To != null)
     {
       foreach (MailAddress mailAddress in (Collection<MailAddress>) message.To)
     ((Collection<MailAddress>) this.recipients).Add(mailAddress);
     }
     if (message.Bcc != null)
     {
       foreach (MailAddress mailAddress in (Collection<MailAddress>) message.Bcc)
     ((Collection<MailAddress>) this.recipients).Add(mailAddress);
     }
     if (message.CC != null)
     {
       foreach (MailAddress mailAddress in (Collection<MailAddress>) message.CC)
     ((Collection<MailAddress>) this.recipients).Add(mailAddress);
     }
     if (this.recipients.Count == 0)
       throw new InvalidOperationException(SR.GetString("SmtpRecipientRequired"));
     try
     {
       this.InCall = true;
       this.cancelled = false;
       this.message = message;
       string pickupDirectory = this.PickupDirectoryLocation;
       CredentialCache credentialCache;
       this.transport.IdentityRequired = this.Credentials != null && (this.Credentials is SystemNetworkCredential || (credentialCache = this.Credentials as CredentialCache) == null || credentialCache.IsDefaultInCache);
       this.asyncOp = AsyncOperationManager.CreateOperation(userToken);
       switch (this.DeliveryMethod)
       {
     case SmtpDeliveryMethod.SpecifiedPickupDirectory:
       if (this.EnableSsl)
         throw new SmtpException(SR.GetString("SmtpPickupDirectoryDoesnotSupportSsl"));
       this.writer = this.GetFileMailWriter(pickupDirectory);
       bool allowUnicode = this.IsUnicodeSupported();
       this.ValidateUnicodeRequirement(message, this.recipients, allowUnicode);
       message.Send((BaseWriter) this.writer, true, allowUnicode);
       if (this.writer != null)
         this.writer.Close();
       this.transport.ReleaseConnection();
       AsyncCompletedEventArgs completedEventArgs = new AsyncCompletedEventArgs((Exception) null, false, this.asyncOp.UserSuppliedState);
       this.InCall = false;
       this.asyncOp.PostOperationCompleted(this.onSendCompletedDelegate, (object) completedEventArgs);
       break;
     case SmtpDeliveryMethod.PickupDirectoryFromIis:
       pickupDirectory = IisPickupDirectory.GetPickupDirectory();
       goto case 1;
     default:
       this.operationCompletedResult = new ContextAwareResult(this.transport.IdentityRequired, true, (object) null, (object) this, SmtpClient._ContextSafeCompleteCallback);
       lock (this.operationCompletedResult.StartPostingAsyncOp())
       {
         this.transport.BeginGetConnection(this.ServicePoint, this.operationCompletedResult, new AsyncCallback(this.ConnectCallback), (object) this.operationCompletedResult);
         this.operationCompletedResult.FinishPostingAsyncOp();
         break;
       }
       }
     }
     catch (Exception ex)
     {
       this.InCall = false;
       if (Logging.On)
     Logging.Exception(Logging.Web, (object) this, "Send", ex);
       if (ex is SmtpFailedRecipientException && !((SmtpFailedRecipientException) ex).fatal)
       {
     throw;
       }
       else
       {
     this.Abort();
     if (this.timedOut)
       throw new SmtpException(SR.GetString("net_timeout"));
     if (!(ex is SecurityException) && !(ex is AuthenticationException) && !(ex is SmtpException))
       throw new SmtpException(SR.GetString("SmtpSendMailFailure"), ex);
     throw;
       }
     }
       }
       finally
       {
     if (Logging.On)
       Logging.Exit(Logging.Web, (object) this, "SendAsync", (string) null);
       }
 }
Example #12
0
 public void Send(MailMessage message)
 {
     if (Logging.On)
     Logging.Enter(Logging.Web, (object) this, "Send", (object) message);
       if (this.disposed)
     throw new ObjectDisposedException(this.GetType().FullName);
       try
       {
     if (Logging.On)
       Logging.PrintInfo(Logging.Web, (object) this, "Send", "DeliveryMethod=" + ((object) this.DeliveryMethod).ToString());
     if (Logging.On)
       Logging.Associate(Logging.Web, (object) this, (object) message);
     SmtpFailedRecipientException exception = (SmtpFailedRecipientException) null;
     if (this.InCall)
       throw new InvalidOperationException(SR.GetString("net_inasync"));
     if (message == null)
       throw new ArgumentNullException("message");
     if (this.DeliveryMethod == SmtpDeliveryMethod.Network)
       this.CheckHostAndPort();
     MailAddressCollection recipients = new MailAddressCollection();
     if (message.From == null)
       throw new InvalidOperationException(SR.GetString("SmtpFromRequired"));
     if (message.To != null)
     {
       foreach (MailAddress mailAddress in (Collection<MailAddress>) message.To)
     ((Collection<MailAddress>) recipients).Add(mailAddress);
     }
     if (message.Bcc != null)
     {
       foreach (MailAddress mailAddress in (Collection<MailAddress>) message.Bcc)
     ((Collection<MailAddress>) recipients).Add(mailAddress);
     }
     if (message.CC != null)
     {
       foreach (MailAddress mailAddress in (Collection<MailAddress>) message.CC)
     ((Collection<MailAddress>) recipients).Add(mailAddress);
     }
     if (recipients.Count == 0)
       throw new InvalidOperationException(SR.GetString("SmtpRecipientRequired"));
     this.transport.IdentityRequired = false;
     try
     {
       this.InCall = true;
       this.timedOut = false;
       this.timer = new System.Threading.Timer(new TimerCallback(this.TimeOutCallback), (object) null, this.Timeout, this.Timeout);
       string pickupDirectory = this.PickupDirectoryLocation;
       bool allowUnicode;
       MailWriter mailWriter;
       switch (this.DeliveryMethod)
       {
     case SmtpDeliveryMethod.SpecifiedPickupDirectory:
       if (this.EnableSsl)
         throw new SmtpException(SR.GetString("SmtpPickupDirectoryDoesnotSupportSsl"));
       allowUnicode = this.IsUnicodeSupported();
       this.ValidateUnicodeRequirement(message, recipients, allowUnicode);
       mailWriter = this.GetFileMailWriter(pickupDirectory);
       break;
     case SmtpDeliveryMethod.PickupDirectoryFromIis:
       pickupDirectory = IisPickupDirectory.GetPickupDirectory();
       goto case 1;
     default:
       this.GetConnection();
       allowUnicode = this.IsUnicodeSupported();
       this.ValidateUnicodeRequirement(message, recipients, allowUnicode);
       mailWriter = this.transport.SendMail(message.Sender ?? message.From, recipients, message.BuildDeliveryStatusNotificationString(), allowUnicode, out exception);
       break;
       }
       this.message = message;
       message.Send((BaseWriter) mailWriter, this.DeliveryMethod != SmtpDeliveryMethod.Network, allowUnicode);
       mailWriter.Close();
       this.transport.ReleaseConnection();
       if (this.DeliveryMethod == SmtpDeliveryMethod.Network && exception != null)
     throw exception;
     }
     catch (Exception ex)
     {
       if (Logging.On)
     Logging.Exception(Logging.Web, (object) this, "Send", ex);
       if (ex is SmtpFailedRecipientException && !((SmtpFailedRecipientException) ex).fatal)
       {
     throw;
       }
       else
       {
     this.Abort();
     if (this.timedOut)
       throw new SmtpException(SR.GetString("net_timeout"));
     if (!(ex is SecurityException) && !(ex is AuthenticationException) && !(ex is SmtpException))
       throw new SmtpException(SR.GetString("SmtpSendMailFailure"), ex);
     throw;
       }
     }
     finally
     {
       this.InCall = false;
       if (this.timer != null)
     this.timer.Dispose();
     }
       }
       finally
       {
     if (Logging.On)
       Logging.Exit(Logging.Web, (object) this, "Send", (string) null);
       }
 }