fil avec type de retour

Idéalement, utilisez la bibliothèque parallèle de tâches et la Task place … mais sinon, vous devrez configurer une sorte de variable partagée pour représenter le résultat. une fois le fil terminé, lisez le résultat sur le fil de votre choix.

Une autre alternative consiste à utiliser un délégué qui retourne une valeur BeginInvoke et à appeler BeginInvoke sur ce délégué pour l’exécuter sur le pool de threads, en renvoyant un IAsyncResult qui vous permettra d’attendre le résultat.

Les threads n’ont pas de valeur de retour. Mais il existe des solutions de contournement telles que l’enveloppement du fil dans une classe. Cette solution utilise une classe pour stocker à la fois la méthode à exécuter (indirectement) et la valeur renvoyée. La classe peut être utilisée pour toute fonction et tout type de retour. Il vous suffit d’instancier l’object à l’aide du type de valeur de retour, puis de transmettre la fonction à appeler via un lambda (ou un délégué).

 public class ThreadedMethod { private T result; public T Result { get { return result; } private set { result = value; } } public ThreadedMethod() { } //If supporting .net 3.5 public void ExecuteMethod(Func func) { Result = func.Invoke(); } //If supporting only 2.0 use this and //comment out the other overload public void ExecuteMethod(Delegate d) { Result = (T)d.DynamicInvoke(); } } 

Pour utiliser ce code, vous pouvez utiliser un Lambda (ou un délégué). Voici l’exemple utilisant lambdas:

 ThreadedMethod threadedMethod = new ThreadedMethod(); Thread workerThread = new Thread((unused) => threadedMethod.ExecuteMethod(() => SomeMethod())); workerThread.Start(); workerThread.Join(); if (threadedMethod.Result == false) { //do something about it... } 

Si vous attendez simplement le résultat, pourquoi utiliser un fil de discussion?

 bool result = doThis(); 

Normalement, avec une exécution asynchrone, vous devez configurer un rappel pour obtenir le résultat:

 Func handle = doThis; handle.BeginInvoke(Callback, handle); // asynchronous invocation // can do more work... 

Et puis vous obtiendrez le résultat dans le rappel comme ceci:

 void Callback(IAsyncResult ar) { bool result = ((Func)ar.AsyncState).EndInvoke(ar); // ... } 

  static void Main(ssortingng[] args) { bool returnValue = false; new Thread( () => { returnValue =test() ; }).Start(); Console.WriteLine(returnValue); Console.ReadKey(); } public static bool test() { return true; } 

Vous pouvez avoir une variable membre que le thread va définir, puis créer un descripteur d’événement que le thread définira lorsqu’il se terminera. Vous attendez le descripteur d’événement, puis vérifiez la valeur booléenne une fois que le descripteur a été signalé.

Je ne vous suggérerais pas d’avoir un délégué qui retourne une certaine valeur. Il existe une meilleure approche pour obtenir une valeur d’une méthode une fois que celle-ci est exécutée, c’est-à-dire en utilisant des parameters “out”.

Dans votre cas, vous pouvez avoir quelque chose comme le code ci-dessous:

 public delegate void DoThisWithReturn(out bool returnValue); public static void DoThisMethod(out bool returnValue) { returnValue = true; } public static void Start() { var delegateInstance = new DoThisWithReturn(DoThisMethod); bool returnValue; var asyncResult = delegateInstance.BeginInvoke(out returnValue, null, null); //Do Some Work.. delegateInstance.EndInvoke(out returnValue, asyncResult); var valueRecievedWhenMethodDone = returnValue; } 

 public class ThreadExecuter where T : class { public delegate void CallBack (T returnValue); public delegate T Method(); private CallBack callBack; private Method method; private Thread t; public ThreadExecuter(Method _method, CallBack _callBack) { this.method = _method; this.callBack = _callBack; t = new Thread(this.Process); } public void Start() { t.Start(); } public void Abort() { t.Abort(); callBack(null); } public void Join() { t.Join(); } private void Process() { callBack(method()); } } 

usage:

 namespace Tester { class Program { static void Main(ssortingng[] args) { #region [ Paket Data] ... #endregion for (int i = 0; i < 20; i++) { Packet packet = new Packet() { Data = data, Host = "www.google.com.tr", Port = 80, Id = i }; SocketManager sm = new SocketManager() { packet = packet };  ThreadExecuter te = new ThreadExecuter(sm.Send, writeScreen); te.Start(); } Console.WriteLine("bitti."); Console.ReadKey(); } private static void writeScreen(Packet p) { Console.WriteLine(p.Id + " - " + p.Status.ToSsortingng()); } } } 

Source: http://onerkaya.blogspot.com/2013/04/returning-value-from-thread-net.html