C# – Unsichere Codes

C# erlaubt die Verwendung von Zeigervariablen in einer Funktion oder einem Codeblock, wenn er mit unsicher gekennzeichnet ist Modifikator. Der unsichere Code oder der nicht verwaltete Code ist ein Codeblock, der einen Zeiger verwendet Variable.

Hinweise

Ein Zeiger ist eine Variable, deren Wert die Adresse einer anderen Variablen ist, d. h. die direkte Adresse des Speicherplatzes. Ähnlich wie bei jeder Variablen oder Konstante müssen Sie einen Zeiger deklarieren, bevor Sie ihn zum Speichern einer Variablenadresse verwenden können.

Die allgemeine Form einer Zeigerdeklaration ist −

type *var-name;

Es folgen gültige Zeigerdeklarationen −

int    *ip;    /* pointer to an integer */
double *dp;    /* pointer to a double */
float  *fp;    /* pointer to a float */
char   *ch     /* pointer to a character */

Das folgende Beispiel veranschaulicht die Verwendung von Zeigern in C# unter Verwendung des unsicheren Modifikators −

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("Address is: {0}",  (int)p);
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wurde, erzeugt er das folgende Ergebnis −

Data is: 20
Address is: 99215364

Anstatt eine ganze Methode als unsicher zu deklarieren, können Sie auch einen Teil des Codes als unsicher deklarieren. Das Beispiel im folgenden Abschnitt zeigt dies.

Abrufen des Datenwerts mit einem Zeiger

Sie können die Daten abrufen, die an der Stelle gespeichert sind, auf die durch die Zeigervariable verwiesen wird, indem Sie ToString() verwenden Methode. Das folgende Beispiel demonstriert dies −

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("Address is: {0} " , (int)p);
         }
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wurde, erzeugt er das folgende Ergebnis −

Data is: 20
Data is: 20
Address is: 77128984

Zeiger als Parameter an Methoden übergeben

Sie können einer Methode eine Zeigervariable als Parameter übergeben. Das folgende Beispiel veranschaulicht dies −

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("Before Swap: var1:{0}, var2: {1}", var1, var2);
         p.swap(x, y);

         Console.WriteLine("After Swap: var1:{0}, var2: {1}", var1, var2);
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Before Swap: var1: 10, var2: 20
After Swap: var1: 20, var2: 10

Zugriff auf Array-Elemente mit einem Zeiger

In C# sind ein Arrayname und ein Zeiger auf einen Datentyp, der den Arraydaten entspricht, nicht derselbe Variablentyp. Beispielsweise sind int *p und int[] p nicht vom gleichen Typ. Sie können die Zeigervariable p inkrementieren, weil sie nicht im Speicher fest ist, aber eine Array-Adresse im Speicher fest ist, und Sie können diese nicht inkrementieren.

Wenn Sie also mit einer Zeigervariablen auf Array-Daten zugreifen müssen, wie wir es traditionell in C oder C++ tun (bitte überprüfen Sie:C-Zeiger), müssen Sie den Zeiger mit fixed reparieren Schlüsselwort.

Das folgende Beispiel demonstriert dies −

using System;

namespace UnsafeCodeApplication {
   class TestPointer {
      public unsafe static void Main() {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)
         
         /* let us have array address in pointer */
         for ( int i = 0; i < 3; i++) {
            Console.WriteLine("Address of list[{0}]={1}",i,(int)(ptr + i));
            Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
         }
         
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wurde, erzeugt er das folgende Ergebnis −

Address of list[0] = 31627168
Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200

Kompilieren von unsicherem Code

Um unsicheren Code zu kompilieren, müssen Sie /unsafe angeben Befehlszeilenschalter mit Befehlszeilencompiler.

Um beispielsweise ein Programm namens prog1.cs zu kompilieren, das unsicheren Code enthält, geben Sie in der Befehlszeile den Befehl −

ein

csc /unsafe prog1.cs

Wenn Sie Visual Studio IDE verwenden, müssen Sie die Verwendung von unsicherem Code in den Projekteigenschaften aktivieren.

Dazu −

• Öffnen Sie Projekteigenschaften indem Sie im Projektmappen-Explorer auf den Eigenschaftenknoten doppelklicken.

• Klicken Sie auf Bauen Registerkarte.

• Wählen Sie die Option „Unsicheren Code zulassen ".