C# Return value from function invoked in thread

Question

I have a calculating thread function which invokes message function from other thread using Invoke and I want that calculating thread to get value(of valuetype, like integer) from that message function. How can I do this?

The problem is that I still get old value of x variable after Invoke(...) and I expect value of 15

delegate void mes_del(object param);

void MyThreadFunc()
{
...
int x = 5;
object [] parms = new object []{x};
Invoke(new mes_del(MessageFunc), (object)parms);
...
}

void MessageFunc(object result)
{
   int res = 15;
   (result as object[])[0] = res;
}

I tried some approaches like using object[], object as parameters with no success. I though boxing/unboxing operations should occur in such a case but they don't. Should I use auxiliary type like it is done in .NET event mode and create mediator object like class holder { public int x; }

Answer 1

Perhaps the best answer to your question is in .NET 4.0 System.Threading.Tasks

Here the main thread is blocked till the Result is returned by the method called on the other thread. If the result is already returned by the main thread reaches the WriteLine there is no blocking.

Task task = Task.Factory.StartNew(SomeMethod);
Console.WriteLine(task.Result);

public static string SomeMethod()
{
    return "Hello World";
}

OR

Task task = Task.Factory.StartNew(() => { return "Hello World"; } );
Console.WriteLine(task.Result);

Check this blog for more interesting samples.

Answer 2

Just return value from method

void MyThreadFunc()
{
...
int x = 5;
object [] parms = new object []{x};
var callResult = (int)Invoke((Func<object,int>)MessageFunc, (object)parms);
...
}

int MessageFunc(object result)
{
   int res = 15;
   return res;
}

Answer 3

int x = 5;
object [] parms = new object []{x};

What the above code does is declare a local variable, assign it the value 5, then construct an object[] array containing one element which is a copy of that local variable.

You then pass this array into your Invoke call.

I think what you'll find is that after Invoke is called, parms[0] is 15. But this does not affect x, which would actually have to be passed as a ref parameter for any method to be able to modify its local value.

---

What I've seen done before is something like this:

class Box<T>
{
    public T Value { get; set; }
}

Then you could do:

void MyThreadFunc()
{
    var x = new Box<int> { Value = 5 };

    // By the way, there's really no reason to define your own
    // mes_del delegate type.
    Invoke(new Action<Box<int>>(MessageFunc), x);
}

void MessageFunc(Box<int> arg)
{
    arg.Value = 15;
}

Answer 4

Are you talking about Control.Invoke from Windows Forms? If yes, the method can also return a result, so you can write:

delegate int mes_del(int param);

void MyThreadFunc() {
  int x = 5;
  object [] parms = new object []{x};
  x = (int)Invoke(new mes_del(MessageFunc), x);
  // you'll get a new value of 'x' here (incremented by 10)
}

int MessageFunc(int result) {
  return result + 10;
}

Your code probably didn't work, because you were accessing x instead of picking a new value from the array (that should be modified). However, using an overload that returns a new value should be a much clearer solution.