C # - Unsichere Codes

C # ermöglicht die Verwendung von Zeigervariablen in einer Funktion des Codeblocks, wenn dieser durch das gekennzeichnet ist unsafeModifikator. Dasunsafe code oder der nicht verwaltete Code ist ein Codeblock, der a verwendet pointer Variable.

Note- Um die in diesem Kapitel genannten Programme auf codingground auszuführen , setzen Sie die Kompilierungsoption unter Projekt >> Kompilierungsoptionen >> Kompilierungsbefehl auf

mcs *.cs -out:main.exe -unsafe"

Zeiger

EIN pointerist eine Variable, deren Wert die Adresse einer anderen Variablen ist, dh die direkte Adresse des Speicherorts. Ä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 zeigt 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, ergibt sich das folgende Ergebnis:

Data is: 20
Address is: 99215364

Anstatt eine gesamte 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, die an dem Ort gespeichert sind, auf den durch die Zeigervariable verwiesen wird, mit der Taste abrufen ToString()Methode. Das folgende Beispiel zeigt 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, ergibt sich das folgende Ergebnis:

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

Zeiger als Parameter an Methoden übergeben

Sie können eine Zeigervariable als Parameter an eine Methode ü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, ergibt sich 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 Array-Name und ein Zeiger auf einen Datentyp, der mit den Array-Daten identisch ist, nicht derselbe Variablentyp. Zum Beispiel sind int * p und int [] p nicht vom gleichen Typ. Sie können die Zeigervariable p erhöhen, da sie nicht im Speicher festgelegt ist, sondern eine Array-Adresse im Speicher festgelegt ist, und Sie können dies nicht erhöhen.

Wenn Sie daher mit einer Zeigervariablen auf Array-Daten zugreifen müssen, wie dies traditionell in C oder C ++ der Fall ist (bitte überprüfen Sie: C-Zeiger ), müssen Sie den Zeiger mithilfe der Zeigervariablen korrigierenfixed Stichwort.

Das folgende Beispiel zeigt 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, ergibt sich 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

Unsicheren Code kompilieren

Zum Kompilieren von unsicherem Code müssen Sie Folgendes angeben /unsafe Befehlszeilenschalter mit Befehlszeilen-Compiler.

Um beispielsweise ein Programm mit dem Namen prog1.cs mit unsicherem Code über die Befehlszeile zu kompilieren, geben Sie den Befehl -

csc /unsafe prog1.cs

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

Um dies zu tun -

• Öffnen project properties durch Doppelklicken auf den Eigenschaftsknoten im Projektmappen-Explorer.

• Klick auf das Build Tab.

• Wählen Sie die Option "Allow unsafe code".