Unsafe Klass

Definition

Namnområde:
System.Runtime.CompilerServices
Sammansättning:
System.Runtime.dll
Sammansättning:
System.Runtime.CompilerServices.Unsafe.dll
Sammansättningar:
System.Runtime.dll, System.Runtime.CompilerServices.Unsafe.dll
Källa:
Unsafe.cs
Källa:
Unsafe.cs
Källa:
Unsafe.cs
Källa:
Unsafe.cs
Källa:
Unsafe.cs

Innehåller allmänna funktioner på låg nivå för att manipulera hanterade och ohanterade pekare.

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

Kommentarer

Varning

Den här typen är avsedd för avancerade pekarmanipuleringsscenarier. Uppringare antas vara bekanta med ECMA-335, sek. II.14.4 och III.1.1.5, och med ECMA-335 CLI Specification Addendum.

De flesta API:er för den här typen utför inte någon argumentkontroll eller validering. Felaktig användning av dessa API:er kan skada processminnet eller destabilisera .NET körning.

Den här typen används vanligtvis av biblioteksförfattare på låg nivå som vill skriva kod med höga prestanda och är villiga att undertrycka .NET typiska typsäkerhetskontroller för att uppfylla sina prestandamål.

Tänk på följande exempel, som vänder elementen i en Span<T>.

Note

De här exemplen finns bara i demonstrationssyfte. I verkliga program bör utvecklare i stället använda hjälpfunktioner som Reverse, som är bättre optimerade än till och med dessa exempel.

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

Den här metoden är helt typsäker och den .NET körningen kan infoga gränskontroller för att upprätthålla säkerheten. Biblioteksförfattare på låg nivå kanske dock vill förhindra .NET normala säkerhetskontroller för att förbättra prestandan för sin egen kod. Sådana utvecklare skulle vanligtvis förlita sig på statiska analysverktyg eller sina egna kodgranskningar för att upprätthålla korrekthet. Unsafe API:erna gör det möjligt för en utvecklare att skriva om den här koden med hjälp av icke-verifierade konstruktioner, vilket visas i följande exempel.

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

Eftersom API:erna Unsafe undertrycker typisk typsäkerhetsverifiering är det upp till anroparna att se till att koden de skriver är laglig. Missbruk av dessa API:er kan orsaka åtkomstöverträdelser, skapa GC-hål, generera felaktigt kodgen eller på annat sätt framkalla odefinierade och destabiliserande beteenden inom .NET körning.

Metoder

Name Description
Add<T>(T, Int32)

Lägger till en förskjutning till den angivna hanterade pekaren.
Add<T>(T, IntPtr)

Lägger till en elementförskjutning till den angivna hanterade pekaren.
Add<T>(T, UIntPtr)

Lägger till en elementförskjutning till den angivna hanterade pekaren.
Add<T>(Void*, Int32)

Lägger till en elementförskjutning till den angivna ohanterade pekaren.
AddByteOffset<T>(T, IntPtr)

Lägger till en byteförskjutning till den angivna hanterade pekaren.
AddByteOffset<T>(T, UIntPtr)

Lägger till en byteförskjutning till den angivna hanterade pekaren.
AreSame<T>(T, T)

Avgör om de angivna hanterade pekarna pekar på samma plats.
As<T>(Object)

Omvandlar det angivna objektet till den angivna typen.
As<TFrom,TTo>(TFrom)

Omtolkar den angivna hanterade pekaren som en ny hanterad pekare till ett värde av typen TTo.
AsPointer<T>(T)

Konverterar en hanterad pekare till en ohanterad pekare.
AsRef<T>(T)

Omtolkar den angivna skrivskyddade referensen som en föränderlig referens.
AsRef<T>(Void*)

Konverterar en ohanterad pekare till en hanterad pekare till ett värde av typen T.
BitCast<TFrom,TTo>(TFrom)

Omtolkar det angivna värdet av typen TFrom som ett värde av typen TTo.
ByteOffset<T>(T, T)

Avgör byteförskjutningen från ursprung till mål från de angivna hanterade pekarna.
Copy<T>(T, Void*)

Kopierar ett värde av typen T till den angivna platsen.
Copy<T>(Void*, T)

Kopierar ett värde av typen T till den angivna platsen.
CopyBlock(Byte, Byte, UInt32)

Kopierar byte från källadressen till måladressen.
CopyBlock(Void*, Void*, UInt32)

Kopierar byte från källadressen till måladressen.
CopyBlockUnaligned(Byte, Byte, UInt32)

Kopierar byte från källadressen till måladressen utan att anta arkitekturberoende justering av adresserna.
CopyBlockUnaligned(Void*, Void*, UInt32)

Kopierar byte från källadressen till måladressen utan att anta arkitekturberoende justering av adresserna.
InitBlock(Byte, Byte, UInt32)

Initierar ett minnesblock på den angivna platsen med ett angivet initialvärde.
InitBlock(Void*, Byte, UInt32)

Initierar ett minnesblock på den angivna platsen med ett angivet initialvärde.
InitBlockUnaligned(Byte, Byte, UInt32)

Initierar ett minnesblock på den angivna platsen med ett angivet initialt värde utan att anta arkitekturberoende justering av adressen.
InitBlockUnaligned(Void*, Byte, UInt32)

Initierar ett minnesblock på den angivna platsen med ett angivet initialt värde utan att anta arkitekturberoende justering av adressen.
IsAddressGreaterThan<T>(T, T)

Returnerar ett värde som anger om en angiven hanterad pekare är större än en annan angiven hanterad pekare.
IsAddressGreaterThanOrEqualTo<T>(T, T)

Avgör om minnesadressen som refereras av left är större än eller lika med den minnesadress som refereras av right.
IsAddressLessThan<T>(T, T)

Returnerar ett värde som anger om en angiven hanterad pekare är mindre än en annan angiven hanterad pekare.
IsAddressLessThanOrEqualTo<T>(T, T)

Avgör om minnesadressen som refereras av left är mindre än eller lika med den minnesadress som refereras av right.
IsNullRef<T>(T)

Avgör om en given hanterad pekare till ett värde av typen T är en null-referens.
NullRef<T>()

Returnerar en nullhanterad pekare till ett värde av typen T.
Read<T>(Void*)

Läser ett värde av typen T från den angivna platsen.
ReadUnaligned<T>(Byte)

Läser ett värde av typen T från den angivna adressen utan att anta arkitekturberoende justering av källadressen.
ReadUnaligned<T>(Void*)

Läser ett värde av typen T från den angivna platsen utan att anta arkitekturberoende justering av källadressen.
SizeOf<T>()

Returnerar storleken på ett värde för den angivna typparametern.
SkipInit<T>(T)

Kringgår bestämda tilldelningsregler för en viss referens.
Subtract<T>(T, Int32)

Subtraherar en förskjutning från den angivna hanterade pekaren.
Subtract<T>(T, IntPtr)

Subtraherar en elementförskjutning från den angivna hanterade pekaren.
Subtract<T>(T, UIntPtr)

Subtraherar en elementförskjutning från den angivna hanterade pekaren.
Subtract<T>(Void*, Int32)

Subtraherar en elementförskjutning från den angivna ohanterade pekaren.
SubtractByteOffset<T>(T, IntPtr)

Subtraherar en byteförskjutning från den angivna hanterade pekaren.
SubtractByteOffset<T>(T, UIntPtr)

Subtraherar en byteförskjutning från den angivna hanterade pekaren.
Unbox<T>(Object)

Returnerar ett mutable ref till ett rutat värde.
Write<T>(Void*, T)

Skriver ett värde av typen T till den angivna platsen.
WriteUnaligned<T>(Byte, T)

Skriver ett värde av typen T till den angivna platsen utan att anta arkitekturberoende justering av måladressen.
WriteUnaligned<T>(Void*, T)

Skriver ett värde av typen T till den angivna platsen utan att anta arkitekturberoende justering av måladressen.

Gäller för