Unsafe.As Methode

Definition

Namespace:

System.Runtime.CompilerServices

Assembly:

System.Runtime.dll

Paket:

System.Runtime.CompilerServices.Unsafe v6.0.0

Überlädt

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.

As<T>(Object)

Quelle:

Unsafe.cs

Wandelt das angegebene Objekt in den angegebenen Typ um.

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

Typparameter

T

Der Typ, in den das Objekt umgewandelt wird.

Parameter

o

Object

Das Objekt, das umgewandelt werden soll.

Gibt zurück

T

Das ursprüngliche Objekt, das in den angegebenen Typ umgewandelt wird.

Hinweise

Diese API wird verwendet, um ein Objekt in den angegebenen Typ zu umwandeln, wodurch die Sicherheitsüberprüfungen des normalen Typs der Laufzeit unterdrückt werden. Es liegt in der Verantwortung des Anrufers sicherzustellen, dass die Umwandlung legal ist. Nein InvalidCastException wird ausgelöst.

Das Verhalten von Unsafe.As<T>(o) ist nur gut definiert, wenn der typische "sichere" Umwandlungsvorgang (T)o erfolgreich gewesen wäre. Die Verwendung dieser API zum Umgehen von Umwandlungen, die andernfalls fehlgeschlagen wären, wird nicht unterstützt und kann zu Laufzeitinstabilität führen.

Um die korrekte Verwendung zu erzwingen, können Entwickler in Erwägung ziehen, eine Standardumwandlung oder eine reine Debug-Assertion in ihrem Code zu verwenden, wie in den folgenden Beispielen gezeigt.

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)

Quelle:

Unsafe.cs

Interpretiert den angegebenen verwalteten Zeiger als neuen verwalteten Zeiger auf einen Wert vom Typ TToneu.

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

Typparameter

TFrom

Der Typ des verwalteten Zeigers, der neu interpretiert werden soll.

TTo

Der gewünschte Typ des verwalteten Zeigers.

Parameter

source

TFrom

Der verwaltete Zeiger, der neu interpretiert werden soll.

Gibt zurück

TTo

Ein verwalteter Zeiger auf einen Wert vom Typ TTo.

Hinweise

Diese API ähnelt konzeptionell der von C++.reinterpret_cast<> Es liegt in der Verantwortung des Anrufers sicherzustellen, dass die Umwandlung legal ist. Es wird keine Laufzeitüberprüfung durchgeführt.

Nur der verwaltete Zeiger wird neu interpretiert. Der Wert, auf den verwiesen wird, bleibt unverändert. Betrachten Sie das folgende Beispiel.

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

Die Ausgabe dieses Programms hängt von der Endianität des aktuellen Computers ab. In Big-End-Architekturen gibt dieser Code aus 0x1234. In Little-Endian-Architekturen gibt dieser Code aus 0x5678.

Wenn ein verwalteter Zeiger von einem schmaleren Typ in einen breiteren Typ umgewandelt wird, muss der Aufrufer sicherstellen, dass durch die Deferencierung des Zeigers kein zugriff außerhalb der Grenzen entsteht. Der Aufrufer ist auch dafür verantwortlich, sicherzustellen, dass der resultierende Zeiger für den Typ, auf den verwiesen wird, ordnungsgemäß ausgerichtet ist. Weitere Informationen zu Ausrichtungsannahmen finden Sie unter ECMA-335, Abschnitt I.12.6.2 ("Ausrichtung").