Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. FluentEmail C#
.NET AIDE

FluentEmail C# (Comment ça fonctionne pour les développeurs)

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

À l'ère numérique d'aujourd'hui, le courrier électronique reste un pilier de la communication pour les entreprises et les particuliers. Intégrer des fonctionnalités de messagerie robustes dans les applications ASP.NET Core est essentiel pour automatiser les notifications, envoyer des newsletters et faciliter les interactions avec les clients. FluentEmail, une bibliothèque puissante pour .NET, combinée aux clés d'API Mailgun, offre aux développeurs une solution transparente pour améliorer les capacités de messagerie avec fiabilité et évolutivité. Plus loin dans cet article, nous examinerons également la bibliothèque IronPDF sur IronSoftware.com pour générer et gérer des documents PDF.

FluentEmail simplifie le processus d'envoi de plusieurs courriers électroniques par programmation au sein des applications .NET. Il offre une interface intuitive et fluide pour configurer les messages électroniques, gérer les pièces jointes et gérer les listes de destinataires. Cette bibliothèque abstrait les complexités de la configuration SMTP et prend en charge plusieurs fournisseurs de modèles de rendu et fournisseurs de services de test de messagerie, y compris Mailgun.

FluentEmail.NET est une bibliothèque populaire dans .NET Core pour envoyer des e-mails et prend en charge Razor et Liquid pour générer dynamiquement les corps des courriels. Utiliser le moteur de rendu de modèles Razor avec FluentEmail.NET vous permet d'exploiter la puissance de la syntaxe Razor pour créer un contenu d'email bien formaté et dynamique et résoudre les fichiers de mise en page.

Voici un guide de base sur comment utiliser FluentEmail.NET avec les modèles Razor d'ASP.NET Core.

Étape 1 : Installer FluentEmail

Tout d'abord, vous devez installer le paquet FluentEmail et le paquet du moteur de rendu des modèles Razor en utilisant soit la commande Install-Package soit la commande add package .NET :

# 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

Étape 2 : Créer un modèle Razor

Créez un modèle Razor pour le corps de votre courriel. Il peut s'agir d'un fichier .cshtml contenant du code HTML et une syntaxe de code Razor valide. Par exemple, créez un fichier nommé 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

Veillez à remplacer YourNamespace.EmailViewModel par l'espace de noms et le nom de classe réels de votre modèle de vue ou simplement par le modèle de domaine que vous transmettrez à ce modèle.

Étape 3 : Configurer FluentEmail avec le moteur de rendu Razor

Configurez FluentEmail pour utiliser le moteur de rendu Razor et fournir les dépendances nécessaires :

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

Étape 4 : Rendre et envoyer le courriel

Dans le code de votre application, rendez le modèle Razor avec le modèle souhaité et envoyez le courriel :

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

Assurez-vous que EmailViewModel correspond au modèle défini dans votre modèle Razor (EmailTemplate.cshtml). Ce modèle doit contenir les propriétés auxquelles vous faites référence dans votre modèle Razor (@Model.Name, par exemple).

Intégration des clés d'API Mailgun

Mailgun est un fournisseur de services de messagerie populaire connu pour sa fiabilité, sa délivrabilité et ses riches fonctionnalités. En intégrant des clés d'API Mailgun avec FluentEmail, les développeurs peuvent exploiter l'infrastructure de Mailgun pour envoyer des courriels efficacement et en toute sécurité.

Étapes pour intégrer les clés d'API Mailgun avec FluentEmail

  1. Obtenir les clés API Mailgun :

    • Inscrivez-vous pour un compte Mailgun si ce n'est déjà fait.
    • Accédez au tableau de bord Mailgun et créez une nouvelle clé d'API. Fournissez une description.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 1 - Mailgun

  1. Installez le package FluentEmail :

    Utilisez le Package Manager NuGet ou la Console du Package Manager dans Visual Studio pour installer FluentMail :

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

ou depuis Visual Studio :

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 2 - FluentEmail.Mailgun

  1. Configurer FluentEmail avec les clés API Mailgun :

Configurez FluentEmail pour utiliser Mailgun comme fournisseur de services de messagerie ou expéditeur SMTP en configurant vos clés d'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. Rédiger et envoyer des courriels :

    Utilisez l'interface fluide de FluentEmail pour rédiger et envoyer des courriels :

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. Configuration avancée :

    • Personnalisez les paramètres de courriel tels que les pièces jointes, le formatage HTML, les destinataires CC/BCC, et les en-têtes de courriel en utilisant l'API fluide de FluentEmail.

