Unsafe Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Runtime.CompilerServices
Assembly:
System.Runtime.CompilerServices.Unsafe.dll
Assembly:
System.Runtime.dll
Pacchetto:
System.Runtime.CompilerServices.Unsafe v6.0.0
Origine:
Unsafe.cs
Origine:
Unsafe.cs
Origine:
Unsafe.cs

Contiene funzionalità generica e di basso livello per la modifica di puntatori gestiti e non gestiti.

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

Commenti

Avviso

Questo tipo è destinato agli scenari di manipolazione avanzata del puntatore. I chiamanti si presupponeno avere familiarità con ECMA-335, Sec. II.14.4 e III.1.1.5 e con l'addendum della specifica dell'interfaccia della riga di comando ECMA-335.

La maggior parte delle API di questo tipo non esegue alcun controllo o convalida degli argomenti. L'uso errato di queste API potrebbe danneggiare la memoria del processo o destabilizzare il runtime .NET.

Questo tipo viene in genere usato dagli autori di librerie di basso livello che vogliono scrivere codice ad alte prestazioni e sono disposti a eliminare . I controlli di sicurezza dei tipi tipici di NET soddisfano gli obiettivi di prestazioni.

Si consideri l'esempio seguente, che inverte gli elementi all'interno di un Span<T>oggetto .

Nota

Questi esempi esistono semplicemente a scopo dimostrativo. Nelle applicazioni reali, gli sviluppatori devono invece usare funzioni helper come Reverse, che sono ottimizzate meglio di anche questi esempi.

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

Questo metodo è completamente sicuro per il tipo e il runtime .NET può inserire i controlli dei limiti per applicare la sicurezza. Tuttavia, gli autori di librerie di basso livello potrebbero voler eliminare . I normali controlli di sicurezza di NET consentono di migliorare le prestazioni del proprio codice. Tali sviluppatori si affidano in genere a strumenti di analisi statici o alle proprie revisioni del codice per applicare la correttezza. Le Unsafe API consentono a uno sviluppatore di riscrivere questo codice usando costrutti non verificabili, come illustrato nell'esempio seguente.

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

Poiché le API eliminano la convalida tipica della sicurezza dei tipi, è necessario che i Unsafe chiamanti assicurino che il codice che scrivono sia legale. L'uso improprio di queste API potrebbe causare violazioni di accesso, creare fori GC, produrre codicegeno non corretto o in caso contrario indurre comportamenti non definiti e destabilibili all'interno del runtime .NET.

Metodi

Add<T>(T, Int32)

Aggiunge un offset al puntatore gestito specificato.
Add<T>(T, IntPtr)

Aggiunge un offset di elemento al puntatore gestito specificato.
Add<T>(T, UIntPtr)

Aggiunge un offset di elemento al puntatore gestito specificato.
Add<T>(Void*, Int32)

Aggiunge un offset di elemento al puntatore non gestito specificato.
AddByteOffset<T>(T, IntPtr)

Aggiunge un offset di byte al puntatore gestito specificato.
AddByteOffset<T>(T, UIntPtr)

Aggiunge un offset di byte al puntatore gestito specificato.
AreSame<T>(T, T)

Determina se i puntatori gestiti specificati puntano alla stessa posizione.
As<T>(Object)

Eseguire il cast dell'oggetto specificato al tipo specificato.
As<TFrom,TTo>(TFrom)

Reinterpreta il puntatore gestito specificato come nuovo puntatore gestito a un valore di tipo TTo.
AsPointer<T>(T)

Converte un puntatore gestito in un puntatore non gestito.
AsRef<T>(T)

Reinterpreta il riferimento di sola lettura specificato come riferimento modificabile.
AsRef<T>(Void*)

Converte un puntatore non gestito in un puntatore gestito in un valore di tipo T.
BitCast<TFrom,TTo>(TFrom)

Reinterpreta il valore specificato di tipo TFrom come valore di tipo TTo.
ByteOffset<T>(T, T)

Determina l'offset di byte dall'origine alla destinazione dai puntatori gestiti specificati.
Copy<T>(T, Void*)

Copia un valore di tipo T nella posizione specificata.
Copy<T>(Void*, T)

Copia un valore di tipo T nella posizione specificata.
CopyBlock(Byte, Byte, UInt32)

Copia i byte dall'indirizzo di origine all'indirizzo di destinazione.
CopyBlock(Void*, Void*, UInt32)

Copia i byte dall'indirizzo di origine all'indirizzo di destinazione.
CopyBlockUnaligned(Byte, Byte, UInt32)

Copia i byte dall'indirizzo di origine all'indirizzo di destinazione senza presupporre l'allineamento dipendente dall'architettura degli indirizzi.
CopyBlockUnaligned(Void*, Void*, UInt32)

Copia i byte dall'indirizzo di origine all'indirizzo di destinazione senza presupporre l'allineamento dipendente dall'architettura degli indirizzi.
InitBlock(Byte, Byte, UInt32)

Inizializza un blocco di memoria in corrispondenza della posizione specificata con un valore iniziale specificato.
InitBlock(Void*, Byte, UInt32)

Inizializza un blocco di memoria in corrispondenza della posizione specificata con un valore iniziale specificato.
InitBlockUnaligned(Byte, Byte, UInt32)

Inizializza un blocco di memoria in corrispondenza della posizione specificata con un valore iniziale specificato senza presupporre l'allineamento dipendente dall'architettura dell'indirizzo.
InitBlockUnaligned(Void*, Byte, UInt32)

Inizializza un blocco di memoria in corrispondenza della posizione specificata con un valore iniziale specificato senza presupporre l'allineamento dipendente dall'architettura dell'indirizzo.
IsAddressGreaterThan<T>(T, T)

Restituisce un valore che indica se un puntatore gestito specificato è maggiore di un altro puntatore gestito specificato.
IsAddressLessThan<T>(T, T)

Restituisce un valore che indica se un puntatore gestito specificato è minore di un altro puntatore gestito specificato.
IsNullRef<T>(T)

Determina se un puntatore gestito specificato a un valore di tipo T è un riferimento Null.
NullRef<T>()

Restituisce un puntatore gestito null a un valore di tipo T.
Read<T>(Void*)

Legge un valore di tipo T dalla posizione specificata.
ReadUnaligned<T>(Byte)

Legge un valore di tipo T dall'indirizzo specificato senza presupponere l'allineamento dipendente dall'architettura dell'indirizzo di origine.
ReadUnaligned<T>(Void*)

Legge un valore di tipo T dalla posizione specificata senza presupponere l'allineamento dipendente dall'architettura dell'indirizzo di origine.
SizeOf<T>()

Restituisce le dimensioni di un valore del parametro di tipo specificato.
SkipInit<T>(T)

Ignora le regole di assegnazione definite per un riferimento specificato.
Subtract<T>(T, Int32)

Sottrae un offset dal puntatore gestito specificato.
Subtract<T>(T, IntPtr)

Sottrae un offset di elemento dal puntatore gestito specificato.
Subtract<T>(T, UIntPtr)

Sottrae un offset di elemento dal puntatore gestito specificato.
Subtract<T>(Void*, Int32)

Sottrae un offset di elemento dal puntatore non gestito specificato.
SubtractByteOffset<T>(T, IntPtr)

Sottrae un offset di byte dal puntatore gestito specificato.
SubtractByteOffset<T>(T, UIntPtr)

Sottrae un offset di byte dal puntatore gestito specificato.
Unbox<T>(Object)

Restituisce un mutable ref a un valore boxed.
Write<T>(Void*, T)

Scrive un valore di tipo T nella posizione specificata.
WriteUnaligned<T>(Byte, T)

Scrive un valore di tipo T nella posizione specificata senza presupponere l'allineamento dipendente dall'architettura dell'indirizzo di destinazione.
WriteUnaligned<T>(Void*, T)

Scrive un valore di tipo T nella posizione specificata senza presupponere l'allineamento dipendente dall'architettura dell'indirizzo di destinazione.

Si applica a