Thread th = new Thread(delegate {ThreadProc(myParam);});

...

void ThreadProc(MyParam myParam) {...}

14.5.15.2 Anonymous method blocks
...
The block has access to the outer variables (§14.5.15.3) of the anonymous method. Access of an outer
variable will reference the instance of the variable that is active at the time the anonymous-methodexpression
is evaluated (§14.5.15.4).

Thread Constructor (ParameterizedThreadStart)
Thread.Start Method (Object)

AVK>Thread th = new Thread(delegate {ThreadProc(myParam);});
AVK>...
AVK>void ThreadProc(MyParam myParam) {...}
AVK>

        string str = "This is a test!";
        ThreadStart ts = new ThreadStart(delegate() { Method(str); });
        Thread t = new Thread(ts);
        str = "This is a second test!";
        t.Start();
        t.Join();
        
    static void Method(string str)
    {
        Console.WriteLine(str);
    }

public void Start (object parameter)

    public class Main
    {
        public Main()
        {
            CustomThread customThread = new CustomThread(new string[]{"1", "2", "3"}); 
            Thread thread = new Thread(new ThreadStart(customThread.Start));  
        }

        public void ThreadWorker()
        {
        }
    }

    public class CustomThread
    {
        private object _data;

        public object Data
        {
            get
            {
                return _data;
            }
        }

        public CustomThread(object data)
        {
            this._data = data;
        }

        public void Start()
        {
            // do smth with _data
        }
    }

AVK>Thread th = new Thread(delegate {ThreadProc(myParam);});

AVK>...

AVK>void ThreadProc(MyParam myParam) {...}
AVK>

Error    5    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)'

static void Main(string[] args)
{
    string str = "This is a test!";
    ThreadStart ts = new ThreadStart(delegate() { Method(str); str = "Учите матчасть, AndrewVK ;)"; });
    Thread t = new Thread(ts);
    str = "This is a second test!";
    t.Start();
    t.Join();
    Console.WriteLine(str);

    Console.ReadLine();
}

private static void Method(string str)
{
    Console.WriteLine(str);
}

    StringBuilder str = new StringBuilder("This is a test!");
    ThreadStart ts = new ThreadStart(delegate() { Method(str); });
    Thread t = new Thread(ts);
    str.Length = 0; str.Append("This is a second test!");
    t.Start();
    t.Join();

AVK>    StringBuilder str = new StringBuilder("This is a test!");
AVK>    ThreadStart ts = new ThreadStart(delegate() { Method(str); });
AVK>    Thread t = new Thread(ts);
AVK>    str.Length = 0; str.Append("This is a second test!");
AVK>    t.Start();
AVK>    t.Join();
AVK>

str = new StringBuilder("This is a second test!");

any changes to such variables from within the body of anonymous method are not visible after it returns. This is because anonymous methods are in fact implemented in a way very similar to anonymous inner classes in Java, and do not have direct access to variables from the enclosing scope; rather, the method makes a copy of all local variables it uses.

любые именения этих переменных, сделанные внутри тела анонимного метода не видны после возврата из анонимного метода. Так происходит потому что анонимные методы в действительности реализованы способом, очень схожим с тем как реализованы inner-классы в джаве. и (анонимные методы) не имеют прямого доступа к переменным из внешней области видимости; метод создает копию всех локальных переменных, которые он ипользует.

L>>Но, как минимум, по отношению к .net-у он не верен.

delegate { Method(str); }

class TEST
{
   static public void Main()
   {
      MyThreadData td = new MyThreadData();
      td.str = "This is a test!";

      Thread t = new Thread(td.threadProc);
      t.Start();
      t.Join();
   }
   class MyThreadData
   {
      public string str;
      public void threadProc()
      {
         Console.WriteLine("{0}", str);
      }
   }
}

S>delegate { Method(str); }
S>

    private static void Method(string str)
    {
        Console.WriteLine(str);
    }

    private static void Main(string[] args)
    {
        Temp temp = new Temp();
        temp.str = "This is a test!";
        ThreadStart start1 = new ThreadStart(temp.Method);
        Thread thread1 = new Thread(start1);
        temp.str = "This is a second test!";
        thread1.Start();
        thread1.Join();
        Console.ReadLine();
    }
    
    private sealed class Temp
    {
        public string str;
        public void Method()
        {
            Test.Method(str);
        }
    }