blocks|key|3081993|text|private+void+RunAsync()
{
++++//Beware+of+closures.++String+is+immutable.
++++string+param+=+"Hi";
++++Task.Run(()+=>+MethodWithParameter(param));
}

private+void+MethodWithParameter(string+param)
{
++++//Do+stuff
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3081994|编辑|unstyled|offset|length|style|BOLD|3081995|由于普遍的需求，我必须注意，启动的Task将与调用线程并行运行。假设是默认的TaskScheduler，这将使用.NET+ThreadPool。无论如何，这意味着您需要说明传递给Task的任何参数，因为它可能同时被多个线程访问，使它们成为共享状态。这包括在调用线程上访问它们。|CODE|3081996|在我上面的代码中，这种情况完全没有意义。字符串是不可变的。这就是为什么我用它们作为例子。但如果你不使用String..。|3081997|一种解决方案是使用async和await。默认情况下，这将捕获调用线程的SynchronizationContext，并在调用await之后为该方法的其余部分创建一个延续，并将其附加到创建的Task。如果此方法在WinForms+GUI线程上运行，则它的类型为WindowsFormsSynchronizationContext。|3081998|该延续将在回发到捕获的SynchronizationContext后运行--在默认情况下也是如此。因此，您将回到在await调用之后启动的线程。您可以通过多种方式改变这种情况，特别是使用ConfigureAwait。简而言之，该方法的其余部分将在完成之后，Task在另一个线程上完成后才会继续。但是调用线程将继续并行运行，而不是方法的其余部分。|3081999|等待完成方法其余部分的运行可能是可取的，也可能是不可取的。如果该方法中没有任何内容稍后访问传递给Task的参数，则可能根本不想使用await。|3082000|或者，您可能会在方法的后面使用这些参数。没有理由立即await，因为您可以安全地继续工作。请记住，您可以将返回的Task存储在变量中，稍后也可以将await存储在变量上--甚至在相同的方法中。例如，一旦您需要在完成一些其他工作之后安全地访问传递的参数。同样，在运行await时，不需要在Task上直接使用它。|3082001|无论如何，对于传递给Task.Run的参数，使这个线程安全的一个简单方法是这样做：|3082002|你必须首先用RunAsync装饰async|3082003|private+async+void+RunAsync()|3082004|重要备注|3082005|最好是标记为async+的方法不应该像链接文档所提到的那样返回。这方面的常见例外是事件处理程序，如单击按钮等。他们必须返回虚空。否则，我总是尝试在使用Task或Task<TResult>时返回async。这是个很好的练习，有很多原因。|3082006|现在您可以像下面这样运行await来运行Task了。没有await就不能使用async。|3082007|await+Task.Run(()+=>+MethodWithParameter(param));
//Code+here+and+below+in+the+same+method+will+not+run+until+AFTER+the+above+task+has+completed+in+one+fashion+or+another|3082008|因此，通常情况下，如果您await任务，您可以避免将传入的参数视为一个潜在的共享资源，同时也会遇到从多个线程修改某些内容的所有缺陷。另外，要小心闭包。我不会深入讨论这些内容，但是链接的文章做得很好。|3082009|关于Run和StartNew，我发现下面的代码是最重要的，真的。使用这两种方法都是有正当理由的，既不过时，也不“更好”。请注意，简单地用另一个替换一个是一个非常糟糕的主意，除非您理解这一点：|3082010|//These+are+exactly+the+same
Task.Run(x);+
Task.Factory.StartNew(x,+CancellationToken.None,
TaskCreationOptions.DenyChildAttach,+TaskScheduler.Default);

//These+are+also+exactly+the+same
Task.Factory.StartNew(x);
Task.Factory.StartNew(x,+CancellationToken.None,+
TaskCreationOptions.None,+TaskScheduler.Current);|3082011|边备注|3082012|话题有点离题，但是在WinForms+GUI线程上使用任何类型的“阻塞”都要小心，因为它被标记为[STAThread]。使用await一点也不会阻塞，但有时我确实看到它与某种阻塞一起使用。|3082013|"Block“是引号，因为严格意义上说是无法阻止WinForms+GUI线程。是的，如果在lock图形用户界面线程上使用WinForms，它仍然会泵出消息，尽管您认为它是“阻塞的”。事实并非如此。|3082014|在非常罕见的情况下，这会引起一些奇怪的问题。例如，您不想在绘图时使用lock的原因之一。但这是一个边缘和复杂的案件，但我看到它引起了疯狂的问题。为了完整起见，我注意到了这一点。|3082015|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/system.threading.tasks.task.configureawait(v=vs.110).aspx)|1|https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async|2|http://csharpindepth.com/Articles/Chapter5/Closures.aspx|3|https://stackoverflow.com/questions/4154429/apartmentstate-for-dummies/4156000#4156000^0|0|0|2|0|H|4|12|D|1P|A|2H|4|0|1F|6|0|9|5|F|5|10|M|1R|5|2N|4|3M|Y|0|B|M|1L|5|2L|E|3K|4|3F|2|2L|E|0|0|1C|4|1T|5|0|Q|5|1K|4|21|5|3O|5|3Z|4|0|A|8|0|6|8|G|5|0|0|0|4|0|6|5|23|4|28|D|2O|5|C|J|6|5|1|0|C|5|K|4|S|5|12|5|0|0|C|5|20|2|2|0|2|3|6|8|0|0|0|3|0|1C|B|1Q|5|0|19|4|K|I|3|0|Y|4|0^^$0|@$1|2|3|4|5|6|7|23|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|24|8|@$G|25|H|26|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|27|8|@$G|28|H|29|I|M]|$G|2A|H|2B|I|M]|$G|2C|H|2D|I|M]|$G|2E|H|2F|I|M]]|9|@]|A|$]]|$1|N|3|O|5|F|7|2G|8|@$G|2H|H|2I|I|M]]|9|@]|A|$]]|$1|P|3|Q|5|F|7|2J|8|@$G|2K|H|2L|I|M]|$G|2M|H|2N|I|M]|$G|2O|H|2P|I|M]|$G|2Q|H|2R|I|M]|$G|2S|H|2T|I|M]|$G|2U|H|2V|I|M]]|9|@]|A|$]]|$1|R|3|S|5|F|7|2W|8|@$G|2X|H|2Y|I|M]|$G|2Z|H|30|I|M]|$G|31|H|32|I|M]|$G|33|H|34|I|M]|$G|35|H|36|I|J]]|9|@$G|37|H|38|1|39]]|A|$]]|$1|T|3|U|5|F|7|3A|8|@$G|3B|H|3C|I|M]|$G|3D|H|3E|I|M]]|9|@]|A|$]]|$1|V|3|W|5|F|7|3F|8|@$G|3G|H|3H|I|M]|$G|3I|H|3J|I|M]|$G|3K|H|3L|I|M]|$G|3M|H|3N|I|M]|$G|3O|H|3P|I|M]]|9|@]|A|$]]|$1|X|3|Y|5|F|7|3Q|8|@$G|3R|H|3S|I|M]]|9|@]|A|$]]|$1|Z|3|10|5|F|7|3T|8|@$G|3U|H|3V|I|M]|$G|3W|H|3X|I|M]]|9|@]|A|$]]|$1|11|3|12|5|6|7|3Y|8|@]|9|@]|A|$B|C]]|$1|13|3|14|5|F|7|3Z|8|@$G|40|H|41|I|J]]|9|@]|A|$]]|$1|15|3|16|5|F|7|42|8|@$G|43|H|44|I|M]|$G|45|H|46|I|M]|$G|47|H|48|I|M]|$G|49|H|4A|I|M]|$G|4B|H|4C|I|J]]|9|@$G|4D|H|4E|1|4F]]|A|$]]|$1|17|3|18|5|F|7|4G|8|@$G|4H|H|4I|I|M]|$G|4J|H|4K|I|M]|$G|4L|H|4M|I|M]|$G|4N|H|4O|I|M]]|9|@]|A|$]]|$1|19|3|1A|5|6|7|4P|8|@]|9|@]|A|$B|C]]|$1|1B|3|1C|5|F|7|4Q|8|@$G|4R|H|4S|I|M]]|9|@$G|4T|H|4U|1|4V]]|A|$]]|$1|1D|3|1E|5|F|7|4W|8|@$G|4X|H|4Y|I|M]|$G|4Z|H|50|I|M]]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|51|8|@]|9|@]|A|$B|C]]|$1|1H|3|1I|5|F|7|52|8|@$G|53|H|54|I|J]]|9|@]|A|$]]|$1|1J|3|1K|5|F|7|55|8|@$G|56|H|57|I|M]|$G|58|H|59|I|M]]|9|@]|A|$]]|$1|1L|3|1M|5|F|7|5A|8|@$G|5B|H|5C|I|M]]|9|@$G|5D|H|5E|1|5F]]|A|$]]|$1|1N|3|1O|5|F|7|5G|8|@$G|5H|H|5I|I|M]]|9|@]|A|$]]|$1|1P|3|-4|5|F|7|5J|8|@]|9|@]|A|$]]]|1Q|$1R|$5|1S|1T|1U|A|$1V|1W]]|1X|$5|1S|1T|1U|A|$1V|1Y]]|1Z|$5|1S|1T|1U|A|$1V|20]]|21|$5|1S|1T|1U|A|$1V|22]]]]

<pre><code>private void RunAsync()
{
 //Beware of closures. String is immutable.
 string param = &quot;Hi&quot;;
 Task.Run(() =&gt; MethodWithParameter(param));
}

private void MethodWithParameter(string param)
{
 //Do stuff
}
</code></pre>
Edit
Due to popular demand I must note that the <code>Task</code> launched will run in parallel with the calling thread. Assuming the default <code>TaskScheduler</code> this will use the .NET <code>ThreadPool</code>. Anyways, this means you need to account for whatever parameter(s) being passed to the <code>Task</code> as potentially being accessed by multiple threads at once, making them shared state. This includes accessing them on the calling thread.
In my above code that case is made entirely moot. Strings are immutable. That's why I used them as an example. But say you're not using a <code>String</code>...
One solution is to use <code>async</code> and <code>await</code>. This, by default, will capture the <code>SynchronizationContext</code> of the calling thread and will create a continuation for the rest of the method after the call to <code>await</code> and attach it to the created <code>Task</code>. If this method is running on the WinForms GUI thread it will be of type <code>WindowsFormsSynchronizationContext</code>.
The continuation will run after being posted back to the captured <code>SynchronizationContext</code> - again only by default. So you'll be back on the thread you started with after the <code>await</code> call. You can change this in a variety of ways, notably using <a href="https://msdn.microsoft.com/en-us/library/system.threading.tasks.task.configureawait(v=vs.110).aspx" rel="noreferrer"><code>ConfigureAwait</code></a>. In short, the rest of that method will not continue until after the <code>Task</code> has completed on another thread. But the calling thread will continue to run in parallel, just not the rest of the method.
This waiting to complete running the rest of the method may or may not be desirable. If nothing in that method later accesses the parameters passed to the <code>Task</code> you may not want to use <code>await</code> at all.
Or maybe you use those parameters much later on in the method. No reason to <code>await</code> immediately as you could continue safely doing work. Remember, you can store the <code>Task</code> returned in a variable and <code>await</code> on it later - even in the same method. For instance, once you need to access the passed parameters safely after doing a bunch some other work. Again, you do not need to <code>await</code> on the <code>Task</code> right when you run it.
Anyways, a simple way to make this thread-safe with respect to the parameters passed to <code>Task.Run</code> is to do this:
You must first decorate <code>RunAsync</code> with <code>async</code>:
<pre><code>private async void RunAsync()
</code></pre>
Important Notes
Preferably the method marked <a href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async" rel="noreferrer"><code>async</code></a> should not return void, as the linked documentation mentions. The common exception to this is event handlers such as button clicks and such. They must return void. Otherwise I always try to return a <code>Task</code> or <code>Task&lt;TResult&gt;</code> when using <code>async</code>. It's good practice for a quite a few reasons.
Now you can <code>await</code> running the <code>Task</code> like below. You cannot use <code>await</code> without <code>async</code>.
<pre><code>await Task.Run(() =&gt; MethodWithParameter(param));
//Code here and below in the same method will not run until AFTER the above task has completed in one fashion or another
</code></pre>
So, in general, if you <code>await</code> the task you can avoid treating passed in parameters as a potentially shared resource with all the pitfalls of modifying something from multiple threads at once. Also, beware of <a href="http://csharpindepth.com/Articles/Chapter5/Closures.aspx" rel="noreferrer">closures</a>. I won't cover those in depth but the linked article does a great job of it.
Regarding <code>Run</code> and <code>StartNew</code> the code below I find most important to know, really. There are legitimate reasons to use either, neither is obsolete or &quot;better&quot; than the other. Be aware simply replacing one with the other is a very bad idea unless you understand this:
<pre><code>//These are exactly the same
Task.Run(x); 
Task.Factory.StartNew(x, CancellationToken.None,
TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

//These are also exactly the same
Task.Factory.StartNew(x);
Task.Factory.StartNew(x, CancellationToken.None, 
TaskCreationOptions.None, TaskScheduler.Current);
</code></pre>
Side Notes
A bit off topic, but be careful using any type of &quot;blocking&quot; on the WinForms GUI thread due to it being marked with <code>[STAThread]</code>. Using <code>await</code> won't block at all, but I do sometimes see it used in conjunction with some sort of blocking.
&quot;Block&quot; is in quotes because you technically <a href="https://stackoverflow.com/questions/4154429/apartmentstate-for-dummies/4156000#4156000">cannot block the WinForms GUI thread</a>. Yes, if you use <code>lock</code> on the WinForms GUI thread it will still pump messages, despite you thinking it's &quot;blocked&quot;. It's not.
This can cause bizarre issues in very rare cases. One of the reasons you never want to use a <code>lock</code> when painting, for example. But that's a fringe and complex case; however I've seen it cause crazy issues. So I noted it for completeness sake.

blocks|key|3082048|text|使用变量捕获“传入”参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3082049|var+x+=+rawData;
Task.Run(()+=>
{
++++//+Do+something+with+'x'
});|code-block|syntax|javascript|3082050|您也可以直接使用rawData，但您必须小心，如果在任务外部更改rawData的值(例如，for循环中的迭代器)，它还会更改任务内部的值。|offset|length|style|CODE|3082051|entityMap^0|0|0|8|7|W|7|19|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

Use variable capture to "pass in" parameters.

<pre><code>var x = rawData;
Task.Run(() =&gt;
{
 // Do something with 'x'
});
</code></pre>

You also could use <code>rawData</code> directly but you must be careful, if you change the value of <code>rawData</code> outside of a task (for example a iterator in a <code>for</code> loop) it will also change the value inside of the task.

blocks|key|742288|text|只需使用Task.Run|type|unstyled|depth|inlineStyleRanges|entityRanges|data|742289|var+task+=+Task.Run(()+=>
{
++++//this+will+already+share+scope+with+rawData,+no+need+to+use+a+placeholder
});|code-block|syntax|javascript|742290|或者，如果您想在方法中使用它，然后等待任务的执行。|742291|public+Task<T>+SomethingAsync<T>()
{
++++var+task+=+Task.Run(()+=>
++++{
++++++++//presumably+do+something+which+takes+a+few+ms+here
++++++++//this+will+share+scope+with+any+passed+parameters+in+the+method
++++++++return+default(T);
++++});

++++return+task;
}|742292|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just use Task.Run

<pre><code>var task = Task.Run(() =&gt;
{
 //this will already share scope with rawData, no need to use a placeholder
});
</code></pre>

Or, if you would like to use it in a method and await the task later

<pre><code>public Task&lt;T&gt; SomethingAsync&lt;T&gt;()
{
 var task = Task.Run(() =&gt;
 {
 //presumably do something which takes a few ms here
 //this will share scope with any passed parameters in the method
 return default(T);
 });

 return task;
}
</code></pre>

blocks|key|742297|text|从现在开始，您还可以：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|742298|Action<int>+action+=+(o)+=>+Thread.Sleep(o);
int+param+=+10;
await+new+TaskFactory().StartNew(action,+param)|code-block|syntax|javascript|742299|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

From now you can also :

<pre><code>Action&lt;int&gt; action = (o) =&gt; Thread.Sleep(o);
int param = 10;
await new TaskFactory().StartNew(action, param)
</code></pre>

blocks|key|1784300|text|我知道这是一个旧的线程，但我想分享一个解决方案，我不得不使用，因为接受的帖子仍然有一个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1784301|这一问题：|1784302|正如Alexandre所指出的，如果param+(在下面的函数中)在函数调用后不久发生变化，您可能会在MethodWithParameter中得到一些意想不到的行为。|offset|length|style|CODE|1784303|Task.Run(()+=>+MethodWithParameter(param));+|code-block|syntax|javascript|1784304|我的解决方案：|1784305|为了说明这一点，我最后编写了更类似于以下代码的代码：|1784306|(new+Func<T,+Task>(async+(p)+=>+await+Task.Run(()+=>+MethodWithParam(p)))).Invoke(param);|1784307|这使我能够安全地异步使用该参数，尽管在启动任务后参数更改非常快(这会导致发布的解决方案出现问题)。|1784308|使用这种方法，param+(值类型)获得它的值，因此即使异步方法在param更改后运行，p在运行这一行代码时也将拥有param所拥有的任何值。|1784309|entityMap^0|0|0|I|5|1F|J|0|0|0|0|0|0|7|5|X|5|18|1|1M|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@$F|13|G|14|H|I]|$F|15|G|16|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|17|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|1A|8|@]|9|@]|A|$M|N]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@$F|1D|G|1E|H|I]|$F|1F|G|1G|H|I]|$F|1H|G|1I|H|I]|$F|1J|G|1K|H|I]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|Z|$]]

