ASP.NET Core 1.0 is a reboot of the ASP.NET framework which can target the traditional full .NET framework or the new .NET Core framework. Together ASP.NET Core and .NET Core have been designed to work cross-platform and have a lighter, faster footprint compared to the current full .NET framework. Many of the .NET Core APIs are the same as they are in the full framework and the team has worked hard to try and keep things reasonably similar where it makes sense and is practical to do so. However, as a consequence of developing a smaller, more modular framework of dependent libraries and most significantly making the move to support cross-platform development and hosting; some of the libraries have been lost. Take a look at this post from Ammo Land worth which describes the changes in more detail and discusses considerations for porting existing applications to .NET Core.
I’ve been working with ASP.NET Core for quite a few months now and generally, I have enjoyed the experience. Personally, I’ve hit very few issues along the way and expect to continue using the new framework going forward wherever possible. Recently though I did hit a roadblock on a project at work where I had a requirement to send emails from within my web application. In the full framework, I’d have used the Smtp Client class in system.net.mail namespace. However, in .NET Core this is not currently available to us.
Solutions available in the cloud world include services such as SendGrid; which, depending on the scenario I can see as a very reasonable solution. For my personal projects and tests, this would indeed be my preferred approach, since I don’t have to worry about maintaining and supporting an SMTP server. However at work, we have SMTP systems in place and a specialized support team that manage them, so I ideally needed a solution to allow me to send emails directly as we do in our traditionally ASP.NET 4.x applications.
As with most coding challenges I jumped straight onto Google to see who else had had this requirement and how they solved the problem. However, I didn’t find as many documented solutions that helped me as I was expecting to. Eventually, I landed on this issue within the core fx repo on Github. That led me onto the MailKit library maintained by Jeffrey Stedfast and it turned out to be a great solution for me as it has recently been updated to work on .NET Core.
In this post, I will take you through how I got this working for the two scenarios I needed to tackle. Firstly sending mail directly via an SMTP relay and secondly the possibility to save the email message into an SMTP pickup folder. Both turned out to be pretty painless to get going.
Adding MailKit to your Project
The first step is to add the reference to the NuGet package for MailKit. I now prefer to use the project.json file directly to set up my dependencies. You’ll need to add the MailKit library – which is at version 1.3.0-beta6 at the time of writing this post – to your dependencies section in the project.json file.
Sending email via a SMTP server
I tested this solution in a default ASP.NET Core web application project which already includes an Email Sender interface and a class Auth Message Sender which just needs implementing. It was an obvious choice for me to test the implementation using this class as DI is already hooked up for it. For this post, I’ll show the bare-bones code needed to get started with sending emails via an SMTP server.
To follow along, open up the Message Services.cs file in your web application project.
We need three using statements at the top of the file.
First, we declare a new Mime Message object which will represent the email message we will be sending. We can then set some of its basic properties.
The Mime Message has a “from” address list and a “to” address list that we can populate with our sender and recipient(s). For this example, I’ve added a single new Mailbox Address for each. The basic constructor for the Mailbox Address takes in a display name and the email address for the mailbox. In my case, the “to” mailbox takes the address which is passed into the Send Email Async method by the caller.
We then add the subject string to the email message object and then define the body. There are a couple of ways to build up the message body but for now, I’ve used a simple approach to populate the plain text part using the message passed into the SendEmailAsync method. We could also populate an Html body for the message if required.
That leaves us with a very simple email message object, just enough to form a proof of concept here. The final step is to send the message and to do that we use a SmtpClient. Note that this isn’t the Smtp Client from system.net.mail, it is part of the MailKit library.
We create an instance of the Smtp Client wrapped with a using statement to ensure that it is disposed of when we’re done with it. We don’t want to keep connections open to the SMTP server once we’ve sent our email. You can if required (and I have done in my code) set the Local Domain used when communicating with the SMTP server. This will be presented as the origin of the emails. In my case, I needed to supply the domain so that our internal testing SMTP server would accept and relay my emails.
We then asynchronously connect to the SMTP server. The ConnectAsync method can take just the URI of the SMTP server or as I’ve done here be overloaded with a port and SSL option. For my case when testing with our local test SMTP server no SSL was required so I specified this explicitly to make it work.
Finally, we can send the message asynchronously and then close the connection. At this point, the email should have been fired off via the SMTP server.