Blazor 中的 SendGrid email 服务 - 依赖注入或 Static 方法

Question

I am setting up a SendGrid email sender in a Blazor app (.NET 5).

Per the SendGrid docs and examples, they are writing a method signed as static async Task and then they await the response from their api. Their example code just runs immediately from Main() and doesn't show any method calls.

Does using this as a static method violate how I should be using Dependency Injenction? Shouldn't I register this EmailSender class as a service with Dependency Injection and then inject it in my components that need to send emails?

Code from SendGrid example:

private static void Main()
{
    Execute().Wait();
}

static async Task Execute()
{
    //Boilerplate code setting up email from/to/apiKey etc removed
    var response = await client.SendEmailAsync(msg);
}

With this setup, I could make the Execute() method public and then call it directly as a static method.

Would it be more appropriate to make something like the following:

public class EmailService
{
    public async Task SendEmail(string to, string subject, string message)
    {
        //Boilerplate code setting up email from/to/apiKey etc removed
        var response = await client.SendEmailAsync(msg);
    }
}

Then I could inject and use the service via DI, like:

@inject EmailService emailService

@code {
    //Calling line below in the appropriate spot
    await emailService.SendEmail(to, subject, message);
}

Answer 1

A generalized implementation in .NET Core:

Startup.cs

using SendGrid.Extensions.DependencyInjection; // nuget package

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // sendgrid
        services.AddSendGrid(options =>
        {
            options.ApiKey = Environment.GetEnvironmentVariable("SENDGRID_API_KEY");
        });
    }
}

EmailController.cs

using SendGrid; // nuget package

public class EmailController : ControllerBase
{
    private ISendGridClient = sendGridClient;
    
    public EmailController(ISendGridClient sendGridClient)
    {
        _sendGridClient = sendGridClient;
    }
    
    public IActionResult SendEmail(Email email)
    {
        var emailManager = new EmailManager(_sendGridClient);
        return emailManager.SendEmail(email);
    }
}

EmailManager.cs

using SendGrid;

public class EmailManager
{
    private ISendGridClient = _sendGridClient;
    
    public EmailManager(ISendGridClient sendGridClient)
    {
        _sendGridClient = sendGridClient;
    }
    
    public bool SendEmail(Email email)
    {
        ...
        var response = await _sendGridClient.SendEmailAsync(msg);
        ...
    }
}

Answer 2

An example for NET 6 Web API with Controllers

https://github.com/Davidmendoza1987/dotnet-sendgrid-examples

You will need the following nuget packages installed

• SendGrid
• SendGrid.Extensions.DependencyInjection

Program.cs

using SendGridExample.Net6.V1.Extensions;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Custom Code
builder.Services.AddThirdPartyServices();
builder.Services.AddRepositories();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();    
app.UseAuthorization();    
app.MapControllers();

app.Run();

ServiceCollectionExtensions.cs

using SendGrid;
using SendGrid.Extensions.DependencyInjection;
using SendGridExample.Net6.V1.Repositories;

namespace SendGridExample.Net6.V1.Extensions;

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddThirdPartyServices(this IServiceCollection servicesCollection)
    {
        var sendGridApiKey = Environment.GetEnvironmentVariable("SENDGRID_API_KEY");
        if (sendGridApiKey is null)
        {
            throw new ArgumentNullException(sendGridApiKey, "SendGrid API key has not been configured"); 
        }

        servicesCollection.AddSendGrid(options => options.ApiKey = sendGridApiKey);

        return servicesCollection;
    }

    public static IServiceCollection AddRepositories(this IServiceCollection servicesCollection)
    {
        servicesCollection.AddTransient<ISendGridRepository, SendGridRepository>(x =>
            new SendGridRepository(x.GetRequiredService<ISendGridClient>()));

        return servicesCollection;
    }    
}

SendEmailRequest.cs

using System.ComponentModel.DataAnnotations;

namespace SendGridExample.Net6.V1.Models;

public class SendEmailRequest
{
    [Required]
    public List<string> To { get; set; } = new List<string>();

    [Required]
    public string From { get; set; } = string.Empty;

    [Required]
    public string FromName { get; set; } = string.Empty;

    [Required]
    public string Subject { get; set; } = string.Empty;

    public string? PlainTextContent { get; set; }

    public string? HtmlContent { get; set; }

    public bool? ShowAllRecipients { get; set; } = false;
}

SendGridController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using SendGrid;
using SendGridExample.Net6.V1.Models;
using SendGridExample.Net6.V1.Repositories;

namespace SendGridExample.Net6.Controllers;

[ApiController]
[Route("[controller]")]
public class SendGridController : ControllerBase
{
    private readonly ISendGridRepository sendGridRepository;

    public SendGridController(ISendGridRepository sendGridRepository) => this.sendGridRepository = sendGridRepository;

    [HttpPost("send-email")]
    [ProducesResponseType(typeof(Response), StatusCodes.Status200OK)]
    public async Task<ActionResult<Response>> SendEmail([FromBody, BindRequired] SendEmailRequest request)
    {
        if (string.IsNullOrWhiteSpace(request.PlainTextContent) &&
            string.IsNullOrWhiteSpace(request.HtmlContent))
        {
            return BadRequest("Either PlainTextContent or HtmlContent must be provided.");
        }

        var response = await sendGridRepository.SendTransactionEmailAsync(request);
        return StatusCode((int)response.StatusCode, response);
    }
}

SendGridRepository.cs

using SendGrid;
using SendGrid.Helpers.Mail;
using SendGridExample.Net6.V1.Models;

namespace SendGridExample.Net6.V1.Repositories;

public interface ISendGridRepository
{
    Task<Response> SendTransactionEmailAsync(SendEmailRequest request);
}

public class SendGridRepository : ISendGridRepository
{
    private readonly ISendGridClient sendGridClient;

    public SendGridRepository(ISendGridClient sendGridClient) => this.sendGridClient = sendGridClient;

    public async Task<Response> SendTransactionEmailAsync(SendEmailRequest request)
    {
        var toAddresses = request.To.Select(n => new EmailAddress(n)).ToList();
        var fromAddress = new EmailAddress(request.From, request.FromName);
        var msg = MailHelper.CreateSingleEmailToMultipleRecipients(fromAddress, toAddresses, request.Subject, request.PlainTextContent, request.HtmlContent, request.ShowAllRecipients!.Value);

        return await sendGridClient.SendEmailAsync(msg);
    }
}