C# 使用线程调用方法的便捷方式

已于 2024-08-10 13:41:44 修改
阅读量207 收藏 3
点赞数 2
分类专栏： C# 文章标签： c#
于 2024-07-09 08:31:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38693757/article/details/140284722
版权

一、简介

在使用线程代码时，因为用到委托的方式，所以写起来不是特别方便，为了简化异步操作的执行，我特意做了一个简单的封装。

二、功能实现

新建一个 Winform 项目，新建一个类 AsyncRunner.cs，主要作用是以异步方式运行 Action 和 Func 委托来简化异步操作的执行，支持从无参数到最多四个参数的不同重载版本，如果需要更多的参数重载可以自己加一下。

using System;
using System.Threading.Tasks;

public class AsyncRunner
{
    /// <summary>
    /// 使用线程去调用一个无参数的方法
    /// </summary>
    /// <param name="action"></param>
    public static void RunAsync(Action action)
    {
        Task.Run(action);
    }
    /// <summary>
    /// 使用线程去调用一个无参数，但有返回值的方法
    /// </summary>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="func"></param>
    /// <returns></returns>
    public static Task<TResult> RunAsync<TResult>(Func<TResult> func)
    {
        return Task.Run(func);
    }
    /// <summary>
    /// 使用线程去调用参数只有1个，并无返回值的方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="action"></param>
    /// <param name="param"></param>
    public static void RunAsync<T>(Action<T> action, T param)
    {
        Task.Run(() => action(param));
    }
    /// <summary>
    /// 使用线程去调用参数只有1个，并有返回值的方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="func"></param>
    /// <param name="param"></param>
    /// <returns></returns>
    public static Task<TResult> RunAsync<T, TResult>(Func<T, TResult> func, T param)
    {
        return Task.Run(() => func(param));
    }
    /// <summary>
    /// 使用线程去调用参数只有2个，并无返回值的方法
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <param name="action"></param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    public static void RunAsync<T1, T2>(Action<T1, T2> action, T1 param1, T2 param2)
    {
        Task.Run(() => action(param1, param2));
    }
    /// <summary>
    /// 使用线程去调用参数只有2个，并有返回值的方法
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="func"></param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <returns></returns>
    public static Task<TResult> RunAsync<T1, T2, TResult>(Func<T1, T2, TResult> func, T1 param1, T2 param2)
    {
        return Task.Run(() => func(param1, param2));
    }
    /// <summary>
    /// 使用线程去调用参数只有3个，并无返回值的方法
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <typeparam name="T3"></typeparam>
    /// <param name="action"></param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <param name="param3"></param>
    public static void RunAsync<T1, T2, T3>(Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3)
    {
        Task.Run(() => action(param1, param2, param3));
    }
    /// <summary>
    /// 使用线程去调用参数只有3个，并有返回值的方法
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <typeparam name="T3"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="func"></param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <param name="param3"></param>
    /// <returns></returns>
    public static Task<TResult> RunAsync<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> func, T1 param1, T2 param2, T3 param3)
    {
        return Task.Run(() => func(param1, param2, param3));
    }
    /// <summary>
    /// 使用线程去调用参数只有4个，并无返回值的方法
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <typeparam name="T3"></typeparam>
    /// <typeparam name="T4"></typeparam>
    /// <param name="action"></param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <param name="param3"></param>
    /// <param name="param4"></param>
    public static void RunAsync<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        Task.Run(() => action(param1, param2, param3, param4));
    }
    /// <summary>
    /// 使用线程去调用参数只有4个，并有返回值的方法
    /// </summary>
    /// <typeparam name="T1"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <typeparam name="T3"></typeparam>
    /// <typeparam name="T4"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="func"></param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <param name="param3"></param>
    /// <param name="param4"></param>
    /// <returns></returns>
    public static Task<TResult> RunAsync<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> func, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return Task.Run(() => func(param1, param2, param3, param4));
    }

    private AsyncRunner() { }
}

稍微讲解下方法中的泛型，T1，T2 都是传值方法的类型，param1，param2 则是泛型的具体值

