As várias maneiras de mandar e.mail utilizando .NET

ASP.NET

Saturday, January 1, 2011

Requisitos:
Linguagem: C#.NET
Tecnologia: ASP.NET
Tipo: Envio de e-mail de duas maneiras
Nível: Avançado

   Olá pessoal, neste artigo mostrarei como criar métodos para mandar e-mail a usuários de forma diferente. Por exemplo, existe sistema que não pode mandar e-mail para outras contas, ou seja, com uma conta do próprio domínio mandar e-mail para o mesmo domínio, e existe outro sistema que pode. Isso porque, para mandar qualquer e-mail para outra pessoa, é necessário autenticação de e-mail que envia junto ao servidor.

Como assim?

   Para ser mais prático, imagine que você tem um sistema que o usuário preenche os dados e envia, ao enviar os dados, automaticamente é passado um e-mail pra ele e um e-mail para o administrador do sistema. Esse tipo de envio de e-mail precisa de autenticação no servidor. Para enviar e-mail do provedor1 para o provedor1, isto é, do seu provedor para o seu provedor, já não precisa de autenticação.

   Toda essa explicação que tentei fazer, mostrarei via código, como desenvolver um e-mail que é enviado via autenticação e sem autenticação.

Configuração

   Antes de começar o desenvolvimento, é bom gerenciar as formas dos dados, ou seja, no arquivo web.config é bom conter todos os dados necessários para envio de e-mail, configuração de smtp e outros. Pois caso altere alguma coisa no servidor ou domínio, basta alterar no arquivo de configuração. Dentro do <AppSettings> pode ser colocado estes dados.

Exemplo:
   <add key="SMTP" value="smtp.seuprovedor.com.br"/> seu smtp
   <add key="EmailDeAutomatico" value="seu@email_que_envia.com.br"/> seu e-mail responsável pelo envio dos dados ao usuário. Geralmente um e-mail genérico ou automático.

   Depois de atribuir os valores corretamente em seu arquivo de configuração, basta fazer os métodos para utilizá-los. Lembro que, para cada exemplo mostrado, coloco o exemplo testado e comprovado, facilitando assim uma melhor visualização.

Primeiro Exemplo:
Neste primeiro exemplo, mostro a forma mais comum para enviar e-mail sem qualquer tipo de autenticação de SMTP, usuário e senha.

    public void enviarEmailPart(string[] args)
        {
            string host = ConfigurationManager.AppSettings["SMTP"].ToString();
            string from = args[0];
            string to = args[1];
            string subject = args[2];
            string body = args[3];
            try
            {
                using (MailMessage message = new MailMessage(from, to, subject, body))
                {
                    SmtpClient client = new SmtpClient(host);
                    client.UseDefaultCredentials = true;
                    client.Send(message);
                }
            }
            catch (SmtpException exception)
            {
                throw new Exception("M\x00e9todo: enviarEmailPart()", exception);
            }
            catch (Exception exception2)
            {
                throw new Exception("M\x00e9todo: enviarEmailPart()", exception2);
            }
        }

Referência: Cod. 1.1

Explicação:
Esse método envia e-mail passando como parâmetro um array de string[]. São 4 posições, ou seja, de 0 a 3. Dessa forma, antes de passar os dados, os mesmos devem ser atribuídos.

            string host = ConfigurationManager.AppSettings["SMTP"].ToString();
            string from = args[0];
            string to = args[1];
            string subject = args[2];
            string body = args[3];

Referência: Cod. 1.2
Note que criei algumas variáveis fixas dentro do método que envia e-mail. O host pega a configuração do web.config, o from pega o primeiro argumento do array, o to pega o segundo argumento, o subject para o terceiro argumento e o body pega o quarto argumento. Todos os nomes são intuitivos.

        try
            {
                using (MailMessage message = new MailMessage(from, to, subject, body))
                {
                    SmtpClient client = new SmtpClient(host);
                    client.UseDefaultCredentials = true;
                    client.Send(message);
                }
            }

Referência: Cod. 1.3
Depois de montados, basta enviar os dados. Lembro que estou usando using System.Net.Mail; no início da classe. O SMTPCliente é passado pela variável host, atribuo o mesmo e mando o send passando a variável message criada anteriormente no using.

   Esse é o método principal para enviar o e-mail. Podem ser criados outros métodos para setar/atribuir os valores antes de chamar o método principal. No corpo da mensagem tem uma manha legal, faço com StringBuilder com vários parâmetros e no final crio o argumento. Veja um exemplo para não ficar perdido.

public void enviaEmailSistema(EmailVO vo)
        {
            try
            {
                string[] args = new string[4];
                args[0] = ConfigurationManager.AppSettings["EmailDeAutomatico"].ToString();
                args[1] = ConfigurationManager.AppSettings["EmailDeAutomatico"].ToString();
                args[2] = "Acampamento - Fale Conosco";
                StringBuilder builder = new StringBuilder();
                builder.Append("######################################################");
                builder.Append("\n\r");
                builder.Append("\n\r");
                builder.Append("FALE CONOSCO");
                builder.Append("\n\r");
                builder.Append("Usu\x00e1rio: " + vo.Nome);
                builder.Append("\n\r");
                builder.Append("E-mail: " + vo.Email);
                builder.Append("\n\r");
                builder.Append("Descricao: " + vo.Descricao);
                builder.Append("\n\r");
                builder.Append("\n\r");
                builder.Append("Telefone: " + vo.Telefone);
                builder.Append("\n\r");
                builder.Append(".......Por favor, n\x00e3o responda este e-mail...........");
                builder.Append("\n\r");
                builder.Append("####################################################");
                args[3] = builder.ToString();
                this.enviarEmailPart(args);
            }
            catch (Exception exception)
            {
                throw new Exception("Erro na classe cadastro.cs", exception);
            }
        }

Referência: Cod. 1.4
Note que no começo do método criei uma variável do tipo string[] onde possui um array de string com 4 posições. Logo depois atribuo os dados e no final mando para o método principal.

   Todos esses passos são necessários para enviar e-mail do usuário local para o usuário local, ou seja, se você tenta envia algum e-mail do seu domínio para um domínio hotmail, yahoo ou gmail, acaba voltando e não chegando; pois o mesmo precisa de autenticação.
   Necessariamente precisa de autenticação para mandar e-mail a outro terceiro e-mail, é como mandar um e-mail do seu outlook e com sua conta, para um e-mail do sua mãe. Esse procedimento de envio precisa que você se autentique para enviar.
   Da forma mostrada acima (Cod. 1.1), envia e-mail do seu domínio para o seu domínio, ou seja, do automatico AT dominio.com.br para auto AT dominio.com.br.
   O segundo que mostrarei será com autenticação, você pode mandar e-mail para qualquer outro e-mail; lembrando da lei de SPAM que existe hoje em dia.

Segundo Exemplo

public void enviaEmailColecao(string emailPara, string mensagem, string titulo)
        {
            try
            {
                MailMessage mail = new MailMessage();
                mail.From = "email_de "; //email de
                mail.To = emailPara.ToString(); // email para
                mail.Subject = titulo.ToString(); // titulo
                mail.BodyFormat = MailFormat.Html; //formato html

                mail.Body += "<br><br><font face='verdana' size='2'>" + mensagem.ToString() + "</font>";

                mailField(mail);

                SmtpMail.SmtpServer = "endereco_smtp";
                SmtpMail.Send(mail);
            }
            catch (Exception e)
            {
                e.Message.ToString();
            }
        }

Referência: Cod.1.5
   Antes de explicar o método, devo importar a classe using System.Web.Mail. Assim não terá erro no momento de instanciar o método MailMessage().
Analisando o método, depois da instância criada, tenho que atribuir os dados, tanto de entrada quando de saída. No atributo BodyFormat; posso escolher a forma que o e-mail tem que chegar. Geralmente utilizo no MailFormat o tipo HTML.
O método mailField(mail) é responsável pela autenticação de usuário e senha. Veja a referência Cod. 1.6.

/// método para autenticar e-mail.
private static void mailField(MailMessage mail)
        {
            mail.Fields["http://schemas.microsoft.com/cdo/configuration/smtpauthenticate"] = 1;
            mail.Fields["http://schemas.microsoft.com/cdo/configuration/sendusername"] = "seu_email";
            mail.Fields["http://schemas.microsoft.com/cdo/configuration/sendpassword"] = "sua_senha";
        }

Referência: Cod.1.6

   O atributo MailMessage possui os campos Fields, e neles podemos atribuir o método de autenticação, passando o usuário e senha. O primeiro field é smtpauthenticate onde aceita os valores 0 e 1. O segundo field é o usuário, ou seja, o seu e-mail com @ AT e tudo mais. O terceiro field pode ser colocado a senha do seu e-mail. O campo 2 e 3 são do tipo string.
   Depois de atribuir os dados, coloco o STMP_SERVER colocando o endereço do smtp que o email valida. Logo após faço o send.

Bom, fico por aqui.
Espero ter ajudado, qualquer dúvida só entrar em contato.