SafeFileHandle Clase

Definición

Representa una clase contenedora de un identificador de archivo.Represents a wrapper class for a file handle.

public ref class SafeFileHandle sealed : Microsoft::Win32::SafeHandles::SafeHandleZeroOrMinusOneIsInvalid
[System.Security.SecurityCritical]
public sealed class SafeFileHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
type SafeFileHandle = class
    inherit SafeHandleZeroOrMinusOneIsInvalid
Public NotInheritable Class SafeFileHandle
Inherits SafeHandleZeroOrMinusOneIsInvalid
Herencia
Atributos

Ejemplos

En el ejemplo de código siguiente se muestra cómo abrir un archivo SafeFileHandle mediante la clase y la CreateFile función no administrada.The following code example demonstrates how to open a file using the SafeFileHandle class and the unmanaged CreateFile function.

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

class SafeHandlesExample
{

    static void Main()
    {
        try
        {

            UnmanagedFileLoader loader = new UnmanagedFileLoader("example.xml");


        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
        Console.ReadLine();


    }
}

class UnmanagedFileLoader 
{

    public const short FILE_ATTRIBUTE_NORMAL = 0x80;
    public const short INVALID_HANDLE_VALUE = -1;
    public const uint GENERIC_READ = 0x80000000;
    public const uint GENERIC_WRITE = 0x40000000;
    public const uint CREATE_NEW = 1;
    public const uint CREATE_ALWAYS = 2;
    public const uint OPEN_EXISTING = 3;

    // Use interop to call the CreateFile function.
    // For more information about CreateFile,
    // see the unmanaged MSDN reference library.
    [DllImport("kernel32.dll", SetLastError = true, CharSet=CharSet.Unicode)]
    static extern SafeFileHandle CreateFile(string lpFileName, uint dwDesiredAccess,
      uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition,
      uint dwFlagsAndAttributes, IntPtr hTemplateFile);



    private SafeFileHandle handleValue = null;


    public UnmanagedFileLoader(string Path)
    {
        Load(Path);
    }


    public void Load(string Path)
    {
        if (Path == null || Path.Length == 0)
        {
            throw new ArgumentNullException("Path");
        }

        // Try to open the file.
        handleValue = CreateFile(Path, GENERIC_WRITE, 0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);

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

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

    }

}
Imports Microsoft.Win32.SafeHandles
Imports System.Runtime.InteropServices
Imports System.ComponentModel



Module SafeHandlesExample

    Sub Main()
        Try

            Dim loader As New UnmanagedFileLoader("example.xml")


        Catch e As Exception
            Console.WriteLine(e)
        End Try
        Console.ReadLine()

    End Sub
End Module



Class UnmanagedFileLoader


    Public Const FILE_ATTRIBUTE_NORMAL As Short = &H80
    Public Const INVALID_HANDLE_VALUE As Short = -1
    Public Const GENERIC_READ As Long = &H80000000
    Public Const GENERIC_WRITE As UInteger = &H40000000
    Public Const CREATE_NEW As UInteger = 1
    Public Const CREATE_ALWAYS As UInteger = 2
    Public Const OPEN_EXISTING As UInteger = 3


    ' Use interop to call the CreateFile function.
    ' For more information about CreateFile,
    ' see the unmanaged MSDN reference library.
    <DllImport("kernel32.dll", SetLastError:=True, CharSet:=CharSet.Unicode)> _
    Private Shared Function CreateFile(ByVal lpFileName As String, ByVal dwDesiredAccess As System.UInt32, ByVal dwShareMode As System.UInt32, ByVal lpSecurityAttributes As IntPtr, ByVal dwCreationDisposition As System.UInt32, ByVal dwFlagsAndAttributes As System.UInt32, ByVal hTemplateFile As IntPtr) As Microsoft.Win32.SafeHandles.SafeFileHandle

    End Function


    Private handleValue As Microsoft.Win32.SafeHandles.SafeFileHandle = Nothing



    Public Sub New(ByVal Path As String)
        Load(Path)

    End Sub


    Public Sub Load(ByVal Path As String)
        If Path Is Nothing OrElse Path.Length = 0 Then
            Throw New ArgumentNullException("Path")
        End If

        ' Try to open the file.
        handleValue = CreateFile(Path, GENERIC_WRITE, 0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero)

        ' If the handle is invalid,
        ' get the last Win32 error 
        ' and throw a Win32Exception.
        If handleValue.IsInvalid Then
            Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error())
        End If

    End Sub


    Public ReadOnly Property Handle() As Microsoft.Win32.SafeHandles.SafeFileHandle
        Get
            ' If the handle is valid,
            ' return it.
            If Not handleValue.IsInvalid Then
                Return handleValue
            Else
                Return Nothing
            End If
        End Get
    End Property
End Class

Comentarios

Esta clase se deriva de SafeHandleZeroOrMinusOneIsInvalid.This class is derived from SafeHandleZeroOrMinusOneIsInvalid. Un valor de 0 o-1 es un identificador de archivo no válido.A value of 0 or -1 is an invalid file handle.

Importante

Este tipo implementa la interfaz IDisposable.This type implements the IDisposable interface. Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Constructores

SafeFileHandle(IntPtr, Boolean)

Inicializa una nueva instancia de la clase SafeFileHandle.Initializes a new instance of the SafeFileHandle class.

Campos

handle

Especifica el identificador que se va a ajustar.Specifies the handle to be wrapped.

(Heredado de SafeHandle)

Propiedades

IsClosed

Obtiene un valor que indica si el identificador está cerrado.Gets a value indicating whether the handle is closed.

(Heredado de SafeHandle)
IsInvalid

Obtiene un valor que indica si el identificador no es válido.Gets a value that indicates whether the handle is invalid.

Métodos

Close()

Marca el identificador para soltar y liberar recursos.Marks the handle for releasing and freeing resources.

(Heredado de SafeHandle)
DangerousAddRef(Boolean)

Aumenta manualmente el recuento de referencias en instancias de SafeHandle.Manually increments the reference counter on SafeHandle instances.

(Heredado de SafeHandle)
DangerousGetHandle()

Devuelve el valor del campo handle.Returns the value of the handle field.

(Heredado de SafeHandle)
DangerousRelease()

Disminuye manualmente el recuento de referencias en una instancia de SafeHandle.Manually decrements the reference counter on a SafeHandle instance.

(Heredado de SafeHandle)
Dispose()

Libera todos los recursos que utiliza la clase SafeHandle.Releases all resources used by the SafeHandle class.

(Heredado de SafeHandle)
Dispose(Boolean)

Libera los recursos no administrados utilizados por la clase SafeHandle que especifica si se va a realizar una operación de desecho normal.Releases the unmanaged resources used by the SafeHandle class specifying whether to perform a normal dispose operation.

(Heredado de SafeHandle)
Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ReleaseHandle()

Cuando se invalida en una clase derivada, ejecuta el código necesario para liberar el identificador.When overridden in a derived class, executes the code required to free the handle.

(Heredado de SafeHandle)
SetHandle(IntPtr)

Establece el identificador en el identificador preexistente.Sets the handle to the specified pre-existing handle.

(Heredado de SafeHandle)
SetHandleAsInvalid()

Marca un identificador para indicar que ya no se utiliza.Marks a handle as no longer used.

(Heredado de SafeHandle)
ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no puede ser utilizado por código transparente o de confianza parcial.This member cannot be used by partially trusted or transparent code.

Se aplica a

Consulte también: