Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. FluentEmail C#
POMOC .NET

FluentEmail C# (Jak to dziala dla programistow)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

W dzisiejszej erze cyfrowej poczta elektroniczna pozostaje podstawą komunikacji zarówno dla firm, jak i osób prywatnych. Włączenie solidnej funkcjonalności poczty elektronicznej do aplikacji .NET Core jest niezbędne do automatyzacji powiadomień, wysyłania biuletynów i ułatwiania interakcji z klientami. FluentEmail, potężna biblioteka dla platformy .NET, w połączeniu z kluczami API Mailgun, oferuje programistom płynne rozwiązanie pozwalające rozszerzyć możliwości poczty elektronicznej o niezawodność i skalowalność. W dalszej części tego artykułu przyjrzymy się również bibliotece IronPDF dostępnej na stronie ironsoftware.com, służącej do generowania dokumentów PDF i zarządzania nimi.

FluentEmail upraszcza proces programowego wysyłania wielu wiadomości e-mail w aplikacjach .NET. Zapewnia intuicyjny i płynny interfejs do konfigurowania wiadomości e-mail, zarządzania załącznikami oraz obsługiwania list odbiorców. Biblioteka ta eliminuje złożoność konfiguracji SMTP i obsługuje wielu dostawców rendererów szablonów oraz dostawców usług testowych wiadomości e-mail, w tym Mailgun.

FluentEmail.NET to popularna biblioteka w ekosystemie .NET Core służąca do wysyłania wiadomości e-mail, która obsługuje szablony e-mailowe Razor oraz szablony Liquid do dynamicznego tworzenia treści wiadomości. Korzystanie z renderera szablonów Razor w połączeniu z FluentEmail.NET pozwala wykorzystać możliwości składni Razor do tworzenia dobrze sformatowanych, dynamicznych treści wiadomości e-mail oraz rozwiązywania plików układu.

Oto podstawowy przewodnik dotyczący korzystania z FluentEmail.NET w szablonach ASP.NET Core Razor.

Krok 1: Zainstaluj FluentEmail

Najpierw należy zainstalować pakiet FluentEmail oraz pakiet renderera szablonów Razor, używając polecenia Install-Package lub polecenia .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

Krok 2: Utwórz szablon Razor

Utwórz szablon Razor dla treści wiadomości e-mail. Może to być plik .cshtml zawierający kod HTML i poprawną składnię kodu Razor. Na przykład utwórz plik o nazwie 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

Pamiętaj, aby zastąpić YourNamespace.EmailViewModel rzeczywistą przestrzenią nazw i nazwą klasy Twojego modelu widoku lub po prostu modelem domeny, który przekażesz do tego szablonu.

Krok 3: Skonfiguruj FluentEmail z rendererem Razor

Skonfiguruj FluentEmail tak, aby korzystał z renderera Razor i zapewnij niezbędne zależności:

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

Krok 4: Wygeneruj i wyślij wiadomość e-mail

W kodzie aplikacji wyrenderuj szablon Razor z żądanym modelem i wyślij wiadomość 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

Upewnij się, że EmailViewModel odpowiada modelowi zdefiniowanemu w szablonie Razor (EmailTemplate.cshtml). Ten model powinien zawierać właściwości, do których odwołujesz się w swoim szablonie Razor (na przykład @Model.Name).

Integracja kluczy API Mailgun

Mailgun to popularny dostawca usług poczty elektronicznej znany ze swojej niezawodności, skuteczności dostarczania wiadomości oraz bogatego zestawu funkcji. Dzięki integracji kluczy API Mailgun z FluentEmail programiści mogą wykorzystać infrastrukturę Mailgun do wydajnego i bezpiecznego wysyłania wiadomości e-mail.

Kroki integracji kluczy API Mailgun z FluentEmail

  1. Uzyskaj klucze API Mailgun:

    • Jeśli jeszcze tego nie zrobiłeś, załóż konto w Mailgun.
    • Przejdź do pulpitu nawigacyjnego Mailgun i utwórz nowy klucz API. Podaj opis.

FluentEmail C# (Jak to działa dla programistów): Rysunek 1 – Mailgun

  1. Zainstaluj pakiet FluentEmail:

    Aby zainstalować FluentMail, użyj menedżera pakietów NuGet lub konsoli menedżera pakietów w Visual Studio:

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

lub z programu Visual Studio:

FluentEmail C# (Jak to działa dla programistów): Rysunek 2 – FluentEmail.Mailgun

  1. Skonfiguruj FluentEmail za pomocą kluczy API Mailgun:

Skonfiguruj FluentEmail tak, aby korzystał z Mailgun jako dostawcy usług poczty elektronicznej lub nadawcy SMTP, konfigurując swoje klucze 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. Tworzenie i wysyłanie wiadomości e-mail:

    Skorzystaj z płynnego interfejsu FluentEmail do tworzenia i wysyłania wiadomości e-mail:

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. Konfiguracja zaawansowana:

    • Dostosuj ustawienia wiadomości e-mail, takie jak załączniki, formatowanie HTML, odbiorcy w polach DW/UDW oraz nagłówki wiadomości, korzystając z płynnego interfejsu API FluentEmail.

Korzyści z używania FluentEmail z Mailgun

  • Prostota: FluentEmail eliminuje złożoność konfiguracji SMTP, ułatwiając wysyłanie wiadomości e-mail przy minimalnej konfiguracji.
  • Niezawodność: Wykorzystanie infrastruktury Mailgun zapewnia wysokie wskaźniki dostarczalności i solidne możliwości obsługi poczty elektronicznej.
  • Skalowalność: Bez wysiłku dostosuj swoje potrzeby w zakresie wysyłania wiadomości e-mail dzięki skalowalnej infrastrukturze Mailgun, odpowiedniej zarówno dla aplikacji na małą skalę, jak i rozwiązań na poziomie Enterprise.
  • Bogate funkcje: Wykorzystaj funkcje Mailgun, takie jak śledzenie, analityka i zaawansowana weryfikacja adresów e-mail, aby zoptymalizować swoje kampanie e-mailowe.

Wprowadzenie do IronPDF

FluentEmail C# (Jak to działa dla programistów): Rysunek 3 – IronPDF

IronPDF for Node.js to biblioteka PDF, która umożliwia generowanie, zarządzanie i wyodrębnianie treści z dokumentów PDF w projektach .NET. Oto kilka kluczowych funkcji:

  1. Konwersja HTML do PDF:

    • Konwertuj treści HTML, CSS i JavaScript na dokumenty PDF.
    • Silnik renderujący Chrome zapewniający pliki PDF o idealnej rozdzielczości.
    • Generuj pliki PDF na podstawie adresów URL, plików HTML lub ciągów znaków HTML jako danych wejściowych.

  2. Konwersja obrazów i treści:

    • Konwertuj obrazy do i z plików PDF.
    • Wyodrębnianie tekstu i obrazów z istniejących dokumentów PDF.
    • Obsługa różnych formatów obrazów, takich jak JPG, PNG itp.

  3. Edycja i obróbka:

    • Ustawianie właściwości, zabezpieczeń i uprawnień dla plików PDF.
    • Dodaj podpisy cyfrowe.
    • Edytuj metadane i historię zmian.

IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty 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");
    }
}
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

Generowanie dokumentu PDF przy użyciu IronPDF i FluentEmail .NET z wysyłką Mailgun

Na początek utwórz aplikację konsolową za pomocą programu Visual Studio, jak pokazano poniżej.

FluentEmail C# (Jak to działa dla programistów): Rysunek 4 – Aplikacja konsolowa

Podaj nazwę projektu.

FluentEmail C# (Jak to działa dla programistów): Rysunek 5 – Konfiguracja projektu

Podaj wersję .NET.

FluentEmail C# (Jak to działa dla programistów): Rysunek 6 – Docelowa platforma

Zainstaluj pakiet IronPDF.

FluentEmail C# (Jak to działa dla programistów): Rysunek 7 – IronPDF

Zainstaluj FluentEmail Mailgun.

FluentEmail C# (Jak to działa dla programistów): Rysunek 8 – FluentEmail.Mailgun

Aby otrzymywać wiadomości e-mail w ramach bezpłatnej wersji próbnej, adres e-mail odbiorcy powinien być zarejestrowany w panelu Mailgun Registration Dashboard, jak pokazano poniżej.

FluentEmail C# (Jak to działa dla programistów): Rysunek 9 – Pulpit nawigacyjny 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

Wyjaśnienie kodu

  1. Integracja FluentEmail i Mailgun:

    • FluentEmail.Core: Zapewnia płynny interfejs do tworzenia i wysyłania wiadomości e-mail.
    • FluentEmail.Mailgun: Umożliwia integrację z Mailgun w celu dostarczania wiadomości e-mail.

  2. ChromePdfRenderer:

    • Zakłada się, że jest to instancja ChromePdfRenderer z biblioteki IronPDF, używana do renderowania treści HTML do dokumentu PDF.

  3. Przygotowanie treści:

    • Przygotowano treść HTML (content), zawierającą szczegółowe informacje na temat IronPDF. Treść ta jest wykorzystywana zarówno do generowania pliku PDF (renderer.RenderHtmlAsPdf(content)), jak i do treści wiadomości e-mail.

  4. Konfiguracja MailgunSender:

    • MailgunSender jest inicjowany przy użyciu poświadczeń API Mailgun (domena i klucz API). Email.DefaultSender jest przypisany do tego nadawcy, co gwarantuje, że wszystkie kolejne wiadomości e-mail będą dostarczane za pośrednictwem Mailgun.

  5. Generowanie plików PDF i dołączanie ich:

    • Treść HTML (content) jest renderowana do formatu PDF (pdf) przy użyciu metody RenderHtmlAsPdf biblioteki IronPDF.
    • Wygenerowany plik PDF jest zapisywany jako "AwesomeFluentEmailAndIron.pdf".

  6. Tworzenie i wysyłanie wiadomości e-mail:

    • Wiadomość e-mail jest tworzona przy użyciu płynnego interfejsu API FluentEmail:
      • Adres "Od" jest ustawiany przy użyciu domeny nadawcy.
      • Adres "Do" jest ustawiony na adres e-mail odbiorcy.
      • Temat i treść wiadomości e-mail są zdefiniowane.
      • Do wiadomości e-mail załączono plik PDF "AwesomeFluentEmailAndIron.pdf".
    • Wiadomość e-mail jest wysyłana przy użyciu .Send(), a status powodzenia (email.Successful) jest wyświetlany w konsoli.

  7. Wynik konsoli:

    • Po próbie wysłania wiadomości e-mail kod wyświetla informację, czy wiadomość została wysłana pomyślnie (Is Send Success: true/false).

Wynikowa wiadomość e-mail

FluentEmail C# (Jak to działa dla programistów): Rysunek 10 – Wynik wiadomości e-mail

Załączony plik PDF

FluentEmail C# (Jak to działa dla programistów): Rysunek 11 – Wynik w formacie PDF

Licencjonowanie IronPDF

Pakiet IronPDF wymaga licencji do uruchomienia i generowania plików PDF. Dodaj poniższy kod na początku aplikacji, zanim nastąpi dostęp do pakietu.

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

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

Licencja Trial jest dostępna na stronie Licencjonowanie i wersja próbna IronPDF.

Wnioski

FluentEmail w połączeniu z kluczami API Mailgun umożliwia programistom .NET usprawnienie funkcji poczty elektronicznej w ich aplikacjach. Niezależnie od tego, czy wysyłasz e-maile transakcyjne, biuletyny czy powiadomienia, ta integracja zapewnia niezawodność, skalowalność i łatwość użytkowania. Dzięki wyeliminowaniu złożoności związanej z dostarczaniem wiadomości e-mail FluentEmail pozwala programistom skupić się na tworzeniu solidnych aplikacji, wykorzystując jednocześnie potężną infrastrukturę pocztową Mailgun. Wykorzystaj możliwości FluentEmail i Mailgun, aby już dziś zwiększyć możliwości komunikacji e-mailowej w aplikacjach .NET.
Z kolei IronPDF to solidna biblioteka C# do tworzenia, edycji i konwersji dokumentów PDF w aplikacjach .NET. Wyróżnia się w konwersji HTML do PDF, oferuje kompleksowe możliwości manipulacji plikami PDF i płynnie integruje się z .NET Framework, zapewniając bezpieczne i wszechstronne rozwiązania do obsługi plików PDF.

