FluentEmail C# (How It Works For Developers)
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
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>
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
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
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
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.
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
or from Visual Studio:
- 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
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
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
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:
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.
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.
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
Generate PDF document Using IronPDF And FluentEmail .NET with Mailgun sender
To start with, create a Console application using Visual Studio as below.
Provide Project Name.
Provide .NET Version.
Install IronPDF package.
Install 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.
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
Code Explanation
FluentEmail and Mailgun Integration:
- FluentEmail.Core: Provides a fluent interface for composing and sending emails.
- FluentEmail.Mailgun: Enables integration with Mailgun for email delivery.
ChromePdfRenderer:
- This is assumed to be an instance of ChromePdfRenderer from the IronPDF library, used to render HTML content into a PDF document.
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.
- HTML content (
MailgunSender Setup:
MailgunSender
is initialized with Mailgun API credentials (domain and API key). TheEmail.DefaultSender
is set to this sender, ensuring all subsequent emails use Mailgun for delivery.
PDF Generation and Attachment:
- The HTML content (
content
) is rendered into a PDF (pdf
) using IronPDF'sRenderHtmlAsPdf
method. - The generated PDF is saved as "AwesomeFluentEmailAndIron.pdf".
- The HTML content (
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.
- An email is composed using FluentEmail's fluent API:
Console Output:
- After attempting to send the email, the code outputs whether the email was sent successfully (
Is Send Success: true/false
).
- After attempting to send the email, the code outputs whether the email was sent successfully (
Output Email Message
Attached PDF
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
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.
Frequently Asked Questions
What is a popular library in the .NET Core ecosystem for sending emails?
FluentEmail.NET is a popular library in the .NET Core ecosystem for sending emails, supporting Razor and Liquid templates for dynamic email bodies.
How do I install a library for sending emails with Razor templates?
You can install FluentEmail and the Razor templates renderer package using the Package Manager Console with `Install-Package FluentEmail.Core` and `Install-Package FluentEmail.Razor`, or use the .NET CLI with `dotnet add package FluentEmail.Core` and `dotnet add package FluentEmail.Razor`.
How can I integrate an email service API with a .NET library for sending emails?
To integrate Mailgun API keys with FluentEmail, first obtain your API keys from the Mailgun dashboard. Then, use the `FluentEmail.Mailgun` package and configure Mailgun as the email service provider.
What are the benefits of using a .NET library for emails with a popular email service provider?
FluentEmail with Mailgun offers simplicity by abstracting SMTP configurations, reliability through Mailgun's infrastructure, scalability for varying needs, and rich features like tracking and analytics.
What is the process to create and send an email using a .NET email library?
To create and send an email using FluentEmail, configure the Razor renderer and SMTP sender, compose the email with the desired template and model, and use the `Send` method to deliver it.
How does a .NET library facilitate PDF operations in applications?
IronPDF integrates with .NET applications by providing functionality for HTML to PDF conversion, image and content conversion, and PDF editing and manipulation using a Chrome Rendering Engine.
How can I generate a PDF using a .NET library?
To generate a PDF using IronPDF, use the ChromePdfRenderer to render HTML content into a PDF document, which can then be saved as a file.
Is a license required to use a .NET PDF library?
Yes, IronPDF requires a license to generate PDFs. You can obtain a trial license from the IronPDF Licensing and Trial page.
What are the key features of a .NET PDF library?
IronPDF offers features like HTML to PDF conversion, content extraction, PDF editing, digital signatures, and security settings.
How does a .NET email library enhance communication in applications?
FluentEmail enhances email communication by streamlining the process of sending transactional emails, newsletters, and notifications, ensuring reliability and scalability with ease of use.