public static Task<TResult> RunAsync<T1, T2, TResult>(Func<T1, T2, TResult> func, T1 param1, T2 param2)
{
    return Task.Run(() => func(param1, param2));
}

TResult 不是一个特定的类或类型，而是一个泛型类型参数的占位符。TResult 通常出现在泛型方法或者委托中，表示该方法或委托返回的类型。

例：

public TResult GetDefaultValue<TResult>()
{
    return default(TResult);
}

调用：

int defaultInt = GetDefaultValue<int>(); // 返回 0

string defaultString = GetDefaultValue<string>(); // 返回 null

添加一个类 Test.cs，用来测试  AsyncRunner 类中的方法效果

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

internal class Test
{
    public void test1()
    {
        Console.WriteLine("test1");
    }

    public int test2()
    {
        return 1;
    }

    public void test3(int x)
    {
        Console.WriteLine("x：{0}", x);
    }

    public int test4(int x)
    {
        return x;
    }

    public void test5(int x, int y)
    {
        int result = x + y;
        Console.WriteLine("相加：{0}", result);
    }

    public (bool, int) test6(int x, int y)
    {
        int result = x + y;
        return (true, result);
    }
}

三、测试

Winform 界面如下：

这里，我只演示2个参数的重载方法，多个参数的用法基本差不多。

Form1 代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 多线程封装
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        Test test = new Test();

        //调用一个无参数的方法
        private void button1_Click(object sender, EventArgs e)
        {
            AsyncRunner.RunAsync(test.test1);
        }

        //调用一个无参数，但有返回值的方法
        private async void button2_Click(object sender, EventArgs e)
        {
            int result = await AsyncRunner.RunAsync(test.test2);
            Console.WriteLine("结果：{0}", result);
        }

        //调用参数只有1个，并无返回值的方法
        private void button3_Click(object sender, EventArgs e)
        {
            AsyncRunner.RunAsync(test.test3, 2);
        }

        //调用参数只有1个，并有返回值的方法
        private async void button4_Click(object sender, EventArgs e)
        {
            int result = await AsyncRunner.RunAsync(test.test4, 2);
            Console.WriteLine("结果：{0}", result);
        }

        //调用参数只有2个，并无返回值的方法
        private void button5_Click(object sender, EventArgs e)
        {
            AsyncRunner.RunAsync(test.test5, 2, 3);
        }

        //调用参数只有2个，并有返回值的方法
        private async void button6_Click(object sender, EventArgs e)
        {
            var (isError, result) = await AsyncRunner.RunAsync(test.test6, 5, 3);
            Console.WriteLine("是否错误：{0}，结果：{1}", isError, result);
        }
    }
}

运行：

源码是免费的哦

https://download.csdn.net/download/qq_38693757/89627229

结束

如果这个帖子对你有所帮助，欢迎 关注 + 点赞 + 留言

end

