Unsafe Klasse

  • Referenz

Definition

Namespace:
System.Runtime.CompilerServices
Assembly:
System.Runtime.CompilerServices.Unsafe.dll
Assembly:
System.Runtime.dll
Paket:
System.Runtime.CompilerServices.Unsafe v6.1.0
Quelle:
Unsafe.cs
Quelle:
Unsafe.cs
Quelle:
Unsafe.cs

Enthält allgemeine Funktionen auf niedriger Ebene zum Bearbeiten verwalteter und nicht verwalteter Zeiger.

public ref class Unsafe abstract sealed
public static class Unsafe
type Unsafe = class
Public Class Unsafe
Vererbung
Object
Unsafe

Hinweise

Warnung

Dieser Typ ist für erweiterte Zeigerbearbeitungsszenarien vorgesehen. Anrufer werden angenommen, dass sie mit ECMA-335, Sec. II.14.4 und III.1.1.5 sowie mit dem ECMA-335 CLI Specification Addendum vertraut sind.

Die meisten APIs für diesen Typ führen keine Argumentüberprüfung oder -validierung durch. Eine falsche Verwendung dieser APIs kann den Prozessspeicher beschädigen oder die .NET-Runtime destabilisieren.

Dieser Typ wird in der Regel von Low-Level-Bibliotheksautoren verwendet, die leistungsstarken Code schreiben möchten und bereit sind, zu unterdrücken. Die typischen Typsicherheitsprüfungen von NET, um ihre Leistungsziele zu erreichen.

Sehen Sie sich das folgende Beispiel an, das die Elemente innerhalb einer Span<T>umkehrt.

Hinweis

Diese Beispiele dienen lediglich zu Demonstrationszwecken. In realen Anwendungen sollten Entwickler stattdessen Hilfsfunktionen wie Reverseverwenden, die besser optimiert sind als diese Beispiele.

// 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];
  }
}

Diese Methode ist vollständig typsicher, und die .NET-Runtime kann Begrenzungsprüfungen einfügen, um die Sicherheit zu erzwingen. Die Autoren von Bibliotheken auf niedriger Ebene möchten jedoch möglicherweise unterdrücken. Die normalen Sicherheitsüberprüfungen von NET, um die Leistung des eigenen Codes zu verbessern. Solche Entwickler würden sich in der Regel auf statische Analysetools oder ihre eigenen Code reviews verlassen, um die Richtigkeit zu erzwingen. Die Unsafe APIs ermöglichen es einem Entwickler, diesen Code mit nicht überprüfbaren Konstrukten neu zu schreiben, wie im folgenden Beispiel gezeigt.

// 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));
  }
}

Da die APIs die Unsafe typische Typsicherheitsüberprüfung unterdrücken, müssen Aufrufer sicherstellen, dass der code, den sie schreiben, legal ist. Der Missbrauch dieser APIs kann zugriffsverstöße verursachen, GC-Löcher erstellen, falsche Codegen erzeugen oder anderweitig undefinierte und destabilisierende Verhaltensweisen innerhalb der .NET-Runtime induzieren.

Methoden

Add<T>(T, Int32)

Fügt dem angegebenen verwalteten Zeiger einen Offset hinzu.
Add<T>(T, IntPtr)

Fügt dem angegebenen verwalteten Zeiger einen Elementoffset hinzu.
Add<T>(T, UIntPtr)

Fügt dem angegebenen verwalteten Zeiger einen Elementoffset hinzu.
Add<T>(Void*, Int32)

Fügt dem angegebenen nicht verwalteten Zeiger einen Elementoffset hinzu.
AddByteOffset<T>(T, IntPtr)

Fügt dem angegebenen verwalteten Zeiger einen Byteoffset hinzu.
AddByteOffset<T>(T, UIntPtr)

Fügt dem angegebenen verwalteten Zeiger einen Byteoffset hinzu.
AreSame<T>(T, T)

Bestimmt, ob die angegebenen verwalteten Zeiger auf denselben Speicherort zeigen.
As<T>(Object)

Wandelt das angegebene Objekt in den angegebenen Typ um.
As<TFrom,TTo>(TFrom)

Interpretiert den angegebenen verwalteten Zeiger als neuen verwalteten Zeiger auf einen Wert vom Typ TToneu.
AsPointer<T>(T)

Konvertiert einen verwalteten Zeiger in einen nicht verwalteten Zeiger.
AsRef<T>(T)

Interpretiert den angegebenen schreibgeschützten Verweis als veränderlichen Verweis neu.
AsRef<T>(Void*)

Konvertiert einen nicht verwalteten Zeiger in einen verwalteten Zeiger in einen Wert vom Typ T.
BitCast<TFrom,TTo>(TFrom)

Interpretiert den angegebenen Wert des Typs TFrom als Wert des Typs TToneu.
ByteOffset<T>(T, T)

Bestimmt den Byteoffset vom Ursprung zum Ziel aus den angegebenen verwalteten Zeigern.
Copy<T>(T, Void*)

Kopiert einen Wert vom Typ T zum angegebenen Speicherort.
Copy<T>(Void*, T)

Kopiert einen Wert vom Typ T zum angegebenen Speicherort.
CopyBlock(Byte, Byte, UInt32)

Kopiert Bytes von der Quelladresse zur Zieladresse.
CopyBlock(Void*, Void*, UInt32)

Kopiert Bytes von der Quelladresse zur Zieladresse.
CopyBlockUnaligned(Byte, Byte, UInt32)

Kopiert Bytes aus der Quelladresse zur Zieladresse, ohne eine architekturabhängige Ausrichtung der Adressen vorauszusetzen.
CopyBlockUnaligned(Void*, Void*, UInt32)

Kopiert Bytes aus der Quelladresse zur Zieladresse, ohne eine architekturabhängige Ausrichtung der Adressen vorauszusetzen.
InitBlock(Byte, Byte, UInt32)

Initialisiert einen Speicherblock an dem angegebenen Speicherort mit einem angegebenen Anfangswert.
InitBlock(Void*, Byte, UInt32)

Initialisiert einen Speicherblock an dem angegebenen Speicherort mit einem angegebenen Anfangswert.
InitBlockUnaligned(Byte, Byte, UInt32)

Initialisiert einen Speicherblock an dem angegebenen Speicherort mit einem angegebenen Anfangswert, ohne eine architekturabhängige Ausrichtung der Adresse vorauszusetzen.
InitBlockUnaligned(Void*, Byte, UInt32)

Initialisiert einen Speicherblock an dem angegebenen Speicherort mit einem angegebenen Anfangswert, ohne eine architekturabhängige Ausrichtung der Adresse vorauszusetzen.
IsAddressGreaterThan<T>(T, T)

Gibt einen Wert zurück, der angibt, ob ein angegebener verwalteter Zeiger größer als ein anderer angegebener verwalteter Zeiger ist.
IsAddressLessThan<T>(T, T)

Gibt einen Wert zurück, der angibt, ob ein angegebener verwalteter Zeiger kleiner als ein anderer angegebener verwalteter Zeiger ist.
IsNullRef<T>(T)

Bestimmt, ob ein bestimmter verwalteter Zeiger auf einen Wert vom Typ T ein NULL-Verweis ist.
NullRef<T>()

Gibt einen mit NULL verwalteten Zeiger auf einen Wert vom Typ Tzurück.
Read<T>(Void*)

Liest einen Wert vom Typ T aus dem angegebenen Speicherort.
ReadUnaligned<T>(Byte)

Liest einen Wert vom Typ T aus der angegebenen Adresse, ohne von der architekturabhängigen Ausrichtung der Quelladresse auszugehen.
ReadUnaligned<T>(Void*)

Liest einen Wert vom Typ T vom angegebenen Speicherort, ohne von der architekturabhängigen Ausrichtung der Quelladresse auszugehen.
SizeOf<T>()

Gibt die Größe eines Werts des angegebenen Typparameters zurück.
SkipInit<T>(T)

Umgeht bestimmte Zuweisungsregeln für einen bestimmten Verweis.
Subtract<T>(T, Int32)

Subtrahiert einen Offset vom angegebenen verwalteten Zeiger.
Subtract<T>(T, IntPtr)

Subtrahiert einen Elementoffset vom angegebenen verwalteten Zeiger.
Subtract<T>(T, UIntPtr)

Subtrahiert einen Elementoffset vom angegebenen verwalteten Zeiger.
Subtract<T>(Void*, Int32)

Subtrahiert einen Elementoffset vom angegebenen nicht verwalteten Zeiger.
SubtractByteOffset<T>(T, IntPtr)

Subtrahiert einen Byteoffset vom angegebenen verwalteten Zeiger.
SubtractByteOffset<T>(T, UIntPtr)

Subtrahiert einen Byteoffset vom angegebenen verwalteten Zeiger.
Unbox<T>(Object)

Gibt eine mutable ref für einen geschachtelten Wert zurück.
Write<T>(Void*, T)

Schreibt einen Wert vom Typ T in den angegebenen Speicherort.
WriteUnaligned<T>(Byte, T)

Schreibt einen Wert vom Typ T in den angegebenen Speicherort, ohne von der architekturabhängigen Ausrichtung der Zieladresse auszugehen.
WriteUnaligned<T>(Void*, T)

Schreibt einen Wert vom Typ T in den angegebenen Speicherort, ohne von der architekturabhängigen Ausrichtung der Zieladresse auszugehen.

Gilt für: