DEV Community: sofiatarhonska

Sending Emails in Laravel – All You Want to Know

sofiatarhonska — Thu, 22 Sep 2022 12:41:37 +0000

Many Mailtrap users create their apps with PHP and the vast majority of them choose Laravel. It is simple and in addition, is covered in-depth by documentation and tutorials. However, we still observe numerous questions on sending emails with Laravel, testing them, as well as Mailtrap configurations. We have analyzed the most popular requests on Stack Overflow, Reddit as well as Google search and in this post we will provide you with the list of answers. How to send an email with Laravel? How to send a Laravel email via Mailtrap? Why isn’t Laravel mail working? Let’s figure it out.

Why Laravel and how it works

Laravel is a PHP framework that stands out for its simplicity, modernity, and connectivity. Probably, those characteristics make it especially popular among startups.

Laravel is widely used for building websites, marketplaces, web apps, and even frameworks.

The mail function is essential for these tasks, to register or notify the users, so it’s native in Laravel and provides a wide range of capabilities:

A list of integrations for sending emails through local or cloud-based services. Now Laravel proposes using drivers for SMTP, Mailtrap Email Delivery, Mailgun, SparkPost, Amazon SES, and sendmail.
Options for queueing emails.
Markdown support, which is available in a quite few frameworks. It lets you create beautiful templates and easily include buttons, tables, or panels.
Regular plain text and HTML messages.
Attaching files of different formats and MIME types, as well as raw data, inline attachments, and even embedding raw data into mail templates.
Templating system, which lets you use various templates and configure the view.
Message previews in-browser.

In addition, there are some noteworthy options:

Localization methods, so that you can set the desired language for a specific user.
Local development mailing. This is how you can prevent sending test emails to real inboxes. Mailtrap is one of the preferred options.

What you need to know about Laravel Mail

You will intuitively find all guidelines on the Laravel website and the educational Laracasts portal. That is why we rejected the idea of creating our own tutorial. For a better understanding, we decided to outline some basic principles, provide you with examples of creating an email in Laravel, and give you some tips and explanations.

Building email in Laravel

Here are a couple of basic things to keep in mind.

Laravel includes its own command-line interface called Artisan. (Yes, it definitely refers to their slogan “The PHP framework for web artisans”). It provides a bundle of useful commands, for email creation in particular. To get all available commands, type:

php artisan list

Each email category can be represented as a “mailable”. It’s a class that is responsible for building a specific email message using a set of methods.

For example:

php artisan make:mail NewUserNotification

command generates a class, which you’ll find at ‘app/Mail/NewUserNotification.php. The build() method of this class creates email messages:

public function build()
{
    return $this->from('example@example.com')
        ->view('emails.newuser');
}

This way, we have written a mailable with a build() method. Of course, it’s a minimal example, but you can make the necessary configuration and the next time you need to send it again, you will just type:

Mail::to($emailAddress)->send(new NewUserNotification);

Note: Mailables were introduced in Laravel 5.3.

Sending an email in Laravel

To send an email, you have a bunch of options. Laravel’s creators recommend using one of the API based drivers: Mailgun, SparkPost, or Amazon SES.

Laravel 7.0 introduces multiple drivers. It means that you can set one of the drivers as a default one in your mail configuration file (Mailgun, for example), but configure sending particular types of messages (let’s say, notifications) with SparkPost.

Mail::mailer('sparkpost')
        ->to($emailAddress())
        ->send(new NewUserNotification));

For configurations, follow this section of the Laravel Documentation.

You are also free to use any SMTP server you prefer, like Gmail. The related configurations are made in the config/mail.php file. In the default Laravel setup, the email configuration is read from environment variables so to edit them, you should save your changes to the .env file (you will find it in the root directory).

The Mailtrap SMTP server is one of the recommended SMTP methods in Laravel. It helps you avoid sending test emails to real inboxes by accident. It is designed to catch these interim emails and help you debug them. With Mailtrap, your email will never land in the real inbox in any of the email clients.

So, if you are ready to send your message to your own or even your customer’s inbox, don’t forget to replace the configuration with that of the real server. For example:

MAIL_MAILER=smtp
MAIL_HOST=smtp.googlemail.com
MAIL_PORT=465
MAIL_USERNAME=youremail@gmail.com
MAIL_PASSWORD=your password
MAIL_ENCRYPTION=ssl

