C# Threading.Suspendre dans Obsolète, le fil a été abandonné?

Dans mon application, j'effectue ma lecture du fichier par un autre thread(autres que le thread GUI). Il y a deux boutons qui permettent de suspendre et de reprendre le Fil respectivement.

private void BtnStopAutoUpd_Click(object sender, EventArgs e)
        {
           autoReadThread.Suspend();
        }

private void BtnStartAutoUpd_Click(object sender, EventArgs e)
        {
           autoReadThread.Resume();  
        }

mais je suis face à cet avertissement,

Fil.Suspendre a été désapprouvée. Veuillez utiliser d'autres classes dans le Système.Threading, tel qu'un Moniteur, Mutex, de l'Événement, et un Sémaphore, pour synchroniser les Threads ou de protéger les ressources. http://go.microsoft.com/fwlink/?linkid=14202

Tout comment je cours seul thread (plutôt que de thread GUI), alors Comment puis-je appliquer la Synchronisation ici, ou du moniteur.

Code De Mise À Jour:

 class ThreadClass
{
//This delegate enables asynchronous calls for setting the text property on a richTextBox control.
delegate void UpdateTextCallback(object text);
//create thread that perform actual task
public Thread autoReadThread = null;
public ManualResetEvent _event = new ManualResetEvent(true);
//a new reference to rich text box
System.Windows.Forms.RichTextBox Textbox = null;
private volatile bool _run;
public bool Run
{
get { return _run; }
set { _run = value; }
}
public ThreadClass(string name, System.Windows.Forms.RichTextBox r1)
{
Textbox = r1;
Run = true;
this.autoReadThread = new Thread(new ParameterizedThreadStart(UpdateText));
this.autoReadThread.Start(name);
}
private void UpdateText(object fileName)
{
//while (true)
//{
//   _event.WaitOne();
while (Run)
{
if (Textbox.InvokeRequired)
{
UpdateTextCallback back = new UpdateTextCallback(UpdateText);
Textbox.BeginInvoke(back, new object[] { fileName });
Thread.Sleep(1000);
}
else
{
string fileToUpdate = (string)fileName;
using (StreamReader readerStream = new StreamReader(fileToUpdate))
{
Textbox.Text = readerStream.ReadToEnd();
}
break;
//}
}
}       
}
}

}

run est bool valeur, un fil de contrôle(à l'origine de son vrai)

et démarrer le thread, je suis la création de cette instance de classe(ce début de thread également) dans d'autres classe

Vous mise à jour ne montrent pas: a) Comment votre thread est démarré, b) le fil complet de la méthode.
InvokeRequired est toujours vrai. Votre fils ne veut pas faire quelque chose d'utile, tout fonctionne sur le thread d'INTERFACE utilisateur.

OriginalL'auteur PawanS | 2010-12-22

  1. 8
     //true makes the thread start as "running", false makes it wait on _event.Set()
ManualResetEvent _event = new ManualResetEvent(true); 
Thread _thread = new Thread(ThreadFunc);
public void ThreadFunc(object state)
{
while (true)
{
_event.Wait();
//do operations here
}
}
_thread.Start();
//to suspend thread.
_event.Reset();
//to resume thread
_event.Set();

    Noter que toutes les opérations soient terminées avant que le thread est "suspendu"

    Ce que vous voulez

    private void ThreadFunc(object fileName)
{
string fileToUpdate = (string)fileName;
while (Run)
{
_event.WaitOne(); 
string data;
using (StreamReader readerStream = new StreamReader(fileToUpdate))
{
data = readerStream.ReadToEnd();
}
if (Textbox.InvokeRequired)
{
UpdateTextCallback back = new UpdateTextCallback(UpdateText);
Textbox.BeginInvoke(back, new object[] { data });
}
Thread.Sleep(1000); 
}       
}
private void UpdateText(string data)
{
Textbox.Text = data;
}
    Pas de travail... de l'exécution des arrêts à _event.Wait(); après que mes activités ne sont pas d'être exécutée.
    Avez-vous essayé d'utiliser _event.Set()? - Je définir l'état initial à false sur le ManualResetEvent qui en fait attendre avant de continuer
    Je n'ai pas atteint. after_evenr.Wait (), j'ai écrit mon code pour obtenir l'exécution, mais attendez stmnt se bloque. _event.réinitialiser et _evenr.Jeu je l'ai écrit dans des événements de bouton.
    Je serais personnellement la première ligne ManualResetEvent _event = new ManualResetEvent(true);, depuis le comportement par défaut devrait être pour l'exécution du thread.
    Correct. @Pawan Kumar: modification vrai dans le ManualResetEvent constructeur. Vérifier la mise à jour du code.

    OriginalL'auteur jgauffin

  2. 5

    La raison de Suspendre et de Reprendre sont dépréciées est parce qu'il n'existe aucune garantie à ce point dans l'exécution du thread sera suspendu. C'est une mauvaise chose. Le problème est décrit ici ainsi que d'une solution.

    La solution doit impliquer un WaitHandle (peut-être AutoResetEvent ou ManualResetEvent) que vous pouvez utiliser pour signaler à votre autoReadThread de démarrage/arrêt.

    OriginalL'auteur Szymon Rozga

  3. 3

    Je voudrais utiliser le Moniteur mécanisme pour la réalisation de la suspension et la reprise de threads. Le Moniteur.Attente en cause le fil d'attente pour le Moniteur.Pouls.

    private bool _pause = false;
private object _threadLock = new object();
private void RunThread()
{
while (true)
{
if (_pause)
{
lock (_threadLock)
{
Monitor.Wait(_threadLock);
}
}
//Do work
}
}
private void PauseThread()
{
_pause = true;
}
private void ResumeThread()
{
_pause = false;
lock (_threadLock)
{
Monitor.Pulse(_threadLock);
}
}

    OriginalL'auteur Mas