Action 作为参数，对方法进行传参的写法

一般应用

基本示例

1. 无参数的 Action

在 C# 中，可以将方法作为参数传递给其他方法，通过 Action 委托来实现。这允许你将逻辑分离并使代码更加灵活和可重用。以下是一些示例，展示了如何使用 Action 委托作为参数进行方法传参：

using System;

class Program
{
    static void Main()
    {
        // 调用方法，传递一个 Action 委托
        ExecuteAction(() => Console.WriteLine("Hello from Action!"));
    }

    static void ExecuteAction(Action action)
    {
        // 执行传入的 Action 委托
        action();
    }
}

在这个示例中，ExecuteAction 方法接受一个 Action 委托作为参数，并执行它。Main 方法传递了一个打印消息的 Action 委托。

2. 带参数的 Action

using System;

class Program
{
    static void Main()
    {
        // 调用方法，传递一个带参数的 Action 委托
        ExecuteAction((message) => Console.WriteLine(message), "Hello with parameter!");
    }

    static void ExecuteAction(Action<string> action, string message)
    {
        // 执行传入的 Action 委托，并传递参数
        action(message);
    }
}

这个示例中，ExecuteAction 方法接受一个 Action<string> 委托和一个字符串参数。Main 方法传递了一个打印消息的 Action<string> 委托。

3. 多个参数的 Action

using System;

class Program
{
    static void Main()
    {
        // 调用方法，传递一个带多个参数的 Action 委托
        ExecuteAction((x, y, z) => Console.WriteLine($"x: {x}, y: {y}, z: {z}"), 1, 2, 3);
    }

    static void ExecuteAction(Action<int, int, int> action, int x, int y, int z)
    {
        // 执行传入的 Action 委托，并传递多个参数
        action(x, y, z);
    }
}

在这个示例中，ExecuteAction 方法接受一个 Action<int, int, int> 委托和三个整数参数。Main 方法传递了一个打印多个整数的 Action<int, int, int> 委托。

更复杂的示例

4. 使用 Action 处理异步操作

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // 调用方法，传递一个 Action 委托来处理异步操作
        await ExecuteAsyncAction(async () =>
        {
            await Task.Delay(1000); // 模拟异步操作
            Console.WriteLine("Async action completed!");
        });
    }

    static async Task ExecuteAsyncAction(Func<Task> asyncAction)
    {
        // 执行传入的异步 Action 委托
        await asyncAction();
    }
}

在这个示例中，ExecuteAsyncAction 方法接受一个 Func<Task> 委托（异步的 Action）作为参数，并执行它。Main 方法传递了一个执行异步操作的 Func<Task> 委托。

总结

• 无参数的 Action：Action。
• 带一个参数的 Action：Action<T1>。
• 带多个参数的 Action：Action<T1, T2, T3>, 等等。
• 异步操作：使用 Func<Task> 来处理异步操作的 Action。

通过使用 Action 委托，你可以将方法作为参数传递，灵活地处理各种逻辑，并使代码更加模块化和可维护。

应用场景

在 C# 中，将 Action 委托作为参数传递的方法有许多实际应用场景。以下是一些常见的应用场景及其示例：

1. 回调函数

在需要在某个操作完成后执行额外的代码时，可以使用 Action 委托作为回调函数。

示例：

using System;

class Program
{
    static void Main()
    {
        ProcessData(() => Console.WriteLine("Data processing complete!"));
    }

    static void ProcessData(Action onComplete)
    {
        // 模拟数据处理
        Console.WriteLine("Processing data...");
        // 调用回调函数
        onComplete();
    }
}

2. 事件处理

使用 Action 委托处理事件，使得事件处理代码可以从事件触发逻辑中分离出来。

示例：

using System;

class Program
{
    static void Main()
    {
        // 注册事件处理
        RegisterEvent(() => Console.WriteLine("Event occurred!"));
        // 触发事件
        TriggerEvent();
    }

    static void RegisterEvent(Action eventHandler)
    {
        // 保存事件处理器
        _eventHandler = eventHandler;
    }

    static void TriggerEvent()
    {
        // 触发事件
        _eventHandler?.Invoke();
    }

    private static Action _eventHandler;
}

3. 操作配置

在需要根据不同的配置执行不同操作时，使用 Action 委托来传递操作逻辑。

示例：

using System;

class Program
{
    static void Main()
    {
        ConfigureOperation(true, () => Console.WriteLine("Operation for condition A"));
        ConfigureOperation(false, () => Console.WriteLine("Operation for condition B"));
    }

    static void ConfigureOperation(bool condition, Action operation)
    {
        if (condition)
        {
            operation();
        }
    }
}

4. 异步操作

在处理异步操作时，使用 Action 或 Func 委托来传递异步回调函数。

示例：

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        await ExecuteWithCallback(async () =>
        {
            await Task.Delay(1000); // 模拟异步操作
            Console.WriteLine("Async operation completed!");
        });
    }

    static async Task ExecuteWithCallback(Func<Task> asyncCallback)
    {
        // 执行异步操作
        await asyncCallback();
    }
}

5. 条件执行

根据条件执行不同的操作，Action 委托可以帮助你在不同情况下执行不同的逻辑。

示例：

using System;

class Program
{
    static void Main()
    {
        PerformActionBasedOnCondition(true, () => Console.WriteLine("Condition is true"));
        PerformActionBasedOnCondition(false, () => Console.WriteLine("Condition is false"));
    }

    static void PerformActionBasedOnCondition(bool condition, Action action)
    {
        if (condition)
        {
            action();
        }
    }
}

总结

• 回调函数：在操作完成后执行额外逻辑。
• 事件处理：将事件处理逻辑从事件触发代码中分离。
• 操作配置：根据配置执行不同的操作。
• 异步操作：处理异步操作的回调。
• 条件执行：根据条件执行不同的逻辑。

这些应用场景展示了如何利用 Action 委托提高代码的灵活性和可重用性，使得方法可以接收并执行不同的操作逻辑。