Sending Transactional Emails with Transmitly (C#)

Whether you’re confirming an order, resetting a password, or sending an account notification, transactional emails are key to ensuring a smooth user experience. However, managing these emails effectively can be complex. That’s where Transmitly comes in — a solution designed to streamline and enhance your transactional email process. In this article, you’ll explore how Transmitly, with its powerful features, can revolutionize the way you handle email communication.

What is are Transactional Emails?

Transactional emails are messages sent in response to specific actions or events within your application or service. Unlike marketing emails, which are sent in bulk to promote products or services, transactional emails are integral to your business operations. Common examples include:

• Order confirmations
• Password reset requests
• Account notifications
• Shipping updates
• Appointment reminders

What is Transmitly?

Transmitly is a robust platform for managing and controlling outgoing transactional communications, including emails, SMS, and push notifications. It centralizes your communication management, offers flexible configuration, and simplifies message composition. Whether you’re a developer or running a business, Transmitly helps you streamline your communication processes. It supports multiple service providers and integrates easily with a variety of tools, making your communications more efficient and reliable.

Methods of Sending Email

• SMTP: Gmail, Zoho, Custom Mail Servers, SendGrid
• 3rd-Party Service Providers: SendGrid, InfoBip, Bandwidth, and more

Without Transmitly

Typically, your first few email communications might involve using Simple Mail Transfer Protocol (SMTP) servers because it’s the simplest and fastest method to implement.

A common approach:

using System.Net;
using System.Net.Mail;
public class EmailService : IEmailService
{
  public void SendPasswordReminder(string toEmail, string subject, string body)
  {
      var fromAddress = new MailAddress("your-from-email@example.com", "Your Name");
      var toAddress = new MailAddress(toEmail);
      const string fromPassword = "your-email-password";

      var smtp = new SmtpClient
      {
          Host = "smtp.example.com",
          Port = 587,
          EnableSsl = true,
          DeliveryMethod = SmtpDeliveryMethod.Network,
          UseDefaultCredentials = false,
          Credentials = new NetworkCredential(fromAddress.Address, fromPassword)
      };

      using (var message = new MailMessage(fromAddress, toAddress)
      {
          Subject = subject,
          Body = body
      })
      {
          smtp.Send(message);
      }
  }
}

What’s Wrong with This Approach?

While this method works for low-volume emails, it has several limitations if you need to scale:

• Scalability Issues: Handling a high volume of emails can strain your SMTP server, especially if it’s not optimized for large-scale sending.
• Deliverability Concerns: Ensuring your emails land in the recipient’s inbox (and not their spam folder) requires constant monitoring and fine-tuning, often without much insight or tooling.
• Limited Features: Basic SMTP solutions lack advanced features like email templates, scheduling, and automated workflows.
• Security Risks: Directly managing email sending involves handling sensitive credentials and configurations, which increases the risk of security breaches.

The Transmitly Way

First, you need to install the nuget package:

# Install the base Transmitly package
dotnet install Transmitly

# We'll need the MailKit Transmitly package to use SMTP
dotnet install Transmitly.ChannelProvider.MailKit

# To make our lives easier, we'll use the optional MS DI extensions 
dotnet install Transmitly.Microsoft.Extensions.DependencyInjection

We need to do a little configuration first. In your Startup.cs

//All usual extensions and properties are located in this root namespace
using Transmitly;
...
//AddTransmitly comes from MS DI extensions library.
//Without the MS DI library, you can still wire up Transmitly using it's
//fluent builder.
services.AddTransmitly(tly=>{ 
  tly
  //AddMailKitSupport comes from the MailKit library
  //This allows us to setup what's needed in a strongly typed and central way
  .AddMailKitSupport(options =>
  {
    options.Host = "smtp.example.com";
    options.Port = 587;
    options.UseSsl = true;
    options.UserName = "MySMTPUsername";
    options.Password = "MyPassword";
  })
  //The simpliest example -- this allows you to quickly move from your 
  //existing code into transmitly.
  //Behind the scenes this is actually a Pipeline. Something you can learn
  //more about in the github docs
  .AddEmailMessage("SendPasswordReminder", "your-from-email@example.com", "Reset your password", "<a href=\"url.com/reset-password\">Click here to reset your password</a>")
})

At first glance, it looks similar to the original SMTP code. You still have credentials and email content, but now everything is centralized. Configuration is placed in your Startup.cs, but as your system grows, you can easily move this into its own class library.

With Transmitly, you’re also creating a communications pipeline, which gives you centralized control over your communications. You can manage what messages are available and which channel providers are used to send them. In short, you now have a loosely coupled, centralized way of managing your communications.

Next, let’s modify our original sending code:

using Transmitly;

public class EmailService : IEmailService
{
  public EmailService(ICommunicationsClient commsClient)
  {
    _commsClient = commsClient;
  }

  public async Task SendPasswordReminder(string toEmail)
  {
      var result = await _commsClient.Dispatch("SendPasswordReminder", toEmail);

      if (response.IsSuccessful)
      {
          Console.WriteLine("Email sent successfully!");
      }
      else
      {
          Console.WriteLine($"Failed to send email.");
      }
  }
}

That’s all there is to it! The code may look similar, but these changes open up several new possibilities:

• Change Channels: While today you might only need email, in the future, you might want to add push notifications or give users communication preferences. Transmitly lets you manage that easily with Pipelines, Channels, and Channel Providers.
• Change Providers: If SMTP gives you issues, you can quickly switch to another provider, like SendGrid, ZeptoMail, or AmazonSES, by adding a new Transmitly library and updating your configuration.

You now have the power and flexibility to grow your communication strategy in a safe, controlled, and testable manner.

Key Benefits of Using Transmitly

• Centralized Communication Management: Manage emails, SMS, and push notifications from one platform, reducing complexity and boosting efficiency.
• Flexible Configuration: Switch between service providers like SendGrid, Twilio, or MailKit without altering your code.
• Simplified Message Composition: Externalize message composition, making it easier to modify and manage your communication strategy.
• Scalability and Reliability: Designed for high-volume communications with reliable performance.
• Provider Agnostic: Integrates seamlessly with almost any communication service (e.g., Twilio, Infobip, SMTP).

Conclusion

Transactional emails are vital to modern applications, ensuring timely and effective communication with users. While traditional email-sending methods can be limiting, Transmitly offers a powerful alternative that simplifies the process, improves deliverability, and provides valuable insights. By integrating Transmitly into your app, you can ensure your transactional emails are sent efficiently and reliably, enhancing user experience and engagement.

For more information check out the Transmitly Github Repo.