熊思宇
关注
专栏目录
C#跨线程调用控件的四种方式
10-13
C#非控件创建线程调用控件的四种使用方式，从而避免跨线程调用的异常
c#中三种线程调用方法（Task、Thread、Action）
weixin_47759903的博客
11-07 339
【代码】c#中三种线程调用方法（Task、Thread、Action）
C#Winform常见的多线程实现方法：
最新发布
qq_40637881的博客
09-05 453
你可以根据具体需求选择合适的多线程实现方式，如 Thread 类、BackgroundWorker 类、Task 类和 async/await 关键字等。现代 C# 推荐使用 Task 类和 async/await 关键字，因为它们使代码更易读，并且更容易处理异步操作。WinForms 提供了多种方式来实现多线程，包括使用 Thread 类、BackgroundWorker 类、Task 类和 async/await 关键字等。如果你需要在后台操作中报告进度，可以使用 Progress 类。
c#线程调用
qq_54756591的博客
04-19 291
用线程把字一个一个输出 static void Main(string[] args) { //创建Thread对象 Thread thread = new Thread(()=> { string txt = "等待输入..."; for (int i = 0; i < txt.Length; i++) {
C#如何调用多线程?
绿龙术士的专栏
09-30 2250
1. Thread 调用线程 Thread thread = new Thread(Run1); Thread thread2 = new Thread(Run2); thread.Start(); thread2.Start(); 2. ThreadPool 调用线程池 ThreadPool.QueueUserWorkItem(m => {Run1();}); Thre...
C#通过线程调用方法
一路向北
01-26 2091
1：无参方法 Thread thread = new Thread(ExecServerCheck); thread.Start(); 2：有参方法 Thread thread = new Thread(new ParameterizedThreadStart(ExecServerCheck)); thread.Start("R"); 
C# 跨线程调用控件.zip
08-15
为了解决这个问题，C#提供了跨线程调用控件的方法。本项目"**C# 跨线程调用控件.zip**"提供了一个很好的实例，展示了如何正确地实现这一功能。 首先，我们需要理解.NET中的线程模型。主线程是负责创建并管理UI的...
C#中线程同步对象的方法分析
09-04
本篇文章主要分析了C#中线程同步对象的几种方法，包括Mutex类、Monitor类、lock关键字以及EventWaitHandle类的子类。 1. Mutex类：Mutex是一种互斥锁，用于保护资源在某一时刻仅被一个线程访问。当一个线程获得...
halcon与c#联合编程实例 多线程图像处理Project，适合初学者~
11-25
以下是使用Halcon和C#实现多线程图像处理的一些关键步骤： 1. **设置项目环境**：首先，你需要在Visual Studio中创建一个新的C#项目，并确保已安装Halcon的.NET接口。这样可以在C#代码中调用Halcon的函数和类。 2....
c#Winform异步线程刷新UI
12-27
3. **启动异步操作**：在按钮点击事件或其他适当的地方，调用BackgroundWorker的`RunWorkerAsync`方法开始异步任务。 4. **执行后台任务**：在`DoWork`事件处理程序中，执行你的耗时操作，并通过`ReportProgress`...
简单C#winform多线程委托调用进度条!
01-20
简单winform多线程调用进度条的例子 BeginInvoke
C#线程操作常见的六大操作方法
拓
02-04 1306
来自：http://developer.51cto.com/art/200908/147771.htm C#线程操作常见的操作方法是什么呢？C#线程操作方法的具体实现是什么样子的呢?那么下面我们来看看具体的C#线程操作的六大方法分别是什么，以及他们的特点是什么？ C#线程操作一、用委托(Delegate)的BeginInvoke和EndInvoke方法操作线程 在C#
C# winform delegate委托以及异步调用委托(跨线程调用控件UI)使用总结
何浩翔的博客
01-05 4404
C# winform delegate委托以及异步调用委托(跨线程调用控件UI)使用总结
C#线程函数调用方式
wzg_soullon的专栏
12-01 2708
C#中线创建线程调用线程函数有2种方式： 1，调用不带参数的线程函数 2，调用带参数的线程函数         在不传递参数情况下，一般大家都使用ThreadStart代理来连接执行函数。执行函数声明格式如下： public static void ThreadProc(); 如果希望传递参数给执行函数，则使用ParameterizedThreadStart代理来链接执行函
WinForm中跨线程修改界面控件
weixin_39035475的博客
08-04 1091
WinForm界面控件跨线程操作
使用线程操作刷新Winform界面
weixin_33755554的博客
03-25 517
主窗体中添加代码 public FrmMain() { InitializeComponent(); System.Threading.Thread thread = new System.Threading.Thread(Do_work); thread.IsBackground = t...
c#多线程操作Windows Forms控件
weixin_30267697的博客
01-08 132
c#多线程操作Windows Forms控件 在Windows Forms编程中涉及到的多线程操作，多个线程来更新Forms上的控件，比如textbox等。但是如果你直接在线程中更新textbox的text属性是会报错的。因为textbox是主线程创建的，子线程访问的时候就会报错。 解决方案如下，建立一个Windows Forms项目，拖拉一个textbox和button就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊思宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值