[C#-Tutorial] Unsicherer C#-Code

Unsicherer C#-Code

C# ermöglicht die Verwendung von Zeigervariablen in Funktionen, wenn ein Codeblock mit dem unsicheren Modifikator markiert ist. Unsicherer Code oder nicht verwalteter Code ist ein Codeblock, der Zeigervariablen verwendet.

Zeigervariablen

Ein Zeiger ist eine Variable, deren Wert die Adresse einer anderen Variablen ist, also die direkte Adresse eines Speicherorts. Genau wie andere Variablen oder Konstanten müssen Sie einen Zeiger deklarieren, bevor Sie ihn zum Speichern der Adresse einer anderen Variablen verwenden.

Die allgemeine Form der Zeigervariablendeklaration ist:

type *var-name;

Das Folgende sind gültige Zeigerdeklarationen:

int    *ip;    /* 指向一个整数 */
double *dp;    /* 指向一个双精度数 */
float  *fp;    /* 指向一个浮点数 */
char   *ch     /* 指向一个字符 */

Das folgende Beispiel veranschaulicht die Verwendung unsicherer Änderungen in C#-Verwendung von Laufzeitzeigern:

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 wird, erzeugt er die folgenden Ergebnisse:

Data is: 20
Address is: 99215364

Sie können auch vermeiden, die gesamte Methode als unsicher zu deklarieren Code muss nur ein Teil der Methode als unsicherer Code deklariert werden. Das folgende Beispiel verdeutlicht diesen Punkt.

Datenwerte mithilfe von Zeigern abrufen

Sie können die ToString()-Methode verwenden, um Daten abzurufen, die an der Stelle gespeichert sind, auf die eine Zeigervariable verweist. 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 wird, erzeugt er die folgenden Ergebnisse:

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

Übergabe eines Zeigers als Methodenargument

Sie können Zeigervariablen als Parameter der Methode an Methoden ü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 die folgenden Ergebnisse:

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

Verwendung von Zeigern für den Zugriff auf Array-Elemente

In C# sind ein Array-Name und ein Zeiger auf denselben Datentyp wie die Array-Daten unterschiedliche Variablentypen. Beispielsweise sind int *p und int[] p unterschiedliche Typen. Sie können die Zeigervariable p erhöhen, da sie nicht im Speicher festgelegt ist. Die Array-Adresse ist jedoch im Speicher festgelegt, sodass Sie das Array p nicht erhöhen können.

Wenn Sie also mithilfe von Zeigervariablen auf Array-Daten zugreifen müssen, können Sie das Schlüsselwort „fixed“ verwenden, um den Zeiger zu fixieren, wie wir es normalerweise in C oder C++ tun.

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)

         /* 显示指针中数组地址 */
         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 wird, erzeugt er die folgenden Ergebnisse:

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

Bei der Kompilierung wird kein sicherer Code erstellt

Um unsicheren Code zu kompilieren, müssen Sie zum Befehlszeilen-Compiler wechseln und die Befehlszeile /unsafe angeben.

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

csc /unsafe prog1.cs

Wenn Sie die Visual Studio-IDE verwenden, dann Sie Sie müssen unsicheren Code in den Projekteigenschaften aktivieren.

Die Schritte sind wie folgt:

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

Klicken Sie auf die Registerkarte „Erstellen“.

Wählen Sie die Option „Unsicheren Code zulassen“.

Das Obige ist der Inhalt des [c#-Tutorials] C#-unsicherer Code. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!