Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. FluentEmail C#
.NET HILFE

FluentEmail C# (Wie es für Entwickler funktioniert)

Curtis Chau
Curtis Chau
Aktualisiert:

In today's digital age, email remains a cornerstone of communication for businesses and individuals. Integrating robust email functionality into ASP.NET Core applications is essential for automating notifications, sending newsletters, and facilitating customer interactions. FluentEmail, a powerful library for .NET, combined with Mailgun API keys, offers developers a seamless solution to enhance email capabilities with reliability and scalability. Later in this article, we will also look at the IronPDF Library on ironsoftware.com to generate and manage PDF documents.

FluentEmail simplifies the process of sending multiple emails programmatically within .NET applications. It provides an intuitive and fluent interface for configuring email messages, managing attachments, and handling recipient lists. This library abstracts away the complexities of SMTP configuration and supports multiple template renderer providers and test email service providers, including Mailgun.

FluentEmail.NET is a popular library in the .NET Core ecosystem for sending emails, and it supports Razor email templates as well as Liquid templates for creating email bodies dynamically. Using Razor template renderer with FluentEmail.NET allows you to leverage the power of Razor syntax to create well-formatted, dynamic email content and resolve layout files.

Here’s a basic guide on how to use FluentEmail.NET with ASP.NET Core Razor templates.

Step 1: Install FluentEmail

First, you need to install the FluentEmail package and the Razor templates renderer package by either using the Install-Package command or the .NET add package command:

# 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

Step 2: Create a Razor Template

Create a Razor template for your email body. This can be a .cshtml file containing HTML and valid Razor code syntax. For example, create a file named 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

Make sure to replace YourNamespace.EmailViewModel with the actual namespace and class name of your view model or just the domain model that you will pass to this template.

Step 3: Set Up FluentEmail with Razor Renderer

Configure FluentEmail to use the Razor renderer and provide the necessary dependencies:

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

Step 4: Render and Send Email

In your application code, render the Razor template with the desired model and send the email:

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

Ensure that EmailViewModel matches the model defined in your Razor template (EmailTemplate.cshtml). This model should contain properties you reference in your Razor template (@Model.Name, for example).

Integrating Mailgun API Keys

Mailgun is a popular email service provider known for its reliability, deliverability, and rich features. By integrating Mailgun API keys with FluentEmail, developers can leverage Mailgun's infrastructure to send emails efficiently and securely.

Steps to Integrate Mailgun API Keys with FluentEmail

  1. Obtain Mailgun API Keys:

    • Sign up for a Mailgun account if you haven't already.
    • Navigate to the Mailgun Dashboard and create a new API key. Provide a description.

FluentEmail C# (How It Works For Developers): Figure 1 - Mailgun

  1. Install FluentEmail Package:

    Use NuGet Package Manager or Package Manager Console in Visual Studio to install FluentMail:

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

or from Visual Studio:

FluentEmail C# (How It Works For Developers): Figure 2 - FluentEmail.Mailgun

  1. Configure FluentEmail with Mailgun API Keys:

Set up FluentEmail to use Mailgun as the email service provider or SMTP sender by configuring your API keys:

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. Compose and Send Emails:

    Use FluentEmail's fluent interface to compose and send emails:

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();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

  1. Advanced Configuration:

    • Customize email settings such as attachments, HTML formatting, CC/BCC recipients, and email headers using FluentEmail's fluent API.

Benefits of Using FluentEmail with Mailgun

  • Simplicity: FluentEmail abstracts away the complexities of SMTP configuration, making it easy to send emails with minimal setup.
  • Reliability: Leveraging Mailgun's infrastructure ensures high deliverability rates and robust email handling capabilities.
  • Scalability: Scale your email-sending needs effortlessly with Mailgun's scalable infrastructure, suitable for both small-scale applications and enterprise-level solutions.
  • Rich Features: Take advantage of Mailgun's features such as tracking, analytics, and advanced email validation to optimize your email campaigns.

Introduction to IronPDF

FluentEmail C# (How It Works For Developers): Figure 3 - IronPDF

IronPDF is a Node.js PDF library that allows generating, managing, and extracting content from PDF documents in .NET projects. Here are some key features:

  1. HTML to PDF Conversion:

    • Convert HTML, CSS, and JavaScript content to PDF Documents.
    • Chrome Rendering Engine for pixel-perfect PDFs.
    • Generate PDFs from URLs, HTML files, or HTML strings as input.

  2. Image and Content Conversion:

    • Convert images to and from PDFs.
    • Extract text and images from existing PDF documents.
    • Support for various image formats like JPG, PNG, etc.

  3. Editing and Manipulation:

    • Set properties, security, and permissions for PDFs.
    • Add digital signatures.
    • Edit metadata and revision history.

IronPDF excels in HTML to PDF conversion, ensuring precise preservation of original layouts and styles. It's perfect for creating PDFs from web-based content such as reports, invoices, and documentation. With support for HTML files, URLs, and raw HTML strings, IronPDF easily produces high-quality PDF documents.

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

Generate PDF document Using IronPDF And FluentEmail .NET with Mailgun sender

To start with, create a Console application using Visual Studio as below.

FluentEmail C# (How It Works For Developers): Figure 4 - Console App

Provide Project Name.

FluentEmail C# (How It Works For Developers): Figure 5 - Project Configuration

Provide .NET Version.

FluentEmail C# (How It Works For Developers): Figure 6 - Target Framework

Install IronPDF package.

FluentEmail C# (How It Works For Developers): Figure 7 - IronPDF

Install FluentEmail Mailgun.

FluentEmail C# (How It Works For Developers): Figure 8 - FluentEmail.Mailgun

To receive email messages in the free trial, the receiver email should be registered in the dashboard on the Mailgun Registration Dashboard as shown below.

FluentEmail C# (How It Works For Developers): Figure 9 - Mailgun Dashboard

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

Code Explanation

  1. FluentEmail and Mailgun Integration:

    • FluentEmail.Core: Provides a fluent interface for composing and sending emails.
    • FluentEmail.Mailgun: Enables integration with Mailgun for email delivery.

  2. ChromePdfRenderer:

    • This is assumed to be an instance of ChromePdfRenderer from the IronPDF library, used to render HTML content into a PDF document.

  3. Content Preparation:

    • HTML content (content) is prepared, including details about IronPDF. This content is used both for generating the PDF (renderer.RenderHtmlAsPdf(content)) and for the email body.

  4. MailgunSender Setup:

    • MailgunSender is initialized with Mailgun API credentials (domain and API key). The Email.DefaultSender is set to this sender, ensuring all subsequent emails use Mailgun for delivery.

  5. PDF Generation and Attachment:

    • The HTML content (content) is rendered into a PDF (pdf) using IronPDF's RenderHtmlAsPdf method.
    • The generated PDF is saved as "AwesomeFluentEmailAndIron.pdf".

  6. Email Composition and Sending:

    • An email is composed using FluentEmail's fluent API:
      • The 'From' address is set using the sender's domain.
      • The 'To' address is set to the recipient's email.
      • The subject and body of the email are defined.
      • The PDF file "AwesomeFluentEmailAndIron.pdf" is attached to the email.
    • The email is sent using .Send(), and the success status (email.Successful) is printed to the console.

  7. Console Output:

    • After attempting to send the email, the code outputs whether the email was sent successfully (Is Send Success: true/false).

Output Email Message

FluentEmail C# (How It Works For Developers): Figure 10 - Email Output

Attached PDF

FluentEmail C# (How It Works For Developers): Figure 11 - PDF Output

IronPDF Licensing

IronPDF package requires a license to run and generate the PDF. Add below code at the start of the application before the package is accessed.

IronPdf.License.LicenseKey = "IRONPDF-LICENSE-KEY";
IronPdf.License.LicenseKey = "IRONPDF-LICENSE-KEY";
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Trial License is available at IronPDF Licensing and Trial.

Conclusion

FluentEmail, combined with Mailgun API keys, empowers .NET developers to streamline email functionality within their applications. Whether sending transactional emails, newsletters, or notifications, this integration ensures reliability, scalability, and ease of use. By abstracting the complexities of email delivery, FluentEmail allows developers to focus on building robust applications while leveraging Mailgun's powerful email infrastructure. Embrace the power of FluentEmail and Mailgun to enhance your email communication capabilities in .NET applications today.
IronPDF on the other hand is a robust C# library for creating, editing, and converting PDF documents within .NET applications. It excels in HTML to PDF conversion, offers comprehensive PDF manipulation capabilities, and integrates seamlessly with .NET frameworks, providing secure and versatile PDF handling solutions.

