标签：11 task 自定义 C# tasks Task static null public

.NET 7 和 C# 11 的 7 大自定义扩展方法

原创2023-01-13 11:59·启辰8

 

介绍

自从我开始了解扩展方法以来，我不断地发现新的可能性，让我的编码生活更轻松。 扩展方法是 SOLID完美应用 中的O ——开闭原则。 一个类应该尽可能简单，并且只在其他组件真正需要时才将属性和方法暴露给外部。

通过扩展方法，您可以为您的类实现额外的方法，而无需更改类本身！ 这非常适合将类作为参数的重复方法。

实现扩展方法非常简单。 看看下面的例子：

namespace System;

public static class EnumerableExtensions
{
    public static void ForEach<T>(this IEnumerable<T> sequence, Action<T> action) {
        foreach (var item in sequence) 
            action(item);
    }
}

这在每个 IEnumerable<T>（由 this 关键字引入）上实现了 ForEach() 方法，就像您从 List<T> 类型中了解到的那样。 要访问此方法，您唯一需要做的就是添加对相应命名空间的引用，在本例中为 System。

我最常用的 7 种扩展方法

自 .NET 6 以来，Microsoft 为 IEnumerable<T> 实现了一些扩展方法，我之前将这些方法列在了我的首选列表中，包括 DistinctBy() 和 Chunk()。 但是，从 .NET 7 开始，我仍然缺少一些非常重要的方法，尤其是处理任务（Task）集合的方法。

事不宜迟，以下是我在 .NET 7 中最常用的扩展方法：

1. TryAsync

第一种扩展方法是我最喜欢的一种。 您有多少次在刚刚创建的方法周围添加 try-catch 块，并且因为它破坏了外观而变得有点恼火？ 当您的方法返回 Task 或 Task<T> 时，这是一个非常简洁的解决方案：

public static async Task<Result> TryAsync(
    this Task task,
    Action<Exception> errorHandler = null
) {
    try {
        await task;
        return Result.Ok();
    }
    catch (Exception ex) {
        if (errorHandler is not null) errorHandler(ex);
        return ex;
    }
}

public static async Task<Result<T>> TryAsync<T>(
    this Task<T> task,
    Action<Exception> errorHandler = null
) where T : class {
    try {
        return await task;
    }
    catch (Exception ex) {
        if (errorHandler is not null) errorHandler(ex);
        return ex;
    }
}

现在你可以这样写：

var result = await GetSomethingAsync().TryAsync();

您的方法将自动包装在 try-catch 块中。 此外，您可以为其他辅助逻辑（如日志记录）提供 errorHandler。 然后可以检查这些方法返回的结果是否成功，后续您可以继续您的逻辑。

 

2. WhenAllAsync

集合中有多个 Task 或 Task<T> 以正常方式处理有点不方便。 您需要调用 Task.WhenAll(tasks) 这让我有点脱离流程，因为它不是流畅的风格。 这是它的样子：

public static async Task<IEnumerable<T>> WhenAllAsync<T>(this IEnumerable<Task<T>> tasks) {
    if (tasks is null)
        throw new ArgumentNullException(nameof(tasks));

    return await Task
        .WhenAll(tasks)
        .ConfigureAwait(false);
}

public static Task WhenAllAsync(this IEnumerable<Task> tasks) {
    if (tasks is null)
        throw new ArgumentNullException(nameof(tasks));

    return Task
        .WhenAll(tasks);
}

现在我可以方便的地处理任何任务集合：

var results = await tasks.WhenAllAsync();

3. WhenAllSequentialAsync

下一个扩展方法甚至可以为您节省几行代码，并让您能够逐个执行每个任务。 这在您可能不会并行执行许多任务的情况下很有用。

public static async Task<IEnumerable<T>> WhenAllSequentialAsync<T>(this IEnumerable<Task<T>> tasks) {
    if (tasks is null)
        throw new ArgumentNullException(nameof(tasks));

    var results = new List<T>();
    foreach (var task in tasks)
        results.Add(await task.ConfigureAwait(false));
    return results;
}

public static async Task WhenAllSequentialAsync(this IEnumerable<Task> tasks) {
    if (tasks is null)
        throw new ArgumentNullException(nameof(tasks));

    foreach (var task in tasks)
        await task.ConfigureAwait(false);
}

4. WhenAllParallelAsync

最后但同样重要的是，可能有一个用例，您可以并行执行任务，但可能有最大数量限制。 对于这种情况，我有以下扩展方法：

