DEV Community: Jeremy

Sending Transactional Emails with Transmitly (C#)

Jeremy — Tue, 29 Oct 2024 18:00:00 +0000

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 SMTP Transmitly package
dotnet install Transmitly.ChannelProvider.Smtp

# 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
  //AddSmtpSupport comes from the Smtp library
  //This allows us to setup what's needed in a strongly typed and central way
  .AddSmtpSupport(options =>
  {
    options.Host = "smtp.example.com";
    options.Port = 587;
    options.UseSsl = true;
    options.UserName = "MySMTPUsername";
    options.Password = "MyPassword";
  })
  //The simplest 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 SMTP 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.

Sending SMS with Transmitly (C#)

Jeremy — Wed, 23 Oct 2024 06:00:00 +0000

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

What is a transactional communication?

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

Order confirmations
Password reset requests
Account notifications
One time password (OTP)
Appointment reminders

What is Transmitly?

Methods of Sending SMS

SMS Gateway: Strangely enough, some carriers support sending SMS messages via special email addresses. They are generally not very reliable and you must know which provider your recipient is using.
3rd-Party Service Providers: Twilio, InfoBip, Plivo, and more

Without Transmitly

There’s quite a few options out there to choose from for SMS communications. There’s also a lot more restrictions to be allowed to send SMS with any service. We’ll assume you’ve made it through the hoops of getting setup and you’ve chosen Twilio.

Add the Twilio Api:

dotnet install Twilio

// Install the C# / .NET helper library from twilio.com/docs/csharp/install
using System;
using Twilio;
using Twilio.Rest.Api.V2010.Account;
using System.Threading.Tasks;

class SmsService {

    public static async Task OrderProcessed(string recipient) {

        // Find your Account SID and Auth Token at twilio.com/console
        // and set the environment variables. See http://twil.io/secure
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
        string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");

        TwilioClient.Init(accountSid, authToken);

        var message = await MessageResource.CreateAsync(
            body: "Your order is being processed, thanks!",
            from: new Twilio.Types.PhoneNumber("+15017122661"),
            to: new Twilio.Types.PhoneNumber(recipient));
        Console.WriteLine(message.Body);
    }
}

(Example take from the Twilio quick start)

What’s Wrong with This Approach?

On the surface, not a lot. Twilio and their SDK will work great for a long time.

More work to be done: Not shown is just how to deserialize the API response and make sense of it in your application.
Vendor Lock: The more communications, the more you’re going to use their API. That doesn’t pose a problem until something changes with their service. Price increases, API changes, etc are all going to cost you and your application.

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.Twilio
# 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
  //AddTwilioSupport comes from the Twilio library
  //This allows us to setup what's needed in a strongly typed and central way
  .AddTwilioSupport(twilio =>
  {
      twilio.AuthToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
      twilio.AccountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
  }
  .AddPipeline("OrderProcessing", pipeline=>
  {
    //AddSms is a core feature, a channel, of Transmitly
    //Out of the box there are Email, SMS, Voice and Push
    pipeline.AddSms(sms=>{
      //Transmitly is a bit different. All of our communication content is configured by using templates.
      //Out of the box, we have static or string templates, file and even embedded template support.
      //There are multiple types of templates to get you started. You can even create templates 
      //specific to certain cultures!
      sms.Body.AddStringTemplate("Your order is being processed, thanks!");
      //We've kept it simple for this example, but Transmitly also supports various template engines.
      //Adding a template engine can make your messages a bit more useful by showing the order# or user's name.
   });
})

At first glance, it looks similar to the original code. You still have credentials and SMS 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.

Next, let’s modify our original sending code:

using Transmitly;

public class SmsService
{
  private readonly ICommunicationsClient _commsClient;

  public EmailService(ICommunicationsClient commsClient)
  {
    _commsClient = commsClient;
  }

  public async Task OrderProcessed(string recipient)
  {
    //Dispatch (send) the transactional sms to our recipient using our configured Twilio account and our "OrderProcessing" pipeline.
    var result = await communicationsClient.DispatchAsync("OrderProcessing", "+15017122661".AsAudienceAddress(), new { });

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

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 SMS, in the future, you might want to add email, push notifications or better yet, let users set their communication preferences. Transmitly lets you manage that easily with Pipelines, Channels, and Channel Providers.
Change Providers: If Twilio gives you issues, you can quickly switch to another provider, like Infobip 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 or Infobip without altering your business logic.
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). Easily extensible for adding any missing features you might need.

Conclusion

Transactional communications are vital to modern applications, ensuring timely and effective communication with users. 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 communications are sent efficiently and reliably, enhancing user experience and engagement.

Peaked your interest? Check out the Transmitly Github Repo for more exciting ways to manage your business' communications strategies.

Transactional Emails: A long term view

Jeremy — Thu, 17 Oct 2024 01:59:40 +0000

Sending emails has become essential for almost all modern applications and games. The most common type of emails in your first app are transactional. Examples of transactional communications include order confirmations, password reset requests, account notifications, and appointment reminders. Luckily, Microsoft has made this task pretty simple out of the box. So much so that you may not put much thought into how you’re sending out your app’s communications. And that’s okay — we all have deadlines to meet.

Getting Started

Once you’ve identified the required transactional communications for your app, you need to decide how to send them. Again, you’re in luck here, too. You have a few different options when deciding how to send your emails. To keep things simple, you can start by using an established SMTP server. There are countless examples of how to use Gmail, Zoho, and other third-party SMTP services. It’s simple enough and will get you through development and even to the MVP phase.

As your app grows, you might notice you’re being rate-limited by the SMTP service, transient errors are creeping in, and your simple email solution is no longer holding up to the stress of your growing app. First of all, congrats! Your app is growing! Second, it’s time to revisit our communications strategy. You’re in luck here as well. Numerous third-party APIs make it even easier to send emails. Services such as SendGrid, Mailgun, and ZeptoMail all come with their own pros and cons and a wide range of features. Now, you can do some really neat things with your emails. Again, your communications strategy has evolved, and so has the complexity.

Smooth Sailing…

You’ve chosen a third-party service you love, and it’s working great. You’ve created an email service using their SDK. Now you can get back to growing your app, team, and business. Unfortunately, you receive an email from your third-party service. They are increasing their prices… again. Or worse, they’ve moved a feature you’ve been using heavily behind an expensive paywall.

It’s time to change your service… again. It’s generally not too big of a deal, right? …Right?! Integrating a new email service only took a day. But the app is growing quickly, we have tech debt throughout, and not all of our emails are consistent. It wasn’t a big deal, but the new service doesn’t handle our older, legacy formats.

While it may only be a mild annoyance that only rears its ugly head every few years, you’ve got a successful app. You don’t have time to learn a new service, a new API, all the quirks of a new service, and regression test all of your communications… again. This is why the open-source Transmitly communications library was created.

Transmit-Who?

The Transmitly library is an open-source library designed to manage and control outgoing transactional communications, including emails, SMS, and push notifications. It offers centralized communication management, allowing developers to handle multiple communication channels from a single platform.

Transmitly provides flexible configuration, enabling easy switching between SMTP and service providers like SendGrid, Twilio, and Infobip without altering domain code. It simplifies message composition and delivery and integrates seamlessly with various dependency injection containers and template engines.

And Now for Something Completely Different

Transmitly is built on concepts pioneered by Serilog, Microsoft, and many other extensibility-first libraries. At its core, Transmitly enables you to choose as much or as little integration as you have the time or effort to use.

Love the idea? Convert your whole codebase in a day or two. Not sure? Try it on only new transactional communications to start. It’s up to you.

All this extensibility doesn’t come without some downsides. There’s going to be a ‘different’ way of doing things. And with different, there come some new terms we need to understand before we can really grasp the full scope of what’s possible.

Channels

A channel is the base of all communications. Out of the box, Transmitly supports email, SMS, voice and push notifications. But you’re not limited to these channels. Transmitly is built with extensibility in mind at all times. This means that if you have an idea for a channel; such as physical mail, fax, or Slack, practically any kind of channel can be built in.

Channel Providers

Channel Providers do the heavy lifting for your Channels. A Channel Provider can support one to many channels. Examples include SMTP (Email), SendGrid (Email), Infobip (Email & SMS), or Firebase (iOS/Android/App push notifications).

Pipelines

Pipelines are where the real power of Transmitly starts to materialize. With a pipeline, you gain control of managing communications in a single location. You can also manage which communications are available and which channel providers are allowed to send them.

That’s it! For now, at least. There are a few more advanced concepts that make the Transmitly transition even sweeter. For now, we’re sticking to the basics to get you up to speed ASAP. After all, you have a fast-growing application to maintain!

Writing Code

First, you’ll need to install the Transmitly NuGet library in your app:

# Install the base Transmitly package
dotnet install Transmitly

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

Next, we’ll continue with our email theme by recreating a welcome email that is sent to a newly signed-up user of your app.

Startup.cs

using Transmitly;

var builder = WebApplication.CreateBuilder(args);
var emailConfig = builder.Configuration.GetRequiredSection("EmailSettings").Get<EmailSettingsConfiguration>();

builder.Services.AddTransmitly(tly =>
{
    // Pipelines allow you to define your communications
    // as a domain action. This allows your domain code to 
    // stay agnostic to the details of how you
    // may send out a transactional communication.

    // Notice "WelcomeKit" doesn't specify the how or what
    // might be sent. This is our 'intent'. It's up to our configuration
    // or domain if any communications will spawn and to whom.
    tly.AddPipeline("WelcomeKit", pipeline =>
    {
        // AsIdentityAddress() is also a convenience method that helps us create an audience identity
        // Identity addresses can be anything: email, phone, or even a device/app ID for push notifications!
        pipeline.AddEmail("welcome@my.app".AsIdentityAddress("Welcome Committee"), email =>
        {
            // Transmitly is a bit different. Most channel content is configured by using 
            // templates. The immediate benefit out of the box is being able to configure
            // culture-based templates. 
            // For this example, we'll keep things simple and send a static message.
            // But as you may have guessed, Transmitly also has Template Engine plugins as well.
            email.Subject.AddStringTemplate("Thanks for creating an account!");
            email.HtmlBody.AddStringTemplate("Check out the <a href=\"https://my.app/getting-started\">Getting Started</a> section to see all the cool things you can do!");
            email.TextBody.AddStringTemplate("Check out the Getting Started (https://my.app/getting-started) section to see all the cool things you can do!");
        });
    });

Next, we can trigger this welcome kit to happen in the same place we used to send our email. Note how simple your domain logic becomes when we remove communications details.

Using Transmitly:

public class RegistrationService
{
    private readonly ICommunicationsClient _commsClient;

    public RegistrationService(ICommunicationsClient commsClient)
    {
        _commsClient = commsClient ?? throw new ArgumentNullException(nameof(commsClient));
    }

    public async Task<User> RegisterUser(string email, AccountDetail detail)
    {
        // Create user
        var newUser = new User(email);
        // Trigger the welcome kit email
        var result = await _commsClient.DispatchAsync("WelcomeKit", email, TransactionalModel.Create(new { }));
        if (result.IsSuccessful)
            return newUser;
        throw new RegistrationException("Registration failed. Rollback!");
    }
}

If you run this new code… technically, it will work. However, you’ll be disappointed that you’re no longer sending emails. This is because we have not yet defined the 'how' of sending the emails out. With Transmitly, the 'how' or services are referred to as Channel Providers. Channel Providers are what the name implies: they are providers for any given channel. Examples of channel providers are SMTP, Twilio, SendGrid, Infobip etc.

# We want to continue using SMTP for now, so we'll add the SMTP extension
dotnet install Transmitly.ChannelProvider.Smtp

Now we can configure the SMTP server settings Transmitly will use for our pipeline intent, 'WelcomeKit'.

using Transmitly;

var builder = WebApplication.CreateBuilder(args);
var emailConfig = builder.Configuration.GetRequiredSection("EmailSettings").Get<EmailSettingsConfiguration>();

builder.Services.AddTransmitly(tly =>
{
    // Configure the SMTP Channel Provider Settings
    tly.AddSmtpSupport(smtp =>
    {
        smtp.Host = emailConfig.Host;
        smtp.Port = emailConfig.Port;
        smtp.UserName = emailConfig.Username;
        smtp.Password = emailConfig.Password;
    })
    // Pipelines allow you to define your communications
    // as a domain action. This allows your domain code to 
    // stay agnostic to the details of how you
    // may send out a transactional communication.
    .AddPipeline("WelcomeKit", pipeline =>
    {
        // AsIdentityAddress() is also a convenience method that helps us create an audience identity
        // Identity addresses can be anything: email, phone, or even a device/app ID for push notifications!
        pipeline.AddEmail("welcome@my.app".AsIdentityAddress("Welcome Committee"), email =>
        {
            // Transmitly is a bit different. Most channel content is configured by using 
            // templates. The immediate benefit out of the box is being able to configure
            // culture-based templates. 
            // For this example, we'll keep things simple and send a static message.
            // But as you may have guessed, Transmitly also has Template Engine plugins as well.
            email.Subject.AddStringTemplate("Thanks for creating an account!");
            email.HtmlBody.AddStringTemplate("Check out the <a href=\"https://my.app/getting-started\">Getting Started</a> section to see all the cool things you can do!");
            email.TextBody.AddStringTemplate("Check out the Getting Started (https://my.app/getting-started) section to see all the cool things you can do!");
        });
    });

After deploying your code, sending a simple email can remain just as easy as it was before.

If SMTP doesn’t quite fit the bill for your app anymore, try a different channel provider.

Adding SMS or push notifications? Communication preferences? Modify your pipelines to effortlessly add new channels. Handling your user communication preferences are just as easy.

Conclusion

As your app grows and evolves, having a flexible and scalable communication strategy is crucial. Transmitly not only simplifies the process of sending transactional communications but also provides a robust framework for handling various channels and channel providers. This reduces the time spent managing communication logic and enables you to focus on building and improving your core application.

Check out the Transmitly Github repo if you're interested in learning more!

Happy holidays from the C# Advent Calendar 2024!

Transactional Emails: From SMTP to Transmitly

Jeremy — Mon, 02 Sep 2024 21:21:06 +0000

Getting Started

Smooth Sailing…

Transmit-Who?

Transmitly provides flexible configuration, enabling easy switching between SMTP (MailKit) and service providers like SendGrid, Twilio, and Infobip without altering domain code. It simplifies message composition and delivery and integrates seamlessly with various dependency injection containers and template engines.

And Now for Something Completely Different

Love the idea? Convert your whole codebase in a day or two. Not sure? Try it on only new transactional communications to start. It’s up to you.

Channels

A channel is the base of all communications. Out of the box, Transmitly supports email, SMS, and push notifications. But you’re not limited to these channels. Transmitly is built with extensibility in mind at all times. This means that if you have a need for any kind of channel, such as physical mail, fax, or Slack, practically any kind of channel can be built in.

Channel Providers

Channel Providers do the heavy lifting for your Channels. A Channel Provider can support one to many channels. Examples include MailKit (SMTP Email), SendGrid (Email), Infobip (Email & SMS), or Firebase (iOS/Android/App push notifications).

Pipelines

Writing Code

First, you’ll need to install the Transmitly NuGet library in your app:

# Install the base Transmitly package
dotnet install Transmitly

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

Next, we’ll continue with our email theme by recreating a welcome email that is sent to a newly signed-up user of your app.

Startup.cs

using Transmitly;

var builder = WebApplication.CreateBuilder(args);
var emailConfig = builder.Configuration.GetRequiredSection("EmailSettings").Get<EmailSettingsConfiguration>();

builder.Services.AddTransmitly(tly =>
{
    // Pipelines allow you to define your communications
    // as a domain action. This allows your domain code to 
    // stay agnostic to the details of how you
    // may send out a transactional communication.
    tly.AddPipeline("WelcomeKit", pipeline =>
    {
        // AsIdentityAddress() is also a convenience method that helps us create an audience identity
        // Identity addresses can be anything: email, phone, or even a device/app ID for push notifications!
        pipeline.AddEmail("welcome@my.app".AsIdentityAddress("Welcome Committee"), email =>
        {
            // Transmitly is a bit different. Most channel content is configured by using 
            // templates. The immediate benefit out of the box is being able to configure
            // culture-based templates. 
            // For this example, we'll keep things simple and send a static message.
            // But as you may have guessed, Transmitly also has Template Engine plugins as well.
            email.Subject.AddStringTemplate("Thanks for creating an account!");
            email.HtmlBody.AddStringTemplate("Check out the <a href=\"https://my.app/getting-started\">Getting Started</a> section to see all the cool things you can do!");
            email.TextBody.AddStringTemplate("Check out the Getting Started (https://my.app/getting-started) section to see all the cool things you can do!");
        });
    });

Next, we can trigger this welcome kit to happen in the same place we used to send our email. Note how simple your domain logic becomes when we remove communications details.

Using Transmitly:

public class RegistrationService
{
    private readonly ICommunicationsClient _commsClient;

    public RegistrationService(ICommunicationsClient commsClient)
    {
        _commsClient = commsClient ?? throw new ArgumentNullException(nameof(commsClient));
    }

    public async Task<User> RegisterUser(string email, AccountDetail detail)
    {
        // Create user
        var newUser = new User(email);
        // Trigger the welcome kit email
        var result = await _commsClient.DispatchAsync("WelcomeKit", email, TransactionalModel.Create(new { }));
        if (result.IsSuccessful)
            return newUser;
        throw new RegistrationException("Registration failed. Rollback!");
    }
}

If you run this new code… technically, it will work. However, you’ll be disappointed that you’re no longer sending emails. This is because we have not yet defined the ‘how’ of sending the emails out. With Transmitly, the “how” or services are referred to as Channel Providers. Channel Providers are what the name implies: they are providers for any given channel (email, SMS, push, etc.).

# We want to continue using SMTP for now, so we'll add the MailKit extension
dotnet install Transmitly.ChannelProvider.MailKit

Now we can configure the SMTP server settings Transmitly will use for our WelcomeKit.

using Transmitly;

var builder = WebApplication.CreateBuilder(args);
var emailConfig = builder.Configuration.GetRequiredSection("EmailSettings").Get<EmailSettingsConfiguration>();

builder.Services.AddTransmitly(tly =>
{
    // Configure the MailKit Channel Provider Settings
    tly.AddMailKitSupport(mailkit =>
    {
        mailkit.Host = emailConfig.Host;
        mailkit.UseSsl = emailConfig.UseSsl;
        mailkit.Port = emailConfig.Port;
        mailkit.UserName = emailConfig.Username;
        mailkit.Password = emailConfig.Password;
    })
    // Pipelines allow you to define your communications
    // as a domain action. This allows your domain code to 
    // stay agnostic to the details of how you
    // may send out a transactional communication.
    .AddPipeline("WelcomeKit", pipeline =>
    {
        // AsIdentityAddress() is also a convenience method that helps us create an audience identity
        // Identity addresses can be anything: email, phone, or even a device/app ID for push notifications!
        pipeline.AddEmail("welcome@my.app".AsIdentityAddress("Welcome Committee"), email =>
        {
            // Transmitly is a bit different. Most channel content is configured by using 
            // templates. The immediate benefit out of the box is being able to configure
            // culture-based templates. 
            // For this example, we'll keep things simple and send a static message.
            // But as you may have guessed, Transmitly also has Template Engine plugins as well.
            email.Subject.AddStringTemplate("Thanks for creating an account!");
            email.HtmlBody.AddStringTemplate("Check out the <a href=\"https://my.app/getting-started\">Getting Started</a> section to see all the cool things you can do!");
            email.TextBody.AddStringTemplate("Check out the Getting Started (https://my.app/getting-started) section to see all the cool things you can do!");
        });
    });

After deploying your code, sending a simple email can remain just as easy as it was before.

If SMTP doesn’t quite fit the bill for your app anymore, try a different channel provider.

Adding SMS or push notifications? Communication preferences? Modify your pipelines to effortlessly add new channels. Handling your user communication preferences are just as easy.

Conclusion

Check out the github repo for more details and examples of all the great things Transmitly can do.