Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. FluentEmail C#
AJUDA DO .NET

FluentEmail em C# (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Na era digital atual, o e-mail continua sendo um pilar fundamental da comunicação para empresas e indivíduos. Integrar funcionalidades robustas de e-mail em aplicações ASP.NET Core é essencial para automatizar notificações, enviar newsletters e facilitar a interação com o cliente. FluentEmail , uma poderosa biblioteca for .NET, combinada com as chaves da API do Mailgun , oferece aos desenvolvedores uma solução integrada para aprimorar os recursos de e-mail com confiabilidade e escalabilidade. Mais adiante neste artigo, também analisaremos a biblioteca IronPDF em ironsoftware.com para gerar e gerenciar documentos PDF.

O FluentEmail simplifica o processo de envio programático de múltiplos e-mails em aplicações .NET . Oferece uma interface intuitiva e fluida para configurar mensagens de e-mail, gerenciar anexos e administrar listas de destinatários. Esta biblioteca abstrai as complexidades da configuração SMTP e oferece suporte a vários provedores de renderização de modelos e provedores de serviços de e-mail de teste, incluindo o Mailgun.

FluentEmail .NET é uma biblioteca popular no ecossistema .NET Core para envio de e-mails, e oferece suporte a modelos de e-mail Razor , bem como a modelos Liquid para a criação dinâmica do corpo do e-mail. Utilizar o renderizador de modelos Razor com o FluentEmail .NET permite aproveitar o poder da sintaxe Razor para criar conteúdo de e-mail dinâmico e bem formatado, além de resolver arquivos de layout.

Aqui está um guia básico sobre como usar o FluentEmail .NET com modelos Razor do ASP.NET Core .

Passo 1: Instale o FluentEmail

Primeiro, você precisa instalar o pacote FluentEmail e o pacote do renderizador de modelos Razor usando o comando Install-Package ou o comando .NET add package:

# Install packages using the Package Manager Console
Install-Package FluentEmail.Core
Install-Package FluentEmail.Razor

# Or install packages using the .NET CLI
dotnet add package FluentEmail.Core
dotnet add package FluentEmail.Razor
# Install packages using the Package Manager Console
Install-Package FluentEmail.Core
Install-Package FluentEmail.Razor

# Or install packages using the .NET CLI
dotnet add package FluentEmail.Core
dotnet add package FluentEmail.Razor
SHELL

Passo 2: Criar um modelo Razor

Crie um modelo Razor para o corpo do seu e-mail. Este pode ser um arquivo .cshtml contendo HTML e sintaxe de código Razor válida. Por exemplo, crie um arquivo chamado EmailTemplate.cshtml:

@model YourNamespace.EmailViewModel
<!DOCTYPE html>
<html>
<head>
    <title>Email Template</title>
</head>
<body>
    <h1>Hello, @Model.Name!</h1>
    <p>This is a sample email template.</p>
</body>
</html>
@model YourNamespace.EmailViewModel
<!DOCTYPE html>
<html>
<head>
    <title>Email Template</title>
</head>
<body>
    <h1>Hello, @Model.Name!</h1>
    <p>This is a sample email template.</p>
</body>
</html>
HTML

Certifique-se de substituir YourNamespace.EmailViewModel pelo namespace e nome da classe reais do seu modelo de visualização ou simplesmente pelo modelo de domínio que você passará para este modelo.

Etapa 3: Configurar o FluentEmail com o Razor Renderer

Configure o FluentEmail para usar o renderizador Razor e forneça as dependências necessárias:

using FluentEmail.Core;
using FluentEmail.Razor;

public void ConfigureFluentEmail()
{
    // Set up the Razor renderer
    Email.DefaultRenderer = new RazorRenderer();

    // Set up SMTP sender address
    Email.DefaultSender = new SmtpSender(new SmtpClient("smtp.yourserver.com"));
}
using FluentEmail.Core;
using FluentEmail.Razor;

public void ConfigureFluentEmail()
{
    // Set up the Razor renderer
    Email.DefaultRenderer = new RazorRenderer();

    // Set up SMTP sender address
    Email.DefaultSender = new SmtpSender(new SmtpClient("smtp.yourserver.com"));
}
Imports FluentEmail.Core
Imports FluentEmail.Razor

Public Sub ConfigureFluentEmail()
	' Set up the Razor renderer
	Email.DefaultRenderer = New RazorRenderer()

	' Set up SMTP sender address
	Email.DefaultSender = New SmtpSender(New SmtpClient("smtp.yourserver.com"))
