How to call a method in a thread using aruguments and return some value

Question

I like to call a method in a stream using aruguments and return some value here is an example

class Program
    {
        static void Main()
        {
            Thread FirstThread = new Thread(new ThreadStart(Fun1));
            Thread SecondThread = new Thread(new ThreadStart(Fun2));
            FirstThread.Start();
            SecondThread.Start();        


        }
        public static void Fun1()
        {
            for (int i = 1; i <= 1000; i++)
            {
                Console.WriteLine("Fun1 writes:{0}", i);
            }
        }
        public static void Fun2()
        {
            for (int i = 1000; i >= 6; i--)
            {
                Console.WriteLine("Fun2 writes:{0}", i);
            }
        }

    }

I know that this example above works successfully, but if fun1 method looks like this

public int fun1(int i,int j)
{
    int k;
    k=i+j;
    return k;
}

then how can I call it in a stream. Is it possible. Any organ Help me .. I need all possible ways of this

Answer 1

This may be a different approach. Here, the input is passed as a parameterized Thread and the return type is passed in the event dellet, so that when the thread completes, the delegate will call. It will be good to get the result when the thread is completed.

 public class ThreadObject
    {
        public int i;
        public int j;
        public int result;
        public string Name;
    }



    public delegate void ResultDelegate(ThreadObject threadObject);

    public partial class Form1 : Form
    {

        public event ResultDelegate resultDelete;

        public Form1()
        {
            InitializeComponent();

            resultDelete += new ResultDelegate(resultValue);
        }

        void resultValue(ThreadObject threadObject)
        {
            MessageBox.Show("Thread Name : " + threadObject.Name + " Thread Value : " + threadObject.result);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            ThreadObject firstThreadObject = new ThreadObject();
            firstThreadObject.i = 0;
            firstThreadObject.j = 100;
            firstThreadObject.Name = "First Thread";

            Thread firstThread = new Thread(Fun);
            firstThread.Start(firstThreadObject);


            ThreadObject secondThreadObject = new ThreadObject();
            secondThreadObject.i = 0;
            secondThreadObject.j = 200;
            secondThreadObject.Name = "Second Thread";

            Thread secondThread = new Thread(Fun);
            secondThread.Start(secondThreadObject);

        }


        private void Fun(object parameter)
        {
            ThreadObject threadObject = parameter as ThreadObject;

            for (; threadObject.i < threadObject.j; threadObject.i++)
            {
                threadObject.result += threadObject.i;

                Thread.Sleep(10);
            }

            resultValue(threadObject);
        }
    }

Answer 2

:

Thread FirstThread = new Thread(() => Fun1(5, 12));

- :

Thread FirstThread = new Thread(() => {
    int i = Fun1(5, 12);
    // do something with i
});

, " -" ( (Main) " " ).

# 2.0 ( ), :

Thread FirstThread = new Thread((ThreadStart)delegate { Fun1(5, 12); });

Thread FirstThread = new Thread((ThreadStart)delegate {
    int i = Fun1(5, 12);
    // do something with i
});

Answer 3

. :

int fun1, fun2;
Thread FirstThread = new Thread(() => {
    fun1 = Fun1(5, 12);
});
Thread SecondThread = new Thread(() => {
    fun2 = Fun2(2, 3); 
});

FirstThread.Start();
SecondThread.Start();
FirstThread.Join();
SecondThread.Join();

Console.WriteLine("Fun1 returned {0}, Fun2 returned {1}", fun1, fun2);

Answer 4

:

// Create function delegate (it can be any delegate)
var FunFunc = new Func<int, int, int>(fun1);
// Start executing function on thread pool with parameters
IAsyncResult FunFuncResult = FunFunc.BeginInvoke(1, 5, null, null);
// Do some stuff
// Wait for asynchronous call completion and get result
int Result = FunFunc.EndInvoke(FunFuncResult);

, . , .

Answer 5

ParameterizedThreadStart Thread. . Object, . , .

, , "". :)

:

void Main()
{
    var thread = new Thread(Fun);
    var obj = new ThreadObject
    {
        i = 1,
        j = 15,
    };

    thread.Start(obj);
    thread.Join();
    Console.WriteLine(obj.result);
}

public static void Fun(Object obj)
{
    var threadObj = obj as ThreadObject;
    threadObj.result = threadObj.i + threadObj.j;
}

public class ThreadObject
{
    public int i;
    public int j;
    public int result;
}

Answer 6

; :

static ThreadStart CurryForFun(int i, int j)
{ // also needs a target object if Fun1 not static
    return () => Fun1(i, j);
}

Thread FirstThread = new Thread(CurryForFun(5, 12));

or write your own capture type (this is generally comparable to what the compiler does for you when you use the anon methods / lambdas with the captured variables, but are implemented differently):

class MyCaptureClass
{
    private readonly int i, j;
    int? result;
    // only available after execution
    public int Result { get { return result.Value; } }
    public MyCaptureClass(int i, int j)
    {
        this.i = i;
        this.j = j;
    }
    public void Invoke()
    { // will also need a target object if Fun1 isn't static
        result = Fun1(i, j);
    }
}
...
MyCaptureClass capture = new MyCaptureClass(5, 12);
Thread FirstThread = new Thread(capture.Invoke);
// then in the future, access capture.Result

Answer 7

try backgroundWorker http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx you can pass the value to the DoWork event using DoWorkEventArgs and get the value in RunWorkerCompleted.