État des variables en C#

Sont des variables de condition, & moniteurs utilisés en C#?

Quelqu'un peut-il me donner un exemple?

Ainsi que le lock-déclaration et le Moniteur de classe, ont un oeil à WaitHandles (msdn.microsoft.com/en-us/library/...) qui peut être très utile et vous sauver de l'alésage standard.

OriginalL'auteur Tony The Lion | 2009-12-31

  1. 13

    L'équivalent d'une variable de condition que l'on utilise pour la signalisation .NET est le résumé WaitHandle classe. Les implémentations pratiques sont le ManualResetEvent et AutoResetEvent classes.

    Une variable de condition que vous l'utiliser comme un moniteur nécessite Système.Le filetage.Moniteur. Le C# lock déclaration, il est très facile à utiliser, il assure le moniteur est toujours sorti sans explicitement la programmation de la Sortie ().

    Notez que la sortie d'un moniteur si le code déclenche une exception n'est pas forcément une bonne chose; le moniteur était probablement protéger une mutation pour s'assurer que le résultat lors de la sortie du moniteur est cohérente; une exception est la preuve que la mutation n'a été que partiellement achevé et, par conséquent, vous avez juste débloqué l'accès à l'état incohérent. Si l'exception est interceptée et le programme se poursuit alors vous ne pouvez pas compter sur le programme de l'état de façon cohérente.
    Très bon point, j'ai re-formulé que. Merci.
    Attendre (pardonnez le calembour). Sont un de ceux qui sont effectivement un équivalent direct d'une variable de condition?? Pour ma non-spécialiste de l'œil, ils ne sont rien comme une variable de condition. En fait, j'ai vu une page web qui montre comment construire une variable de condition de noyau de windows objets comme la remise à zéro automatique des événements, et c'est vraiment un processus complexe impliquant de plus qu'un objet de noyau...
    Je suis d'accord avec @mackenir -- Dire un WaitHandle est la même que la variable de condition conduit à des malentendus, comme stackoverflow.com/questions/18276944/...
    Sauf si vous avez besoin d'une mutex avant pour une autre raison, parce que vous êtes peut-être apporter des modifications aux données partagées avant l'attente pour que la condition devienne vraie. Une variable de condition, c'est comme un appel inter-threads. Vous obtenez le mutex, définissez les paramètres d'entrée, de réveiller l'autre thread (ce qui attend le mutex), puis utilisez une variable de condition de atomiquement débloquer l'autre thread et d'attendre le résultat. Après que vous maintenez à nouveau le mutex, de sorte que vous pouvez lire les paramètres de sortie.

    OriginalL'auteur Hans Passant

  2. 4

    Système.Le filetage.Moniteur est une façon (exemple)

    OriginalL'auteur jspcal

  3. 3

    Vous pouvez utiliser le Verrou de l'objet qui sert de sucre syntaxique pour le Moniteur de classe.

    lock(someObject)
{
    //Thread safe code here.
}

    http://msdn.microsoft.com/en-us/library/c5kehkcz%28VS.80%29.aspx

    Une petite correction, ce n'est pas un objet, mais un mot-clé, et est écrit en minuscules, lock 🙂
    Merci, un développement en VB.NET au travail, il a donc SyncLock sur le cerveau et simplement retiré de la Synchronisation de la partie heh.

    OriginalL'auteur Brett Allen

  4. 2

    Comme une alternative à ManualResetEvent et amis, Windows offre désormais la prise en charge native pour les variables de condition. Je n'ai pas comparé moi-même, mais il ya une bonne chance que votre performance s'améliorera lorsque les tirant parti de l'API native.

    Voici un Projet de Code de l'article qui explique comment accéder à cette (relativement nouveau) construire à partir de C#:

    Un .NET Wrapper pour le Vista/Server 2008 Variable de Condition

    OriginalL'auteur kgriffs

  5. 0

    Cette version atomiquement débloque un Mutex ou ReaderWriterLockSlim en attendant de signalisation, et se verrouille de nouveau avant de retourner - qui est la posix.

    using System.Collections.Concurrent;
namespace System.Threading.More {
public class ConditionVariable {
private readonly ConcurrentQueue<ManualResetEventSlim> _waitingThreads = new ConcurrentQueue<ManualResetEventSlim>();
///<summary>
///    Atomically unlocks and waits for a signal.
///    Then relocks the mutex before returning
///</summary>
///<param name="mutex"></param>
public void Wait(Mutex mutex) {
if (mutex == null) {
throw new ArgumentNullException("mutex");
}
var waitHandle = new ManualResetEventSlim();
try {
_waitingThreads.Enqueue(waitHandle);
mutex.ReleaseMutex();
waitHandle.Wait();
} finally {
waitHandle.Dispose();
}
mutex.WaitOne();
}
public void WaitRead(ReaderWriterLockSlim readerWriterLock) {
if (readerWriterLock == null) {
throw new ArgumentNullException("readerWriterLock");
}
var waitHandle = new ManualResetEventSlim();
try {
_waitingThreads.Enqueue(waitHandle);
readerWriterLock.ExitReadLock();
waitHandle.Wait();
} finally {
waitHandle.Dispose();
}
readerWriterLock.EnterReadLock();
}
public void Signal() {
ManualResetEventSlim waitHandle;
if (_waitingThreads.TryDequeue(out waitHandle)) {
waitHandle.Set();
}
}
public void Broadcast() {
ManualResetEventSlim waitHandle;
while (_waitingThreads.TryDequeue(out waitHandle)) {
waitHandle.Set();
}
}
}
}

    OriginalL'auteur Brent