Häufig gestellte Fragen

Wie kann ich E-Mails mit Razor-Templates in einer .NET-Anwendung versenden?

Sie können FluentEmail verwenden, um E-Mails mit Razor-Templates in einer .NET-Anwendung zu versenden. Installieren Sie zuerst FluentEmail und das Razor-Rendering-Paket mit NuGet oder der .NET CLI. Konfigurieren Sie dann den Razor-Renderer und verwenden Sie die FluentEmail-Schnittstelle, um E-Mails mit Razor-Template-Unterstützung zu erstellen und zu versenden.

Wie integriere ich Mailgun in eine .NET-E-Mail-Bibliothek?

Um Mailgun mit FluentEmail zu integrieren, beschaffen Sie Ihre API-Schlüssel aus dem Mailgun-Dashboard. Installieren Sie dann das `FluentEmail.Mailgun`-Paket und konfigurieren Sie Mailgun als E-Mail-Dienstanbieter, der es Ihnen ermöglicht, E-Mails effizient über die Infrastruktur von Mailgun zu senden.

Welche Vorteile bietet FluentEmail für E-Mail-Funktionen in .NET?

FluentEmail bietet eine fließende Schnittstelle zum Erstellen und Versenden von E-Mails, unterstützt Razor- und Liquid-Templates für dynamische Inhalte, vereinfacht die SMTP-Konfigurationen und integriert sich mit Mailgun für eine zuverlässige und skalierbare E-Mail-Zustellung.

Kann ich E-Mail-Benachrichtigungen in ASP.NET Core mit einer .NET-Bibliothek automatisieren?

Ja, Sie können E-Mail-Benachrichtigungen in ASP.NET Core mit FluentEmail automatisieren. Durch die Nutzung von Razor-Templates und Mailgun-Integration können Sie das Versenden von Transaktions-E-Mails, Newslettern und Benachrichtigungen einfach automatisieren.

Wie kann ich E-Mail-Anhänge mit FluentEmail in .NET verwalten?

Mit FluentEmail können Sie E-Mail-Anhänge einfach verwalten, indem Sie beim Erstellen Ihrer E-Mail Anhänge hinzufügen. Die Bibliothek bietet Methoden zum Anhängen von Dateien an Ihre E-Mails, um sicherzustellen, dass Anhänge zusammen mit Ihrem E-Mail-Inhalt gesendet werden.

Wie verbessert IronPDF die PDF-Funktionalität für .NET-Anwendungen?

IronPDF verbessert die PDF-Funktionalität durch Funktionen zur HTML-zu-PDF-Konvertierung, Inhaltsauszug und umfassende PDF-Bearbeitung. Es verwendet eine Chrome-Rendering-Engine, die es Entwicklern ermöglicht, PDFs aus HTML zu generieren, Inhalte zu extrahieren und PDFs effizient zu bearbeiten.

Welche Schritte sind erforderlich, um HTML in einer .NET-Anwendung in PDF zu konvertieren?

Um HTML in einer .NET-Anwendung mit IronPDF in PDF zu konvertieren, können Sie die `ChromePdfRenderer`-Klasse verwenden, um HTML-Inhalte in ein PDF-Dokument zu rendern. Dieses PDF kann dann als Datei gespeichert oder weiter manipuliert werden.

Wie können PDFs in E-Mails in einer .NET-Anwendung angehängt werden?

Um PDFs in E-Mails in einer .NET-Anwendung anzuhängen, erstellen Sie zuerst das PDF mit IronPDF. Sobald das PDF erstellt ist, verwenden Sie FluentEmail, um Ihre E-Mail zu erstellen und die PDF-Datei mit den verfügbaren Methoden für Dateianhänge hinzuzufügen, bevor Sie die E-Mail versenden.

Ist es möglich, Inhalte aus einem PDF mit einer .NET-Bibliothek zu extrahieren?

Ja, mit IronPDF können Sie Inhalte aus einem PDF extrahieren. Die Bibliothek bietet Methoden, um Text und Bilder aus PDF-Dokumenten zu lesen, was ermöglicht, Inhalte für weitere Verarbeitung oder Analyse zu extrahieren.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion