Unsafe.As Método

Definición

Espacio de nombres:

System.Runtime.CompilerServices

Ensamblado:

System.Runtime.dll

Sobrecargas

As<T>(Object)	Convierte el objeto indicado al tipo especificado.
As<TFrom,TTo>(TFrom)	Reinterpreta el puntero administrado dado como un nuevo puntero administrado a un valor de tipo TTo.

As<T>(Object)

Source:

Unsafe.cs

Convierte el objeto indicado al tipo especificado.

public:
generic <typename T>
 where T : class static T As(System::Object ^ o);

public static T? As<T> (object? o) where T : class;

static member As : obj -> 'T (requires 'T : null)

Public Shared Function As(Of T As Class) (o As Object) As T

Parámetros de tipo

T

Tipo al que se convertirá el objeto.

Parámetros

o

Object

Objeto que se convertirá.

Devoluciones

T

Objeto original, convertido al tipo especificado.

Comentarios

Esta API se usa para convertir un objeto en el tipo especificado, suprimiendo las comprobaciones de seguridad de tipos normales del entorno de ejecución. Es responsabilidad del autor de la llamada asegurarse de que la conversión es legal. No InvalidCastException se producirá.

El comportamiento de Unsafe.As<T>(o) solo está bien definido si la operación (T)o típica de conversión "segura" se habría realizado correctamente. El uso de esta API para eludir las conversiones que, de lo contrario, habrían producido un error no se admite y podría dar lugar a inestabilidad en tiempo de ejecución.

Para ayudar a aplicar el uso correcto, los desarrolladores pueden considerar el uso de una conversión estándar o una aserción de solo depuración en su código, como se muestra en los ejemplos siguientes.

void ReinterpretCastAndUse_Sample1(object o)
{
  // Assume that we know through some other means that 'o' is a string,
  // and we want our library's debug builds to verify this.
  // One way to do this is through a standard-style cast.
  // A standard-style cast will throw InvalidCastException at runtime if the cast fails.
  // n.b. Casts of null objects to reference types will succeed.

#if DEBUG
  string s = (string)o;
#else
  string s = Unsafe.As<string>(o);
#endif

  DoSomethingWith(s);
}

void ReinterpretCastAndUse_Sample2(object o)
{
  // Another way to check this is through a debug-only assert.
  // Failed assertions will trigger attached debuggers or terminate the application immediately.
  // Calls to Debug.Assert are removed from release builds.

  Debug.Assert(o is null or string, "Unsafe.As call below is illegal!");
  string s = Unsafe.As<string>(o);

  DoSomethingWith(s);
}

As<TFrom,TTo>(TFrom)

Source:

Unsafe.cs

Reinterpreta el puntero administrado dado como un nuevo puntero administrado a un valor de tipo TTo.

public:
generic <typename TFrom, typename TTo>
 static TTo % As(TFrom % source);

public static ref TTo As<TFrom,TTo> (ref TFrom source);

static member As : 'From -> 'o

Public Shared Function As(Of TFrom, TTo) (ByRef source As TFrom) As TTo

Parámetros de tipo

TFrom

Tipo de puntero administrado que se va a reinterpretar.

TTo

Tipo deseado del puntero administrado.

Parámetros

source

TFrom

Puntero administrado que se va a reinterpretar.

Devoluciones

TTo

Puntero administrado a un valor de tipo TTo.

Comentarios

Esta API es conceptualmente similar a la de reinterpret_cast<>C++. Es responsabilidad del autor de la llamada asegurarse de que la conversión es legal. No se realizará ninguna comprobación en tiempo de ejecución.

Solo se reinterpreta el puntero administrado. El propio valor al que se hace referencia permanecerá sin cambios. Considere el ejemplo siguiente.

int[] intArray = new int[] { 0x1234_5678 }; // a 1-element array
ref int refToInt32 = ref intArray[0]; // managed pointer to first Int32 in array
ref short refToInt16 = ref Unsafe.As<int, short>(ref refToInt32); // reinterpret as managed pointer to Int16
Console.WriteLine($"0x{refToInt16:x4}");

La salida de este programa depende de la endianidad de la máquina actual. En las arquitecturas big-endian, este código genera 0x1234. En las arquitecturas little-endian, este código genera 0x5678.

Al convertir un puntero administrado de un tipo más estrecho a un tipo más amplio, el autor de la llamada debe asegurarse de que la desreferenciación del puntero no incurrirá en un acceso fuera de límite. El autor de la llamada también es responsable de garantizar que el puntero resultante esté alineado correctamente para el tipo al que se hace referencia. Para obtener más información sobre las suposiciones de alineación, vea ECMA-335, Sec. I.12.6.2 ("Alignment").