I know this is an old thread, but I wanted to share a solution I ended up having to use since the accepted post still has an issue.

The Issue:

As pointed out by Alexandre Severino, if <code>param</code> (in the function below) changes shortly after the function call, you might get some unexpected behavior in <code>MethodWithParameter</code>.

<pre><code>Task.Run(() =&gt; MethodWithParameter(param)); 
</code></pre>

My Solution:

To account for this, I ended up writing something more like the following line of code:

<pre><code>(new Func&lt;T, Task&gt;(async (p) =&gt; await Task.Run(() =&gt; MethodWithParam(p)))).Invoke(param);
</code></pre>

This allowed me to safely use the parameter asynchronously despite the fact that the parameter changed very quickly after starting the task (which caused issues with the posted solution).

Using this approach, <code>param</code> (value type) gets its value passed in, so even if the async method runs after <code>param</code> changes, <code>p</code> will have whatever value <code>param</code> had when this line of code ran.

blocks|key|742405|text|还不清楚最初的问题是否与我的问题相同:希望在循环中计算时最大限度地使用CPU线程，同时保留迭代器的值，并保持内联，以避免将大量变量传递给工作者函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|742406|for+(int+i+=+0;+i+<+300;+i%2B%2B)
{
++++Task.Run(()+=>+{
++++++++var+x+=+ComputeStuff(datavector,+i);+//+value+of+i+was+incorrect
++++++++var+y+=+ComputeMoreStuff(x);
++++++++//+...
++++});
}|code-block|syntax|javascript|742407|我通过改变外部迭代器并用一个门来定位它的值来实现这一点。|742408|for+(int+ii+=+0;+ii+<+300;+ii%2B%2B)
{
++++System.Threading.CountdownEvent+handoff+=+new+System.Threading.CountdownEvent(1);
++++Task.Run(()+=>+{
++++++++int+i+=+ii;
++++++++handoff.Signal();

++++++++var+x+=+ComputeStuff(datavector,+i);
++++++++var+y+=+ComputeMoreStuff(x);
++++++++//+...

++++});
++++handoff.Wait();
}|742409|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It's unclear if the original problem was the same problem I had: wanting to max CPU threads on computation inside a loop while preserving the iterator's value and keeping inline to avoid passing a ton of variables to a worker function.

<pre><code>for (int i = 0; i &lt; 300; i++)
{
 Task.Run(() =&gt; {
 var x = ComputeStuff(datavector, i); // value of i was incorrect
 var y = ComputeMoreStuff(x);
 // ...
 });
}
</code></pre>

I got this to work by changing the outer iterator and localizing its value with a gate.

<pre><code>for (int ii = 0; ii &lt; 300; ii++)
{
 System.Threading.CountdownEvent handoff = new System.Threading.CountdownEvent(1);
 Task.Run(() =&gt; {
 int i = ii;
 handoff.Signal();

 var x = ComputeStuff(datavector, i);
 var y = ComputeMoreStuff(x);
 // ...

 });
 handoff.Wait();
}
</code></pre>

blocks|key|3082166|text|想法是避免使用像上面这样的信号。将int值注入结构可以防止这些值更改(在结构中)。我遇到了以下问题:在调用DoSomething+(i+)之前，循环var+i将发生变化(在调用=>+DoSomething(i，i_i)之前，在循环结束时我会递增)。有了结构，这种事就不会再发生了。查找讨厌的bug+:+DoSomething(i，i_i)看起来很棒，但从不确定每次调用时是否为i(或仅用i=100调用100次)调用它，因此->结构|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3082167|struct+Job+{+public+int+P1;+public+int+P2;+}
…
for+(int+i+=+0;+i+<+100;+i%2B%2B)+{
++++var+job+=+new+Job+{+P1+=+i,+P2+=+i+*+i};+//+structs+immutable...
++++Task.Run(()+=>+DoSomething(job));
}|code-block|syntax|javascript|3082168|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Idea is to avoid using a Signal like above.
Pumping int values into a struct prevents those values from changing (in the struct).
I had the following Problem: loop var i would change before DoSomething(i) was called (i was incremented at end of loop before ()=> DoSomething(i,ii) was called). With the structs it doesn't happen anymore. Nasty bug to find: DoSomething(i, ii) looks great, but never sure if it gets called each time with a different value for i (or just a 100 times with i=100), hence -> struct

<pre><code>struct Job { public int P1; public int P2; }
…
for (int i = 0; i &lt; 100; i++) {
 var job = new Job { P1 = i, P2 = i * i}; // structs immutable...
 Task.Run(() =&gt; DoSomething(job));
}
</code></pre>

blocks|key|742440|text|还有一种方法可以做到这一点。我觉得很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|742441|int+param;
ThreadPool.QueueUserWorkItem(someMethod,+param);
void+someMethod(object+parameter){
++++var+param+=+(int)+parameter;
++++//+do+the+job
}|code-block|syntax|javascript|742442|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There is another way of doing this. I found it useful.
<pre><code>int param;
ThreadPool.QueueUserWorkItem(someMethod, param);
void someMethod(object parameter){
 var param = (int) parameter;
 // do the job
}
</code></pre>

I'm working on a multi-tasking network project and I'm new on <code>Threading.Tasks</code>. I implemented a simple <code>Task.Factory.StartNew()</code> and I wonder how can I do it with <code>Task.Run()</code>?

Here is the basic code:

<pre><code>Task.Factory.StartNew(new Action&lt;object&gt;(
(x) =&gt;
{
 // Do something with 'x'
}), rawData);
</code></pre>

I looked into <code>System.Threading.Tasks.Task</code> in Object Browser and I couldn't find a <code>Action&lt;T&gt;</code> like parameter. There is only <code>Action</code> that takes <code>void</code> parameter and no type.

There are only 2 things similiar: <code>static Task Run(Action action)</code> and <code>static Task Run(Func&lt;Task&gt; function)</code> but can't post parameter(s) with both.

Yes, I know I can create a simple extension method for it but my main question is can we write it on single line with <code>Task.Run()</code>?

Task.Run with Parameter(s)?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我正在从事一个多任务网络项目，我是Threading.Tasks的新手。我实现了一个简单的Task.Factory.StartNew()，我想知道如何使用Task.Run()实现它以下是基本代码：Task.Factory.StartNew(new Action<object>((x) =>{ // Do some...

问具有参数的Task.Run？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问具有参数的Task.Run？EN