End Sub
$vbLabelText   $csharpLabel

Etapa 4: Renderizar e enviar e-mail

No código da sua aplicação, renderize o template Razor com o modelo desejado e envie o e-mail:

using FluentEmail.Core;
using FluentEmail.Razor;

public void SendEmail()
{
    // Specify the template file
    var template = "EmailTemplate.cshtml";

    // Create the email
    var email = Email
        .From("sender@example.com") // Set the sender's email address
        .To("recipient@example.com") // Set the recipient's email address
        .Subject("Sample Email"); // Set the email subject

    // Define the model to pass to the template
    var model = new EmailViewModel { Name = "John Doe" };

    // Render the template with the model
    email.UsingTemplateFromFile(template, model);

    // Send the email
    email.Send();
}
using FluentEmail.Core;
using FluentEmail.Razor;

public void SendEmail()
{
    // Specify the template file
    var template = "EmailTemplate.cshtml";

    // Create the email
    var email = Email
        .From("sender@example.com") // Set the sender's email address
        .To("recipient@example.com") // Set the recipient's email address
        .Subject("Sample Email"); // Set the email subject

    // Define the model to pass to the template
    var model = new EmailViewModel { Name = "John Doe" };

    // Render the template with the model
    email.UsingTemplateFromFile(template, model);

    // Send the email
    email.Send();
}
Imports FluentEmail.Core
Imports FluentEmail.Razor

Public Sub SendEmail()
	' Specify the template file
	Dim template = "EmailTemplate.cshtml"

	' Create the email
	Dim email = Email.From("sender@example.com").To("recipient@example.com").Subject("Sample Email") ' Set the email subject

	' Define the model to pass to the template
	Dim model = New EmailViewModel With {.Name = "John Doe"}

	' Render the template with the model
	email.UsingTemplateFromFile(template, model)

	' Send the email
	email.Send()
End Sub
$vbLabelText   $csharpLabel

Certifique-se de que EmailViewModel corresponda ao modelo definido em seu modelo Razor (EmailTemplate.cshtml). Este modelo deve conter propriedades que você referencia em seu modelo Razor (@Model.Name, por exemplo).

Integrando chaves de API do Mailgun

O Mailgun é um provedor de serviços de e-mail popular, conhecido por sua confiabilidade, capacidade de entrega e recursos avançados. Ao integrar as chaves da API do Mailgun com o FluentEmail, os desenvolvedores podem aproveitar a infraestrutura do Mailgun para enviar e-mails de forma eficiente e segura.

Passos para integrar as chaves da API do Mailgun com o FluentEmail

  1. Obtenha as chaves da API do Mailgun:

    • Crie uma conta no Mailgun, caso ainda não tenha uma.
    • Acesse o painel de controle do Mailgun e crie uma nova chave de API. Forneça uma descrição.

FluentEmail C# (Como funciona para desenvolvedores): Figura 1 - Mailgun

  1. Instale o pacote FluentEmail:

    Utilize o Gerenciador de Pacotes NuGet ou o Console do Gerenciador de Pacotes no Visual Studio para instalar o FluentMail:

# Install the FluentEmail.Mailgun package
Install-Package FluentEmail.Mailgun
# Install the FluentEmail.Mailgun package
Install-Package FluentEmail.Mailgun
SHELL

ou a partir do Visual Studio:

FluentEmail C# (Como funciona para desenvolvedores): Figura 2 - FluentEmail.Mailgun

  1. Configure o FluentEmail com as chaves da API do Mailgun:

Configure o FluentEmail para usar o Mailgun como provedor de serviços de e-mail ou remetente SMTP, configurando suas chaves de API:

using FluentEmail.Core;
using FluentEmail.Mailgun;

// Create an instance of MailgunSender
var sender = new MailgunSender("your-domain.com", "your-mailgun-api-key");

// Set the default sender for all emails
Email.DefaultSender = sender;
using FluentEmail.Core;
using FluentEmail.Mailgun;

// Create an instance of MailgunSender
var sender = new MailgunSender("your-domain.com", "your-mailgun-api-key");

// Set the default sender for all emails
Email.DefaultSender = sender;
Imports FluentEmail.Core
Imports FluentEmail.Mailgun

' Create an instance of MailgunSender
Private sender = New MailgunSender("your-domain.com", "your-mailgun-api-key")

