Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

SafeWaitHandle (Clase)

Representa una clase contenedora para un identificador de espera.

Espacio de nombres:  Microsoft.Win32.SafeHandles
Ensamblado:  mscorlib (en mscorlib.dll)

public sealed class SafeWaitHandle : SafeHandleZeroOrMinusOneIsInvalid

El tipo SafeWaitHandle expone los siguientes miembros.

  NombreDescripción
Método públicoSafeWaitHandleInicializa una nueva instancia de la clase SafeWaitHandle.
Arriba

  NombreDescripción
Propiedad públicaIsClosedObtiene un valor que indica si el identificador está cerrado. (Se hereda de SafeHandle).
Propiedad públicaIsInvalidObtiene un valor que indica si el identificador no es válido. (Se hereda de SafeHandleZeroOrMinusOneIsInvalid).
Arriba

  NombreDescripción
Método públicoCloseMarca el identificador para soltar y liberar recursos. (Se hereda de SafeHandle).
Método públicoDangerousAddRefAumenta manualmente el recuento de referencias en instancias de SafeHandle. (Se hereda de SafeHandle).
Método públicoDangerousGetHandleDevuelve el valor del campo handle. (Se hereda de SafeHandle).
Método públicoDangerousReleaseDisminuye manualmente el recuento de referencias en una instancia de SafeHandle. (Se hereda de SafeHandle).
Método públicoDispose()Libera todos los recursos que utiliza la clase SafeHandle. (Se hereda de SafeHandle).
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetType Obtiene el Typede la instancia actual. (Se hereda de Object).
Método públicoSetHandleAsInvalidMarca un identificador para indicar que ya no se utiliza. (Se hereda de SafeHandle).
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

La clase System.Threading.WaitHandle utiliza la clase SafeWaitHandle. Se trata de un contenedor para las exclusiones mutuas de Win32 y los eventos de reinicio manuales y automáticos.

Nota importanteImportante

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, se debe eliminar de directa o indirectamente. Para desechar de tipo directamente, llame al método de Dispose en un bloque de try/decatch . Para desechar de indirectamente, utilice una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea “Uso de objeto que implementa sección IDisposable” en el tema de la interfaz de IDisposable .

En el siguiente ejemplo de código se muestra cómo utilizar la interoperabilidad para crear una exclusión mutua mediante la clase SafeWaitHandle y la función CreateMutex no administrada.


using System;
using Microsoft.Win32.SafeHandles;
using System.Runtime.InteropServices;


class SafeHandlesExample
{

    static void Main()
    {
        UnmanagedMutex uMutex = new UnmanagedMutex("YourCompanyName_SafeHandlesExample_MUTEX");

        try
        {

            uMutex.Create();
            Console.WriteLine("Mutex created. Press Enter to release it.");
            Console.ReadLine();


        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
        finally
        {
            uMutex.Release();
            Console.WriteLine("Mutex Released.");
        }

        Console.ReadLine();


    }
}

class UnmanagedMutex 
{


    // Use interop to call the CreateMutex function.
    // For more information about CreateMutex,
    // see the unmanaged MSDN reference library.
    [DllImport("kernel32.dll", CharSet=CharSet.Unicode)]
    static extern SafeWaitHandle CreateMutex(IntPtr lpMutexAttributes, bool bInitialOwner,
    string lpName);


    // Use interop to call the ReleaseMutex function.
    // For more information about ReleaseMutex,
    // see the unmanaged MSDN reference library.
    [DllImport("kernel32.dll")]
    public static extern bool ReleaseMutex(SafeWaitHandle hMutex);



    private SafeWaitHandle handleValue = null;
    private IntPtr mutexAttrValue = IntPtr.Zero;
    private string nameValue = null;

    public UnmanagedMutex(string Name)
    {
        nameValue = Name;
    }


    public void Create()
    {
        if (nameValue == null && nameValue.Length == 0)
        {
            throw new ArgumentNullException("nameValue");
        }

        handleValue = CreateMutex(mutexAttrValue,
                                        true, nameValue);

        // If the handle is invalid,
        // get the last Win32 error 
        // and throw a Win32Exception.
        if (handleValue.IsInvalid)
        {
            Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
        }
    }

    public SafeWaitHandle Handle
    {
        get
        {
            // If the handle is valid,
            // return it.
            if (!handleValue.IsInvalid)
            {
                return handleValue;
            }
            else
            {
                return null;
            }
        }

    }

    public string Name
    {
        get
        {
            return nameValue;
        }

    }


    public void Release()
    {
        ReleaseMutex(handleValue);
    }

}


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

  • SecurityCriticalAttribute 

    requiere plena confianza para el llamador inmediato. Un código de confianza parcial o transparente no puede utilizar este miembro.

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft