Unsafe Classe

Définition

Espace de noms:

System.Runtime.CompilerServices

Assembly:

System.Runtime.dll

Source:

Unsafe.cs

Contient des fonctionnalités génériques de bas niveau pour manipuler des pointeurs managés et non managés.

public ref class Unsafe abstract sealed

public static class Unsafe

type Unsafe = class

Public Class Unsafe

Héritage

Object

Unsafe

Remarques

Avertissement

Ce type est destiné aux scénarios de manipulation de pointeur avancés. Les appelants sont supposés être familiarisés avec ECMA-335, sec. II.14.4 et III.1.1.5, et avec l’addendum sur la spécification DE l’interface CLI ECMA-335.

La plupart des API de ce type n’effectuent aucune vérification ou validation d’argument. Une utilisation incorrecte de ces API peut endommager la mémoire du processus ou déstabiliser le runtime .NET.

Ce type est généralement utilisé par les auteurs de bibliothèques de bas niveau qui souhaitent écrire du code hautes performances et sont prêts à supprimer . Les contrôles de sécurité de type typiques de NET pour atteindre leurs objectifs de performances.

Prenons l’exemple suivant, qui inverse les éléments d’un Span<T>.

Notes

Ces exemples existent simplement à des fins de démonstration. Dans les applications réelles, les développeurs doivent plutôt utiliser des fonctions d’assistance telles que Reverse, qui sont mieux optimisées que ces exemples.

// A safe, verifiable way to reverse a Span<T>.
static void Reverse<T>(Span<T> span)
{
  while (span.Length > 1)
  {
    T firstElement = span[0];
    T lastElement = span[^1];
    span[0] = lastElement;
    span[^1] = firstElement;
    span = span[1..^1];
  }
}

Cette méthode est entièrement sécurisée de type et le runtime .NET peut insérer des vérifications de limites pour aider à appliquer la sécurité. Toutefois, les auteurs de bibliothèques de bas niveau peuvent vouloir supprimer . Les contrôles de sécurité normaux de NET afin d’améliorer les performances de leur propre code. Ces développeurs s’appuient généralement sur des outils d’analyse statique ou leurs propres révisions de code pour aider à appliquer l’exactitude. Les Unsafe API permettent à un développeur de réécrire ce code à l’aide de constructions non vérifiables, comme le montre l’exemple suivant.

// A correct but unverifiable way to reverse a Span<T>.
static void Reverse<T>(Span<T> span)
{
  if (span.Length > 1)
  {
    ref T refLeft = ref MemoryMarshal.GetReference(span);
    ref T refRight = ref Unsafe.Add(ref refLeft, span.Length - 1);
    do
    {
      T leftElement = refLeft;
      T rightElement = refRight;
      refLeft = rightElement;
      refRight = leftElement;
      refLeft = ref Unsafe.Add(ref refLeft, 1);
      refRight = ref Unsafe.Subtract(ref refRight, 1);
    } while (Unsafe.IsAddressLessThan(ref refLeft, ref refRight));
  }
}

Étant donné que les Unsafe API suppriment la validation de sécurité de type classique, il incombe aux appelants de s’assurer que le code qu’ils écrivent est légal. Une mauvaise utilisation de ces API peut entraîner des violations d’accès, créer des trous GC, produire un codegen incorrect ou induire des comportements non définis et déstabilisants au sein du runtime .NET.

Méthodes

Add<T>(T, Int32)	Ajoute un décalage au pointeur managé donné.
Add<T>(T, IntPtr)	Ajoute un décalage d’élément au pointeur managé donné.
Add<T>(T, UIntPtr)	Ajoute un décalage d’élément au pointeur managé donné.
Add<T>(Void*, Int32)	Ajoute un décalage d’élément au pointeur non managé donné.
AddByteOffset<T>(T, IntPtr)	Ajoute un décalage d’octets au pointeur managé donné.
AddByteOffset<T>(T, UIntPtr)	Ajoute un décalage d’octets au pointeur managé donné.
AreSame<T>(T, T)	Détermine si les pointeurs managés spécifiés pointent vers le même emplacement.
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.
AsPointer<T>(T)	Convertit un pointeur managé en pointeur non managé.
AsRef<T>(T)	Réinterprète la référence en lecture seule donnée en tant que référence mutable.
AsRef<T>(Void*)	Convertit un pointeur non managé en pointeur managé en une valeur de type T.
BitCast<TFrom,TTo>(TFrom)	Réinterprète la valeur donnée de type TFrom en tant que valeur de type TTo.
ByteOffset<T>(T, T)	Détermine le décalage d’octets entre l’origine et la cible à partir des pointeurs managés donnés.
Copy<T>(T, Void*)	Copie une valeur de type T à l’emplacement donné.
Copy<T>(Void*, T)	Copie une valeur de type T à l’emplacement donné.
CopyBlock(Byte, Byte, UInt32)	Copie les octets de l’adresse source vers l’adresse de destination.
CopyBlock(Void*, Void*, UInt32)	Copie les octets de l’adresse source vers l’adresse de destination.
CopyBlockUnaligned(Byte, Byte, UInt32)	Copie les octets de l’adresse source vers l’adresse de destination sans supposer de l’alignement dépendant de l’architecture des adresses.
CopyBlockUnaligned(Void*, Void*, UInt32)	Copie les octets de l’adresse source vers l’adresse de destination sans supposer de l’alignement dépendant de l’architecture des adresses.
InitBlock(Byte, Byte, UInt32)	Initialise un bloc de mémoire à l’emplacement spécifié avec une valeur initiale donnée.
InitBlock(Void*, Byte, UInt32)	Initialise un bloc de mémoire à l’emplacement spécifié avec une valeur initiale donnée.
InitBlockUnaligned(Byte, Byte, UInt32)	Initialise un bloc de mémoire à l’emplacement spécifié avec une valeur initiale donnée sans supposer de l’alignement dépendant de l’architecture de l’adresse.
InitBlockUnaligned(Void*, Byte, UInt32)	Initialise un bloc de mémoire à l’emplacement spécifié avec une valeur initiale donnée sans supposer de l’alignement dépendant de l’architecture de l’adresse.
IsAddressGreaterThan<T>(T, T)	Retourne une valeur qui indique si un pointeur managé spécifié est supérieur à un autre pointeur managé spécifié.
IsAddressLessThan<T>(T, T)	Retourne une valeur qui indique si un pointeur managé spécifié est inférieur à un autre pointeur managé spécifié.
IsNullRef<T>(T)	Détermine si un pointeur managé donné vers une valeur de type T est une référence Null.
NullRef<T>()	Retourne un pointeur managé Null vers une valeur de type T.
Read<T>(Void*)	Lit une valeur de type T à partir de l’emplacement donné.
ReadUnaligned<T>(Byte)	Lit une valeur de type T à partir de l’adresse donnée sans supposer l’alignement dépendant de l’architecture de l’adresse source.
ReadUnaligned<T>(Void*)	Lit une valeur de type T à partir de l’emplacement donné sans supposer l’alignement dépendant de l’architecture de l’adresse source.
SizeOf<T>()	Retourne la taille d’une valeur du paramètre de type donné.
SkipInit<T>(T)	Contourne les règles d’affectation définies pour une référence donnée.
Subtract<T>(T, Int32)	Soustrait un décalage du pointeur managé donné.
Subtract<T>(T, IntPtr)	Soustrait un décalage d’élément du pointeur managé donné.
Subtract<T>(T, UIntPtr)	Soustrait un décalage d’élément du pointeur managé donné.
Subtract<T>(Void*, Int32)	Soustrait un décalage d’élément du pointeur non managé donné.
SubtractByteOffset<T>(T, IntPtr)	Soustrait un décalage d’octets du pointeur managé donné.
SubtractByteOffset<T>(T, UIntPtr)	Soustrait un décalage d’octets du pointeur managé donné.
Unbox<T>(Object)	Retourne mutable ref à une valeur boxed.
Write<T>(Void*, T)	Écrit une valeur de type T à l’emplacement donné.
WriteUnaligned<T>(Byte, T)	Écrit une valeur de type T dans l’emplacement donné sans supposer l’alignement dépendant de l’architecture de l’adresse de destination.
WriteUnaligned<T>(Void*, T)	Écrit une valeur de type T dans l’emplacement donné sans supposer l’alignement dépendant de l’architecture de l’adresse de destination.