Visual Studio pendant le débogage: l'évaluation de la fonction nécessite l'exécution de tous les threads

msdn forum:

Ce n'est pas une erreur en soi, mais plus d'une caractéristique de votre débogueur. Certaines propriétés requièrent que le code soit exécuté pour que la propriété soit lue, mais si cela nécessite une interaction de threads croisés, alors d'autres threads peuvent devoir s'exécuter aussi. Le débogueur ne fait pas cela automatiquement, mais il le peut certainement, avec votre permission. Il suffit de cliquer sur la petite icône d'évaluation et il exécutera votre code et d'évaluer le propriété.

Pour plus de détails sur ce comportement cochez cette excelent article

MUG4N a en effet fourni une réponse correcte mais si vous survolez la ligne de code dans debug, vous pouvez regarder quelque chose comme ce qui suit. Si c'est le cas, cliquez sur l'icône petite réévaluation surlignée dans l'image ci-dessous...

NB: j'ai obtenu cette image en épinglant, normalement les icones de réévaluation sont au milieu de la fenêtre et pas en bas de la colonne de gauche.

vous devez faire l'appel de thread sûr parce que l'accès aux contrôles de formulaire de Windows ne sont pas Thread sûr dans le multithreading. C'est mon code simple qui rend L'appel de Thread sûr et fixe la barre de progression.

public partial class Form1 : Form
{// This delegate enables asynchronous calls for setting  
    // the text property on a TextBox control.  
    delegate void StringArgReturningVoidDelegate(string text);
    private Thread demoThread = null;

    public int Progresscount = 0;
    static EventWaitHandle waithandler = new AutoResetEvent(false);
    public Form1()
    {
        InitializeComponent();
    }
    public static bool CheckForInternetConnection()
    {
        try
        {


            using (var client = new WebClient())
            {
                using (var stream = client.OpenRead("http://www.google.com"))
                {
                    return true;
                }
            }
        }
        catch
        {
            return false;
        }
    }

    public  void Progressincrement()
    {

        waithandler.WaitOne();
        while (CheckForInternetConnection()==true)
        {
            if (Progresscount==100)

            {
                break;
            }
            SetLabel("Connected");
            Progresscount += 1;

       SetProgress(Progresscount.ToString());
            Thread.Sleep(TimeSpan.FromSeconds(1));
        }
        if (Progresscount <100)
        {
            Startthread();
        }
        SetLabel("Completed");


    }

  public  void Startthread ()
        {

   this.demoThread=   new Thread(new ThreadStart(Progressincrement));
        this.demoThread.Start();
     SetLabel("Waiting for connection");
        while (CheckForInternetConnection() == false) ;

        waithandler.Set();
    }
    private void SetLabel(string text)
    {
        // InvokeRequired required compares the thread ID of the  
        // calling thread to the thread ID of the creating thread.  
        // If these threads are different, it returns true.  
        if (this.label1.InvokeRequired)
        {
            StringArgReturningVoidDelegate d = new StringArgReturningVoidDelegate(SetLabel);
            this.Invoke(d, new object[] { text });
        }
        else
        {
            this.label1.Text = text;
        }
    }
    private void SetProgress(string Value)
    {
        // InvokeRequired required compares the thread ID of the  
        // calling thread to the thread ID of the creating thread.  
        // If these threads are different, it returns true.  
        if (this.progressBar1.InvokeRequired)
        {
            StringArgReturningVoidDelegate d = new StringArgReturningVoidDelegate(SetProgress);
            this.Invoke(d, new object[] {Value});
        }
        else
        {
            this.progressBar1.Value = Convert.ToInt32(Value);
        }
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        Startthread();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        MessageBox.Show("Responsive");
    }
}

Pour plus d'information MSDN

j'ai utiliser la solution suivante:

var OtherThreadField = "";
Invoke(new MethodInvoker(delegate
                    {
                        OtherThreadField = ExecuteNeededMEthod();
                    }));

maintenant J'ai une valeur pour OtherThreadField.

j'ai rencontré ce problème juste en essayant d'obtenir des articles à partir d'une table appelée "AGENCY" en utilisant Entity Framework:

var agencies = db.AGENCY.OrderBy(e => e.FULLNAME);

survoler les agences en mode debug, cliquer pour étendre les options, et cliquer sur les résultats donnerait le redouté "l'évaluation de la fonction nécessite tous les threads à exécuter" avec un icône "ne pas entrer" à la fin que, sur lequel, cliquer n'a rien fait.

2 solutions:

1. Ajouter .ToList() à la fin:

   var agencies = db.AGENCY_TABLE.OrderBy(e => e.FULLNAME).ToList();

   List<AGENCY_TABLE> agencies = db.AGENCY_TABLE.OrderBy(e => e.FULLNAME).ToList();

   C'est à Hp93 que revient le mérite de m'avoir aidé à trouver cette solution. Dans les commentaires sur la réponse de MUG4N où j'ai trouvé cette solution, il est aussi question d'essayer .Any() au lieu de .ToList(), mais cela donne un Booléen au lieu d'un <T>, comme <AGENCY> est, donc ça n'aiderait probablement pas.

2. solution de contournement-essayer un chemin différent dans le debug option. J'ai trouvé que je pouvais cliquer sur la vue" Non-Public Members " > "_internalQuery" > ObjectQuery > Results et obtenir mes valeurs de cette façon.