Unsafe C# Code Beheersen: Handleiding voor Pointers en Geheugenbeheer

Wat is Unsafe Code?

C# stelt je in staat om pointer-variabelen te gebruiken in een functie of codeblok wanneer dit gemarkeerd is met de unsafe modifier. Unsafe code (of unmanaged code) is een codeblok dat een pointer variabele gebruikt.

Pointers

Een pointer is een variabele wiens waarde het adres is van een andere variabele, dus het directe adres van de geheugenlocatie. Net als elke variabele of constante, moet je een pointer declareren voordat je het kunt gebruiken om een variabele-adres op te slaan.

De algemene vorm van een pointer-declaratie is:

type *var-name;

Geldige pointer-declaraties:

int *ip;    /* pointer naar een integer */
double *dp; /* pointer naar een double */
float *fp;  /* pointer naar een float */
char *ch;   /* pointer naar een character */

Het volgende voorbeeld illustreert het gebruik van pointers in C# met de unsafe modifier:

using System;
namespace UnsafeCodeApplication {
    class Program {
        static unsafe void Main(string[] args) {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} ", var);
            Console.WriteLine("Adres is: {0}", (int)p);
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Data is: 20
Adres is: 99215364

In plaats van een hele methode als unsafe te declareren, kun je ook een deel van de code als unsafe markeren. Het voorbeeld in de volgende sectie toont dit.

Datawaarde Ophalen met een Pointer

Je kunt de data ophalen die opgeslagen is op de locatie waarnaar de pointer verwijst, met behulp van de ToString() methode. Het volgende voorbeeld demonstreert dit:

using System;
namespace UnsafeCodeApplication {
    class Program {
        public static void Main() {
            unsafe {
                int var = 20;
                int* p = &var;
                Console.WriteLine("Data is: {0} ", var);
                Console.WriteLine("Data is: {0} ", p->ToString());
                Console.WriteLine("Adres is: {0} ", (int)p);
            }
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Data is: 20
Data is: 20
Adres is: 77128984

Pointers als Parameters Doorgeven aan Methodes

Je kunt een pointer-variabele als parameter aan een methode doorgeven. Het volgende voorbeeld illustreert dit:

using System;
namespace UnsafeCodeApplication {
    class TestPointer {
        public unsafe void swap(int* p, int* q) {
            int temp = *p;
            *p = *q;
            *q = temp;
        }
        public unsafe static void Main() {
            TestPointer p = new TestPointer();
            int var1 = 10;
            int var2 = 20;
            int* x = &var1;
            int* y = &var2;
            Console.WriteLine("Voor Swap: var1:{0}, var2: {1}", var1, var2);
            p.swap(x, y);
            Console.WriteLine("Na Swap: var1:{0}, var2: {1}", var1, var2);
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Voor Swap: var1: 10, var2: 20
Na Swap: var1: 20, var2: 10

Array-elementen Benaderen met een Pointer

In C# zijn een arraynaam en een pointer naar een datatype dat hetzelfde is als de arraydata, niet hetzelfde variabeltype. Bijvoorbeeld: int *p en int[] p zijn niet hetzelfde type. Je kunt de pointer-variabele p incrementeren omdat deze niet vastligt in het geheugen, maar een arrayadres is vast in het geheugen en kan niet geïncrementeerd worden.

Daarom, als je arraydata wilt benaderen met een pointer-variabele (zoals traditioneel in C of C++), moet je de pointer fixeren met het fixed sleutelwoord.

Het volgende voorbeeld demonstreert dit:

using System;
namespace UnsafeCodeApplication {
    class TestPointer {
        public unsafe static void Main() {
            int[] list = {10, 100, 200};
            fixed(int* ptr = list) /* arrayadres in pointer */
            for (int i = 0; i < 3; i++) {
                Console.WriteLine("Adres van list[{0}]={1}", i, (int)(ptr + i));
                Console.WriteLine("Waarde van list[{0}]={1}", i, *(ptr + i));
            }
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Adres van list[0] = 31627168
Waarde van list[0] = 10
Adres van list[1] = 31627172
Waarde van list[1] = 100
Adres van list[2] = 31627176
Waarde van list[2] = 200

Unsafe Code Compileren

Voor het compileren van unsafe code moet je de /unsafe command-line switch opgeven bij de command-line compiler.

Bijvoorbeeld, om een programma genaamd prog1.cs met unsafe code te compileren vanaf de command line:

csc /unsafe prog1.cs

Als je Visual Studio IDE gebruikt, moet je het gebruik van unsafe code inschakelen in de projecteigenschappen:

• Open project properties door dubbel te klikken op de properties-node in de Solution Explorer.

• Klik op het tabblad Build.

• Selecteer de optie "Allow unsafe code".