Code non sécurisé C#

Lorsque l'un des blocs de code unsafe Lorsque le modificateur est utilisé pour marquer, C# permet l'utilisation de variables de pointeur dans les fonctions.code non sécuriséou le code non géré est celui qui utilisepointeurbloc de code de variable

variable de pointeur

pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe d'une position mémoire. Comme d'autres variables ou constantes, vous devez déclarer un pointeur avant de stocker l'adresse d'une autre variable dans le pointeur.

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

type*　var-name;

Voici des exemples de déclarations de types de pointeurs :

Lorsque plusieurs pointeurs sont déclarés dans la même déclaration, l'astérisque * Ne s'écrit qu'avec des types de base ; il ne doit pas être utilisé comme préfixe pour chaque nom de pointeur. Par exemple :

int*　p1, p2, p3;　　　　　//　Correct　　
int　*p1,　*p2,　*p3;　　　//　Erreur

L'exemple suivant montre que dans C#, unsafe L'utilisation des modificateurs :

using System;
namespace UnsafeCodeApplication
{
　　　　class Program
　　　　{
　　　　　　　　static unsafe void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int var =　20;
　　　　　　　　　　　　int*　p = &var;
　　　　　　　　　　　　Console.WriteLine("Les données sont : {0} ", var);
　　　　　　　　　　　　Console.WriteLine("L'adresse est : {0}", (int)p);
　　　　　　　　　　　　Console.ReadKey();
　　　　　　　　}
　　　　}
}

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

Les données sont :　20
L'adresse est :　99215364

Vous pouvez également ne pas déclarer toute la méthode en tant que code non sécurisé, mais seulement une partie de la méthode en tant que code non sécurisé. L'exemple suivant illustre cela.

Utiliser un pointeur pour rechercher la valeur des données

Vous pouvez utiliser ToString() La méthode recherche les données stockées à l'emplacement pointé par une variable de pointeur. L'exemple suivant illustre cela :

using System;
namespace UnsafeCodeApplication
{
　　　class Program
　　　{
　　　　　　public static void Main()
　　　　　　{
　　　　　　　　　unsafe
　　　　　　　　　{
　　　　　　　　　　　　int var =　20;
　　　　　　　　　　　　int*　p = &var;
　　　　　　　　　　　　Console.WriteLine("Les données sont : {0} ", var);
　　　　　　　　　　　　Console.WriteLine("Les données sont : {0} ", p->ToString());
　　　　　　　　　　　　Console.WriteLine("L'adresse est : {0} ", (int)p);
　　　　　　　　　}
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

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

Les données sont :　20
Les données sont :　20
L'adresse est :　77128984

Passer un pointeur en tant que paramètre de méthode

Vous pouvez passer des variables de pointeur en tant que paramètres de 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("Avant Échange : var1:{0}, var2: {1}1, var2);
　　　　　　　　　p.swap(x, y);
　　　　　　　　　Console.WriteLine("Après Échange : var1:{0}, var2: {1}1, var2);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

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

Avant Échange : var1:　10, var2:　20
Après Échange : var1:　20, var2:　10

Accès aux éléments de l'array à l'aide de pointeurs

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

Par conséquent, si vous avez besoin d'accéder aux données de l'array à l'aide d'une variable de pointeur, vous pouvez le faire comme nous le faisons généralement en C ou C++++ comme fait dans fixed les mots-clés pour fixer les pointeurs.

L'exemple suivant montre cela :

using System;
namespace UnsafeCodeApplication
{
　　　class TestPointer
　　　{
　　　　　　public unsafe static void Main()
　　　　　　{
　　　　　　　　　int[] list = {10,　100,　200};
　　　　　　　　　fixed(int　*ptr = list)
　　　　　　　　　/*　Afficher l'adresse de l'array dans le pointeur　*/
　　　　　　　　　for ( int i = 0; i <　3; i++)
　　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("Adresse de la liste[{0}]=")1}　+　i));
　　　　　　　　　　　　Console.WriteLine("Valeur de la liste[{0}]=")1}　*(ptr　+　i));
　　　　　　　　　}
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

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

Adresse de la liste[0] =　31627168
Valeur de la liste[0] =　10
Adresse de la liste[1] =　31627172
Valeur de la liste[1] =　100
Adresse de la liste[2] =　31627176
Valeur de la liste[2] =　200

Compilation de code non sécurisé

Pour compiler du code non sécurisé, vous devez passer au compilateur en ligne de commande spécifié /unsafe Ligne de commande.

Par exemple, pour compiler un programme nommé prog contenant du code non sécurisé1Pour compiler un programme .cs contenant du code non sécurisé nommé prog, entrez la commande suivante dans la ligne de commande :

csc　/unsafe prog1.cs

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

Les étapes sont les suivantes :

• Pour ouvrir, double-cliquez sur le noeud Propriétés (Solution Explorer) dans l'explorateur de ressources.Propriétés du projet (project properties)。

• Cliquez Build Onglet.

• Sélectionnez l'option "Autoriser le code non sécurisé"。