none
Erros SMTP RRS feed

  • Pergunta

  • Boa tarde pessoal, baixei uma rotina da internet e estou tentando adaptá-la ao meu sistema. No momento de enviar o email está dando esse error o erro está nesse endereço:

    https://www.dropbox.com/s/2wmashgcxco0p9e/Captura%20de%20tela%202015-06-29%2017.18.54.png?dl=0

    porém, estou passando o código

            public static string EnviaMensagemComAnexos(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario, 
                                                    string cNumeroPorta, ArrayList anexos)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido:" + Destinatario;
    
                    // Cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(
                       Remetente,
                       Destinatario,
                       Assunto,
                       enviaMensagem);
    
                    // The anexos arraylist should point to a file location where
                    // the attachment resides - add the anexos to the message
                    foreach (string anexo in anexos)
                    {
                        Attachment anexado = new Attachment(anexo, MediaTypeNames.Application.Octet);
                        mensagemEmail.Attachments.Add(anexado);
                    }
    
    //                SmtpClient client = new SmtpClient("smtp.gmail.com", 587);
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // Inclui as credenciais
                    client.UseDefaultCredentials = true;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    string erro = ex.InnerException.ToString();
                    return ex.Message.ToString() + erro;
                }
            }
            /// <summary>
            /// Confirma a validade de um email
            /// </summary>
            /// <param name="enderecoEmail">Email a ser validado</param>
            /// <returns>Retorna True se o email for valido</returns>
            public static bool ValidaEnderecoEmail(string enderecoEmail)
            {
                try
                {
                    //define a expressão regulara para validar o email
                    string texto_Validar = enderecoEmail;
                    Regex expressaoRegex = new Regex(@"\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}");
    
                    // testa o email com a expressão
                    if (expressaoRegex.IsMatch(texto_Validar))
                    {
                        // o email é valido
                        return true;
                    }
                    else
                    {
                        // o email é inválido
                        return false;
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
        }
    

    segunda-feira, 29 de junho de 2015 20:26

Respostas

  • Fiz os testes e alguns ajustes e esta funcionando:

    public static string EnviaMensagemEmail(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario,
                                                    string cNumeroPorta)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    // Se o email não é validao retorna uma mensagem
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido: " + Destinatario;
    
                    // cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(Remetente, Destinatario, Assunto, enviaMensagem);
    
                    //----------------------------------------------------------------------------------------------------------------------------------
                    //obtem os valores smtp do arquivo de configuração . Não vou usar estes valores estou apenas mostrando como obtê-los
                    //Configuration configurationFile = WebConfigurationManager.OpenWebConfiguration(null);
                    //MailSettingsSectionGroup mailSettings = configurationFile.GetSectionGroup("system.net/mailSettings") as MailSettingsSectionGroup;
                    //if (mailSettings != null)
                    //{
                    //    string host = mailSettings.Smtp.Network.Host;
                    //    string password = mailSettings.Smtp.Network.Password;
                    //    string username = mailSettings.Smtp.Network.UserName;
                    //    int port = mailSettings.Smtp.Network.Port;
                    //}
                    //---------------------------------------------------------------------------------------------------------------------------------------
    
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // inclui as credenciais
                    //client.UseDefaultCredentials = true;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para  " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    return ex.Message;
                }
            }
            /// <summary>
            /// Transmite uma mensagem de email com um anexo
            /// </summary>
            /// <param name="Destinatario">Destinatario (Recipient)</param>
            /// <param name="Remetente">Remetente (Sender)</param>
            /// <param name="Assunto">Assunto da mensagem (Subject)</param>
            /// <param name="enviaMensagem">Corpo da mensagem(Body)</param>
            /// <param name="anexos">Um array de strings apontando para a localização de cada anexo</param>
            /// <returns>Status da mensagem</returns>
            public static string EnviaMensagemComAnexos(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario,
                                                    string cNumeroPorta, List<string> anexos)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido:" + Destinatario;
    
                    // Cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(
                       Remetente,
                       Destinatario,
                       Assunto,
                       enviaMensagem);
    
                    // The anexos arraylist should point to a file location where
                    // the attachment resides - add the anexos to the message
    
                    if (anexos != null)
                    {
                        Attachment anexado=null;
                        foreach (string anexo in anexos)
                        {
                            anexado = new Attachment(anexo, MediaTypeNames.Application.Octet);
                            mensagemEmail.Attachments.Add(anexado);
                        }
                    }
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    string erro = ex.InnerException.ToString();
                    return ex.Message.ToString() + erro;
                }
            }
            /// <summary>
            /// Confirma a validade de um email
            /// </summary>
            /// <param name="enderecoEmail">Email a ser validado</param>
            /// <returns>Retorna True se o email for valido</returns>
            public static bool ValidaEnderecoEmail(string enderecoEmail)
            {
                try
                {
                    //define a expressão regulara para validar o email
                    string textoValidar = enderecoEmail;
                    Regex expressaoRegex = new Regex(@"\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}");
    
                    // testa o email com a expressão
                    if (expressaoRegex.IsMatch(textoValidar))
                    {
                        // o email é valido
                        return true;
                    }
                    else
                    {
                        // o email é inválido
                        return false;
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
    

    OBS IMPORTANTE: É NECESSÁRIO QUE OS RESPECTIVOS SERVIDORES SMTP ESTEJAM COM A SEGURANÇA DE ENVIO DESATIVADOS, SENÃO APRESENTA ERRO.

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    • Sugerido como Resposta Lucio Rogerio SPBanned quarta-feira, 8 de julho de 2015 12:19
    • Marcado como Resposta Marcos SJ segunda-feira, 20 de julho de 2015 20:30
    terça-feira, 7 de julho de 2015 23:03

Todas as Respostas

  • Antes de mais nada para que o envio via SMTP pelo Gmail funcione você deve desabilitar a segurança de envio via SMTP pelo webmail do GMAIL, ai pode testar novamente provavelmente a mensagem será outra.

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    segunda-feira, 29 de junho de 2015 22:10
  • Mr.GMSOFT boa noite. Não estou enviando pelo gmail e sim pelo ig. o Valor que a variável cSMTP está recebendo é: "smtp.ig.com.br".

    segunda-feira, 29 de junho de 2015 23:08
  • A porta é 465 para a  Ig

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    segunda-feira, 29 de junho de 2015 23:33
  • Você tinha razão voltou a dá outro error.

    https://www.dropbox.com/s/jbjb187y0xeiflp/Captura%20de%20tela%202015-06-29%2020.48.47.png?dl=0

    segunda-feira, 29 de junho de 2015 23:50
  • Tente fazer os testes de envio sem os anexos

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    terça-feira, 30 de junho de 2015 00:09
  • Deu Falha ao enviar email.

    terça-feira, 30 de junho de 2015 00:50
  • Verifique se o seu firewall ou mesmo antivirus não esta bloqueando a porta

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    terça-feira, 30 de junho de 2015 01:04
  • O firewall já estava desabilitado, porém, desativei o antivirus e o error persiste.
    terça-feira, 30 de junho de 2015 01:08
  • Voltou a dar o erro, porém, eu fiz uma tentativa com anexos e deu o seguinte error:

    https://www.dropbox.com/s/jbjb187y0xeiflp/Captura%20de%20tela%202015-06-29%2020.48.47.png?dl=0

    terça-feira, 30 de junho de 2015 02:16
  • Olá Garibaldo, tudo bom?

    Quais foram as tratativas que você tomou para resolver o erro que você postou por último?

    Se possível, poste o código como está atualmente para que o Lúcio e o GMSOFT possam entender melhor.

    Abraços

    terça-feira, 7 de julho de 2015 19:08
  • Boa noite Cristopher, Nenhuma das tentativas solucionou o meu problema. 

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Net.Mail;
    using System.Net.Mime;
    using System.Net;
    using System.Text.RegularExpressions;
    using System.Net.Configuration;
    using System.Configuration;
    using System.Web.Configuration;
    using System.Web;
    using Transportes.Transportes;
    
    namespace Interface.BLL
    {
        public class EnviaEmail
        {
            /// <summary>
            /// Transmite uma mensagem de email sem anexos
            /// </summary>
            /// <param name="Destinatario">Destinatario (Recipient)</param>
            /// <param name="Remetente">Remetente (Sender)</param>
            /// <param name="Assunto">Assunto da mensagem (Subject)</param>
            /// <param name="enviaMensagem">Corpo da mensagem(Body)</param>
            /// <returns>Status da mensagem</returns>
            public static string EnviaMensagemEmail(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario, 
                                                    string cNumeroPorta)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    // Se o email não é validao retorna uma mensagem
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido: " + Destinatario;
    
                    // cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(Remetente,Destinatario,Assunto,enviaMensagem);
    
                    //----------------------------------------------------------------------------------------------------------------------------------
                    //obtem os valores smtp do arquivo de configuração . Não vou usar estes valores estou apenas mostrando como obtê-los
                    Configuration configurationFile = WebConfigurationManager.OpenWebConfiguration(null);
                    MailSettingsSectionGroup mailSettings = configurationFile.GetSectionGroup("system.net/mailSettings") as MailSettingsSectionGroup;
                    if (mailSettings != null)
                    {
                         string host = mailSettings.Smtp.Network.Host;
                         string password = mailSettings.Smtp.Network.Password;
                         string username = mailSettings.Smtp.Network.UserName;
                         int port = mailSettings.Smtp.Network.Port;
                    }
                    //---------------------------------------------------------------------------------------------------------------------------------------
    
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // inclui as credenciais
                    client.UseDefaultCredentials = true;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para  " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    return ex.Message.ToString();
                }
            }
            /// <summary>
            /// Transmite uma mensagem de email com um anexo
            /// </summary>
            /// <param name="Destinatario">Destinatario (Recipient)</param>
            /// <param name="Remetente">Remetente (Sender)</param>
            /// <param name="Assunto">Assunto da mensagem (Subject)</param>
            /// <param name="enviaMensagem">Corpo da mensagem(Body)</param>
            /// <param name="anexos">Um array de strings apontando para a localização de cada anexo</param>
            /// <returns>Status da mensagem</returns>
            public static string EnviaMensagemComAnexos(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario, 
                                                    string cNumeroPorta, ArrayList anexos)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido:" + Destinatario;
    
                    // Cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(
                       Remetente,
                       Destinatario,
                       Assunto,
                       enviaMensagem);
    
                    // The anexos arraylist should point to a file location where
                    // the attachment resides - add the anexos to the message
    
                    if (anexos != null)
                    {
                        foreach (string anexo in anexos)
                        {
                            Attachment anexado = new Attachment(anexo, MediaTypeNames.Application.Octet);
                            mensagemEmail.Attachments.Add(anexado);
                        }
                    }
    //                foreach (string anexo in anexos)
    //                {
    //                    Attachment anexado = new Attachment(anexo, MediaTypeNames.Application.Octet);
    //                    mensagemEmail.Attachments.Add(anexado);
    //                }
    
    //                SmtpClient client = new SmtpClient("smtp.gmail.com", 587);
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // Inclui as credenciais
                    client.UseDefaultCredentials = true;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    string erro = ex.InnerException.ToString();
                    return ex.Message.ToString() + erro;
                }
            }
            /// <summary>
            /// Confirma a validade de um email
            /// </summary>
            /// <param name="enderecoEmail">Email a ser validado</param>
            /// <returns>Retorna True se o email for valido</returns>
            public static bool ValidaEnderecoEmail(string enderecoEmail)
            {
                try
                {
                    //define a expressão regulara para validar o email
                    string texto_Validar = enderecoEmail;
                    Regex expressaoRegex = new Regex(@"\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}");
    
                    // testa o email com a expressão
                    if (expressaoRegex.IsMatch(texto_Validar))
                    {
                        // o email é valido
                        return true;
                    }
                    else
                    {
                        // o email é inválido
                        return false;
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
        }
    
    }
    

    O código está postado.

    Garibaldo

    terça-feira, 7 de julho de 2015 22:16
  • Fiz os testes e alguns ajustes e esta funcionando:

    public static string EnviaMensagemEmail(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario,
                                                    string cNumeroPorta)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    // Se o email não é validao retorna uma mensagem
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido: " + Destinatario;
    
                    // cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(Remetente, Destinatario, Assunto, enviaMensagem);
    
                    //----------------------------------------------------------------------------------------------------------------------------------
                    //obtem os valores smtp do arquivo de configuração . Não vou usar estes valores estou apenas mostrando como obtê-los
                    //Configuration configurationFile = WebConfigurationManager.OpenWebConfiguration(null);
                    //MailSettingsSectionGroup mailSettings = configurationFile.GetSectionGroup("system.net/mailSettings") as MailSettingsSectionGroup;
                    //if (mailSettings != null)
                    //{
                    //    string host = mailSettings.Smtp.Network.Host;
                    //    string password = mailSettings.Smtp.Network.Password;
                    //    string username = mailSettings.Smtp.Network.UserName;
                    //    int port = mailSettings.Smtp.Network.Port;
                    //}
                    //---------------------------------------------------------------------------------------------------------------------------------------
    
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // inclui as credenciais
                    //client.UseDefaultCredentials = true;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para  " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    return ex.Message;
                }
            }
            /// <summary>
            /// Transmite uma mensagem de email com um anexo
            /// </summary>
            /// <param name="Destinatario">Destinatario (Recipient)</param>
            /// <param name="Remetente">Remetente (Sender)</param>
            /// <param name="Assunto">Assunto da mensagem (Subject)</param>
            /// <param name="enviaMensagem">Corpo da mensagem(Body)</param>
            /// <param name="anexos">Um array de strings apontando para a localização de cada anexo</param>
            /// <returns>Status da mensagem</returns>
            public static string EnviaMensagemComAnexos(string Destinatario, string Remetente, string Assunto, string enviaMensagem, string cSMTP, string cSenhaUsuario,
                                                    string cNumeroPorta, List<string> anexos)
            {
                try
                {
                    // valida o email
                    bool bValidaEmail = ValidaEnderecoEmail(Destinatario);
    
                    if (bValidaEmail == false)
                        return "Email do destinatário inválido:" + Destinatario;
    
                    // Cria uma mensagem
                    MailMessage mensagemEmail = new MailMessage(
                       Remetente,
                       Destinatario,
                       Assunto,
                       enviaMensagem);
    
                    // The anexos arraylist should point to a file location where
                    // the attachment resides - add the anexos to the message
    
                    if (anexos != null)
                    {
                        Attachment anexado=null;
                        foreach (string anexo in anexos)
                        {
                            anexado = new Attachment(anexo, MediaTypeNames.Application.Octet);
                            mensagemEmail.Attachments.Add(anexado);
                        }
                    }
                    SmtpClient client = new SmtpClient(cSMTP, Convert.ToInt32(cNumeroPorta));
                    client.EnableSsl = true;
                    NetworkCredential cred = new NetworkCredential(Remetente, cSenhaUsuario);
                    client.Credentials = cred;
    
                    // envia a mensagem
                    client.Send(mensagemEmail);
    
                    return "Mensagem enviada para " + Destinatario + " às " + DateTime.Now.ToString() + ".";
                }
                catch (Exception ex)
                {
                    string erro = ex.InnerException.ToString();
                    return ex.Message.ToString() + erro;
                }
            }
            /// <summary>
            /// Confirma a validade de um email
            /// </summary>
            /// <param name="enderecoEmail">Email a ser validado</param>
            /// <returns>Retorna True se o email for valido</returns>
            public static bool ValidaEnderecoEmail(string enderecoEmail)
            {
                try
                {
                    //define a expressão regulara para validar o email
                    string textoValidar = enderecoEmail;
                    Regex expressaoRegex = new Regex(@"\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}");
    
                    // testa o email com a expressão
                    if (expressaoRegex.IsMatch(textoValidar))
                    {
                        // o email é valido
                        return true;
                    }
                    else
                    {
                        // o email é inválido
                        return false;
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
    

    OBS IMPORTANTE: É NECESSÁRIO QUE OS RESPECTIVOS SERVIDORES SMTP ESTEJAM COM A SEGURANÇA DE ENVIO DESATIVADOS, SENÃO APRESENTA ERRO.

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    • Sugerido como Resposta Lucio Rogerio SPBanned quarta-feira, 8 de julho de 2015 12:19
    • Marcado como Resposta Marcos SJ segunda-feira, 20 de julho de 2015 20:30
    terça-feira, 7 de julho de 2015 23:03
  • Bom dia Mr.GMSOFT vi que você mudou o array por uma lista. Ainda não tenho o domínio sobre Listas. Qual o procedimento na minha chamada. Segue o meu código que chama o envio do email.
            private void btnEnviarEmail_Click(object sender, EventArgs e)
            {
                if (String.IsNullOrEmpty(txtEnviarPara.Text))
                {
                    MessageBox.Show("Endereço de email do destinatário inválido.", "Erro ");
                    return;
                }
                if (String.IsNullOrEmpty(txtEnviadoPor7.Text))
                {
                    MessageBox.Show("Endereço de email do remetente inválido.", "Erro ");
                    return;
                }
                if (String.IsNullOrEmpty(txtAssuntoTitulo.Text))
                {
                    MessageBox.Show("Definição do assunto inválida.", "Erro ");
                    return;
                }
                if (String.IsNullOrEmpty(txtMensagem.Text))
                {
                    MessageBox.Show("Mensagem inválida.", "Erro ");
                    return;
                }
    
                //separa os anexos em um array de string
                string[] arr = txtAnexos.Text.Split(';');
                //cria um novo arraylist
                aAnexosEmail = new ArrayList();
                //percorre o array de string e inclui os anexos
                for (int i = 0; i < arr.Length; i++)
                {
                    if (!String.IsNullOrEmpty(arr[i].ToString().Trim()))
                    {
                        aAnexosEmail.Add(arr[i].ToString().Trim());
                    }
                }
    
                // Se existirem anexos , envia a mensagem com 
                // a chamada a EnviaMensagemComAnexos senão
                // usa o método enviaMensagemEmail
                if (aAnexosEmail.Count > 0)
                {
                    string resultado = EnviaEmail.EnviaMensagemComAnexos(txtEnviarPara.Text, txtEnviadoPor7.Text, txtAssuntoTitulo.Text, txtMensagem.Text,
                        txtSMTP7.Text, txtSenhaUsuario7.Text, txtPortaSMTP7.Text, aAnexosEmail);
    
                    MessageBox.Show(resultado, "Email enviado com sucesso");
                }
                else
                {
                    string resultado = EnviaEmail.EnviaMensagemEmail(txtEnviarPara.Text, txtEnviadoPor7.Text, txtAssuntoTitulo.Text, txtMensagem.Text,
                        txtSMTP7.Text, txtSenhaUsuario7.Text, txtPortaSMTP7.Text );
    
                    MessageBox.Show(resultado, "Email enviado com sucesso");
                }
            }
    

    quarta-feira, 8 de julho de 2015 15:11
  • Array é praticamente a mesma coisa,primeiro teste com o exemplo que postei colocando os caminhos do arquivo manualmente.

    Da uma lida sobre List<>


    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    quarta-feira, 8 de julho de 2015 15:29
  • É alguma coisa de certeza em seu computador a classe que postei funcionou perfeitamente com e sem anexo

    GTSA vantagem de ser inteligente é que podemos fingir que somos imbecis enquanto ao contrario é completamente impossivel

    quarta-feira, 8 de julho de 2015 16:20