' Set the default sender for all emails
Email.DefaultSender = sender
$vbLabelText   $csharpLabel

  1. Redigir e enviar e-mails:

    Utilize a interface intuitiva do FluentEmail para compor e enviar e-mails:

var email = Email
    .From("sender@example.com")
    .To("recipient@example.com")
    .Subject("Your Subject Here")
    .Body("Hello, this is a test email sent via FluentMail and Mailgun!")
    .Send();
var email = Email
    .From("sender@example.com")
    .To("recipient@example.com")
    .Subject("Your Subject Here")
    .Body("Hello, this is a test email sent via FluentMail and Mailgun!")
    .Send();
Dim email = Email _
    .From("sender@example.com") _
    .To("recipient@example.com") _
    .Subject("Your Subject Here") _
    .Body("Hello, this is a test email sent via FluentMail and Mailgun!") _
    .Send()
$vbLabelText   $csharpLabel

  1. Configuração Avançada:

    • Personalize as configurações de e-mail, como anexos, formatação HTML, destinatários em CC/BCC e cabeçalhos de e-mail usando a API fluente do FluentEmail.

Benefícios de usar o FluentEmail com o Mailgun

  • Simplicidade: O FluentEmail abstrai as complexidades da configuração SMTP, facilitando o envio de e-mails com o mínimo de configuração.
  • Confiabilidade: O uso da infraestrutura da Mailgun garante altas taxas de entrega e recursos robustos de gerenciamento de e-mails.
  • Escalabilidade: Expanda suas necessidades de envio de e-mails sem esforço com a infraestrutura escalável do Mailgun, adequada tanto para aplicações de pequena escala quanto para soluções de nível empresarial.
  • Recursos avançados: Aproveite os recursos do Mailgun, como rastreamento, análises e validação avançada de e-mail, para otimizar suas campanhas de e-mail.

Introdução ao IronPDF

FluentEmail C# (Como funciona para desenvolvedores): Figura 3 - IronPDF

IronPDF é uma biblioteca PDF para .NET que permite gerar, gerenciar e extrair conteúdo de documentos PDF em projetos .NET. Aqui estão algumas características principais:

  1. Conversão de HTML para PDF:

    • Converter conteúdo HTML, CSS e JavaScript em documentos PDF.
    • Mecanismo de renderização do Chrome para PDFs com qualidade de imagem perfeita.
    • Gere PDFs a partir de URLs, arquivos HTML ou strings HTML como entrada.

  2. Conversão de imagem e conteúdo:

    • Converter imagens de e para PDFs.
    • Extrair texto e imagens de documentos PDF existentes.
    • Suporte para diversos formatos de imagem, como JPG, PNG, etc.

  3. Edição e Manipulação:

    • Defina propriedades, segurança e permissões para PDFs.
    • Adicionar assinaturas digitais.
    • Editar metadados e histórico de revisões.

O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        // Create a ChromePdfRenderer instance
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        // Create a ChromePdfRenderer instance
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a ChromePdfRenderer instance
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Gere um documento PDF usando IronPDF e FluentEmail .NET com o remetente Mailgun.

Para começar, crie um aplicativo de console usando o Visual Studio, conforme mostrado abaixo.

FluentEmail C# (Como funciona para desenvolvedores): Figura 4 - Aplicativo de console

Informe o nome do projeto.

FluentEmail C# (Como funciona para desenvolvedores): Figura 5 - Configuração do projeto

Informe a versão do .NET .

FluentEmail C# (Como funciona para desenvolvedores): Figura 6 - Framework de destino

Instale o pacote IronPDF .

FluentEmail C# (Como funciona para desenvolvedores): Figura 7 - IronPDF

Instale o FluentEmail Mailgun.

FluentEmail C# (Como funciona para desenvolvedores): Figura 8 - FluentEmail.Mailgun

Para receber mensagens de e-mail durante o período de teste gratuito, o endereço de e-mail do destinatário deve ser cadastrado no painel de controle do Mailgun, conforme mostrado abaixo.

FluentEmail C# (Como funciona para desenvolvedores): Figura 9 - Painel do Mailgun

using FluentEmail.Core;
using FluentEmail.Mailgun;
using IronPdf;
using System;
using System.IO;

namespace CodeSample
{
    public static class FluentMailDemo
    {
        public static void Execute()
        {
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();

            // HTML Content to be converted into PDF and used in Email
            var content = "<h1>Demo FluentEmail with Mailgun and IronPDF</h1>";
            content += "<h2>Create MailgunSender</h2>";
            content += "<p>1. Get API key from app.mailgun.com</p>";

            var domain = "your-domain.com"; // Use your Mailgun domain
            var sender = new MailgunSender(domain, "your-mailgun-api-key"); // Use your Mailgun API key
            Email.DefaultSender = sender;

            content += "<h2>Prepare Email</h2>";
            content += $"<p>Sender: example@{domain}</p>";
            content += $"<p>Receiver: recipient@example.com</p>";
            content += $"<p>Subject: Checkout the New Awesome IronPDF Library from Iron Software</p>";
            content += $"<p>Body: IronPDF is the leading C# PDF library for generating & editing PDFs. It has friendly API and allows developers to rapidly deliver high quality PDFs from HTML in .NET projects.</p>";

            // Render HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Export the PDF to a file
            pdf.SaveAs("AwesomeFluentEmailAndIron.pdf");

            // Compose and send the email
            var email = Email
                .From($"example@{domain}")
                .To("recipient@example.com")
                .Subject("Checkout the New Awesome IronPDF Library from Iron Software")
                .Body("IronPDF is the leading C# PDF library for generating & editing PDFs. It has a friendly API and allows developers to rapidly deliver high quality PDFs from HTML in .NET projects.")
                .Attach(new FluentEmail.Core.Models.Attachment
                {
                    Data = File.OpenRead("AwesomeFluentEmailAndIron.pdf"),
                    Filename = "AwesomeFluentEmailAndIron.pdf",
                    ContentType = "application/pdf"
                })
                .Send();

            Console.WriteLine($"Is Send Success: {email.Successful}");
        }
    }
}
using FluentEmail.Core;
using FluentEmail.Mailgun;
using IronPdf;
using System;
using System.IO;

namespace CodeSample
{
    public static class FluentMailDemo
    {
        public static void Execute()
        {
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();

            // HTML Content to be converted into PDF and used in Email
            var content = "<h1>Demo FluentEmail with Mailgun and IronPDF</h1>";
            content += "<h2>Create MailgunSender</h2>";
            content += "<p>1. Get API key from app.mailgun.com</p>";

            var domain = "your-domain.com"; // Use your Mailgun domain
            var sender = new MailgunSender(domain, "your-mailgun-api-key"); // Use your Mailgun API key
            Email.DefaultSender = sender;

            content += "<h2>Prepare Email</h2>";
            content += $"<p>Sender: example@{domain}</p>";
            content += $"<p>Receiver: recipient@example.com</p>";
            content += $"<p>Subject: Checkout the New Awesome IronPDF Library from Iron Software</p>";
            content += $"<p>Body: IronPDF is the leading C# PDF library for generating & editing PDFs. It has friendly API and allows developers to rapidly deliver high quality PDFs from HTML in .NET projects.</p>";

            // Render HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Export the PDF to a file
            pdf.SaveAs("AwesomeFluentEmailAndIron.pdf");

            // Compose and send the email
            var email = Email
                .From($"example@{domain}")
                .To("recipient@example.com")
                .Subject("Checkout the New Awesome IronPDF Library from Iron Software")
                .Body("IronPDF is the leading C# PDF library for generating & editing PDFs. It has a friendly API and allows developers to rapidly deliver high quality PDFs from HTML in .NET projects.")
                .Attach(new FluentEmail.Core.Models.Attachment
                {
                    Data = File.OpenRead("AwesomeFluentEmailAndIron.pdf"),
                    Filename = "AwesomeFluentEmailAndIron.pdf",
                    ContentType = "application/pdf"
                })
                .Send();

            Console.WriteLine($"Is Send Success: {email.Successful}");
        }
    }
}
Imports FluentEmail.Core
Imports FluentEmail.Mailgun
Imports IronPdf
Imports System
Imports System.IO

Namespace CodeSample
	Public Module FluentMailDemo
		Public Sub Execute()
			' Instantiate Renderer
			Dim renderer = New ChromePdfRenderer()

			' HTML Content to be converted into PDF and used in Email
			Dim content = "<h1>Demo FluentEmail with Mailgun and IronPDF</h1>"
			content &= "<h2>Create MailgunSender</h2>"
			content &= "<p>1. Get API key from app.mailgun.com</p>"

			Dim domain = "your-domain.com" ' Use your Mailgun domain
			Dim sender = New MailgunSender(domain, "your-mailgun-api-key") ' Use your Mailgun API key
			Email.DefaultSender = sender

			content &= "<h2>Prepare Email</h2>"
			content &= $"<p>Sender: example@{domain}</p>"
			content &= $"<p>Receiver: recipient@example.com</p>"
			content &= $"<p>Subject: Checkout the New Awesome IronPDF Library from Iron Software</p>"
			content &= $"<p>Body: IronPDF is the leading C# PDF library for generating & editing PDFs. It has friendly API and allows developers to rapidly deliver high quality PDFs from HTML in .NET projects.</p>"

			' Render HTML content to PDF
			Dim pdf = renderer.RenderHtmlAsPdf(content)

			' Export the PDF to a file
			pdf.SaveAs("AwesomeFluentEmailAndIron.pdf")

			' Compose and send the email
			Dim email = Email.From($"example@{domain}").To("recipient@example.com").Subject("Checkout the New Awesome IronPDF Library from Iron Software").Body("IronPDF is the leading C# PDF library for generating & editing PDFs. It has a friendly API and allows developers to rapidly deliver high quality PDFs from HTML in .NET projects.").Attach(New FluentEmail.Core.Models.Attachment With {
				.Data = File.OpenRead("AwesomeFluentEmailAndIron.pdf"),
				.Filename = "AwesomeFluentEmailAndIron.pdf",
				.ContentType = "application/pdf"
			}).Send()

			Console.WriteLine($"Is Send Success: {email.Successful}")
		End Sub
	End Module
End Namespace
$vbLabelText   $csharpLabel

Explicação do código

  1. Integração do FluentEmail com o Mailgun:

    • FluentEmail.Core: Oferece uma interface fluente para compor e enviar e-mails.
    • FluentEmail.Mailgun: Permite a integração com o Mailgun para entrega de e-mails.

  2. ChromePdfRenderer:

    • Presume-se que seja uma instância de ChromePdfRenderer da biblioteca IronPDF , usada para renderizar conteúdo HTML em um documento PDF.

  3. Preparação do Conteúdo:

    • O conteúdo HTML (content) foi preparado, incluindo detalhes sobre o IronPDF. Este conteúdo é usado tanto para gerar o PDF (renderer.RenderHtmlAsPdf(content)) quanto para o corpo do e-mail.

  4. Configuração do MailgunSender:

    • MailgunSender é inicializado com as credenciais da API do Mailgun (domínio e chave da API). O código Email.DefaultSender está configurado para este remetente, garantindo que todos os e-mails subsequentes sejam entregues pelo Mailgun.

  5. Geração e anexação de PDF:

    • O conteúdo HTML (content) é renderizado em um PDF (pdf) usando o método RenderHtmlAsPdf do IronPDF.
    • O PDF gerado é salvo como "AwesomeFluentEmailAndIron.pdf".

  6. Composição e envio de e-mails:

    • Um e-mail é composto usando a API fluente do FluentEmail:
      • O endereço "De" é definido usando o domínio do remetente.
      • O endereço "Para" está definido como o e-mail do destinatário.
      • O assunto e o corpo do e-mail estão definidos.
      • O arquivo PDF "AwesomeFluentEmailAndIron.pdf" está anexado ao e-mail.
    • O e-mail é enviado usando .Send(), e o status de sucesso (email.Successful) é impresso no console.

  7. Saída do console:

    • Após tentar enviar o e-mail, o código exibe se o e-mail foi enviado com sucesso (Is Send Success: true/false).

Mensagem de e-mail de saída

FluentEmail C# (Como funciona para desenvolvedores): Figura 10 - Saída de e-mail

PDF em anexo

FluentEmail C# (Como funciona para desenvolvedores): Figura 11 - Saída em PDF

Licenciamento IronPDF

O pacote IronPDF requer uma licença para ser executado e gerar o PDF. Adicione o código abaixo no início da aplicação, antes que o pacote seja acessado.

IronPdf.License.LicenseKey = "IRONPDF-LICENSE-KEY";
IronPdf.License.LicenseKey = "IRONPDF-LICENSE-KEY";
Imports IronPdf

IronPdf.License.LicenseKey = "IRONPDF-LICENSE-KEY"
$vbLabelText   $csharpLabel

A licença de avaliação está disponível em Licenciamento e Avaliação do IronPDF .

