Access return value from Thread.Start()'s delegate function

I can't recreate your issue, I've got the same code and I'm seeing the expected result. If you're just going to sleep the current thread until it's complete you could just call .Join() on the thread and wait to be sure it's done executing.

public partial class Form1 : Form { public Form1() { InitializeComponent(); } string someValue = ""; private void Form1_Load(object sender, EventArgs e) { Thread t = new Thread(delegate() { someValue = "asdf"; }); t.Start(); t.Join(); //while (t.IsAlive) Thread.Sleep(1000); System.Diagnostics.Debug.Print(someValue); } } 

One of possible methods to return a value from a Thread is to use a context class as a parameter object. It can be used to pass parameters and retrieve the result as well.

If on the other hand you could use a BackgroundWorker class, it has already a dedicated Result object - that works the same way. But BackgroundWorker cannot be used for some purposes (for instance, it doesn't support STA Apartment State).

Keep in mind that you shouldn't read from ctx.Result until the thread is finished (i.e. t.IsAlive == false).

 void runThread() { ThreadContext ctx = new ThreadContext(); ctx.Value = 8; Thread t = new Thread(new ParameterizedThreadStart(MyThread)); //t.SetApartmentState(ApartmentState.STA); // required for some purposes t.Start(ctx); // ... t.Join(); Console.WriteLine(ctx.Result); } private static void MyThread(object threadParam) { ThreadContext context = (ThreadContext)threadParam; context.Result = context.Value * 4; // compute result } class ThreadContext { public int Value { get; set; } public int Result { get; set; } } 

You can retrieve data from Thread function using delegate callback. The delegate can serve as a bridge between thread and the caller. For example:

public delegate void DelReturnValue(string value); public class SayHello { private string _name; private DelReturnValue _delReturnValue; public SayHello(string name, DelReturnValue delReturnValue) { _name = name; _delReturnValue = delReturnValue; } public void SayHelloMethod() { _delReturnValue(_name); } } public class Caller { private static string _returnedValue; public static void ReturnValue(string value) { _returnedValue = value; } public static void Main() { DelReturnValue delReturnValue=new DelReturnValue(ReturnValue); SayHello sayHello = new SayHello("test", delReturnValue); Thread newThread = new Thread(new ThreadStart(sayHello.SayHelloMethod)); newThread.Start(); Thread.Sleep(1000); Console.WriteLine("value is returned: " + _returnedValue); } } 

Have a look at the Asynchronous Programming Model.

In one of the common patterns the model describes, your class will expose BeginXXX and EndXXX methods. The former starts the asynchronous operation and returns an IAsyncResult object. The latter accepts the IAsyncResult object as an argument, blocks the calling thread until the operation is complete and returns the required value.