And if you’re using Mailtrap Email Delivery as your sending solution, we provide the SMTP configuration for you. Just copy-paste the configuration listed in the app, verify your domain, and you’re good to go.

Laravel versions

A new version of Laravel is released every six months. Then bug fixes are provided for another six months while security fixes are delivered within a year. Also, starting from 5.1, Laravel offers long-term support (LTS) version, with bug fixes valid for two years and security fixes – for three.

For July 2020, Laravel 7.0 is the latest released version.

We observe that in 2020 users were still working with Laravel 6.2, 5.8, 5.6, 5.4, 5.3, or even 5.2 versions. But versions below 5.5 (LTS) were no longer supported:

Source: https://laravel.com/docs/master/releases

Sometimes, the use of the old versions might result in some performance issues. Most likely, you might just miss some functionality and waste your time. Here is a list of some important updates delivered in 6 and 7 versions, which affect email sending options.

Laravel 6 (LTS) introduced semantic versioning, compatibility with Laravel Vapor, enhanced authorization responses, job middleware, lazy collections, and subquery improvements, as well as other bug fixes and usability improvements.

Laravel 7 delivered Laravel Sanctum (an authentication system), Blade component tags, a developer-focused HTTP client, first-party CORS support, multiple mail drivers, a new artisan test command, along with other bug fixes and usability improvements.

How to send email in Laravel 7.0 using SMTP

To sum up, let’s review an example of coding a message in Laravel 7.0 and testing it with Mailtrap’s fake SMTP service. We will take advantage of Laravel’s awesome features like Blade templates, Mailable class, and Markdown support.

We assume that you have been already using Laravel for building your application. If you were working in one of the previous versions, update your laravel/framework dependency to 7.0.* in your composer.json file, as recommended in the official guide.

Let’s start by defining an SMTP server and setting the mailing configuration. We prefer to test our notifications with Mailtrap first, to make sure our code works fine and the content of the messages is rendered properly.

Mailtrap is a default server in Laravel, so you need just to type in your credentials. You will find them in the SMTP Settings tab of your Inbox. Also, you can use Integrations data from the same tab. Choose Laravel from the list, copy the following details, and paste them to your .env file:

MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=1a2b3c4d5e6f7g //your username
MAIL_PASSWORD=1a2b3c4d5e6f7g // your password
MAIL_FROM_ADDRESS=from@example.com
MAIL_FROM_NAME=Example

Now let’s move to the CLI:
php artisan make:mail MailtrapExample

This way, we have created a Mailable class, with the name MailtrapExample.php. Now we should find it in the Mail directory in app/Mail. We have a template, which contains basic needed functions so that we should just modify it.

<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Contracts\Queue\ShouldQueue;
class MailtrapExample extends Mailable
{
    use Queueable, SerializesModels;
    /**
     * Create a new message instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }
    /**
     * Build the message.
     *
     * @return $this
     */
public function build()
    {
        return $this->from('mail@example.com', 'Mailtrap')
            ->subject('Mailtrap Confirmation')
            ->markdown('mails.exmpl')
            ->with([
                'name' => 'New Mailtrap User',
                'link' => '/inboxes/'
            ]);
    }

We’ve added a sender, a subject, a couple of variables and introduced the Markdown support.

Now it’s time to create the body of our message. For this purpose, we will use a Blade template.

We have specified that our mailable is located in the mails.exmpl. Now we need to create a ‘mails’ directory with a blade template file ‘exmpl.blade.php’. inside. Templates represent views in Laravel, so keep the template file in the resources/views/mails directory.

@component('mail::message')
Hello **{{$name}}**,  {{-- use double space for line break --}}
Thank you for choosing Mailtrap!
Click below to start working right now
@component('mail::button', ['url' => $link])
Go to your inbox
@endcomponent
Sincerely,
Mailtrap team.
@endcomponent

Our simple configuration is done, and we can move forward with sending our message. Specify the route in the routes/web.php:

<?php
use App\Mail\MailtrapExample;
use Illuminate\Support\Facades\Mail;
Route::get('/send-mail', function () {
    Mail::to('newuser@example.com')->send(new MailtrapExample());
    return 'A message has been sent to Mailtrap!';
});

Run your application. Usually, it should be php artisan serve in development, then go to /send-mail path of your application in the browser (http://127.0.0.1:8000/send-mail when running with php artisan serve.)

Note that starting from the 5.8 version, Laravel is capable of serving multiple applications. Earlier, only port 8000 was available but now serves scans for free options up to 8009.

That’s it. Your application will send a message and you will see it in your Mailtrap inbox:

Verify if the result matches your expectations: whether all elements are displayed correctly and links work properly. View the Check HTML and Analysis tabs in Mailtrap to make sure your messages won’t be considered spam and will be rendered correctly in most email clients.

Once you are satisfied with the results of tests, replace SMTP configurations with your production server or configure any other option to send emails to real inboxes.

Here we go! I hope you've got a good time reading our guide on sending emails in Laravel to multiple recipients, initially published in the Mailtrap blog.

How to Send Emails from Spring Boot App

sofiatarhonska — Wed, 21 Sep 2022 14:06:06 +0000

Introduction

This article is a step-by-step guide on how to create a landing page that sends a welcome email to subscribers. This will be developed with Java and Spring Boot. It will also show all the required processes for the download of tools and the test for running the web application.

Spring Tools

Starting any application with Spring is a good way to use Spring Tools as it improves the IDEs and brings features to facilitate the codification. This article will be using the Spring Tool 4 for Eclipse on Mac OS. However, it’s also available for Visual Studio Code and Theia, and it can be downloaded from Spring Tools. Choose which one is better for you and download it.

Spring Initializr

Another useful tool for starting a Spring Boot project is the Spring Initializr (https://start.spring.io/), which has a web interface where the configuration of the project can be set up and the dependencies can be chosen. After filling out the form, the project can be downloaded and imported from Spring Tools with the Import Spring Getting Started Content option.

Another way to create a Spring project is using Spring Tools, which provides a feature called Create a New Spring Starter Project. It’s a wizard with the same options available on the web interface.

This article will be using a Gradle Project with Java 15. The dependencies used are:

Spring Web (allows running web application on Apache Tomcat and, because of this, the packaging needs to be a War format)
Java Mail Sender (include the dependencies for sending email)

The image below shows the Spring Initializr form filled out to guide you. Note that the Group field represents the project packages and must be filled with com.domain.

After filling, click on the GENERATE button to download your initialized project. Then, open Spring Tools and click on Import Spring Getting Started Content to open your downloaded project.

If you prefer to do this directly on Spring Tools, click on Create New Spring Starter Project. In the window, the New Spring Starter Project fills the text inputs with the full name and description and chooses the options listed below.

Type: Gradle
Packaging: War
Java Version: 15
Language: Java

Click on Next and choose the dependencies Spring Web and Java Mail Sender. Now, just click Finish to create your project.

Gradle Configuration

A project created with the wizard on Spring Initializr or on Spring Tools will have the build.gradle file filled with the configurations that the project needs to run. Check if your build.gradle has the Thymeleaf as dependencies, it will be necessary to associate the pages with the model in the next steps.

plugins {
id 'org.springframework.boot' version '2.5.0-SNAPSHOT'
id 'io.spring.dependency-management' version '1.0.10.RELEASE'
        id 'java'
id 'war'
}

group = 'com.domain'
version = '0.0.1'
sourceCompatibility = '15'

repositories {
mavenCentral()
        maven { url 'https://repo.spring.io/milestone' }
        maven { url 'https://repo.spring.io/snapshot' }
}

dependencies {
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
        implementation 'org.springframework.boot:spring-boot-starter-mail'
        implementation 'org.springframework.boot:spring-boot-starter-web'
        providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
        testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
useJUnitPlatform()
}

springBoot {
mainClassName = 'com.domain.landing.LandingApplication'
}

Creating a Landing Page
In the LandingApplication.java file, we will define the listener on our web application. It is basically a class with a main method and @SpringBootApplication. This class will create the ApplicationContext and launch the web application. Inside the main method, we need to call run from SpringApplication to start it.

// LandingApplication.java
package com.domain.landing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LandingApplication {
    public static void main(String[] args) {
     SpringApplication.run(LandingApplication.class, args);
    }
}

Model Structure

The class model will be used to store the name and email used in the form. These pieces of information will navigate across the controller and mailer. We need to create a new package to put the model in. Usually, the package will have the model and the controller separating the code by subjects. Following this package structure helps the Spring Boot to scan and find the classes. Another way is to separate a package for models and another for controllers – this is also a valid approach.

// SubscribeForm.java
package com.domain.landing.subscribe;

public class SubscribeForm {
    private String name;
    private String email;

    public String getName() {
     return this.name;
    }

    public void setName(String name) {
     this.name = name;
    }

    public String getEmail() {
     return this.email;
    }

    public void setEmail(String name) {
     this.email = name;
    }
}

Controller and Requests
The first version of our controller implements two routes: GET and POST methods. A method called showForm will receive a subscribe object and mapping to render the form page. This page will have a form with fields for name and email, and also a Submit button. This submits our second method submitForm, which also receives the subscribing object as a parameter. For now, this method will only redirect to the successful subscribe page.

It’s important to highlight that the addViewControllers method is necessary for registering the view that will be used for redirection with the POST method.

// SubscribeController.java
package com.domain.landing.subscribe;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Controller
public class SubscribeController implements WebMvcConfigurer {

@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/subscribe/confirmation").setViewName("subscribe/confirmation");
}

@GetMapping("/")
public String showForm(SubscribeForm subscribeForm) {
return "/subscribe/form";
}

@PostMapping("/")
public String submitForm(SubscribeForm subscribeForm) {
return "redirect:/subscribe/confirmation";
}
}

Views Files

In the src/main/resources/templates package, we’ll create a package called Subscribe to store our HTML files for our views and pages. The form.html file will contain the form and will be the page shown when accessed.

Note that the object has to be the same name as your parameter on the submitForm and the action must be the same as defined on PostMapping.

// src/main/resources/templates/subscribe/form.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
    <title>Subscribe on newsletter</title>
</head>
<body>
        <h1>Subscribe on newsletter</h1>
        <form action="#" th:action="@{/}" th:object="${subscribeForm}" method="post">
                <table>
                <tr>
                            <td>Name:</td>
                    <td><input type="text" th:field="*{name}" /></td>
                </tr>
                    <tr>
                    <td>Email:</td>
                    <td><input type="text" th:field="*{email}" /></td>
                    </tr>
                <tr>
                        <td><button type="submit">Subscribe</button></td>
                </tr>
            </table>
            </form>
</body>
</html>

The confirmation.html file has only a message informing us that everything works. This will be shown after submitting the form.

// confirmation.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Subscribe on newsletter</title>
</head>
<body>
<h1>Successfully subscribed!</h1>
<h2>You will receive an email confirming your subscription.</h2>
</body>
</html>

Testing so Far
Start your application by clicking on the Run button, or open a terminal, go to the project directory, run ./gradlew bootRun on the terminal, and access the URL http://localhost:8080 – it’ll show a page similar to the image below.

Fill out the form and click on the Subscribe button to see the redirect in action and the confirmation page.

If you see this, you can move forward, so let’s implement the sending email.

Sending Emails to Mailtrap Testing Environment

To test our sending emails, we’ll use Mailtrap. Mailtrap is a service for inspecting the email content received before sending it in production. Mailtrap is free for personal side projects, so we can send 500 emails per month and test our application in development and even staging environments.

To start using Mailtrap access https://mailtrap.io/ home page, create your account, and log in to it.

On the sidebar, access the Testing > Inboxes menu. In the shows Projects panel, click on Add Inbox.

Fill the Inbox name field with a meaningful name, such as Subscribers, and then click on the Save button.

Now click on Subscribers to access the configuration page.

Click on Show Credentials to see the SMTP information required to send the email. This information will be added to the Properties in our Mail class.

We also need to get the email used as the sender. To get this, click on the Email Address tab and copy the Inbox Email Address.

Create a new package called Mailer and a new class called Mail. In this class, create constants to store the configuration that you got from Mailtrap. The setProperties method assigns the constants to the Properties object that will be used to create a session authentication with Mailtrap credentials.

The send method creates a message with email fields such as from, recipient, subject, content, and date. The send method of Transport class is responsible for sending the message to Mailtrap inbox.

// Mail.java
package com.domain.landing.mailer;

import java.io.IOException;
import java.util.Date;
import java.util.Properties;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import com.domain.landing.subscribe.SubscribeForm;

public class Mail {
        private final String PORT = "587";
        private final String HOST = "smtp.mailtrap.io";
        private final String USERNAME = "bb817095de807a";
        private final String PASSWORD = "e625767e122812";
        private final String EMAIL = "0b5d29e626-65f490@inbox.mailtrap.io";

        private final boolean AUTH = true;
        private final boolean STARTTLS = true;

        public void send(SubscribeForm subscriber) throws AddressException, MessagingException, IOException {
Message msg = new MimeMessage(setSession(setProperties()));

        msg.setSentDate(new Date());
            msg.setSubject("You're subscribed on newsletter");

msg.setFrom(new InternetAddress(EMAIL, false));
        msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(subscriber.getEmail()));

        msg.setContent(subscriber.getName().concat(", you're very welcome here!"), "text/html");

Transport.send(msg);
    }

private Session setSession(Properties props) {
        Session session = Session.getInstance(props, new javax.mail.Authenticator() {
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(USERNAME, PASSWORD);
                }
});
        return session;
}

private Properties setProperties() {
        Properties props = new Properties();

    props.put("mail.smtp.port", PORT);
            props.put("mail.smtp.host", HOST);
    props.put("mail.smtp.auth", AUTH);
            props.put("mail.smtp.starttls.enable", STARTTLS);

        return props;
}
}

