As várias maneiras de mandar e-mail utilizando .NET (Autenticado e não autenticado)

Neste breve artigo o autor mostra como enviar e-mails de forma autoenticada e não auntenticada.

por Mauricio Junior

Requisitos:

Linguagem: C#.NET

Tecnologia: ASP.NET

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 outro 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 de outra pessoa. Esse procedimento de envio precisa que você se autentique para enviar.

Da forma mostrada acima (Cod. 1.1), é enviado um 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.

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.