[Tutoriel C#] Code dangereux C#

C# Unsafe Code

C# permet l'utilisation de variables de pointeur dans les fonctions lorsqu'un bloc de code est marqué avec le modificateur unsafe. Le code non sécurisé ou code non géré est un bloc de code qui utilise des variables de pointeur.

Variables de pointeur

Un pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe d'un emplacement mémoire. Tout comme les autres variables ou constantes, vous devez déclarer un pointeur avant de l'utiliser pour stocker l'adresse d'une autre variable.

La forme générale de déclaration de variable de pointeur est :

type *var-name;

Ce qui suit est une déclaration de pointeur valide :

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

L'exemple suivant illustre l'utilisation d'une modification non sécurisée en C# Utilisation des pointeurs temporels :

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();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

Data is: 20
Address is: 99215364

Vous pouvez également éviter de déclarer la méthode entière comme code dangereux, seule une partie de la méthode doit être déclarée comme code dangereux. L’exemple suivant illustre ce point.

Récupération de valeurs de données à l'aide de pointeurs

Vous pouvez utiliser la méthode ToString() pour récupérer des données stockées à l'emplacement référencé par une variable de pointeur. L'exemple suivant le démontre :

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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Passer un pointeur comme argument de méthode

Vous pouvez transmettre des variables de pointeur aux méthodes en tant que paramètres de la méthode. L'exemple suivant illustre cela :

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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Utilisation de pointeurs pour accéder aux éléments du tableau

En C#, un nom de tableau et un pointeur vers le même type de données que les données du tableau sont des types de variables différents. Par exemple, int *p et int[] p sont des types différents. Vous pouvez incrémenter la variable de pointeur p car elle n'est pas fixe en mémoire, mais l'adresse du tableau est fixe en mémoire, vous ne pouvez donc pas incrémenter le tableau p.

Donc, si vous avez besoin d'accéder aux données d'un tableau à l'aide de variables de pointeur, vous pouvez utiliser le mot-clé fixe pour corriger le pointeur comme nous le faisons habituellement en C ou C.

L'exemple suivant le démontre :

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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

La compilation ne protège pas le code

Afin de compiler du code non sécurisé, vous devez passer au compilateur de ligne de commande et spécifier la ligne de commande /unsafe.

Par exemple, pour compiler un programme nommé prog1.cs qui contient du code non sécurisé, entrez la commande sur la ligne de commande :

csc /unsafe prog1.cs

Si vous utilisez l'IDE Visual Studio, alors vous devez activer le code non sécurisé dans les propriétés du projet.

Les étapes sont les suivantes :

Ouvrez les propriétés du projet en double-cliquant sur le nœud des propriétés dans l'Explorateur de solutions.

Cliquez sur l'onglet Construire.

Sélectionnez l'option "Autoriser les codes dangereux".

Ce qui précède est le contenu du [tutoriel c#] Code dangereux C# Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !