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.