Conclusão

O FluentEmail, combinado com as chaves da API do Mailgun, permite que os desenvolvedores .NET simplifiquem a funcionalidade de e-mail em seus aplicativos. Seja para o envio de e-mails transacionais, newsletters ou notificações, essa integração garante confiabilidade, escalabilidade e facilidade de uso. Ao abstrair as complexidades da entrega de e-mails, o FluentEmail permite que os desenvolvedores se concentrem na criação de aplicativos robustos, aproveitando a poderosa infraestrutura de e-mail do Mailgun. Aproveite o poder do FluentEmail e do Mailgun para aprimorar seus recursos de comunicação por e-mail em aplicativos .NET hoje mesmo.
Por outro lado, o IronPDF é uma biblioteca C# robusta para criar, editar e converter documentos PDF em aplicações .NET . Ele se destaca na conversão de HTML para PDF, oferece recursos abrangentes de manipulação de PDF e se integra perfeitamente com as estruturas .NET , fornecendo soluções seguras e versáteis para o manuseio de PDFs.

Perguntas frequentes

Como posso enviar e-mails com modelos Razor em uma aplicação .NET?

Você pode usar o FluentEmail para enviar e-mails com modelos Razor em um aplicativo .NET. Primeiro, instale o FluentEmail e o pacote do renderizador Razor usando o NuGet ou a CLI do .NET. Em seguida, configure o renderizador Razor e use a interface do FluentEmail para compor e enviar e-mails com suporte a modelos Razor.

Como faço para integrar o Mailgun com uma biblioteca de e-mail .NET?

Para integrar o Mailgun com o FluentEmail, obtenha suas chaves de API no painel do Mailgun. Em seguida, instale o pacote `FluentEmail.Mailgun` e configure o Mailgun como provedor de serviços de e-mail, permitindo que você envie e-mails de forma eficiente por meio da infraestrutura do Mailgun.

Quais são as vantagens de usar o FluentEmail para funcionalidades de e-mail no .NET?

O FluentEmail oferece uma interface intuitiva para compor e enviar e-mails, suporta modelos Razor e Liquid para conteúdo dinâmico, simplifica as configurações SMTP e integra-se ao Mailgun para entrega de e-mails confiável e escalável.

Posso automatizar notificações por e-mail no ASP.NET Core usando uma biblioteca .NET?

Sim, você pode automatizar notificações por e-mail no ASP.NET Core usando o FluentEmail. Ao aproveitar os modelos Razor e a integração com o Mailgun, você pode automatizar o envio de e-mails transacionais, newsletters e notificações com facilidade.

Como posso lidar com anexos de e-mail usando o FluentEmail no .NET?

Com o FluentEmail, você pode gerenciar facilmente anexos de e-mail, adicionando-os ao compor sua mensagem. A biblioteca fornece métodos para anexar arquivos aos seus e-mails, garantindo que os anexos sejam enviados juntamente com o conteúdo da mensagem.

Como o IronPDF aprimora a funcionalidade de PDF para aplicativos .NET?

O IronPDF aprimora a funcionalidade de PDFs, fornecendo recursos para conversão de HTML para PDF, extração de conteúdo e edição completa de PDFs. Ele utiliza um mecanismo de renderização do Chrome, permitindo que desenvolvedores gerem PDFs a partir de HTML, extraiam conteúdo e modifiquem PDFs com eficiência.

Quais são os passos necessários para converter HTML em PDF em uma aplicação .NET?

Para converter HTML em PDF em uma aplicação .NET usando o IronPDF, você pode usar a classe `ChromePdfRenderer` para renderizar o conteúdo HTML em um documento PDF. Este PDF pode então ser salvo como um arquivo ou manipulado posteriormente, conforme necessário.

Como anexar PDFs a e-mails em uma aplicação .NET?

Para anexar PDFs a e-mails em uma aplicação .NET, primeiro gere o PDF usando o IronPDF. Depois de criar o PDF, use o FluentEmail para compor seu e-mail e anexe o arquivo PDF usando os métodos disponíveis para anexos de arquivos antes de enviar o e-mail.

É possível extrair conteúdo de um PDF usando uma biblioteca .NET?

Sim, usando o IronPDF, você pode extrair conteúdo de um PDF. A biblioteca fornece métodos para ler texto e imagens de documentos PDF, permitindo a extração de conteúdo para posterior processamento ou análise.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim