Suche…


Bemerkungen

  • Um das unsafe Schlüsselwort in einem .NET-Projekt verwenden zu können, müssen Sie in Projekteigenschaften => Erstellen "Nicht sicheren Code zulassen" aktivieren
  • Die Verwendung von unsicherem Code kann die Leistung verbessern, geht jedoch auf Kosten der Codesicherheit (daher der Begriff unsafe ).

Wenn Sie beispielsweise eine for-Schleife eines Arrays verwenden,

for (int i = 0; i < array.Length; i++)
{
    array[i] = 0;
}

.NET Framework stellt sicher, dass Sie die Grenzen des Arrays nicht überschreiten. Eine IndexOutOfRangeException wenn der Index die Grenzen überschreitet.

Wenn Sie jedoch unsicheren Code verwenden, können Sie die Grenzen des Arrays wie folgt überschreiten:

unsafe
{
    fixed (int* ptr = array)
    {
        for (int i = 0; i <= array.Length; i++)
        {
            *(ptr+i) = 0;
        }
    }
}

Unsicherer Array-Index

void Main()
{
    unsafe
    {
        int[] a = {1, 2, 3};
        fixed(int* b = a)
        {
            Console.WriteLine(b[4]);
        }
    }
}

Beim Ausführen dieses Codes wird ein Array der Länge 3 erstellt, es wird jedoch versucht, das fünfte Element (Index 4) abzurufen. Auf meinem Rechner wurde dieser 1910457872 gedruckt, aber das Verhalten ist nicht definiert.

Ohne den unsafe Block können Sie keine Zeiger verwenden und daher nicht auf Werte über das Ende eines Arrays hinaus zugreifen, ohne dass eine Ausnahme ausgelöst wird.

Verwendung von Arrays mit unsicher

Wenn auf Arrays mit Zeigern IndexOutOfRangeException wird, werden keine Begrenzungen IndexOutOfRangeException , und daher wird keine IndexOutOfRangeException ausgelöst. Dies macht den Code schneller.

Zuweisen von Werten zu einem Array mit einem Zeiger:

class Program
{
    static void Main(string[] args)
    {
        unsafe
        {
            int[] array = new int[1000]; 
            fixed (int* ptr = array)
            {
                for (int i = 0; i < array.Length; i++)
                {
                    *(ptr+i) = i; //assigning the value with the pointer
                }
            }
        }
    }
}

Das sichere und normale Gegenstück wäre:

class Program
{
    static void Main(string[] args)
    {            
        int[] array = new int[1000]; 

        for (int i = 0; i < array.Length; i++)
        {
            array[i] = i;
        }
    }
}

Der unsichere Teil ist im Allgemeinen schneller und der Leistungsunterschied kann abhängig von der Komplexität der Elemente im Array sowie der auf jedes Element angewandten Logik variieren. Obwohl es schneller sein kann, sollte es mit Vorsicht verwendet werden, da es schwieriger zu warten und leichter zu brechen ist.

Verwendung von Zeichenketten mit unsicher

var s = "Hello";      // The string referenced by variable 's' is normally immutable, but
                      // since it is memory, we could change it if we can access it in an 
                      // unsafe way.

unsafe                // allows writing to memory; methods on System.String don't allow this
{
  fixed (char* c = s) // get pointer to string originally stored in read only memory
    for (int i = 0; i < s.Length; i++)
      c[i] = 'a';     // change data in memory allocated for original string "Hello"
}
Console.WriteLine(s); // The variable 's' still refers to the same System.String
                      // value in memory, but the contents at that location were 
                      // changed by the unsafe write above.
                      // Displays: "aaaaa"


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow