如何通过lambda表达式“将任何数量的参数传递给方法”？

Question

I follow Passing Data to a Thread of "PART 1: GETTING STARTED" of "Threading in C#" by Joseph Albahari.

Namely the passage:

====== Start of quote

" With this approach, you can pass in (to where?) any number of arguments to the method . You can even wrap the entire implementation in a multi-statement lambda:

new Thread (() =>  
{  
  Console.WriteLine ("I'm running on another thread!");  
  Console.WriteLine ("This is so easy!");  
}).Start();*  

You can do the same thing almost as easily in C# 2.0 with anonymous methods:

  new Thread (delegate()  
  {  
  ...
  }).Start();

============ End of quote

That is, I've tried the "easily" as:

 new Thread (delegate { Console.WriteLine("I'm running on another thread!"); Console.WriteLine("This is so easy!"); } ).Start(); 

but it produces the error:

The call is ambiguous between the following methods or properties: 'System.Threading.Thread.Thread(System.Threading.ThreadStart)' and 'System.Threading.Thread.Thread(System.Threading.ParameterizedThreadStart)'

1. How can you disambiguate the code in order to run it? Answered (missed parenthesis. Anyway, it wasn't the original main question)
2. Also, I did not quite grasp where is the empty list () => directed/applied to?
3. A well as, what is the method to which " you can pass in any number of arguments to the method"?
4. How to understand the passing of (any number of) arguments through the empty list?

Update (addressing Jon Skeet's comment):
No, I am not stuck with C# 2.

The same question(s) to the previous passage :

========== Start of quote:
" The easiest way to pass arguments to a thread's target method is to execute a lambda expression that calls the method with the desired arguments:

 static void Main() { Thread t = new Thread ( () => Print ("Hello from t!") ); t.Start(); } static void Print (string message) { Console.WriteLine (message); } 

With this approach, you can pass in any number of arguments to the method."

=============== End of quote

Update2:
The most complete answer is IMO by @Lee though I marked as correct another answer for guessing to answer at once what I have not even originally asked - how to put something in empty parenthesis (I'm already afraid to call it by list or by arguments)

Answer 1

You need to make the argument list explicit:

new Thread
(delegate()
  {
    Console.WriteLine("I'm running on another thread!");
    Console.WriteLine("This is so easy!");
   }
).Start();

The delegate keyword allows you to define an anonymous method . Lambda expressions (ie using the () => { ... } syntax) are similar, however using delegate allows you to omit the parameter list. This is ambiguous in this case, since there are two constructors for Thread which take different delegate types. One takes a ThreadStart which is defined as

delegate void ThreadStart();

and the other takes a ParameterizedThreadStart which is defined as:

delegate void ParameterizedThreadStart(object state);

Since you are omitting the parameter list, the compiler does not know which delegate type you are using.

I assume the "any number of arguments" are variables which are closed-over by your delegate. For example you could have:

string message = "This is so easy!";
var thread = new Thread(delegate() {
    Console.WriteLine(message);
});
thread.Start();

You can use a ParameterizedThreadStart to pass an arbitrary object to your thread delegate eg

public class ThreadData {
   //properties to pass to thread
}

ThreadData data = new ThreadData { ... }
Thread thread = new Thread((object state) => {
    ThreadData data = (ThreadData)state;
});

thread.Start(data);

Answer 2

You need the parentheses after delegate to specify the parameters, in this case no parameters:

new Thread(
  delegate() {
    Console.WriteLine("I'm running on another thread!");
    Console.WriteLine("This is so easy!");
  }
).Start();

The "any number of arguments" that the author is talking about is that you can use data from the scope where the delegate is created inside the code that runs in a separate thread, without having to pass the data to the Start method:

string msg1 = "I'm running on another thread!";
string msg2 = "This is so easy!";
new Thread(
  delegate() {
    Console.WriteLine(msg1);
    Console.WriteLine(msg2);
  }
).Start();

What's actually happening is that the variables are no longer local variables in the method, instead they are automatically stored in a closure, which the delegate shares with the method where it is defined.

This works well as long as you only want to start one thread. If you want to start multiple threads that uses different data, you would either pass the data into the Start method or create a class that can hold the data, put the code for the thread in the class, and create one instance for each thread that you start.

Answer 3

In order to resolve ambiguous call, you can add empty parentheses (delegate will be treated as ThreadStart delegate):

new Thread(delegate() {
    Console.WriteLine("I'm running on another thread!");
    Console.WriteLine("This is so easy!");
}).Start();

Or add state parameter (delegate will be treated as ParametrizedThreadStart) It works, but it's odd, because you don't need that parameter.

new Thread(delegate(object state) {
    Console.WriteLine("I'm running on another thread!");
    Console.WriteLine("This is so easy!");
}).Start();

Or cast delegate to ThreadStart

new Thread((ThreadStart)delegate {
    Console.WriteLine("I'm running on another thread!");
    Console.WriteLine("This is so easy!");
}).Start();

Answer 4

() => isn't an empty list in C#. In the context it is used in the book it is the start of a lambda expression. The () means that this expression takes no arguments.