AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Asp.Net Core 快速邮件队列设计与实现

2018-07-11 1866
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 发送邮件几乎是软件系统中必不可少的功能，在Asp.Net Core 中我们可以使用MailKit发送邮件，MailKit发送邮件比较简单，网上有许多可以参考的文章，但是应该注意附件名长度，和附件名不能出现中文的问题，如果你遇到了这样的问题可以参考我之前写的这篇博客Asp.Net Core MailKit 完美附件（中文名、长文件名）。

发送邮件几乎是软件系统中必不可少的功能，在Asp.Net Core 中我们可以使用MailKit发送邮件，MailKit发送邮件比较简单，网上有许多可以参考的文章，但是应该注意附件名长度，和附件名不能出现中文的问题，如果你遇到了这样的问题可以参考我之前写的这篇博客Asp.Net Core MailKit 完美附件（中文名、长文件名）。

在我们简单搜索网络，并成功解决了附件的问题之后，我们已经能够发送邮件啦！不过另一个问题显现出来——发送邮件太慢了，没错，在我使用QQ邮箱发送时，单封邮件发送大概要用1.5秒左右，用户可能难以忍受请求发生1.5秒的延迟。

所以，我们必须解决这个问题，我们的解决办法就是使用邮件队列来发送邮件

设计邮件队列

Ok， 第一步就是规划我们的邮件队列有什么

EmailOptions

我们得有一个邮件Options类，来存储邮件相关的选项

/// <summary>
/// 邮件选项
/// </summary>
public class EmailOptions
{
    public bool DisableOAuth { get; set; }
    public string DisplayName { get; set; }
    public string Host { get; set; } // 邮件主机地址
    public string Password { get; set; }
    public int Port { get; set; }
    public string UserName { get; set; }
    public int SleepInterval { get; set; } = 3000;
    ...

SleepInterval 是睡眠间隔，因为目前我们实现的队列是进程内的独立线程，发送器会循环读取队列，当队列是空的时候，我们应该让线程休息一会，不然无限循环会消耗大量CPU资源

然后我们还需要的就是 一个用于存储邮件的队列，或者叫队列提供器，总之我们要将邮件存储起来。以及一个发送器，发送器不断的从队列中读取邮件并发送。还需要一个邮件写入工具，想要发送邮件的代码使用写入工具将邮件转储到队列中。

那么我们设计的邮件队列事实上就有了三个部分：

  • 队列存储提供器（邮件的事实存储）
  • 邮件发送机 （不断读取队列中的邮件，并发送）
  • 邮件服务 （想法送邮件时，调用邮件服务，邮件服务会将邮件写入队列）

队列存储提供器设计

那么我们设计的邮件队列提供器接口如下：

public interface IMailQueueProvider
{
    void Enqueue(MailBox mailBox);
    bool TryDequeue(out MailBox mailBox);
    int Count { get; }
    bool IsEmpty { get; }
    ...

四个方法，入队、出队、队列剩余邮件数量、队列是否是空，我们对队列的基本需求就是这样。

MailBox是对邮件的封装，并不复杂，稍后会介绍到

邮件服务设计

public interface IMailQueueService
{
    void Enqueue(MailBox box);

对于想要发送邮件的组件或者代码部分来讲，只需要将邮件入队，这就足够了

邮件发送机（兼邮件队列管理器）设计

public interface IMailQueueManager
{
    void Run();
    void Stop();
    bool IsRunning { get; }
    int Count { get; }

启动队列，停止队列，队列运行中状态，邮件计数

现在，三个主要部分就设计好了，我们先看下MailBox，接下来就去实现这三个接口

MailBox

MailBox 如下：

public class MailBox
{
    public IEnumerable<IAttachment> Attachments { get; set; }
    public string Body { get; set; }
    public IEnumerable<string> Cc { get; set; }
    public bool IsHtml { get; set; }
    public string Subject { get; set; }
    public IEnumerable<string> To { get; set; }
    ...

这里面没什么特殊的，大家一看便能理解，除了IEnumerable<IAttachment> Attachments { get; set; }。

附件的处理

在发送邮件中最复杂的就是附件了，因为附件体积大，往往还涉及非托管资源（例如：文件），所以附件处理一定要小心，避免留下漏洞和bug。

在MailKit中附件实际上是流Stream，例如下面的代码：

attachment = new MimePart(contentType)
{
    Content = new MimeContent(fs),
    ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
    ContentTransferEncoding = ContentEncoding.Base64,
};

其中new MimeContent(fs)是创建的Content，fs是Stream，MimeContent的构造函数如下：

public MimeContent(Stream stream, ContentEncoding encoding = ContentEncoding.Default)

所以我们的设计的附件是基于Stream的。

一般情况附件是磁盘上的文件，或者内存流MemoryStream或者 byte[]数据。附件需要实际的文件的流Stream和一个附件名，所以附件接口设计如下：

public interface IAttachment : IDisposable
{
    Stream GetFileStream();
    string GetName();

那么我们默认实现了两中附件类型 物理文件附件和内存文件附件，byte[]数据可以轻松的转换成 内存流，所以没有写这种

MemoryStreamAttechment

public class MemoryStreamAttechment : IAttachment
{
    private readonly MemoryStream _stream;
    private readonly string _fileName;
    public MemoryStreamAttechment(MemoryStream stream, string fileName)
    {
        _stream = stream;
        _fileName = fileName;
    }

    public void Dispose()
        => _stream.Dispose();

    public Stream GetFileStream()
        => _stream;

    public string GetName()
        => _fileName;

内存流附件实现要求在创建时传递一个 MemoryStream和附件名称，比较简单

物理文件附件

public class PhysicalFileAttachment : IAttachment
{
    public PhysicalFileAttachment(string absolutePath)
    {
        if (!File.Exists(absolutePath))
        {
            throw new FileNotFoundException("文件未找到", absolutePath);
        }
        AbsolutePath = absolutePath;
    }

    private FileStream _stream;
    public string AbsolutePath { get; }
    public void Dispose()
    {
        _stream.Dispose();
    }

    public Stream GetFileStream()
    {
        if (_stream == null)
        {
            _stream = new FileStream(AbsolutePath, FileMode.Open);
        }
        return _stream;
    }

    public string GetName()
    {
        return System.IO.Path.GetFileName(AbsolutePath);
    ...

这里，我们要注意的是创建FileStream的时机，是在请求GetFileStream方法时，而不是构造函数中，因为创建FileStreamFileStream会占用文件，如果我们发两封邮件使用了同一个附件，那么会抛出异常。而写在GetFileStream方法中相对比较安全（除非发送器是并行的）

实现邮件队列

在我们这篇文章中，我们实现的队列提供器是基于内存的，日后呢我们还可以实现其它的基于其它存储模式的，比如数据库，外部持久性队列等等，另外基于内存的实现不是持久的，一旦程序崩溃。未发出的邮件就会boom然后消失 XD...

邮件队列提供器IMailQueueProvider实现

代码如下：

public class MailQueueProvider : IMailQueueProvider
{
    private static readonly ConcurrentQueue<MailBox> _mailQueue = new ConcurrentQueue<MailBox>();
    public int Count => _mailQueue.Count;
    public bool IsEmpty => _mailQueue.IsEmpty;
    public void Enqueue(MailBox mailBox)
    {
        _mailQueue.Enqueue(mailBox);
    }
    public bool TryDequeue(out MailBox mailBox)
    {
        return _mailQueue.TryDequeue(out mailBox);
    }

本文的实现是一个 ConcurrentQueue

邮件服务IMailQueueService实现

代码如下：

public class MailQueueService : IMailQueueService
{
    private readonly IMailQueueProvider _provider;

    /// <summary>
    /// 初始化实例
    /// </summary>
    /// <param name="provider"></param>
    public MailQueueService(IMailQueueProvider provider)
    {
        _provider = provider;
    }

    /// <summary>
    /// 入队
    /// </summary>
    /// <param name="box"></param>
    public void Enqueue(MailBox box)
    {
        _provider.Enqueue(box);
    }

这里，我们的服务依赖于IMailQueueProvider，使用了其入队功能

邮件发送机IMailQueueManager实现

这个相对比较复杂，我们先看下完整的类，再逐步解释：

public class MailQueueManager : IMailQueueManager
{
    private readonly SmtpClient _client;
    private readonly IMailQueueProvider _provider;
    private readonly ILogger<MailQueueManager> _logger;
    private readonly EmailOptions _options;
    private bool _isRunning = false;
    private bool _tryStop = false;
    private Thread _thread;

    /// <summary>
    /// 初始化实例
    /// </summary>
    /// <param name="provider"></param>
    /// <param name="options"></param>
    /// <param name="logger"></param>
    public MailQueueManager(IMailQueueProvider provider, IOptions<EmailOptions> options, ILogger<MailQueueManager> logger)
    {
        _options = options.Value;

        _client = new SmtpClient
        {
            // For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
            ServerCertificateValidationCallback = (s, c, h, e) => true
        };

        // Note: since we don't have an OAuth2 token, disable
        // the XOAUTH2 authentication mechanism.

        if (_options.DisableOAuth)
        {
            _client.AuthenticationMechanisms.Remove("XOAUTH2");
        }

        _provider = provider;
        _logger = logger;
    }

    /// <summary>
    /// 正在运行
    /// </summary>
    public bool IsRunning => _isRunning;

    /// <summary>
    /// 计数
    /// </summary>
    public int Count => _provider.Count;

    /// <summary>
    /// 启动队列
    /// </summary>
    public void Run()
    {
        if (_isRunning || (_thread != null && _thread.IsAlive))
        {
            _logger.LogWarning("已经运行，又被启动了,新线程启动已经取消");
            return;
        }
        _isRunning = true;
        _thread = new Thread(StartSendMail)
        {
            Name = "PmpEmailQueue",
            IsBackground = true,
        };
        _logger.LogInformation("线程即将启动");
        _thread.Start();
        _logger.LogInformation("线程已经启动，线程Id是：{0}", _thread.ManagedThreadId);
    }

    /// <summary>
    /// 停止队列
    /// </summary>
    public void Stop()
    {
        if (_tryStop)
        {
            return;
        }
        _tryStop = true;
    }

    private void StartSendMail()
    {
        var sw = new Stopwatch();
        try
        {
            while (true)
            {
                if (_tryStop)
                {
                    break;
                }

                if (_provider.IsEmpty)
                {
                    _logger.LogTrace("队列是空，开始睡眠");
                    Thread.Sleep(_options.SleepInterval);
                    continue;
                }
                if (_provider.TryDequeue(out MailBox box))
                {
                    _logger.LogInformation("开始发送邮件 标题：{0},收件人 {1}", box.Subject, box.To.First());
                    sw.Restart();
                    SendMail(box);
                    sw.Stop();
                    _logger.LogInformation("发送邮件结束标题：{0},收件人 {1},耗时{2}", box.Subject, box.To.First(), sw.Elapsed.TotalSeconds);
                }
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "循环中出错,线程即将结束");
            _isRunning = false;
        }

        _logger.LogInformation("邮件发送线程即将停止，人为跳出循环，没有异常发生");
        _tryStop = false;
        _isRunning = false;
    }

    private void SendMail(MailBox box)
    {
        if (box == null)
        {
            throw new ArgumentNullException(nameof(box));
        }

        try
        {
            MimeMessage message = ConvertToMimeMessage(box);
            SendMail(message);
        }
        catch (Exception exception)
        {
            _logger.LogError(exception, "发送邮件发生异常主题：{0},收件人：{1}", box.Subject, box.To.First());
        }
        finally
        {
            if (box.Attachments != null && box.Attachments.Any())
            {
                foreach (var item in box.Attachments)
                {
                    item.Dispose();
                }
            }
        }
    }

    private MimeMessage ConvertToMimeMessage(MailBox box)
    {
        var message = new MimeMessage();

        var from = InternetAddress.Parse(_options.UserName);
        from.Name = _options.DisplayName;

        message.From.Add(from);
        if (!box.To.Any())
        {
            throw new ArgumentNullException("to必须含有值");
        }
        message.To.AddRange(box.To.Convert());
        if (box.Cc != null && box.Cc.Any())
        {
            message.Cc.AddRange(box.Cc.Convert());
        }

        message.Subject = box.Subject;

        var builder = new BodyBuilder();

        if (box.IsHtml)
        {
            builder.HtmlBody = box.Body;
        }
        else
        {
            builder.TextBody = box.Body;
        }

        if (box.Attachments != null && box.Attachments.Any())
        {
            foreach (var item in GetAttechments(box.Attachments))
            {
                builder.Attachments.Add(item);
            }
        }

        message.Body = builder.ToMessageBody();
        return message;
    }

    private void SendMail(MimeMessage message)
    {
        if (message == null)
        {
            throw new ArgumentNullException(nameof(message));
        }

        try
        {
            _client.Connect(_options.Host, _options.Port, false);
            // Note: only needed if the SMTP server requires authentication
            if (!_client.IsAuthenticated)
            {
                _client.Authenticate(_options.UserName, _options.Password);
            }
            _client.Send(message);
        }
        finally
        {
            _client.Disconnect(false);
        }
    }

    private AttachmentCollection GetAttechments(IEnumerable<IAttachment> attachments)
    {
        if (attachments == null)
        {
            throw new ArgumentNullException(nameof(attachments));
        }

        AttachmentCollection collection = new AttachmentCollection();
        List<Stream> list = new List<Stream>(attachments.Count());

        foreach (var item in attachments)
        {
            var fileName = item.GetName();
            var fileType = MimeTypes.GetMimeType(fileName);
            var contentTypeArr = fileType.Split('/');
            var contentType = new ContentType(contentTypeArr[0], contentTypeArr[1]);
            MimePart attachment = null;
            Stream fs = null;
            try
            {
                fs = item.GetFileStream();
                list.Add(fs);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "读取文件流发生异常");
                fs?.Dispose();
                continue;
            }

            attachment = new MimePart(contentType)
            {
                Content = new MimeContent(fs),
                ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
                ContentTransferEncoding = ContentEncoding.Base64,
            };

            var charset = "UTF-8";
            attachment.ContentType.Parameters.Add(charset, "name", fileName);
            attachment.ContentDisposition.Parameters.Add(charset, "filename", fileName);

            foreach (var param in attachment.ContentDisposition.Parameters)
            {
                param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
            }

            foreach (var param in attachment.ContentType.Parameters)
            {
                param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
            }

            collection.Add(attachment);
        }
        return collection;
    }
}

在构造函数中请求了另外三个服务，并且初始化了SmtpClient（这是MailKit中的）

    public MailQueueManager(
        IMailQueueProvider provider, 
        IOptions<EmailOptions> options, 
        ILogger<MailQueueManager> logger)
    {
        _options = options.Value;

        _client = new SmtpClient
        {
            // For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
            ServerCertificateValidationCallback = (s, c, h, e) => true
        };

        // Note: since we don't have an OAuth2 token, disable
        // the XOAUTH2 authentication mechanism.

        if (_options.DisableOAuth)
        {
            _client.AuthenticationMechanisms.Remove("XOAUTH2");
        }

        _provider = provider;
        _logger = logger;
    }

启动队列时创建了新的线程，并且将线程句柄保存起来：

    public void Run()
    {
        if (_isRunning || (_thread != null && _thread.IsAlive))
        {
            _logger.LogWarning("已经运行，又被启动了,新线程启动已经取消");
            return;
        }
        _isRunning = true;
        _thread = new Thread(StartSendMail)
        {
            Name = "PmpEmailQueue",
            IsBackground = true,
        };
        _logger.LogInformation("线程即将启动");
        _thread.Start();
        _logger.LogInformation("线程已经启动，线程Id是：{0}", _thread.ManagedThreadId);
    }

线程启动时运行了方法StartSendMail：

    private void StartSendMail()
    {
        var sw = new Stopwatch();
        try
        {
            while (true)
            {
                if (_tryStop)
                {
                    break;
                }

                if (_provider.IsEmpty)
                {
                    _logger.LogTrace("队列是空，开始睡眠");
                    Thread.Sleep(_options.SleepInterval);
                    continue;
                }
                if (_provider.TryDequeue(out MailBox box))
                {
                    _logger.LogInformation("开始发送邮件 标题：{0},收件人 {1}", box.Subject, box.To.First());
                    sw.Restart();
                    SendMail(box);
                    sw.Stop();
                    _logger.LogInformation("发送邮件结束标题：{0},收件人 {1},耗时{2}", box.Subject, box.To.First(), sw.Elapsed.TotalSeconds);
                }
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "循环中出错,线程即将结束");
            _isRunning = false;
        }

        _logger.LogInformation("邮件发送线程即将停止，人为跳出循环，没有异常发生");
        _tryStop = false;
        _isRunning = false;
    }

这个方法不断的从队列读取邮件并发送，当 遇到异常，或者_tryStop为true时跳出循环，此时线程结束，注意我们会让线程睡眠，在适当的时候。

接下来就是方法SendMail了：

    private void SendMail(MailBox box)
    {
        if (box == null)
        {
            throw new ArgumentNullException(nameof(box));
        }

        try
        {
            MimeMessage message = ConvertToMimeMessage(box);
            SendMail(message);
        }
        catch (Exception exception)
        {
            _logger.LogError(exception, "发送邮件发生异常主题：{0},收件人：{1}", box.Subject, box.To.First());
        }
        finally
        {
            if (box.Attachments != null && box.Attachments.Any())
            {
                foreach (var item in box.Attachments)
                {
                    item.Dispose();
                ...

这里有一个特别要注意的就是在发送之后释放附件(非托管资源)：

foreach (var item in box.Attachments)
{
    item.Dispose();
    ...

发送邮件的核心代码只有两行：

MimeMessage message = ConvertToMimeMessage(box);
SendMail(message);

第一行将mailbox转换成 MailKit使用的MimeMessage实体，第二步切实的发送邮件

为什么，我们的接口中没有直接使用MimeMessage而是使用MailBox？

因为MimeMessage比较繁杂，而且附件的问题不易处理，所以我们设计接口时单独封装MailBox简化了编程接口

转换一共两步，1是主体转换，比较简单。二是附件的处理这里涉及到附件名中文编码的问题。

    private MimeMessage ConvertToMimeMessage(MailBox box)
    {
        var message = new MimeMessage();

        var from = InternetAddress.Parse(_options.UserName);
        from.Name = _options.DisplayName;

        message.From.Add(from);
        if (!box.To.Any())
        {
            throw new ArgumentNullException("to必须含有值");
        }
        message.To.AddRange(box.To.Convert());
        if (box.Cc != null && box.Cc.Any())
        {
            message.Cc.AddRange(box.Cc.Convert());
        }

        message.Subject = box.Subject;

        var builder = new BodyBuilder();

        if (box.IsHtml)
        {
            builder.HtmlBody = box.Body;
        }
        else
        {
            builder.TextBody = box.Body;
        }

        if (box.Attachments != null && box.Attachments.Any())
        {
            foreach (var item in GetAttechments(box.Attachments))
            {
                builder.Attachments.Add(item);
            }
        }

        message.Body = builder.ToMessageBody();
        return message;
    }

    private AttachmentCollection GetAttechments(IEnumerable<IAttachment> attachments)
    {
        if (attachments == null)
        {
            throw new ArgumentNullException(nameof(attachments));
        }

        AttachmentCollection collection = new AttachmentCollection();
        List<Stream> list = new List<Stream>(attachments.Count());

        foreach (var item in attachments)
        {
            var fileName = item.GetName();
            var fileType = MimeTypes.GetMimeType(fileName);
            var contentTypeArr = fileType.Split('/');
            var contentType = new ContentType(contentTypeArr[0], contentTypeArr[1]);
            MimePart attachment = null;
            Stream fs = null;
            try
            {
                fs = item.GetFileStream();
                list.Add(fs);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "读取文件流发生异常");
                fs?.Dispose();
                continue;
            }

            attachment = new MimePart(contentType)
            {
                Content = new MimeContent(fs),
                ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
                ContentTransferEncoding = ContentEncoding.Base64,
            };

            var charset = "UTF-8";
            attachment.ContentType.Parameters.Add(charset, "name", fileName);
            attachment.ContentDisposition.Parameters.Add(charset, "filename", fileName);

            foreach (var param in attachment.ContentDisposition.Parameters)
            {
                param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
            }

            foreach (var param in attachment.ContentType.Parameters)
            {
                param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
            }

            collection.Add(attachment);
        }
        return collection;
    }

在转化附件时下面的代码用来处理附件名编码问题：

var charset = "UTF-8";
attachment.ContentType.Parameters.Add(charset, "name", fileName);
attachment.ContentDisposition.Parameters.Add(charset, "filename", fileName);

foreach (var param in attachment.ContentDisposition.Parameters)
{
    param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
}

foreach (var param in attachment.ContentType.Parameters)
{
    param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
}

到这了我们的邮件队列就基本完成了，接下来就是在程序启动后，启动队列，找到 Program.cs文件，并稍作改写如下：

var host = BuildWebHost(args);
var provider = host.Services;
provider.GetRequiredService<IMailQueueManager>().Run();
host.Run();

这里在host.Run()主机启动之前，我们获取了IMailQueueManager并启动队列（别忘了注册服务）。

运行程序我们会看到控制台每隔3秒就会打出日志：

info: Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager[0]
      User profile is available. Using 'C:\Users\Administrator\AppData\Local\ASP.NET\DataProtection-Keys' as key repository and Windows DPAPI to encrypt keys at rest.
info: MailQueueManager[0]
      线程即将启动
info: MailQueueManager[0]
      线程已经启动，线程Id是：9
trce: MailQueueManager[0]
      队列是空，开始睡眠
Hosting environment: Development
Content root path: D:\publish
Now listening on: http://[::]:5000
Application started. Press Ctrl+C to shut down.
trce: MailQueueManager[0]
      队列是空，开始睡眠
trce: MailQueueManager[0]
      队列是空，开始睡眠

到此，我们的邮件队列就完成了！ ：D

欢迎转载，不过要著名原作者和出处

觉得写的不错的话帮忙点个赞撒 :D

文章标签：
.NET
存储
Windows
网络安全
安全
数据库
开发框架
关键词：
ASP Core
.NET core
ASP.NET core
.NET邮件
.NETCore
rocketrobin
目录
相关文章
Net分享
|
14天前
|
开发框架 .NET 开发者
简化 ASP.NET Core 依赖注入（DI）注册-Scrutor
Scrutor 是一个简化 ASP.NET Core 应用程序中依赖注入（DI）注册过程的开源库，支持自动扫描和注册服务。通过简单的配置，开发者可以轻松地从指定程序集中筛选、注册服务，并设置其生命周期，同时支持服务装饰等高级功能。适用于大型项目，提高代码的可维护性和简洁性。仓库地址：&lt;https://github.com/khellang/Scrutor&gt;
Net分享
36 5
小王老师呀
|
2月前
|
存储 开发框架 JSON
ASP.NET Core OData 9 正式发布
【10月更文挑战第8天】Microsoft 在 2024 年 8 月 30 日宣布推出 ASP.NET Core OData 9，此版本与 .NET 8 的 OData 库保持一致，改进了数据编码以符合 OData 规范，并放弃了对旧版 .NET Framework 的支持，仅支持 .NET 8 及更高版本。新版本引入了更快的 JSON 编写器 `System.Text.UTF8JsonWriter`，优化了内存使用和序列化速度。
小王老师呀
96 0
shiningrise
|
1月前
|
开发框架 .NET C#
在 ASP.NET Core 中创建 gRPC 客户端和服务器
本文介绍了如何使用 gRPC 框架搭建一个简单的“Hello World”示例。首先创建了一个名为 GrpcDemo 的解决方案，其中包含一个 gRPC 服务端项目 GrpcServer 和一个客户端项目 GrpcClient。服务端通过定义 `greeter.proto` 文件中的服务和消息类型，实现了一个简单的问候服务 `GreeterService`。客户端则通过 gRPC 客户端库连接到服务端并调用其 `SayHello` 方法，展示了 gRPC 在 C# 中的基本使用方法。
shiningrise
41 5
在 ASP.NET Core 中创建 gRPC 客户端和服务器
长梦
|
22天前
|
开发框架 缓存 .NET
GraphQL 与 ASP.NET Core 集成：从入门到精通
本文详细介绍了如何在ASP.NET Core中集成GraphQL，包括安装必要的NuGet包、创建GraphQL Schema、配置GraphQL服务等步骤。同时，文章还探讨了常见问题及其解决方法，如处理复杂查询、错误处理、性能优化和实现认证授权等，旨在帮助开发者构建灵活且高效的API。
长梦
24 3
shiningrise
|
2月前
mcr.microsoft.com/dotnet/core/aspnet:2.1安装libgdiplus
mcr.microsoft.com/dotnet/core/aspnet:2.1安装libgdiplus
shiningrise
35 1
追逐时光者
|
2月前
|
开发框架 JavaScript 前端开发
一个适用于 ASP.NET Core 的轻量级插件框架
一个适用于 ASP.NET Core 的轻量级插件框架
追逐时光者
68 0
1508026077072612
|
开发框架 前端开发 .NET
ASP.NET Core 核心特性学习笔记「下」
ASP.NET Core 核心特性学习笔记「下」
1508026077072612
142 0
1508026077072612
|
开发框架 前端开发 中间件
ASP.NET Core 核心特性学习笔记「上」
ASP.NET Core 核心特性学习笔记「上」
1508026077072612
134 0
郑子铭
|
SQL 机器学习/深度学习 Cloud Native
.NET 云原生架构师训练营（模块二 基础巩固 EF Core 更新和迁移）--学习笔记
- 状态 - 自动变更检测 - 不查询删除和更新 - 并发
郑子铭
255 0
.NET 云原生架构师训练营（模块二 基础巩固 EF Core 更新和迁移）--学习笔记
郑子铭
|
SQL Cloud Native 架构师
.NET 云原生架构师训练营（模块二 基础巩固 EF Core 查询）--学习笔记
- 关联数据加载 - 客户端与服务端运算 - 跟踪与不跟踪 - 复杂查询运算 - 原生 SQL 查询 - 全局查询筛选器
郑子铭
249 0
.NET 云原生架构师训练营（模块二 基础巩固 EF Core 查询）--学习笔记