With Mail class created, we need to call the send method when the form was submitted. To do this, create a new instance from Mail in the submitForm method on SubscribeController. This instance will call the send method to pass the subscribe as a parameter. This parameter contains the email and name used to mount the email that will be sent. It’ll throw AddressException, MessagingException and IOException exceptions, and will also need to import these packages.

// SubscribeController.java
...
import com.domain.landing.mailer.Mail;

import java.io.IOException;

import javax.mail.MessagingException;
import javax.mail.internet.AddressException;
...

@Controller
public class SubscribeController implements WebMvcConfigurer {
...
@PostMapping("/")
        public String submitForm(SubscribeForm subscribeForm) throws AddressException, MessagingException, IOException {
Mail mailer = new Mail();
mailer.send(subscribeForm);
return "redirect:/subscribe/confirmation";
    }
}

Run the application again, access http://localhost:8080, fill the form and click on the Subscribe button. Go back to Mailtrap and access Inboxes > Subscribers to see the received email.

Sending Emails with Attachments

Now let’s try sending emails with attachments. Add an image to src/main/resources/static. In my case, I used an image called fine.jpeg.

We need to change the content of the email body to work with multipart to add the message and the attachment. The multipart instance will be initialized on the Mail constructor and will be accessed by the receiver. Two new methods were created: the setMessage to include the multipart as content and the setAttachment to attach the file. After adding this body’s parties to multipart, we can set the multipart as the content of the MimeMessage instance.

