个人中心
gpt4 book ai didi

C#实现向多线程传参的三种方式实例分析

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章C#实现向多线程传参的三种方式实例分析由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

本文实例讲述了C#实现向多线程传参的三种方式。分享给大家供大家参考，具体如下:

从《C#高级编程》了解到给线程传递参数有两种方式，一种方式是使用带ParameterizedThreadStart委托参数的Thread构造函数，另一种方式是创建一个自定义类，把线程的方法定义为实例的方法，这样就可以初始化实例的数据，之后启动线程.

方式一：使用ParameterizedThreadStart委托 。

如果使用了ParameterizedThreadStart委托，线程的入口必须有一个object类型的参数，且返回类型为void。且看下面的例子:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using System.Threading;
namespace ThreadWithParameters
{
   class Program
   {
     static void Main( string [] args)
     {
       string hello = "hello world" ;
       //这里也可简写成Thread thread = new Thread(ThreadMainWithParameters);
       //但是为了让大家知道这里用的是ParameterizedThreadStart委托，就没有简写了
       Thread thread = new Thread( new ParameterizedThreadStart(ThreadMainWithParameters));
       thread.Start(hello);
       Console.Read();
     }
     static void ThreadMainWithParameters( object obj)
     {
       string str = obj as string ;
       if (! string .IsNullOrEmpty(str))
         Console.WriteLine( "Running in a thread,received: {0}" , str);
     }
   }
}

这里稍微有点麻烦的就是ThreadMainWithParameters方法里的参数必须是object类型的，我们需要进行类型转换。为什么参数必须是object类型呢，各位看看ParameterizedThreadStart委托的声明就知道了.

public delegate void ParameterizedThreadStart(object obj);   //ParameterizedThreadStart委托的声明 。

方式二：创建自定义类 。

定义一个类，在其中定义需要的字段，将线程的主方法定义为类的一个实例方法，说得不是很明白，还是看实际的例子吧.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Threading;
namespace ThreadWithParameters
{
   public class MyThread
   {
     private string data;
     public MyThread( string data)
     {
       this .data = data;
     }
     public void ThreadMain()
     {
       Console.WriteLine( "Running in a thread,data: {0}" , data);
     }
   }
   class Program
   {
     static void Main( string [] args)
     {
       MyThread myThread = new MyThread( "hello world" );
       Thread thread = new Thread(myThread.ThreadMain);
       thread.Start();
       Console.Read();
     }
   }
}

对这种方法也不是很满意，总不能一遇到比较耗时的方法，就新建一个类吧。。.

那有什么更好办法即不用强制类型转换，也不用新建一个类呢?

下面就介绍下我无意中找到的一个方法，具体是在哪见过的我也不记得了，罪过啊。.

方式三：使用匿名方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Threading;
namespace ThreadWithParameters
{
   class Program
   {
     static void Main( string [] args)
     {
       string hello = "hello world" ;
       //如果写成Thread thread = new Thread(ThreadMainWithParameters(hello));这种形式，编译时就会报错
       Thread thread = new Thread(() => ThreadMainWithParameters(hello));
       thread.Start();
       Console.Read();
     }
     static void ThreadMainWithParameters( string str)
     {
        Console.WriteLine( "Running in a thread,received: {0}" , str);
     }
   }
}

哇，你会发现既不用类型强制转换也不用新建类就运行成功了.

但是为什么这种方式能行呢，根据昨天 @乱舞春秋 的提示，我也用ildasm反编译了一下，确实如他所说，我所谓的第三种方式其实和第二种方式是一样的，只不过自定义类编译器帮我们做了.

下面的是第三种方式main方法反编译的IL代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
.method private hidebysig static void Main( string [] args) cil managed
{
   .entrypoint
   // 代码大小    51 (0x33)
   .maxstack 3
   .locals init ([0] class [mscorlib]System.Threading.Thread thread,
        [1] class ThreadWithParameters.Program/ '<>c__DisplayClass1' 'CS$<>8__locals2' )
   IL_0000: newobj   instance void ThreadWithParameters.Program/ '<>c__DisplayClass1' ::.ctor()
   IL_0005: stloc.1
   IL_0006: nop
   IL_0007: ldloc.1
   IL_0008: ldstr   "hello world"
   IL_000d: stfld   string ThreadWithParameters.Program/ '<>c__DisplayClass1' ::hello
   IL_0012: ldloc.1
   IL_0013: ldftn   instance void ThreadWithParameters.Program/ '<>c__DisplayClass1' :: '<Main>b__0' ()
   IL_0019: newobj   instance void [mscorlib]System.Threading.ThreadStart::.ctor( object , native int )
   IL_001e: newobj   instance void [mscorlib]System.Threading.Thread::.ctor( class [mscorlib]System.Threading.ThreadStart)
   IL_0023: stloc.0
   IL_0024: ldloc.0
   IL_0025: callvirt  instance void [mscorlib]System.Threading.Thread::Start()
   IL_002a: nop
   IL_002b: call    int32 [mscorlib]System.Console::Read()
   IL_0030: pop
   IL_0031: nop
   IL_0032: ret
} // end of method Program::Main

在看看第二种方式的IL代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
.method private hidebysig static void Main( string [] args) cil managed
{
   .entrypoint
   // 代码大小    44 (0x2c)
   .maxstack 3
   .locals init ([0] class ThreadWithParameters.MyThread myThread,
        [1] class [mscorlib]System.Threading.Thread thread)
   IL_0000: nop
   IL_0001: ldstr   "hello world"
   IL_0006: newobj   instance void ThreadWithParameters.MyThread::.ctor( string )
   IL_000b: stloc.0
   IL_000c: ldloc.0
   IL_000d: ldftn   instance void ThreadWithParameters.MyThread::ThreadMain()
   IL_0013: newobj   instance void [mscorlib]System.Threading.ThreadStart::.ctor( object , native int )
   IL_0018: newobj   instance void [mscorlib]System.Threading.Thread::.ctor( class [mscorlib]System.Threading.ThreadStart)
   IL_001d: stloc.1
   IL_001e: ldloc.1
   IL_001f: callvirt  instance void [mscorlib]System.Threading.Thread::Start()
   IL_0024: nop
   IL_0025: call    int32 [mscorlib]System.Console::Read()
   IL_002a: pop
   IL_002b: ret
} // end of method Program::Main

比较两端代码，可以发现两者都有一个newobj，这句的作用是初始化一个类的实例，第三种方式由编译器生成了一个类：c__DisplayClass1 。

?
1
2
IL_0000: newobj   instance void ThreadWithParameters.Program/ '<>c__DisplayClass1' ::.ctor()
IL_0006: newobj   instance void ThreadWithParameters.MyThread::.ctor( string )

注意：简单并不一定是好事，匿名方法容易造成不易察觉的错误 。

希望本文所述对大家C#程序设计有所帮助.

最后此篇关于C#实现向多线程传参的三种方式实例分析的文章就讲到这里了,如果你想了解更多关于C#实现向多线程传参的三种方式实例分析的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： php获取excel文件数据
文章推荐： TypeScript 中 Interface 与 Type 的区别？该用哪个比较好？
文章推荐： PHP实现限制IP访问的方法
文章推荐： 使用 Linux 安全工具进行渗透测试
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com