.NET 7 和 C# 11 的 7 大自定义扩展方法
.NET 7 和 C# 11 的 7 大自定义扩展方法
介绍
自从我开始了解扩展方法以来，我不断地发现新的可能性，让我的编码生活更轻松。 扩展方法是 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，因为它是流畅的风格。
当然，还有更多的可能性，您可以使用此架构并制作自己的缩写词和扩展方法。 在评论中让我知道你的想法。
我希望您发现其中一些方法有用并将它们应用到您的项目中。
谢谢阅读！
