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 for .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. Cela peut être un fichier .cshtml contenant du 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

Assurez-vous de remplacer YourNamespace.EmailViewModel par le véritable namespace et nom de classe de votre modèle de vue ou simplement le modèle de domaine que vous passerez à 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"));
}
$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();
}
$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 que vous référencez 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. Obtenez les clés API de 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# (Comment cela fonctionne 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# (Comment cela fonctionne pour les développeurs) : Figure 2 - FluentEmail.Mailgun

  1. Configurez FluentEmail avec les clés API de 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;
$vbLabelText   $csharpLabel

  1. Composez et envoyez des e-mails :

    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();
$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 abstrait les complexités de la configuration SMTP, facilitant l'envoi d'e-mails avec un minimum de configuration.
  • Fiabilité : Tirer parti de l'infrastructure de Mailgun assure des taux de délivrabilité élevés et des capacités de gestion des e-mails robustes.
  • Évolutivité : Évoluez facilement vos besoins en matière d'envoi d'e-mails avec l'infrastructure évolutive de Mailgun, adaptée aux applications à petite échelle et aux solutions de niveau entreprise.
  • Fonctionnalités riches : Profitez des fonctionnalités de Mailgun telles que le suivi, l'analyse et la validation avancée des e-mails pour optimiser vos campagnes d'e-mail.

Introduction à IronPDF

FluentEmail C# (Comment cela fonctionne pour les développeurs) : Figure 3 - IronPDF

IronPDF est une bibliothèque Node.js 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 en 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 contenus :

    • 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");
    }
}
$vbLabelText   $csharpLabel

Générer un document PDF en using 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# (Comment cela fonctionne pour les développeurs) : Figure 4 - Application Console

Fournir le nom du projet.

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

Fournissez la version de .NET.

FluentEmail C# (Comment cela fonctionne pour les développeurs) : Figure 6 - Framework Cible

Installer le package IronPDF.

FluentEmail C# (Comment cela fonctionne pour les développeurs) : Figure 7 - IronPDF

Installez FluentEmail Mailgun.

FluentEmail C# (Comment cela fonctionne 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# (Comment cela fonctionne 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}");
        }
    }
}
$vbLabelText   $csharpLabel

Explication du code

  1. Intégration de FluentEmail et Mailgun :
  • FluentEmail.Core : Offre une interface fluide pour composer et envoyer des e-mails.
  • FluentEmail.Mailgun : Permet l'intégration avec Mailgun pour la livraison des e-mails.

  1. 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.
  2. 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.
  1. Configuration du MailgunSender :
  • MailgunSender est initialisé avec les informations d'identification API de Mailgun (domaine et clé API). Le Email.DefaultSender est défini sur cet expéditeur, garantissant que tous les e-mails suivants utilisent Mailgun pour la livraison.
  1. Génération de PDF et pièce jointe :
  • Le contenu HTML (content) est rendu en PDF (pdf) en utilisant la méthode RenderHtmlAsPdf de IronPDF.
  • Le PDF généré est sauvegardé sous le nom "AwesomeFluentEmailAndIron.pdf".

  1. Composition et envoi d'e-mails :

    • 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.
  2. Sortie de la console :
  • Après avoir tenté d'envoyer l'e-mail, le code affiche si l'e-mail a été envoyé avec succès (Is Send Success: true/false).

Message de Sortie du Courriel

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

PDF Joint

FluentEmail C# (Comment cela fonctionne 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";
$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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me