...
import java.io.File;
...

import javax.mail.Multipart;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMultipart;
...

public class Mail {
    ...
private Multipart multipart;

public Mail() {
this.multipart = new MimeMultipart();
}

private Multipart getMultipart() {
     return multipart;
}

public void send(SubscribeForm subscriber) throws AddressException, MessagingException, IOException {
Message msg = new MimeMessage(setSession(setProperties()));

        setAttachment();
            setMessage(subscriber);

            msg.setContent(getMultipart());
            msg.setSentDate(new Date());
            msg.setSubject("You're subscribed on newsletter");

            msg.setFrom(new InternetAddress(EMAIL, false));
            msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(subscriber.getEmail()));

Transport.send(msg);
}

private void setMessage(SubscribeForm subscriber) throws MessagingException {
MimeBodyPart message =  new MimeBodyPart();

message.setContent(subscriber.getName().concat(", you're very welcome here!"), "text/html");

        getMultipart().addBodyPart(message);
}

private void setAttachment() throws MessagingException, IOException {
        MimeBodyPart attachment = new MimeBodyPart();

attachment.attachFile(new File("src/main/resources/static/fine.jpeg").getCanonicalPath());

        getMultipart().addBodyPart(attachment);
}
    ...
}

Re-run the application, access http://localhost:8080, fill out the form, and click on the Subscribe button. Go back to Mailtrap and access Inboxes > Subscribers to view the received email with the attachment. You can download it to check whether the image arrived without any issues.

Sending HTML Email

When we set the content, we can parse the type of our content. In the example above, we are already parsing text/html as a type. Using this configuration, we can parse any HTML code inside a string and send the email with HTML formatting. Something like this will work and send a formatted email.

...
public Mail() {
...
private void setMessage(SubscribeForm subscriber) throws MessagingException {
        MimeBodyPart message =  new MimeBodyPart();

    String content = "<h1>" + subscriber.getName() + "</h1><br />";
    message.setContent(content + ", you're very welcome here!", "text/html");

        getMultipart().addBodyPart(message);
        }
...
}

But we can improve it using StringBuffer to create a string with all the content.

...
public Mail() {
…
private void setMessage(SubscribeForm subscriber) throws MessagingException {
        MimeBodyPart message =  new MimeBodyPart();

    StringBuffer htmlContent = new StringBuffer();
            htmlContent.append("<html><head><style>");
        htmlContent.append("body { background-color: #f2f2f2; }");
        htmlContent.append("h1 { color: #333; }");
        htmlContent.append("</style></head><body><h1>");
        htmlContent.append(subscriber.getName());
        htmlContent.append(", you're very welcome here!");
        htmlContent.append("</h1><br /></body></html>");

message.setContent(htmlContent.toString(), "text/html");

    getMultipart().addBodyPart(message);
}
...
}

Another more sophisticated option is to use some templates for our email and pass the variable as a parameter to the HTML file. Some options that work well with Spring Boot are Thymeleaf and FreeMaker.

One more time, run the application, access http://localhost:8080, fill out the form, and click on the Subscribe button. Go back to Mailtrap and access Inboxes > Subscribers to see the received email with HTML and CSS formatting.

Click on the HTML Source tab to see the generated HTML.

Another awesome feature of Mailtrap is showing whether the HTML and CSS in our email are valid in the email clients. Click on the Check HTML tab to verify the errors.

Conclusion
There are other ways to send an email with Spring Boot. With fewer changes, we can, for example, move the authentication constants from Mail class to the application.properties. We can also use some templates to improve the HTML emails. It’s important to see other possibilities to refactor and grow our code. Did you see something to improve here? Let’s talk!

I hope you’ve had a good time reading our guide on how to send emails to multiple recipients with Java Spring, which was originally published in the Mailtrap Blog!

Send and Receive Emails in ASP.NET C#

sofiatarhonska — Tue, 20 Sep 2022 12:57:46 +0000

You’ve got a long ASP.NET project ahead. You’re trying to wrap your head around all tasks at hand – infrastructure, business logic, admin panel, integrations. On top of that, there’s a long list of ‘could have’ type of features that the team would like to implement if time and resources allow.

One of them is adding the ability to send an email in ASP.NET C# that you’ve been postponing for a while. After all, it’s such an obvious feature that might as well be left for the very end, when almost everything is up and running. Before your project goes live, you will need to validate your email workflows anyway and probably you don’t want to stay extra hours just before the launch to do so.

While sending emails with C# is not rocket science, we strongly recommend thinking about it sooner rather than later. To make it easier to start, we’ve covered the first steps with the various code samples. Let’s start!

MailMessage

Throughout the course of this article, we’ll often be using MailMessage class. It’s a part of System.Net.Mail namespace and is used to create email messages that are then sent to an SMTP server. The delivery is then taken care of by the SmtpClient class.

For the complete set of parameters of this class, please refer to Microsoft’s documentation.

Sending emails in C# with SMTP

This one is fairly easy and quick to set up as SMTP (Simple Mail Transfer Protocol) is the most common communication standard used in email transmission. In the example below, we’ll show how to send a very simple email with the following details:

To: elizabeth@westminster.co.uk

From: piotr@mailtrap.io

Title: Good morning, Elizabeth

Body: Elizabeth, Long time no talk. Would you be up for lunch in Soho on Monday? I’m paying.

In order to send such an email, we’ll use the aforementioned MailMessage class from .NET API.

// in the beginning of the file
using System.Net;
using System.Net.Mail;
MailAddress to = new MailAddress("elizabeth@westminster.co.uk");
MailAddress from = new MailAddress("piotr@mailtrap.io");
MailMessage message = new MailMessage(from, to);
message.Subject = "Good morning, Elizabeth";
message.Body = "Elizabeth, Long time no talk. Would you be up for lunch in Soho on Monday? I'm paying.;";
SmtpClient client = new SmtpClient("smtp.server.address", 2525)
{
    Credentials = new NetworkCredential("smtp_username", "smtp_password"),
    EnableSsl = true
};
// code in brackets above needed if authentication required
try
{
  client.Send(message);
}
catch (SmtpException ex)
{
  Console.WriteLine(ex.ToString());
}

Once the message was configured, we connected to the SMTP server and sent it this way!

Mailtrap Email Delivery also allows you to send emails via SMTP. Just verify your domain, copy the provided SMTP settings to your app or service, and start sending to your recipients.

Sending emails with attachments

Now that we know how to send basic emails, let’s consider a very common scenario and add an attachment to our message to the Queen of England. This could be an invoice for the last royal wedding or a set of pictures we took on that fabulous weekend.

On top of MailMessage class, we’ll use Attachment class from .NET API. Make sure you add the attachment to the current working directory first.


// in the beginning of the file
using System.Net;
using System.Net.Mail;
using System.Net.Mime;
String filePath = "wedding_invoice.pdf";
Attachment data = new Attachment(filePath, MediaTypeNames.Application.Octet);
MailAddress to = new MailAddress("elizabeth@westminster.co.uk");
MailAddress from = new MailAddress("piotr@mailtrap.io");
MailMessage message = new MailMessage(from, to);
message.Subject = "Regarding our meeting";
message.Body = "Elizabeth, as requested, sending you the invoice for Harry and Meghan's wedding. Any questions? Let me know.;";
message.Attachments.Add(data);
SmtpClient client = new SmtpClient("smtp.server.address", 2525)
{
    Credentials = new NetworkCredential("smtp_username", "smtp_password"),
    EnableSsl = true
};
// code in brackets above needed if authentication required
try
{
  client.Send(message);
}
catch (SmtpException ex)
{
  Console.WriteLine(ex.ToString());
}

If you need to send multiple invoices (lucky you!) or other files, simply use a loop and add the other files to the email.

Adding images inline

We’ve just covered sending emails with attachments. But what if you’re sending images but want them displayed inline rather than being attached to an email. Certainly, it will be easier to attract the Queen’s attention this way. With a bit of modification of our previous code, this can be easily achieved.

When trying to send an email with images in C#, you’re not going to use a typical <img src="" alt="" /> construction. It would add an image attachment to the email and that’s the last thing we need right now. Instead, we’ll use LinkedResource object to directly embed an image in the HTML version of our message to the Queen. We will then follow our regular approach with MailMessage class. As always, remember to upload the file first to your current working directory. If it’s missing, an email will be sent without any attachment and, really, aren’t we receiving these “oops, forgot about the attachment!” emails too often already?

// in the beginning of the file
using System.Net;
using System.Net.Mail;
using System.Net.Mime;
String messageBody = "Elizabeth, sending you a quick sneak peak of the pictures" +
  "we took at the last royal wedding. " +
  "Let me know your thoughts.";
MailAddress to = new MailAddress("elizabeth@westminster.co.uk");
MailAddress from = new MailAddress("piotr@mailtrap.io");
MailMessage message = new MailMessage(from, to);
message.Subject = "Pics from the royal wedding";
message.Body = messageBody;
String imagePath = "bestpictureever.png";
LinkedResource LinkedImage = new LinkedResource(@imagePath);
LinkedImage.ContentId = "Wedding";
AlternateView htmlView = AlternateView.CreateAlternateViewFromString(
  $"{messageBody} <br> <img src=cid:Wedding>", null, "text/html"
);
htmlView.LinkedResources.Add(LinkedImage);
message.AlternateViews.Add(htmlView);
try
{
  client.Send(message);
}
catch (SmtpException ex)
{
  Console.WriteLine(ex.ToString());
}

Sending to multiple recipients

Let’s say we want to use the opportunity and remind the Queen and her grandson about unpaid invoices.

No rocket science here either. New recipients are simply added to the code, separated by a comma. As in the example below:

// in the beginning of the file
using System.Net;
using System.Net.Mail;
MailAddress to = new MailAddress("elizabeth@westminster.co.uk, harry@westminster.co.uk");
MailAddress from = new MailAddress("piotr@mailtrap.io");
MailMessage message = new MailMessage(from, to);
message.Subject = "Good morning";
message.Body = "Elizabeth, Harry, There are a few unpaid invoices for the Royal Wedding. Let's talk this over on Monday.;";
SmtpClient client = new SmtpClient("smtp.server.address", 2525)
{
    Credentials = new NetworkCredential("smtp_username", "smtp_password"),
    EnableSsl = true
};
// code in brackets above needed if authentication required
try
{
  client.Send(message);
}
catch (SmtpException ex)
{
  Console.WriteLine(ex.ToString());
}

Things get a tiny bit more tricky when you want to add people in bcc and cc, we’ll need a few additional lines:

// in the beginning of the file
using System.Net;
using System.Net.Mail;
MailAddress to = new MailAddress("elizabeth@westminster.co.uk, harry@westminster.co.uk");
MailAddress from = new MailAddress("piotr@mailtrap.io");
MailMessage message = new MailMessage(from, to);
message.Subject = "Good morning";
message.Body = "Elizabeth, Harry, There are a few unpaid invoices for the Royal Wedding. Let's talk this over on Monday.;";
message.CC.Add(new MailAddress("meghan@westminster.co.uk"));
message.Bcc.Add(new MailAddress("charles@westminster.co.uk"));
SmtpClient client = new SmtpClient("smtp.server.address", 2525)
{
    Credentials = new NetworkCredential("smtp_username", "smtp_password"),
    EnableSsl = true
};
// code in brackets above needed if authentication required
try
{
  client.Send(message);
}
catch (SmtpException ex)
{
  Console.WriteLine(ex.ToString());
}

Voila!

Do I need to have an SMTP server?

Let’s consider a situation when you don’t have (or don’t want to have) an SMTP server configured but still want to send an email in C#.

The first option is to do a DNS MX lookup of the email address that you’re trying to send an email to. This allows you to figure out what the SMTP server is and connect to it. So, you’re still going to use an SMTP server, just not yours!

We don’t, however, recommend such an approach for several reasons:

Your emails might be treated as spam, especially if you send them from a Dynamic IP
Each recipient’s mail server will need to be resolved manually.
Compared to other methods, querying DNS manually consumes more CPU and networking, making the performance worse

In order to implement it, you’ll need to install a 3rd party plugin. DnsPlugin.NET is our choice here. See the sample code:

// in the top of the file
// requires installation of https://www.nuget.org/packages/DnsClient
using System.Net;
using System.Net.Mail;
using DnsClient;
MailAddress to = new MailAddress("elizabeth@westminster.co.uk");
MailAddress from = new MailAddress("piotr@mailtrap.com");
MailMessage message = new MailMessage(from, to);
message.Subject = "See you Monday?";
message.Body = "Elizabeth, I didn't hear back from you. Let me know if we're still scheduled for Monday.";
LookupClient lookup = new LookupClient();
IDnsQueryResponse response = lookup.Query("westminster.co.uk", QueryType.MX);
foreach(DnsClient.Protocol.MxRecord record in response.Answers) {
    Console.WriteLine(ObjectDumper.Dump(record.Exchange));
    SmtpClient client = new SmtpClient(record.Exchange, 25);
    try
    {
        client.Send(message);
        // if we reached this point, our email was sent and we can break the loop
        break;
    }
    catch(SmtpException ex)
    {
        Console.WriteLine(ex.ToString());
    }
}

Using API to send emails

A much better approach to sending emails without SMTP is with API. It’s definitely the fastest one. It also provides an additional layer of security by utilizing API keys and allows you to use many 3rd party providers that give you tons of additional features such as analytics, email authentication, and others.

Mailtrap Email Delivery is one such service, and you get exemplary APIs for nine programming languages. More importantly, we provide comprehensive stats and deliverability alerts to help maintain your domain authority.

Receiving emails in C#

Finally, you might be wondering if there’s a way to receive the emails directly with the C# code. After all, the Queen might get back to us any minute now. Of course, you could easily track new emails with simple email clients, such as Gmail or Thunderbird, without a single line of code and with minimal effort. But let’s assume you need to see at least the topics of incoming emails with your code, for example, to build some integrations around that.

Receiving emails is not a part of core C# stack so you will need to utilize some 3rd party libraries for that purpose. OpenPop.NET open-source library seems to be getting the job done in this case. You can use the following code to fetch the topics of incoming mail:

var client = new POPClient();
client.Connect("pop.gmail.com", 995, true);
client.Authenticate("piotr@mailtrap.io", "My_password_here");
var count = client.GetMessageCount();
Message message = client.GetMessage(count);
Console.WriteLine(message.Headers.Subject);

For the details on using OpenPop library for this or any other purposes, please refer to their documentation.

Summary

Try it out when you launch your first project but consider some more robust solutions if you plan to scale. If you need to do some email testing, the last thing you want is users receiving the test emails they were not supposed to get.

Testing out of the way, feel free to check out Mailtrap’s Email Delivery for free and ensure your transactional emails reach the right recipients.

That's all! Thanks for reading our guide on how to send HTML email using ASP.NET, which was originally published in the Mailtrap Blog by Piotr Malek.