public static async Task<IEnumerable<T>> WhenAllParallelAsync<T>(
    this IEnumerable<Task<T>> tasks,
    int degree
) {
    if (tasks is null)
        throw new ArgumentNullException(nameof(tasks));

    var results = new List<T>();
    foreach (var chunk in tasks.Chunk(degree)) {
        var chunkResults = await Task.WhenAll(chunk).ConfigureAwait(false);
        results.AddRange(chunkResults);
    }
    return results;
}

public static async Task WhenAllParallelAsync(
    this IEnumerable<Task> tasks,
    int degree
) {
    if (tasks is null)
        throw new ArgumentNullException(nameof(tasks));

    foreach (var chunk in tasks.Chunk(degree)) 
        await Task.WhenAll(chunk).ConfigureAwait(false);
}

使用 degree 参数，您可以指定应并行执行多少个任务。

5. MapAsync

这也是一个流畅的扩展，但这次是针对单个 Task 或 Task<T>。

public static async Task<TOut> MapAsync<TIn, TOut>(
    this Task<TIn> task,
    Func<TIn, Task<TOut>> mapAsync
) {
    if (task is null)
        throw new ArgumentNullException(nameof(task));

    if (mapAsync is null)
        throw new ArgumentNullException(nameof(mapAsync));

    return await mapAsync(await task);
}

public static async Task<TOut> MapAsync<TIn, TOut>(
    this Task<TIn> task,
    Func<TIn, TOut> map
) {
    if (task is null)
        throw new ArgumentNullException(nameof(task));

    if (map is null)
        throw new ArgumentNullException(nameof(map));

    return map(await task);
}

使用此扩展方法，您可以将 Task<T1> 流畅地映射到 Task<T2>，类似于 Enumerable.Select() 方法。

6. DoAsync

类似的方法是 DoAsync() ，但不是转换任务，而是可以使用任务结果执行辅助逻辑而不改变其返回值。

public static async Task<T> DoAsync<T>(
    this Task<T> task,
    Func<T, Task> tapAsync
) {
    if (task is null)
        throw new ArgumentNullException(nameof(task));

    if (tapAsync is null)
        throw new ArgumentNullException(nameof(tapAsync));

    var res = await task;
    await tapAsync(res);
    return res;
}

public static async Task<T> DoAsync<T>(
    this Task<T> task,
    Action<T> tap
) {
    if (task is null)
        throw new ArgumentNullException(nameof(task));

    if (tap is null)
        throw new ArgumentNullException(nameof(tap));

    var res = await task;
    tap(res);
    return res;
}

7. String.Join

最后一个是我有时用于连接字符串以进行日志记录的扩展方法。 通常，您可以为此使用 string.Join() ，但同样，这并不流畅，让我无法理解。

public static string Join(this IEnumerable<string> sequence, string separator = "") {
    return string.Join(separator, sequence);
}

缩略

技术上不是扩展方法，但对节省一些代码也很有用，以下是我的缩写方法：

namespace System;

public static class Abbreviations
{
    public static IEnumerable<T> Arr<T>(params T[] elements) => elements;

    public static void Try(
        Action action,
        Action<Exception>? errorHandler = null
    ) {
        try {
            action();
        }
        catch (Exception ex) {
            if (errorHandler is not null) errorHandler(ex);
        }
    }

    public static Result<T> Try<T>(
        Func<T> action,
        Action<Exception>? errorHandler = null
    ) where T : class 
    {
        try {
            return action();
        }
        catch (Exception ex) {
            if (errorHandler is not null) errorHandler(ex);
            return ex;
        }
    }
}

要轻松使用它们，您必须在根级别创建一个特殊文件（我通常将其称为 GlobalUsings.cs）并在其中放入以下行：

global using static System.Abbreviations;

1. Arr

Arr 方法是从现有值创建新 IEnumerable<T> 的缩写。 通常，这将需要非常丑陋的代码，如下所示：

var arr = new [] { param1, param2,... };

现在你可以这样写：

var arr = Arr(param1, param2,... );

哪个看起来更漂亮？

2. Try

您有多少次只是想在一个新方法周围添加一个简单的 try-catch 块，但由于它在您的代码中占用了太多空间，所以感觉很难看？ 这是一个缩写方法 Try() 的解决方案。

在最短的形式中，你可以写：

Try(TestMethod);

其中 TestMethod 是一个不带任何参数的方法。 这使您能够编写极短的代码并消除那些讨厌的 try-catch 块。

对于异步方法，我建议您使用上面的扩展方法 TryAsync，因为它是流畅的风格。

当然，还有更多的可能性，您可以使用此架构并制作自己的缩写词和扩展方法。 在评论中让我知道你的想法。

我希望您发现其中一些方法有用并将它们应用到您的项目中。

谢谢阅读！

标签：11,task,自定义,C#,tasks,Task,static,null,public
From： https://www.cnblogs.com/sexintercourse/p/17167315.html