Introdução ao FluentEmail

Tim começa explicando o contexto: o envio de e-mails em C# costumava depender de ferramentas mais antigas como o .NET, mas com o .NET 5 e versões posteriores, grande parte disso foi descontinuado. É aí que entra o FluentEmail, uma biblioteca de e-mail moderna, para preencher a lacuna tanto para mensagens simples quanto para comunicações mais sofisticadas, como e-mails em HTML e imagens incorporadas.

Tim destaca que o objetivo é criar e-mails facilmente, usar modelos e até mesmo testá-los sem precisar se conectar a servidores de produção.

Configurando o aplicativo de console

À 1:04, Tim cria um novo aplicativo de console chamado EmailDemoApp. Ele destaca a simplicidade de começar com static void Main(string[] args) ou simplesmente public static void Main quando você não precisa de uma interface de usuário. O ponto de partida limpo permite focar exclusivamente no processo de envio de e-mails.

Após criar o aplicativo, Tim configura o projeto para usar o .NET 5, uma atualização moderna do .NET Framework tradicional, garantindo melhor compatibilidade com os protocolos modernos de clientes de e-mail.

Instalando o FluentEmail através do Console do Gerenciador de Pacotes

Em seguida, às 3:50, Tim usa o Console do Gerenciador de Pacotes para instalar o pacote FluentEmail.Smtp, permitindo o uso de um cliente SMTP para enviar e-mails em C#. Além disso, Tim menciona que existem integrações adicionais como MailGun e SendGrid, mas o SMTP é a opção mais universal, funcionando na maioria dos clientes e configurações de e-mail.

Utilizando o seguinte comando, você pode instalá-lo manualmente:

Install-Package FluentEmail.Smtp

Install-Package FluentEmail.Smtp

Tim garante que adicionemos também a dependência FluentEmail.Core, que é necessária para o funcionamento da biblioteca.

Configurando o cliente e o servidor SMTP

Às 6h10, Tim discute a configuração do cliente SMTP usando uma nova configuração do smtpclient:

var sender = new SmtpSender(() => new SmtpClient("localhost")
{
    EnableSsl = false,
    DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
    PickupDirectoryLocation = @"C:\Demos"
});

var sender = new SmtpSender(() => new SmtpClient("localhost")
{
    EnableSsl = false,
    DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
    PickupDirectoryLocation = @"C:\Demos"
});

Tim enfatiza que este servidor SMTP localhost é para testes locais. Em produção, você se conectaria aos detalhes reais do seu servidor SMTP, como o endpoint SMTP do Gmail, possivelmente usando uma senha de aplicativo por segurança.

Ele destaca que configurações sensíveis devem ser movidas para um arquivo de configuração como o appsettings.json para maior segurança e flexibilidade.

Envio de uma mensagem de e-mail simples

Às 11h59, Tim passa a enviar uma mensagem simples usando a API de e-mail do FluentEmail. Ele explica que um objeto var email é criado com o seguinte exemplo de código:

var email = await Email
    .From("tim@timco.com")
    .To("test@test.com", "Sue")
    .Subject("Thanks")
    .Body("Thanks for buying our product.")
    .SendAsync();

var email = await Email
    .From("tim@timco.com")
    .To("test@test.com", "Sue")
    .Subject("Thanks")
    .Body("Thanks for buying our product.")
    .SendAsync();

Dessa forma, você especifica claramente o assunto (string), o e-mail (string) e o corpo da mensagem usando o encadeamento de métodos. A variável message (email) armazena o resultado, permitindo a verificação de erros.

Tim destaca que, embora o e-mail pareça ser de tim@timco.com, o servidor SMTP ainda o autenticará com base nas credenciais de login (como a senha de um aplicativo do Gmail).

Visualizando o e-mail usando o diretório local

Após o envio da mensagem de e-mail, Tim mostra como ela aparece como um arquivo .eml na pasta local. Embora seja possível abri-lo com o Outlook ou o Bloco de Notas, para mensagens de e-mail existentes ou testes em massa, não é a opção mais amigável.

Utilizando o Papercut SMTP para facilitar os testes

Às 17h03, Tim muda de salvar em um diretório para usar o Papercut SMTP, um servidor SMTP falso e leve.

