Unsicherer Code in .NET

# Unsafe mit Arrays verwenden

Beim Zugriff auf Arrays mit Zeigern gibt es keine Begrenzungsprüfung und daher auch kein IndexOutOfRangeException wird geworfen. Dadurch wird der Code schneller.

Werte einem Array mit einem Zeiger zuweisen:

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
                }
            }
        }
    }
}

Während 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 je nach Komplexität der Elemente im Array sowie der jeweils angewendeten Logik variieren. Auch wenn es schneller sein mag, sollte es mit Vorsicht verwendet werden, da es schwieriger zu warten und leichter zu brechen ist.

# Unsafe mit Strings verwenden

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"

# Unsicherer Array-Index

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

Das Ausführen dieses Codes erstellt ein Array der Länge 3, versucht dann aber, das 5. Element (Index 4) abzurufen. Auf meiner Maschine hat dies 1910457872 gedruckt , aber das Verhalten ist nicht definiert.

Ohne unsafe -Block können Sie keine Zeiger verwenden und daher nicht auf Werte hinter dem Ende eines Arrays zugreifen, ohne dass eine Ausnahme ausgelöst wird.

# Bemerkungen

• Um den unsafe verwenden zu können Schlüsselwort in einem .Net-Projekt, müssen Sie "Unsicheren Code zulassen" in den Projekteigenschaften => Erstellen
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 verwenden, wird ein Array wie folgt verwendet:

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

.NET Framework stellt sicher, dass Sie die Grenzen des Arrays nicht überschreiten, indem es einen IndexOutOfRangeException auslöst 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;
        }
    }
}