Avantages de l'utilisation de FluentEmail avec Mailgun

  • Simplicité : FluentEmail simplifie la configuration SMTP, facilitant ainsi l'envoi d'e-mails avec une configuration minimale.
  • Fiabilité : L'utilisation de l'infrastructure de Mailgun garantit des taux de délivrabilité élevés et des capacités de traitement des e-mails robustes.
  • Évolutivité : Faites évoluer sans effort vos besoins d'envoi d'emails grâce à l'infrastructure évolutive de Mailgun, adaptée aussi bien aux applications à petite échelle qu'aux solutions d'entreprise.
  • Fonctionnalités avancées : Profitez des fonctionnalités de Mailgun telles que le suivi, l'analyse et la validation avancée des e-mails pour optimiser vos campagnes par e-mail.

Introduction à IronPDF

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 3 - IronPDF

IronPDF est une bibliothèque .NET pour les PDF qui permet de générer, gérer et extraire du contenu des documents PDF dans les projets .NET. Voici quelques caractéristiques clés :

  1. Conversion HTML vers PDF :

    • Convertir le contenu HTML, CSS et JavaScript en documents PDF.
    • Moteur de rendu Chrome pour des PDF en pixels parfaits.
    • Générer des PDF à partir d'URL, de fichiers HTML, ou de chaînes HTML comme entrée.

  2. Conversion d'images et de contenu :

    • Convertir des images vers et depuis des PDF.
    • Extraire du texte et des images de documents PDF existants.
    • Prise en charge de divers formats d'images comme JPG, PNG, etc.

  3. Édition et manipulation :

    • Définissez des propriétés, la sécurité et les permissions pour les PDF.
    • Ajoutez des signatures numériques.
    • Éditez les métadonnées et l'historique des révisions.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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

Générer un document PDF en utilisant IronPDF et FluentEmail.NET avec Mailgun comme expéditeur

Pour commencer, créez une application Console en utilisant Visual Studio comme ci-dessous.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 4 - Application console

Fournir le nom du projet.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 5 - Configuration du projet

Fournissez la version de .NET.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 6 - Framework cible

Installer le package IronPDF.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 7 - IronPDF

Installez FluentEmail Mailgun.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 8 - FluentEmail.Mailgun

Pour recevoir des messages électroniques dans l'essai gratuit, le courriel du destinataire doit être enregistré dans le tableau de bord sur le Tableau de bord d'inscription Mailgun comme indiqué ci-dessous.

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 9 - Tableau de bord 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

Explication du code

  1. Intégration de FluentEmail et Mailgun :

    • FluentEmail.Core : Fournit une interface fluide pour composer et envoyer des e-mails.
    • FluentEmail.Mailgun : Permet l'intégration avec Mailgun pour la distribution des e-mails.

  2. ChromePdfRenderer :

    • Ceci est supposé être une instance de ChromePdfRenderer de la bibliothèque IronPDF, utilisée pour rendre le contenu HTML dans un document PDF.

  3. Préparation du contenu :

    • Le contenu HTML (content) est préparé, y compris des détails sur IronPDF. Ce contenu est utilisé à la fois pour générer le PDF (renderer.RenderHtmlAsPdf(content)) et pour le corps de l'e-mail.

  4. Configuration de MailgunSender :

    • MailgunSender est initialisé avec les identifiants de l'API Mailgun (domaine et clé API). Le code Email.DefaultSender est défini pour cet expéditeur, garantissant que tous les e-mails suivants utilisent Mailgun pour la livraison.

  5. Génération et pièce jointe du PDF :

    • Le contenu HTML (content) est rendu en PDF (pdf) en utilisant la méthode RenderHtmlAsPdf d'IronPDF.
    • Le PDF généré est sauvegardé sous le nom "AwesomeFluentEmailAndIron.pdf".

  6. Rédaction et envoi des courriels :

    • Un courriel est composé en utilisant l'API fluide de FluentEmail :
      • L'adresse 'De' est définie en utilisant le domaine de l'expéditeur.
      • L'adresse 'À' est définie sur l'adresse électronique du destinataire.
      • L'objet et le corps du courriel sont définis.
    • Le fichier PDF "AwesomeFluentEmailAndIron.pdf" est joint au courriel.
    • L'e-mail est envoyé en utilisant .Send(), et le statut de succès (email.Successful) est imprimé sur la console.

  7. Sortie de la console :

    • Après avoir tenté d'envoyer l'e-mail, le code indique si l'e-mail a été envoyé avec succès (Is Send Success: true/false).

Message de sortie du courriel

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 10 - Sortie de l'e-mail

PDF joint

FluentEmail C# (Fonctionnement pour les développeurs) : Figure 11 - Sortie PDF

Licences IronPDF

Le package IronPDF nécessite une licence pour fonctionner et générer le PDF. Ajoutez le code ci-dessous au début de l'application avant que le paquet ne soit accédé.

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

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

La licence d'essai est disponible sur IronPDF Licensing and Trial.

Conclusion

FluentEmail, combiné aux clés d'API Mailgun, permet aux développeurs .NET de rationaliser la fonctionnalité de courriel dans leurs applications. Que ce soit pour l'envoi de courriels transactionnels, de newsletters ou de notifications, cette intégration assure fiabilité, évolutivité et facilité d'utilisation. En abstraisant les complexités de la livraison des courriels, FluentEmail permet aux développeurs de se concentrer sur la création d'applications robustes tout en exploitant la puissante infrastructure de messagerie de Mailgun. Adoptez la puissance de FluentEmail et Mailgun pour améliorer vos capacités de communication par courriel dans les applications .NET aujourd'hui.
IronPDF, pour sa part, est une robuste bibliothèque C# pour créer, éditer et convertir des documents PDF au sein des applications .NET. Elle excelle dans la conversion HTML en PDF, offre de vastes capacités de manipulation des PDF, et s'intègre parfaitement aux frameworks .NET, fournissant des solutions sécurisées et polyvalentes pour la gestion des PDF.

Questions Fréquemment Posées

Comment puis-je envoyer des emails avec des modèles Razor dans une application .NET ?

Vous pouvez utiliser FluentEmail pour envoyer des emails avec des modèles Razor dans une application .NET. Tout d'abord, installez FluentEmail et le package de rendu Razor en utilisant NuGet ou l'interface CLI .NET. Ensuite, configurez le rendu Razor et utilisez l'interface FluentEmail pour composer et envoyer des emails avec le support des modèles Razor.

Comment intégrer Mailgun avec une bibliothèque d'emails .NET ?

Pour intégrer Mailgun avec FluentEmail, obtenez vos clés API depuis le tableau de bord Mailgun. Ensuite, installez le package `FluentEmail.Mailgun` et configurez Mailgun en tant que fournisseur de services email, vous permettant d'envoyer des emails efficacement via l'infrastructure de Mailgun.

Quels sont les avantages de l'utilisation de FluentEmail pour les fonctionnalités d'email dans .NET ?

FluentEmail offre une interface fluide pour composer et envoyer des emails, prend en charge les modèles Razor et Liquid pour un contenu dynamique, simplifie les configurations SMTP, et s'intègre avec Mailgun pour une distribution d'emails fiable et évolutive.

Puis-je automatiser les notifications par email dans ASP.NET Core en utilisant une bibliothèque .NET ?

Oui, vous pouvez automatiser les notifications par email dans ASP.NET Core en utilisant FluentEmail. En tirant parti des modèles Razor et de l'intégration de Mailgun, vous pouvez automatiser l'envoi d'emails transactionnels, de newsletters et de notifications facilement.

Comment puis-je gérer les pièces jointes des emails avec FluentEmail dans .NET ?

Avec FluentEmail, vous pouvez facilement gérer les pièces jointes des emails en les ajoutant lors de la composition de votre email. La bibliothèque fournit des méthodes pour attacher des fichiers à vos emails, garantissant que les pièces jointes sont envoyées avec le contenu de votre email.

Comment IronPDF améliore-t-il la fonctionnalité PDF pour les applications .NET ?

IronPDF améliore la fonctionnalité PDF en fournissant des fonctionnalités pour la conversion HTML en PDF, l'extraction de contenu et l'édition complète des PDF. Il utilise un moteur de rendu Chrome, permettant aux développeurs de générer des PDFs à partir de HTML, d'extraire du contenu, et de modifier des PDFs efficacement.

Quelles étapes sont nécessaires pour convertir HTML en PDF dans une application .NET ?

Pour convertir HTML en PDF dans une application .NET en using IronPDF, vous pouvez utiliser la classe `ChromePdfRenderer` pour rendre le contenu HTML en un document PDF. Ce PDF peut ensuite être enregistré sous forme de fichier ou manipulé selon les besoins.

Comment les PDFs peuvent-ils être joints aux emails dans une application .NET ?

Pour joindre des PDFs aux emails dans une application .NET, générez d'abord le PDF en using IronPDF. Une fois le PDF créé, utilisez FluentEmail pour composer votre email et joindre le fichier PDF en utilisant les méthodes disponibles pour les pièces jointes avant d'envoyer l'email.

Est-il possible d'extraire du contenu d'un PDF en utilisant une bibliothèque .NET ?

Oui, en using IronPDF, vous pouvez extraire du contenu d'un PDF. La bibliothèque fournit des méthodes pour lire le texte et les images à partir de documents PDF, permettant l'extraction de contenu pour un traitement ou une analyse ultérieurs.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi