CloudYxt.Common 3.1.1

云享通.Net Core基础处理类扩展库

云享通.Net Core基础处理类扩展库，如：常见的类型快捷方法和KTDatatable接收方法

ConcurrentPipelineTask不重复并行独立线程运算队列

类似生产消费队列，但能控制并行独立处理线程数和筛选不重复数据，同时支持同步和异步运算方法，以下为BackgroundWorker中的使用示例：

方法一(自己完成生产、消费线程Task)：

public class Worker_Pipeline : BackgroundService
{
    private readonly ILogger<Worker_Pipeline> _logger;

    public Worker_Pipeline(ILogger<Worker_Pipeline> logger)
    {
        _logger = logger;
    }

    //BackgroundWorker的主线程ExecuteAsync
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        int maxConcurrentAccess = 5; // 设置最大允许的并发访问数量

        //初始化默认最大为100个线程的队列
        //var processor = new ConcurrentPipelineTask<int>();

        //指定最大线程和对象比对方法的队列
        var processor = new ConcurrentPipelineTask<int>(maxConcurrentAccess, (item1, item2) => { return item1 == item2; });

        // 启动生产者和消费者任务
        var producerTask = ProduceNumbers(processor, stoppingToken);
        var consumerTask = ConsumeNumbers(processor, stoppingToken);

        // 等待所有任务完成
        await Task.WhenAll(producerTask, consumerTask);

        _logger.LogInformation("Worker End at: {time}", DateTimeOffset.Now);
    }

    //测试生产子线程
    static async Task ProduceNumbers(ConcurrentPipelineTask<int> processor, CancellationToken stoppingToken)
    {
        var i = 0;
        while (!stoppingToken.IsCancellationRequested)
        {
            i++;
            while (i % 20 != 0) //每次生产20个数
            {
                // 等待 500 毫秒模拟生产过程
                //await Task.Delay(500);

                // 生产数据
                var produce = await processor.ProduceAsync(i); //同步方法为processor.Produce(i);
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Produce: {i} -> {produce}");

                //测试重复元素时使用
                //var y = i / 2;
                //processor.Produce(y);
                //Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Produce: {y}");
            }

            await Task.Delay(TimeSpan.FromMinutes(4), stoppingToken);
        }
    }

    //测试消费子线程
    static async Task ConsumeNumbers(ConcurrentPipelineTask<int> processor, CancellationToken stoppingToken)
    {
        var i = 0;
        while (!stoppingToken.IsCancellationRequested)
        {
            i++;
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Consumer Line Start：{i}");
            Console.WriteLine($"当前运行的filledSet -> {string.Join(',', processor.filledConcurrent)}");

            //异步方法
            await processor.ConsumeAsync(async (number, stopping) =>    //同步方法为processor.Consume
            {
                // 模拟消费过程
                await Task.Delay(700 * number, stopping);

                // 进行数据运算（这里简单实现整数加倍）
                var result = number * 2;

                // 输出结果
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Consumer: {number} -> {result}");

                return true;
            }, stoppingToken);

            await Task.Delay(1000);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Consumer Line End：{i}");
        }

    }
}

方法二(使用内置引擎线程，只需完成生产、消费实现部分)：

public class Worker_Pipeline : BackgroundService
{
    private readonly ILogger<Worker_Pipeline> _logger;

    public Worker_Pipeline(ILogger<Worker_Pipeline> logger)
    {
        _logger = logger;
    }

    //BackgroundWorker的主线程ExecuteAsync
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        int maxConcurrentAccess = 5; // 设置最大允许的并发访问数量

        //初始化默认最大为100个线程的队列
        //var processor = new ConcurrentPipelineTask<int>();

        //指定最大线程和对象比对方法的队列
        var processor = new ConcurrentPipelineTask<int>(maxConcurrentAccess, (item1, item2) => { return item1 == item2; });

        // 启动生产者和消费者任务(同时支持同步实现和async异步实现)
        await processor.ExecuteAsync(async (stoppingToken) =>
        {
            // 持续生产实现代码
            await Task.Delay(100, stoppingToken);

            var allnums = new List<int>();
            while (allnums.Count < 20)
            {
                allnums.Add(new Random().Next(1000, 9999));
            }
            return allnums;
        }, async (number, stoppingToken) =>
        {
            Console.WriteLine($"{DateTime.Now} consume wait {number}");
            // 模拟消费过程
            await Task.Delay(number, stoppingToken);

            // 进行数据运算（这里简单实现整数加倍）
            var result = number * 2;

            // 输出结果
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Consumer: {number} -> {result}");

        }, stoppingToken, async (stat, items, works) =>
        {
            await Task.Delay(1);
            Console.WriteLine($"{DateTime.Now} onwork {stat} items:{items.Count} works:{works.Count} -> {string.Join(',', works)}");
        });

        _logger.LogInformation("Worker End at: {time}", DateTimeOffset.Now);
    }

}

根据文件编码读取文件内容

var html = HtmlFile.ReadAllHtml("文件路径");

Console.WriteLine(html);

拼音处理

//汉字转拼音缩写
var py = CHS2PinYin.GetPYString("中文");

//取单个字符的拼音声母
var pySheng = CHS2PinYin.GetPYChar("中");

//将指定中文字符串转换为拼音形式
var pyAll = CHS2PinYin.Convert("中文说明");

//...

其他常规工具

//判断List是否为空
var mylist = new List<string>();
var isEmpty = mylist.IsEmpty();

//获取MD5
var md5 = "测试的字符".MD5();

//将null转换为空字符
var obj = null;
var str = obj.null2Empty();

//...

datatable相关

datatableDictRequest：字典扩展参数 datatableTRequest：指定扩展参数T datatableRequest：普通扩展参数

XWebClient基于WebClient的扩展(已废弃)

using (var client = new XWebClient())
{
    client.Timeout = 120;
    //同步方法
    client.PostJson(……);
    //异步方法
    await client.PostJsonAsync(……);
}

HttpClient扩展(PostJson建议使用此扩展)

var client = new HttpClient();
//同步方法
client.PostJson<T>(……);
//异步方法
await client.PostJsonAsync<T>(……);

Newtonsoft.Json扩展

JParse：System.Text.Json和Newtonsoft.Json之间的转换 OrderedContractResolver：按字母顺序排序JSON序列化字段

StreamReverseReader反向按行读取文本文件

同步用法：

using var reader = new StreamReverseReader("log.txt", Encoding.UTF8);
string? line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine(line);
}

异步用法：

await using var reader = new StreamReverseReader("log.txt", Encoding.UTF8);
string? line;
while ((line = await reader.ReadLineAsync()) != null)
{
    Console.WriteLine(line);
}