使用C#的异步和依赖注入实现网络数据存储

详细解释

1. 依赖注入（Dependency Injection）:

   • ConfigureServices 方法配置了服务的依赖注入。IDataProcessor 接口与 DataProcessor 类绑定，IDbConnectionFactory 接口与 DbConnectionFactory 类绑定。这样在程序运行时，依赖注入容器会提供这些接口的实现。

2. 主程序入口（Main 方法）:

   • 在 Main 方法中，配置服务，创建服务提供者，并通过服务提供者获取 IDataProcessor 的实现实例来处理数据。

3. 数据处理接口（IDataProcessor 和 DataProcessor 类）:

   • IDataProcessor 是一个接口，定义了 ProcessDataAsync 方法，用于处理数据。
   • DataProcessor 类实现了 IDataProcessor 接口，负责从 API 获取数据、处理数据、保存数据到数据库并写入文件。

4. 异步编程（async 和 await）:

   • 异步编程用于避免阻塞主线程。FetchDataAsync 方法从 API 获取数据，SaveDataToDatabaseAsync 方法将数据异步保存到数据库。

5. 数据处理（ProcessData 方法）:

   • 数据处理的逻辑将每个数据项的名称转换为大写，并计算值的长度。

6. 文件操作（WriteDataToFile 方法）:

   • 将处理后的数据写入到 output.txt 文件中，每行包含 ID、名称和长度。

7. SQLite 数据库操作:

   • 使用 System.Data.SQLite 进行数据库连接和操作。DbConnectionFactory 类提供了创建数据库连接的方法，SaveDataToDatabaseAsync 方法将处理后的数据存储到 SQLite 数据库中的 ProcessedData 表。

8. 错误处理:

   • 使用 try-catch 块来捕捉并处理可能的异常，并输出错误信息。

using Microsoft.Extensions.DependencyInjection; // 引入依赖注入的命名空间
using Newtonsoft.Json; // 引入 JSON 处理的命名空间
using System; // 引入基本的系统功能
using System.Collections.Generic; // 引入泛型集合功能
using System.Data.SQLite; // 引入 SQLite 数据库操作的命名空间
using System.IO; // 引入文件操作的命名空间
using System.Net.Http; // 引入 HTTP 网络请求的命名空间
using System.Threading.Tasks; // 引入异步编程的命名空间

namespace ComplexConsoleApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // 配置服务
            var services = new ServiceCollection();
            ConfigureServices(services);
            var serviceProvider = services.BuildServiceProvider();

            // 获取 IDataProcessor 实现类的实例并处理数据
            var dataProcessor = serviceProvider.GetService<IDataProcessor>();
            await dataProcessor.ProcessDataAsync();
        }

        private static void ConfigureServices(IServiceCollection services)
        {
            // 将 DataProcessor 注册为 IDataProcessor 的实现
            services.AddTransient<IDataProcessor, DataProcessor>();
            // 将 DbConnectionFactory 注册为 IDbConnectionFactory 的实现
            services.AddSingleton<IDbConnectionFactory, DbConnectionFactory>();
        }
    }

    // 数据处理接口
    public interface IDataProcessor
    {
        Task ProcessDataAsync(); // 异步处理数据
    }

    public class DataProcessor : IDataProcessor
    {
        private readonly IDbConnectionFactory _dbConnectionFactory;
        private const string ApiUrl = "https://api.example.com/data"; // API 数据的 URL

        public DataProcessor(IDbConnectionFactory dbConnectionFactory)
        {
            _dbConnectionFactory = dbConnectionFactory;
        }

        public async Task ProcessDataAsync()
        {
            try
            {
                // 获取数据
                var data = await FetchDataAsync();
                // 处理数据
                var processedData = ProcessData(data);
                // 将数据保存到数据库
                await SaveDataToDatabaseAsync(processedData);
                // 将数据写入文件
                WriteDataToFile(processedData);
            }
            catch (Exception ex)
            {
                // 捕捉并输出异常信息
                Console.WriteLine($"发生错误: {ex.Message}");
            }
        }

        private async Task<List<DataItem>> FetchDataAsync()
        {
            using (var client = new HttpClient())
            {
                // 发送 HTTP GET 请求并获取响应内容
                var response = await client.GetStringAsync(ApiUrl);
                // 将 JSON 响应内容转换为 DataItem 对象的列表
                return JsonConvert.DeserializeObject<List<DataItem>>(response);
            }
        }

        private List<ProcessedDataItem> ProcessData(List<DataItem> data)
        {
            // 模拟数据处理
            var processedData = new List<ProcessedDataItem>();
            foreach (var item in data)
            {
                // 将每个数据项的名称转换为大写，并计算值的长度
                processedData.Add(new ProcessedDataItem
                {
                    Id = item.Id,
                    Name = item.Name.ToUpper(),
                    Value = item.Value.Length
                });
            }
            return processedData;
        }

        private async Task SaveDataToDatabaseAsync(List<ProcessedDataItem> data)
        {
            using (var connection = _dbConnectionFactory.CreateConnection())
            {
                await connection.OpenAsync(); // 打开数据库连接
                var transaction = connection.BeginTransaction(); // 开始事务

                foreach (var item in data)
                {
                    // 创建 SQL 命令
                    var command = connection.CreateCommand();
                    command.Transaction = transaction;
                    command.CommandText = "INSERT INTO ProcessedData (Id, Name, Value) VALUES (@Id, @Name, @Value)";
                    command.Parameters.AddWithValue("@Id", item.Id);
                    command.Parameters.AddWithValue("@Name", item.Name);
                    command.Parameters.AddWithValue("@Value", item.Value);
                    await command.ExecuteNonQueryAsync(); // 执行 SQL 命令
                }

                transaction.Commit(); // 提交事务
            }
        }

        private void WriteDataToFile(List<ProcessedDataItem> data)
        {
            using (var writer = new StreamWriter("output.txt"))
            {
                foreach (var item in data)
                {
                    // 将处理后的数据写入文件
                    writer.WriteLine($"{item.Id}, {item.Name}, {item.Value}");
                }
            }
        }
    }

    // 数据库连接工厂接口
    public interface IDbConnectionFactory
    {
        SQLiteConnection CreateConnection(); // 创建 SQLite 连接
    }

    public class DbConnectionFactory : IDbConnectionFactory
    {
        private const string ConnectionString = "Data Source=database.db;Version=3;"; // 数据库连接字符串

        public SQLiteConnection CreateConnection()
        {
            return new SQLiteConnection(ConnectionString); // 创建并返回 SQLite 连接
        }
    }

    // 从 API 获取的原始数据项
    public class DataItem
    {
        public int Id { get; set; } // 数据项的 ID
        public string Name { get; set; } // 数据项的名称
        public string Value { get; set; } // 数据项的值
    }

    // 处理后的数据项
    public class ProcessedDataItem
    {
        public int Id { get; set; } // 数据项的 ID
        public string Name { get; set; } // 数据项的名称（转换为大写）
        public int Value { get; set; } // 数据项的值的长度
    }
}