Ele modifica as configurações do cliente SMTP para:

DeliveryMethod = SmtpDeliveryMethod.Network;
Port = 25;

DeliveryMethod = SmtpDeliveryMethod.Network;
Port = 25;

Com o Papercut, cada e-mail de teste aparece imediatamente em uma interface gráfica. Isso facilita muito a verificação do conteúdo de texto simples e HTML do corpo do e-mail e simula a forma como os clientes de e-mail reais renderizam diferentes formatos.

Criando um e-mail HTML com modelos Razor

Às 19h12, Tim observa que o texto simples estático não é suficiente para muitos casos do mundo real. Para mensagens HTML mais dinâmicas e ricas, ele instala o pacote FluentEmail Razor :

Install-Package FluentEmail.Razor

Install-Package FluentEmail.Razor

Ele atualiza as configurações do projeto com:

<PreserveCompilationContext>true</PreserveCompilationContext>

<PreserveCompilationContext>true</PreserveCompilationContext>

Para garantir que os modelos Razor sejam compilados corretamente.

Criando e usando um modelo de e-mail Razor

Utilizando um construtor de strings (var builder) e a sintaxe Razor , Tim cria um modelo de e-mail dinâmico:

var builder = new StringBuilder();
builder.AppendLine("Dear @Model.FirstName,");
builder.AppendLine("<p>Thanks for purchasing @Model.ProductName.</p>");
builder.AppendLine("The TimCo Team");

var builder = new StringBuilder();
builder.AppendLine("Dear @Model.FirstName,");
builder.AppendLine("<p>Thanks for purchasing @Model.ProductName.</p>");
builder.AppendLine("The TimCo Team");

Em seguida, ele anexa esse modelo à solicitação da variável usando o seguinte código:

await Email
    .UsingTemplate(builder.ToString(), new { FirstName = "Tim", ProductName = "Bacon Wrapped Bacon" })
    .SendAsync();

await Email
    .UsingTemplate(builder.ToString(), new { FirstName = "Tim", ProductName = "Bacon Wrapped Bacon" })
    .SendAsync();

Essa técnica suporta diferentes formatos, como texto simples e corpo HTML, dependendo do conteúdo do modelo.

Lidando com múltiplos destinatários e anexos

Embora não esteja totalmente detalhado na demonstração de Tim, o FluentEmail oferece suporte fácil a vários destinatários por meio de chamadas .To() e da adição de um objeto de anexo para arquivos anexados, semelhante ao funcionamento do objeto mailmessage ou da classe mailmessage no .NET antigo.

Você pode criar anexos usando um novo caminho de arquivo em formato de string ou um ID de conteúdo para imagens embutidas.

Tratamento de exceções no processo de envio de e-mail

Tim sugere que você deve lidar com os erros de forma elegante. Por exemplo:

try
{
    var result = await Email.SendAsync();
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

try
{
    var result = await Email.SendAsync();
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Isso registra quaisquer falhas relacionadas ao SMTP ou à rede durante o processo de envio de e-mail, principalmente se surgirem problemas com o protocolo SMTP.

Resumo e Considerações Finais

Por volta dos 27:56, Tim conclui que, com o FluentEmail, enviar e-mails em C# torna-se simples — desde o envio de mensagens básicas como "Olá, mundo!" até e-mails HTML dinâmicos e profissionais.

Ele também destaca a importância de manter os detalhes e configurações do servidor SMTP flexíveis, utilizando um arquivo de configuração como o appsettings.json, especialmente ao migrar entre o desenvolvimento local e plataformas em nuvem como o Portal do Azure.

Seja para enviar e-mails individualmente ou em massa, o FluentEmail, combinado com o SMTP do Papercut, oferece um fluxo de trabalho moderno e eficiente, compatível com diversas linguagens de programação e ecossistemas.

Considerações finais

Graças ao excelente vídeo de Tim Corey, fica claro que a funcionalidade moderna de envio de e-mails em C# evoluiu muito além do tratamento básico das classes smtpclient e mailmessage. Com a ajuda do FluentEmail, os desenvolvedores podem criar rapidamente um novo projeto, configurar uma conexão SMTP, construir um corpo de e-mail dinâmico e testar tudo localmente antes de implantar em produção.