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.
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.