将具有不同架构或API的系统进行集成可能会相当具有挑战性。适配器设计模式通过将一个系统的接口转换成你的系统期望的形式来解决这个问题。在这篇文章里，我们将探讨如何在C# .NET 8中实现适配器模式，并通过一些高级增强特性使你的实现更加可扩展和健壮。

适配器设计模式是一种结构模式，充当两个不兼容接口之间的桥梁。它允许系统与因API差异而不兼容的另一个类一起工作。

实际示例：一个日志记录服务，其方法与你的应用程序期望的约定不符。

我们首先定义系统期望的合同：

    public interface ILog目标接口  
    {  
        void 记录信息(string message);  
        void 记录错误(string message);  
    }

假设一个拥有不兼容 API 的外部的日志服务，这样的情况：

    public class 外部日志服务类  
    {  
        public void 记录日志(string 日志类型, string 信息)  
        {  
            Console.WriteLine($"[{日志类型.ToUpper()}]: {信息}");  
        }  
    }

适配器实现了 ILogTarget 接口，并将调用转换到外部服务的 API。

    public class 日志适配器 : 日志目标接口  
    {  
        private readonly 外部日志服务 _externalLogService;  

        public LogAdapter(外部日志服务 externalLogService)  
        {  
            _externalLogService = externalLogService;  
        }  

        public void 记录信息(string message)  
        {  
            _externalLogService.写日志("info", message);  
        }  

        public void 记录错误(string message)  
        {  
            _externalLogService.写日志("error", message);  
        }  
    }

你现在可以用适配器把系统连接到外部服务了。

    class Program  
    {  
        static void Main(string[] args)  
        {  
            ExternalLogService externalLogService = new ExternalLogService();  
            ILogTarget logAdapter = new LogAdapter(externalLogService);  

            logAdapter.LogInfo("这是一条信息性消息。");  
            logAdapter.LogError("这是一条错误消息。");  
        }  
    }

使用带有DI功能的适配器可以使依赖项管理更轻松。

// 在 ASP.NET Core 项目中进行依赖注入配置
services.AddSingleton<ExternalLogService>(); // 为整个应用程序提供单例的外部日志服务
services.AddScoped<ILogTarget, LogAdapter>(); // 为每个请求提供日志适配器实例

现在客户端代码可以自动解决适配器问题。

2. Polly 的韧性

增强处理外部服务故障的能力

    public class ResilientLogAdapter : ILogTarget  
    {  
        private readonly ExternalLogService _externalLogService;  
        private readonly Policy _retryPolicy;  

        public ResilientLogAdapter(ExternalLogService externalLogService)  
        {  
            _externalLogService = externalLogService;  
            _retryPolicy = Policy  
                .Handle<Exception>()  
                .Retry(3, (exception, retryCount) =>  
                {  
                    Console.WriteLine($"第 {retryCount} 次重试: {exception.Message}");  
                });  
        }  

        public void LogInfo(string message)  
        {  
            _retryPolicy.Execute(() => _externalLogService.WriteLog("info", message));  
        }  

        public void LogError(string message)  
        {  
            _retryPolicy.Execute(() => _externalLogService.WriteLog("error", message));  
        }  
    }

使用 Polly，短暂的故障会自动处理，从而提高可靠性。

使适配器异步以在I/O密集型情况中提升性能：

    public interface IAsync日志目标  
    {  
        Task LogInfoAsync(string message);  
        Task LogErrorAsync(string message);  
    }  

    public class 异步日志适配器 : IAsync日志目标  
    {  
        private readonly ExternalLogService _外部日志服务;  

        public 异步日志适配器(ExternalLogService 外部日志服务)  
        {  
            _外部日志服务 = 外部日志服务;  
        }  

        public async Task LogInfoAsync(string message)  
        {  
            await Task.Run(() => _外部日志服务.WriteLog("info", message));  
        }  

        public async Task LogErrorAsync(string message)  
        {  
            await Task.Run(() => _外部日志服务.WriteLog("error", message));  
        }  
    }

通过自动化测试确保质量：

    public class LogAdapterTests  
    {  
        [Fact]  
        public void LogInfo_ShouldCallWriteLogWithInfo()  
        {  
            // 准备  
            var mockService = new Mock<ExternalLogService>();  
            var adapter = new LogAdapter(mockService.Object);  

            // 执行  
            adapter.LogInfo("Test message");  

            // 验证  
            mockService.Verify(service => service.WriteLog("info", "Test message"), Times.Once);  
        }  
    }

适配器模式对于整合接口不兼容的系统至关重要。通过结合现代技术，比如依赖注入，使用 Polly 实现的弹性，异步功能以及自动化的测试，你可以创建出稳健且可扩展的解决方案。

试试在你下一个项目中运用这些实践方法，看看合理的架构设计能带来哪些不同。

喜欢这篇文章吗？关注我在 Medium，了解更多的 C# .NET 和软件开发实用技巧！