Accès valeur de retour du Thread.Start (), la fonction de délégué

J'ai un programme qui exécute une méthode par un Fil.Commencer. La méthode a une valeur de retour que j'aimerais avoir accès. Est-il un moyen de faire cela? Voici un échantillon...

var someValue = "";
Thread t = new Thread(delegate() { someValue = someObj.methodCall(); });

t.Start();

while (t.isAlive) Thread.Sleep(1000);

//Check the value of someValue

Donc, une fois que la boucle while se termine, le someValue doit être réglé -, mais parce qu'il est exécuté dans un autre thread, il ne va pas ensemble. Est-il un moyen simple pour obtenir un accès?

  • Avez-vous essayé de déclarer someValue comme volatile?
  • Même si cette technique de synchronisation est assez bizarre, il devrait travailler avec les volatiles modificateur. +1 pour Anon
InformationsquelleAutor bugfixr | 2009-12-21
  1. 6

    Lorsque l'appelant et le filetage de la méthode part d'une variable, vous avez déjà accès à l' - une fois que le thread est terminé, vous venez de vérifier someValue.

    Bien sûr, vous devez connaître lorsque la tige filetée de la méthode est complète pour que cela soit utile. Au fond, il y a deux façons de le faire:

    • Envoyer un rappel dans le filetage de la méthode qu'il peut exécuter quand il est terminé. Vous pouvez passer votre méthode de rappel someValue. Vous pouvez utiliser cette technique si vous n'avez pas de soins lorsque le rappel s'exécute.

    • Utiliser un WaitHandle quelconque (ou Thread.Join). Ces vous dire quand une ressource est prêt ou un événement est terminé. Cette technique est utile si vous souhaitez démarrer un thread, faire autre chose, puis attendre jusqu'à ce que le thread se termine avant de continuer. (En d'autres termes, il est utile si vous souhaitez synchroniser le dos avec le fil, juste pas tout de suite.)

    • S'il vous plaît montrer l'exemple de code.
    InformationsquelleAutor Jeff Sternal
  2. 5

    Je ne peux pas recréer votre question, j'ai le même code et je vois le résultat attendu. Si vous êtes juste d'aller dormir, le thread courant jusqu'à ce qu'elle est complète, vous pouvez simplement appeler .Join() sur le filetage et attendre d'être sûr qu'elle est effectuée en cours d'exécution.

    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);

    }
}
    • Je dors parce que j'ai besoin de regarder pour l'utilisateur annule et signal le thread de s'arrêter.
    • Chu: Ce que vous décrivez est un scénario classique pour un composant BackgroundWorker (si vous êtes sur Windows Forms). C'est beaucoup mieux que de dormir le thread d'INTERFACE utilisateur pour une seconde à la fois.
    • +1 pour le BackgroundWorker. Il a intégré des méthodes pour montrer la progression de l'exécution et l'annulation de la tâche, pour ne pas mentionner de ne pas verrouiller le thread de l'INTERFACE utilisateur, tandis que c'est l'exécution. Si l'utilisateur appuie sur un bouton annuler sur votre thread de l'INTERFACE utilisateur vous pouvez configurer l'indicateur sur le backgroundworker et de vérifier ensuite la CancellationPending bien savoir quand sortir de votre async tâche.
    InformationsquelleAutor Jacob Ewald
  3. 2

    L'une des méthodes possibles pour renvoyer une valeur à partir d'un Thread est d'utiliser une classe de contexte en tant que paramètre de l'objet. Il peut être utilisé pour transmettre des paramètres et de récupérer le résultat en tant que bien.

    Si en revanche, vous pouvez utiliser une classe BackgroundWorker, il a déjà dédié un objet de Résultat - qui fonctionne de la même manière. Mais BackgroundWorker ne peuvent pas être utilisés à certaines fins (par exemple, il n'a pas le personnel de soutien de l'Appartement de l'État).

    Gardez à l'esprit que vous ne devriez pas lire à partir de ctx.Résultat jusqu'à ce que le thread est terminé (c'est à dire 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; }
    }
    InformationsquelleAutor andrew.fox
  4. 1

    Vous pouvez récupérer des données à partir du Fil à l'aide de la fonction de délégué de rappel. Le délégué peut servir de pont entre le fil et l'appelant. Par exemple: 

    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);
    }
}
    InformationsquelleAutor Jackypengyu
  5. 0

    Ont un look à la Modèle De Programmation Asynchrone.

    Dans l'une des communes les modèles le modèle décrit, votre classe exposer BeginXXX et EndXXX méthodes. L'ex commence l'opération asynchrone et renvoie un objet IAsyncResult. Celui-ci accepte l'objet IAsyncResult comme argument, bloque le thread appelant jusqu'à ce que l'opération est terminée et renvoie la valeur requise.

    InformationsquelleAutor Adam Ralph