Często Zadawane Pytania

Jak mogę wysyłać e-maile z szablonami Razor w aplikacji .NET?

Możesz używać FluentEmail do wysyłania e-maili z szablonami Razor w aplikacji .NET. Najpierw zainstaluj FluentEmail i pakiet renderera Razor za pomocą NuGet lub .NET CLI. Następnie skonfiguruj renderer Razor i użyj interfejsu FluentEmail do tworzenia i wysyłania e-maili z obsługą szablonów Razor.

Jak zintegrować Mailgun z biblioteką e-mailową .NET?

Aby zintegrować Mailgun z FluentEmail, pobierz klucze API z panelu Mailgun. Następnie zainstaluj pakiet `FluentEmail.Mailgun` i skonfiguruj Mailgun jako dostawcę usług poczty elektronicznej, co pozwoli Ci efektywnie wysyłać wiadomości e-mail za pośrednictwem infrastruktury Mailgun.

Jakie są zalety korzystania z FluentEmail do obsługi poczty elektronicznej w .NET?

FluentEmail oferuje płynny interfejs do tworzenia i wysyłania wiadomości e-mail, obsługuje szablony Razor i Liquid do tworzenia treści dynamicznych, upraszcza konfigurację SMTP oraz integruje się z Mailgun w celu zapewnienia niezawodnej i skalowalnej dostawy wiadomości e-mail.

Czy mogę zautomatyzować powiadomienia e-mailowe w ASP.NET Core przy użyciu biblioteki .NET?

Tak, w ASP.NET Core można zautomatyzować powiadomienia e-mailowe za pomocą FluentEmail. Wykorzystując szablony Razor i integrację z Mailgun, można z łatwością zautomatyzować wysyłanie e-maili transakcyjnych, biuletynów i powiadomień.

Jak mogę obsługiwać załączniki e-mailowe za pomocą FluentEmail w .NET?

Dzięki FluentEmail możesz łatwo zarządzać załącznikami do wiadomości e-mail, dodając je podczas tworzenia wiadomości. Biblioteka udostępnia metody dołączania plików do wiadomości e-mail, zapewniając, że załączniki zostaną wysłane wraz z treścią wiadomości.

W jaki sposób IronPDF rozszerza funkcjonalność plików PDF w aplikacjach .NET?

IronPDF rozszerza funkcjonalność plików PDF, oferując funkcje konwersji HTML do PDF, wyodrębniania treści oraz kompleksowej edycji plików PDF. Wykorzystuje silnik renderujący Chrome, umożliwiając programistom generowanie plików PDF z HTML, wyodrębnianie treści oraz wydajną modyfikację plików PDF.

Jakie kroki są konieczne, aby przekonwertować HTML na PDF w aplikacji .NET?

Aby przekonwertować HTML na PDF w aplikacji .NET przy użyciu IronPDF, można użyć klasy `ChromePdfRenderer` do renderowania treści HTML do dokumentu PDF. Ten plik PDF można następnie zapisać jako plik lub dalej przetwarzać w razie potrzeby.

Jak dołączać pliki PDF do wiadomości e-mail w aplikacji .NET?

Aby załączyć pliki PDF do wiadomości e-mail w aplikacji .NET, należy najpierw wygenerować plik PDF za pomocą IronPDF. Po utworzeniu pliku PDF należy użyć FluentEmail do skomponowania wiadomości e-mail i załączenia pliku PDF przy użyciu dostępnych metod załączania plików przed wysłaniem wiadomości.

Czy możliwe jest wyodrębnienie treści z pliku PDF przy użyciu biblioteki .NET?

Tak, za pomocą IronPDF można wyodrębnić zawartość z pliku PDF. Biblioteka udostępnia metody odczytu tekstu i obrazów z dokumentów PDF, umożliwiając wyodrębnianie zawartości w celu dalszego przetwarzania lub analizy.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie