wątek z wieloma parametrami

Question

Czy ktoś wie, jak przekazać wiele parametrów do procedury Thread.Start?

Pomyślałem o rozszerzeniu klasy, ale klasa wątku C# jest zapieczętowana.

Oto co myślę, że kod będzie wyglądać następująco:

... 
    Thread standardTCPServerThread = new Thread(startSocketServerAsThread); 

    standardServerThread.Start(orchestrator, initializeMemberBalance, arg, 60000); 
... 
} 

static void startSocketServerAsThread(ServiceOrchestrator orchestrator, List<int> memberBalances, string arg, int port) 
{ 
    startSocketServer(orchestrator, memberBalances, arg, port); 
} 

BTW uruchomić liczbę wątków o różnych orkiestratorów, salda i portów. Proszę również rozważyć bezpieczeństwo wątków.

Answer 1

Spróbuj użyć wyrażenia lambda do przechwytywania argumenty.

Thread standardTCPServerThread = 
    new Thread(
    unused => startSocketServerAsThread(initializeMemberBalance, arg, 60000) 
); 

Answer 2

Musisz zawinąć je w jeden obiekt.

Tworzenie niestandardowej klasy do przekazywania parametrów jest jedną z opcji. Możesz także użyć tablicy lub listy obiektów i ustawić w niej wszystkie swoje parametry.

Answer 3

Nie możesz. Utwórz obiekt, który zawiera wymagane paramery i przekazaj to. W funkcji wątku odrzuć obiekt z powrotem do jego typu.

Answer 4

Możesz wziąć tablicę obiektów i przekazać ją w wątku. Zdaj

System.Threading.ParameterizedThreadStart(yourFunctionAddressWhichContailMultipleParameters) 

Do konstruktora wątków.

yourFunctionAddressWhichContailMultipleParameters(object[]) 

Już ustawiłeś całą wartość w objArray.

trzeba abcThread.Start(objectArray)

Answer 5

Można curry funkcji "praca" z wyrażenia lambda:

public void StartThread() 
{ 
    // ... 
    Thread standardTCPServerThread = new Thread(
     () => standardServerThread.Start(/* whatever arguments */)); 

    standardTCPServerThread.Start(); 
} 

Answer 6

użyć 'Zadanie' wzór:

public class MyTask 
{ 
    string _a; 
    int _b; 
    int _c; 
    float _d; 

    public event EventHandler Finished; 

    public MyTask(string a, int b, int c, float d) 
    { 
     _a = a; 
     _b = b; 
     _c = c; 
     _d = d; 
    } 

    public void DoWork() 
    { 
     Thread t = new Thread(new ThreadStart(DoWorkCore)); 
     t.Start(); 
    } 

    private void DoWorkCore() 
    { 
     // do some stuff 
     OnFinished(); 
    } 

    protected virtual void OnFinished() 
    { 
     // raise finished in a threadsafe way 
    } 
} 

Answer 7

Oto kawałek kodu, który używa Podejście macierzy obiektowej wspomniane tutaj kilka razy.

... 
    string p1 = "Yada yada."; 
    long p2 = 4715821396025; 
    int p3 = 4096; 
    object args = new object[3] { p1, p2, p3 }; 
    Thread b1 = new Thread(new ParameterizedThreadStart(worker)); 
    b1.Start(args); 
    ... 
    private void worker(object args) 
    { 
     Array argArray = new object[3]; 
     argArray = (Array)args; 
     string p1 = (string)argArray.GetValue(0); 
     long p2 = (long)argArray.GetValue(1); 
     int p3 = (int)argArray.GetValue(2); 
     ... 
    }> 

Answer 8

NET 2 konwersja JaredPar odpowiedzieć

Thread standardTCPServerThread = new Thread(delegate (object unused) { 
     startSocketServerAsThread(initializeMemberBalance, arg, 60000); 
    }); 

Answer 9

Czytałem Twoi forum, aby dowiedzieć się, jak to zrobić i zrobiłem to w ten sposób - może być przydatna dla kogoś. Przekazuję argumenty w konstruktorze, który tworzy dla mnie działający wątek, w którym będzie wykonywana moja metoda - metoda execute().

using System; 

using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Diagnostics; 
using System.Windows.Forms; 
using System.IO; 
using System.Threading; 
namespace Haart_Trainer_App 

{ 
    class ProcessRunner 
    { 
     private string process = ""; 
     private string args = ""; 
     private ListBox output = null; 
     private Thread t = null; 

    public ProcessRunner(string process, string args, ref ListBox output) 
    { 
     this.process = process; 
     this.args = args; 
     this.output = output; 
     t = new Thread(new ThreadStart(this.execute)); 
     t.Start(); 

    } 
    private void execute() 
    { 
     Process proc = new Process(); 
     proc.StartInfo.FileName = process; 
     proc.StartInfo.Arguments = args; 
     proc.StartInfo.UseShellExecute = false; 
     proc.StartInfo.RedirectStandardOutput = true; 
     proc.Start(); 
     string outmsg; 
     try 
     { 
      StreamReader read = proc.StandardOutput; 

     while ((outmsg = read.ReadLine()) != null) 
     { 

       lock (output) 
       { 
        output.Items.Add(outmsg); 
       } 

     } 
     } 
     catch (Exception e) 
     { 
      lock (output) 
      { 
       output.Items.Add(e.Message); 
      } 
     } 
     proc.WaitForExit(); 
     var exitCode = proc.ExitCode; 
     proc.Close(); 

    } 
} 
} 

Answer 10

void RunFromHere() 
{ 
    string param1 = "hello"; 
    int param2 = 42; 

    Thread thread = new Thread(delegate() 
    { 
     MyParametrizedMethod(param1,param2); 
    }); 
    thread.Start(); 
} 

void MyParametrizedMethod(string p,int i) 
{ 
// some code. 
} 

Answer 11

Trzeba zdać pojedynczy obiekt, ale jeśli jest zbyt wiele kłopotów, aby zdefiniować swój własny obiekt do jednorazowego użytku, można użyć krotka.