Unsafe.As Méthode

Définition

Espace de noms:

System.Runtime.CompilerServices

Assembly:

System.Runtime.dll

Surcharges

As<T>(Object)	Caste l’objet donné dans le type spécifié.
As<TFrom,TTo>(TFrom)	Réinterpréte le pointeur managé donné en tant que nouveau pointeur managé vers une valeur de type TTo.

As<T>(Object)

Source:

Unsafe.cs

Caste l’objet donné dans le type spécifié.

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

Paramètres de type

T

Type dans lequel l’objet sera casté.

Paramètres

o

Object

Objet à caster.

Retours

T

Objet d’origine, caster vers le type donné.

Remarques

Cette API est utilisée pour caster un objet au type donné, en supprimant les vérifications de sécurité de type normales du runtime. Il incombe à l’appelant de s’assurer que le cast est légal. Non InvalidCastException sera jeté.

Le comportement de n’est Unsafe.As<T>(o) bien défini que si l’opération (T)o de coulée « sécurisée » classique aurait réussi. L’utilisation de cette API pour contourner les casts qui auraient autrement échoué n’est pas prise en charge et peut entraîner une instabilité du runtime.

Pour aider à appliquer une utilisation correcte, les développeurs peuvent envisager d’utiliser une cast standard ou une assertion de débogage uniquement dans leur code, comme illustré dans les exemples suivants.

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

Réinterpréte le pointeur managé donné en tant que nouveau pointeur managé vers une valeur de type 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

Paramètres de type

TFrom

Type de pointeur managé à réinterpréter.

TTo

Type souhaité du pointeur managé.

Paramètres

source

TFrom

Pointeur managé à réinterpréter.

Retours

TTo

Pointeur managé vers une valeur de type TTo.

Remarques

Cette API est conceptuellement similaire à celle de reinterpret_cast<>C++ . Il incombe à l’appelant de s’assurer que le cast est légal. Aucune case activée d’exécution ne sera effectuée.

Seul le pointeur managé est réinterprété. La valeur référencée elle-même reste inchangée. Considérez l'exemple suivant.

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 sortie de ce programme dépend de l’endianness de l’ordinateur actuel. Sur les architectures big-endian, ce code génère 0x1234. Sur les architectures little endian, ce code génère 0x5678.

Lors de la conversion d’un pointeur managé d’un type plus étroit vers un type plus large, l’appelant doit s’assurer que le déréférencement du pointeur n’entraînera pas d’accès hors limites. L’appelant est également chargé de s’assurer que le pointeur résultant est correctement aligné pour le type référencé. Pour plus d’informations sur les hypothèses d’alignement, consultez ECMA-335, sec. I.12.6.2 (« Alignement »).