C # - Codes non sécurisés

C # permet d'utiliser des variables de pointeur dans une fonction de bloc de code lorsqu'il est marqué par le unsafemodificateur. leunsafe code ou le code non managé est un bloc de code qui utilise un pointer variable.

Note- Pour exécuter les programmes mentionnés dans ce chapitre à codingground , veuillez définir l'option de compilation dans Projet >> Options de compilation >> Commande de compilation sur

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

Pointeurs

UNE pointerest une variable dont la valeur est l'adresse d'une autre variable c'est-à-dire l'adresse directe de l'emplacement mémoire. semblable à toute variable ou constante, vous devez déclarer un pointeur avant de pouvoir l'utiliser pour stocker une adresse de variable.

La forme générale d'une déclaration de pointeur est -

type *var-name;

Voici les déclarations de pointeur valides -

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

L'exemple suivant illustre l'utilisation de pointeurs en C #, à l'aide du modificateur unsafe -

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 a été compilé et exécuté, il produit le résultat suivant -

Data is: 20
Address is: 99215364

Au lieu de déclarer une méthode entière comme non sûre, vous pouvez également déclarer une partie du code comme non sûre. L'exemple de la section suivante le montre.

Récupération de la valeur des données à l'aide d'un pointeur

Vous pouvez récupérer les données stockées à l'emplacement référencé par la variable pointeur, à l'aide du ToString()méthode. L'exemple suivant illustre ceci -

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 a été compilé et exécuté, il produit le résultat suivant -

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

Passer des pointeurs en tant que paramètres aux méthodes

Vous pouvez passer une variable de pointeur à une méthode en tant que paramètre. 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 le résultat suivant -

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

Accès aux éléments d'un tableau à l'aide d'un pointeur

En C #, un nom de tableau et un pointeur vers un type de données identique aux données du tableau ne sont pas du même type de variable. Par exemple, int * p et int [] p, ne sont pas du même type. Vous pouvez incrémenter la variable de pointeur p car elle n'est pas fixée en mémoire mais une adresse de tableau est fixée en mémoire, et vous ne pouvez pas l'incrémenter.

Par conséquent, si vous avez besoin d'accéder à des données de tableau en utilisant une variable de pointeur, comme nous le faisons traditionnellement en C ou C ++ (veuillez vérifier: Pointeurs C ), vous devez corriger le pointeur en utilisant lefixed mot-clé.

L'exemple suivant illustre ceci -

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

Lorsque le code ci-dessus a été compilé et exécuté, il produit le résultat suivant -

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

Compilation de code non sécurisé

Pour compiler du code non sécurisé, vous devez spécifier le /unsafe commutateur de ligne de commande avec compilateur de ligne de commande.

Par exemple, pour compiler un programme nommé prog1.cs contenant du code unsafe, à partir de la ligne de commande, donnez la commande -

csc /unsafe prog1.cs

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

Pour ce faire -

  • Ouvert project properties en double-cliquant sur le nœud des propriétés dans l'Explorateur de solutions.

  • Clique sur le Build languette.

  • Sélectionnez l'option "Allow unsafe code".