C# Language
Unsicherer Code in .NET

Bemerkungen

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

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"