Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Estructura LockCookie

 

Publicado: octubre de 2016

Define el bloqueo que implementa la semántica de único escritor y varios lectores. Se trata de un tipo de valor.

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public struct LockCookie

NombreDescripción
System_CAPS_pubmethodEquals(LockCookie)

Indica si la instancia actual es igual al LockCookie especificado.

System_CAPS_pubmethodEquals(Object)

Indica si un objeto especificado es un LockCookie y es igual a la instancia actual.(Invalida ValueType.Equals(Object)).

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodToString()

Devuelve el nombre de tipo completo de esta instancia.(Heredado de ValueType).

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticEquality(LockCookie, LockCookie)

Indica si dos estructuras de LockCookie son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(LockCookie, LockCookie)

Indica si dos estructuras de LockCookie no son iguales.

En el ejemplo siguiente se muestra cómo solicitar un bloqueo de lector, actualizar el bloqueo de lector al bloqueo de escritor y guardar la LockCookie. A continuación, utiliza el LockCookie para degradar a un bloqueo de lector de nuevo.

Este código forma parte de un ejemplo mayor proporcionado para el ReaderWriterLock clase.

// The complete code is located in the ReaderWriterLock class topic.
using System;
using System.Threading;

public class Example
{
   static ReaderWriterLock rwl = new ReaderWriterLock();
   // Define the shared resource protected by the ReaderWriterLock.
   static int resource = 0;
// Requests a reader lock, upgrades the reader lock to the writer
// lock, and downgrades it to a reader lock again.
static void UpgradeDowngrade(int timeOut)
{
   try {
      rwl.AcquireReaderLock(timeOut);
      try {
         // It's safe for this thread to read from the shared resource.
         Display("reads resource value " + resource);
         Interlocked.Increment(ref reads);

         // To write to the resource, either release the reader lock and
         // request the writer lock, or upgrade the reader lock. Upgrading
         // the reader lock puts the thread in the write queue, behind any
         // other threads that might be waiting for the writer lock.
         try {
            LockCookie lc = rwl.UpgradeToWriterLock(timeOut);
            try {
               // It's safe for this thread to read or write from the shared resource.
               resource = rnd.Next(500);
               Display("writes resource value " + resource);
               Interlocked.Increment(ref writes);
            }
            finally {
               // Ensure that the lock is released.
               rwl.DowngradeFromWriterLock(ref lc);
            }
         }
         catch (ApplicationException) {
            // The upgrade request timed out.
            Interlocked.Increment(ref writerTimeouts);
         }

         // If the lock was downgraded, it's still safe to read from the resource.
         Display("reads resource value " + resource);
         Interlocked.Increment(ref reads);
      }
      finally {
         // Ensure that the lock is released.
         rwl.ReleaseReaderLock();
      }
   }
   catch (ApplicationException) {
      // The reader lock request timed out.
      Interlocked.Increment(ref readerTimeouts);
   }
}

.NET Framework
Disponible desde 1.1

Este tipo es seguro para la ejecución de subprocesos.

Volver al principio
Mostrar: