Syntaxe C Sharp

À partir de C# 7.0, le symbole de soulignement peut être utilisé pour séparer les chiffres dans les valeurs numériques à des fins de lisibilité. Le compilateur ignore ces traits de soulignement.

int bin = 0 b1101_0010_1011_0100 ; int hex = 0 x2F_BB_4A_F1 ; int dec = 1 _000_500_954 ; double real = 1 _500 . 200 _2e - 1 _000 ;

En général, il ne peut être placé qu'entre des caractères numériques. Il ne peut pas être placé au début ( _121) ou à la fin de la valeur ( 121_ou 121.05_), à côté de la décimale dans les valeurs à virgule flottante ( 10_.0), à côté du caractère exposant ( 1.1e_1) ou à côté du spécificateur de type ( 10_f).

Les variables sont des identifiants associés à des valeurs. Elles sont déclarées en écrivant le type et le nom de la variable, et sont éventuellement initialisées dans la même instruction.

Déclarer

int myInt ; // Déclaration d'une variable non initialisée appelée 'myInt', de type 'int'

Affectation

int myInt ; // Déclaration d'une variable non initialisée myInt = 35 ; // Affectation d'une valeur à la variable

Initialiser

int myInt = 35 ; // Déclaration et initialisation de la variable

Plusieurs variables du même type peuvent être déclarées et initialisées dans une seule instruction.

int a , b ; // Déclaration de plusieurs variables du même type
int a = 2 , b = 3 ; // Déclaration et initialisation de plusieurs variables du même type

Il s'agit d'une fonctionnalité de C# 3.0 .

C# 3.0 a introduit l'inférence de type, permettant de remplacer le spécificateur de type d'une déclaration de variable par le mot-clé var, si son type réel peut être déterminé de manière statique à partir de l'initialiseur. Cela réduit la répétition, en particulier pour les types avec plusieurs paramètres de type génériques, et adhère plus étroitement au principe DRY .

var mesChars = new char [] { 'A' , 'Ö' }; // ou char[] mesChars = new char[] {'A', 'Ö'};
var myNums = new Liste < int > (); // ou Liste<int> myNums = new Liste<int>();

Les constantes sont des valeurs immuables.

Lors de la déclaration d'une variable locale ou d'un champ avec le constmot-clé comme préfixe, la valeur doit être donnée lors de la déclaration. Après cela, elle est verrouillée et ne peut pas changer. Elles peuvent être déclarées dans le contexte comme un champ ou une variable locale. Les constantes sont implicitement statiques.

constante double PI = 3,14 ;

Ceci montre les deux utilisations du mot-clé.

classe publique Foo { const privée double X = 3 ;
public Foo () { const int y = 2 ; } }

Le readonlymot-clé fait une chose similaire aux champs. Comme les champs marqués comme tels, constils ne peuvent pas changer une fois initialisés. La différence est que l'on peut choisir de les initialiser dans un constructeur, ou à une valeur qui n'est pas connue avant l'exécution. Cela ne fonctionne que sur les champs. readonlyLes champs peuvent être soit des membres d'une instance, soit des membres de classe statiques.

Les accolades sont utilisées pour indiquer un bloc de code et une nouvelle portée . Les membres de classe et le corps d'une méthode sont des exemples de ce qui peut se trouver à l'intérieur de ces accolades dans divers contextes. {...}

À l’intérieur des corps de méthode, les accolades peuvent être utilisées pour créer de nouvelles portées :

void FaireQuelqueChose () { int a ;
{ 
int b ; a = 1 ; }
a = 2 ; b = 3 ; // Échouera car la variable est déclarée dans une portée interne. }

L'application AC# se compose de classes et de leurs membres. Les classes et autres types existent dans des espaces de noms mais peuvent également être imbriqués dans d'autres classes.

Qu'il s'agisse d'une console ou d'une application d'interface graphique, le programme doit avoir un point d'entrée quelconque. Le point d'entrée d'une application C# est la Mainméthode. Il ne peut y avoir qu'une seule déclaration de cette méthode, et il s'agit d'une méthode statique dans une classe. Elle renvoie généralement voiddes arguments de ligne de commande et les reçoit sous forme de tableau de chaînes.

static void Main ( string [] args ) // string[] args peut être omis si le programme n'a pas d'arguments de ligne de commande. { }

La méthode principale est également autorisée à renvoyer une valeur entière si elle est spécifiée.

statique int Main ( chaîne [] args ) { renvoie 0 ; }

Il s'agit d'une fonctionnalité de C# 7.1.

Les tâches asynchrones peuvent être attendues dans la Mainméthode en déclarant le type de retour de la méthode comme Task.

tâche statique asynchrone principale ( chaîne [] args ) { wait DoWorkAsync ( 42 ); }

Toutes les combinaisons de Task, ou Task<int>,et avec ou sans le string[] argsparamètre sont prises en charge.

Il s'agit d'une fonctionnalité de C# 9.0.

Comme dans les langages de script, les instructions de niveau supérieur suppriment la cérémonie de devoir déclarer la Programclasse avec une Mainméthode.

Au lieu de cela, les instructions peuvent être écrites directement dans un fichier spécifique, et ce fichier sera le point d'entrée du programme. Le code dans d'autres fichiers devra toujours être défini dans des classes.

Cela a été introduit pour rendre C# moins verbeux et donc plus accessible aux débutants pour démarrer.

en utilisant le système ;
Console . WriteLine ( "Bonjour tout le monde !" );

Les types sont déclarés après les instructions et seront automatiquement disponibles à partir des instructions situées au-dessus d'eux.

Les espaces de noms font partie d'un nom de type et sont utilisés pour regrouper et/ou distinguer les entités nommées des autres.

System . IO . DirectoryInfo // DirectoryInfo se trouve dans l'espace de noms System.IO

Un espace de noms est défini comme ceci :

espace de noms FooNamespace { // Membres }

Un espace de noms peut être placé à l'intérieur d'un espace de noms comme ceci :

espace de noms FooNamespace { // Membres espace de noms BarNamespace { // Membres } }

Cela peut également être fait comme ceci :

espace de noms FooNamspace { // Membres }
espace de noms FooNamspace.BarNamespace { // Membres }

Dans C# 10 et versions ultérieures, les espaces de noms peuvent également être définis à l'aide de déclarations de portée de fichier en procédant comme suit :

espace de noms FooNamespace ; // les crochets sont omis ici au profit d'un point-virgule.

La usingdirective charge un espace de noms spécifique à partir d'un assemblage référencé. Elle est généralement placée en haut (ou en-tête) d'un fichier de code, mais elle peut être placée ailleurs si nécessaire, par exemple à l'intérieur des classes.

en utilisant System ; en utilisant System.Collections ;

La directive peut également être utilisée pour définir un autre nom pour un espace de noms ou un type existant. Cela est parfois utile lorsque les noms sont trop longs et moins lisibles.

en utilisant Net = System . Net ; en utilisant DirInfo = System . IO . DirectoryInfo ;

La directive charge les membres statiques d'un type spécifié dans la portée actuelle, les rendant accessibles directement par le nom du membre.usingstatic

en utilisant la console système statique ;
WriteLine ( "Bonjour le monde !" );

Certains des opérateurs existants peuvent être surchargés en écrivant une méthode de surcharge.

opérateur public static Foo + ( Foo foo , Bar bar ) { renvoie un nouveau Foo ( foo . Value + bar . Value ); }

Voici les opérateurs surchargeables :

• Les opérateurs d'affectation ( etc.) sont des combinaisons d'un opérateur binaire et de l'opérateur d'affectation ( ) et seront évalués à l'aide des opérateurs ordinaires, qui peuvent être surchargés.+=,*==
• Les opérateurs de conversion ( ) ne peuvent pas être surchargés, mais il est possible de définir des opérateurs de conversion.()
• L'opérateur d'indexation de tableau ( [ ]) n'est pas surchargé, mais il est possible de définir de nouveaux indexeurs.

L'opérateur de conversion n'est pas surchargé, mais on peut écrire une méthode d'opérateur de conversion qui réside dans la classe cible. Les méthodes de conversion peuvent définir deux variétés d'opérateurs, les opérateurs de conversion implicites et explicites. L'opérateur implicite effectuera la conversion sans spécifier l'opérateur de conversion ( ) et l'opérateur explicite nécessite son utilisation. ()

Opérateur de conversion implicite

classe Foo { public int Value ;
opérateur implicite statique public Foo ( int valeur ) { return new Foo ( valeur ); } } // Conversion implicite Foo foo = 2 ;

Opérateur de conversion explicite

classe Foo { public int Value ;
opérateur explicite statique public Foo ( int valeur ) { return new Foo ( valeur ); } } // Conversion explicite Foo foo = ( Foo ) 2 ;

L' asopérateur va tenter d'effectuer un cast silencieux vers un type donné. Il renverra l'objet en tant que nouveau type si possible, et sinon renverra null.

Stream stream = Fichier . Open ( @"C:\Temp\data.dat" ); FileStream fstream = stream as FileStream ; // Renverra un objet.
Chaîne str = flux comme chaîne ; // Renverra null.

Il s'agit d'une fonctionnalité de C# 2.0 .

Ce qui suit:

retourner ifNotNullValue ?? elseValue ;

est l'abréviation de :

retourner ifNotNullValue != null ? ifNotNullValue : elseValue ;

Cela signifie que si le contenu de la variable ifNotNullValuen'est pas nul, ce contenu sera renvoyé, sinon le contenu de la variable otherwiseValueest renvoyé.

C# 8.0 introduit l'affectation de fusion nulle , telle que

variable ??= sinonValeur ;

est équivalent à

si ( la variable est nulle ) variable = elseValue ;

C# hérite de la plupart des structures de contrôle de C/C++ et en ajoute également de nouvelles comme l' foreachinstruction.

Ces structures contrôlent le flux du programme à travers des conditions données.

L' ifinstruction est saisie lorsque la condition donnée est vraie. Les instructions de cas sur une seule ligne ne nécessitent pas de parenthèses en bloc, bien que cela soit généralement préféré par convention.

Déclaration simple en une seule ligne :

si ( i == 3 ) ... ;

Multi-ligne avec else-block (sans aucune accolade) :

si ( i == 2 ) ... sinon ...

Conventions de codage recommandées pour une instruction if.

si ( i == 3 ) { ... } sinon si ( i == 2 ) { ... } sinon { ... }

La switchconstruction sert de filtre pour différentes valeurs. Chaque valeur mène à un « cas ». Il n'est pas permis de passer à travers les sections de cas et donc le mot-clé breakest généralement utilisé pour terminer un cas. Une incondition returndans une section de cas peut également être utilisée pour terminer un cas. Voir aussi comment gotoune instruction peut être utilisée pour passer d'un cas à l'autre. Cependant, de nombreux cas peuvent conduire au même code. Le cas par défaut gère tous les autres cas non gérés par la construction.

switch ( ch ) { case 'A' : statement ; ... break ; case 'B' : statement ; break ; case 'C' : // Une section switch peut avoir plusieurs étiquettes de cas. case 'D' : ... break ; default : ... break ; }

Les instructions d'itération sont des instructions qui sont exécutées de manière répétée lorsqu'une condition donnée est évaluée comme vraie.

tant que ( i == vrai ) { ... }

faire 
{
} 
tandis que ( i == vrai );

La forboucle se compose de trois parties : déclaration , condition et expression de compteur . Chacune d'entre elles peut être omise car elles sont facultatives.

pour ( int i = 0 ; i < 10 ; i ++ ) { ... }

Est équivalent à ce code représenté par une whileinstruction, sauf qu'ici la ivariable n'est pas locale à la boucle.

int i = 0 ; while ( i < 10 ) { //... i ++ ; }

L' foreachinstruction est dérivée de l' forinstruction et utilise un certain modèle décrit dans la spécification du langage C# afin d'obtenir et d'utiliser un énumérateur d'éléments sur lesquels itérer.

Chaque élément de la collection donnée sera renvoyé et accessible dans le contexte du bloc de code. Une fois le bloc exécuté, l'élément suivant sera renvoyé jusqu'à ce qu'il ne reste plus d'éléments.

foreach ( int i dans intList ) { ... }

Les instructions de saut sont héritées du langage C/C++ et, par la suite, des langages assembleurs. Elles représentent simplement les instructions de saut d'un langage assembleur qui contrôle le déroulement d'un programme.

Les étiquettes sont des points donnés dans le code auxquels on peut accéder en utilisant l' gotoinstruction.

début : 
....... aller au début ;

Notez que l'étiquette n'a pas besoin d'être positionnée après l' gotoinstruction ; elle peut être avant celle-ci dans le fichier source.

L' gotoinstruction peut être utilisée dans switchdes instructions pour passer d'un cas à un autre ou pour passer d'un cas à l'autre.

switch ( n ) { case 1 : Console.WriteLine ( "Case 1" ) ; break ; case 2 : Console.WriteLine ( "Case 2" ) ; goto case 1 ; case 3 : Console.WriteLine ( " Case 3 " ); case 4 : // La compilation échouera ici car les cas ne peuvent pas échouer en C#. Console.WriteLine ( " Case 4" ); goto default ; // C'est la bonne façon de passer au cas suivant. case 5 : // Plusieurs étiquettes pour le même code sont OK case 6 : default : Console.WriteLine ( "Default" ); break ; // Même default ne doit pas atteindre le point final }

L' breakinstruction sort de la boucle ou switchde l'instruction la plus proche. L'exécution continue dans l'instruction suivant l'instruction terminée, le cas échéant.

int e = 10 ; for ( int i = 0 ; i < e ; i ++ ) { while ( true ) { break ; } // S'arrêtera à ce point. }

L' continueinstruction interrompt l'itération en cours de l'instruction de contrôle actuelle et commence l'itération suivante.

int ch ; while (( ch = Console . Read ()) != - 1 ) { if ( ch == ' ' ) continue ; // Ignore le reste de la boucle while
// Reste de la boucle while 
... }

La whileboucle dans le code ci-dessus lit les caractères en appelant , en sautant les instructions dans le corps de la boucle si les caractères sont des espaces. GetChar()

La méthode de gestion des exceptions d'exécution en C# est héritée de Java et de C++.

La bibliothèque de classes de base possède une classe appelée à partir de laquelle toutes les autres classes d'exception sont dérivées. Un objet contient toutes les informations sur une exception spécifique ainsi que les exceptions internes qui ont été provoquées. Les programmeurs peuvent définir leurs propres exceptions en dérivant de la classe. System.ExceptionExceptionException

Une exception peut être levée de cette façon :

lancer une nouvelle NotImplementedException ();

Les exceptions sont gérées au sein de blocs. try...catch

try 
{ 
// Instructions qui peuvent générer des exceptions ... } catch ( Exception ex ) { // Exception interceptée et gérée ici ... } finally { // Instructions toujours exécutées après les blocs try/catch ... }

Les instructions contenues dans le trybloc sont exécutées et si l'une d'entre elles génère une exception, l'exécution du bloc est interrompue et l'exception est gérée par le catchbloc. Il peut y avoir plusieurs catchblocs, auquel cas le premier bloc avec une variable d'exception dont le type correspond au type de l'exception générée est exécuté.

Si aucun catchbloc ne correspond au type de l'exception levée, l'exécution du bloc (ou de la méthode) externe contenant l' try ... catchinstruction est interrompue et l'exception est transmise vers le haut et en dehors du bloc ou de la méthode contenant. L'exception est propagée vers le haut dans la pile d'appels jusqu'à ce qu'un catchbloc correspondant soit trouvé dans l'une des méthodes actuellement actives. Si l'exception se propage jusqu'à la méthode la plus élevée sans qu'aucun bloc correspondant ne soit trouvé, l'ensemble du programme est terminé et une description textuelle de l'exception est écrite dans le flux de sortie standard. Main()catch

Les instructions contenues dans le finallybloc sont toujours exécutées après les blocs tryet catch, qu'une exception ait été levée ou non. Ces blocs sont utiles pour fournir un code de nettoyage.

Soit un catchbloc, soit un finallybloc, soit les deux, doivent suivre le trybloc.

C# est un langage typé statiquement comme C et C++. Cela signifie que chaque variable et constante obtient un type fixe lors de sa déclaration. Il existe deux types : les types valeur et les types référence .

Les instances de types de valeur résident sur la pile, c'est-à-dire qu'elles sont liées à leurs variables. Si l'on déclare une variable pour un type de valeur, la mémoire est allouée directement. Si la variable sort de la portée, l'objet est détruit avec elle.

Les structures sont plus communément appelées structs . Les structures sont des types de valeur définis par l'utilisateur qui sont déclarés à l'aide structdu mot-clé . Elles sont très similaires aux classes mais conviennent mieux aux types légers. Certaines différences syntaxiques importantes entre une classe et une structure sont présentées plus loin dans cet article.

structure Foo { ... }

Les types de données primitifs sont tous des structures.

Ce sont les types de données primitifs.

Remarque : string ( ) n’est pas une structure et n’est pas un type primitif. System.String

Les types énumérés (déclarés avec enum) sont des valeurs nommées représentant des valeurs entières.

enum Saison { Hiver = 0 , Printemps = 1 , Été = 2 , Automne = 3 , Automne = Autumn // L'automne s'appelle Fall en anglais américain. }

Les variables d'énumération sont initialisées par défaut à zéro. Elles peuvent être assignées ou initialisées aux valeurs nommées définies par le type d'énumération.

Saison saison ; saison = Saison . Printemps ;

Les variables de type enum sont des valeurs entières. L'addition et la soustraction entre variables du même type sont autorisées sans conversion spécifique, mais la multiplication et la division sont un peu plus risquées et nécessitent une conversion explicite. Les conversions sont également requises pour convertir des variables enum vers et depuis des types entiers. Cependant, la conversion ne génèrera pas d'exception si la valeur n'est pas spécifiée par la définition de type.

season = ( Season ) 2 ; // convertit 2 en une valeur d'énumération de type Season. season = season + 1 ; // Ajoute 1 à la valeur. season = season + season2 ; // Ajout des valeurs de deux variables d'énumération. int value = ( int ) season ; // Conversion de la valeur d'énumération en valeur entière.
saison ++ ; // Season.Spring (1) devient Season.Summer (2). saison -- ; // Season.Summer (2) devient Season.Spring (1).

Les valeurs peuvent être combinées à l'aide de l'opérateur OU au niveau du bit |.

Couleur myColors = Couleur . Vert | Couleur . Jaune | Couleur . Bleu ;

Les variables créées pour les types de référence sont des références gérées typées. Lorsque le constructeur est appelé, un objet est créé sur le tas et une référence est attribuée à la variable. Lorsqu'une variable d'un objet sort de la portée, la référence est rompue et lorsqu'il n'y a plus de référence, l'objet est marqué comme un déchet. Le ramasse-miettes le récupérera et le détruira bientôt.

Une variable de référence est nulle lorsqu'elle ne fait référence à aucun objet.

Un type de tableau est un type de référence qui fait référence à un espace contenant un ou plusieurs éléments d'un certain type. Tous les types de tableau dérivent d'une classe de base commune, . Chaque élément est référencé par son index, comme en C++ et en Java. System.Array

Un tableau en C# est ce qu'on appellerait un tableau dynamique en C++.

int [] nombres = nouveau int [ 2 ]; nombres [ 0 ] = 2 ; nombres [ 1 ] = 5 ; int x = nombres [ 0 ];

Les initialiseurs de tableaux fournissent une syntaxe pratique pour l'initialisation des tableaux.

// Syntaxe longue 
int [] numbers = new int [ 5 ]{ 20 , 1 , 42 , 15 , 34 }; // Syntaxe courte int [] numbers2 = { 20 , 1 , 42 , 15 , 34 }; // Syntaxe inférée var numbers3 = new [] { 20 , 1 , 42 , 15 , 34 };

Les tableaux peuvent avoir plus d'une dimension, par exemple 2 dimensions pour représenter une grille.

int [,] nombres = nouveau int [ 3 , 3 ]; nombres [ 1 , 2 ] = 2 ;
int [,] nombres2 = nouveau int [ 3 , 3 ] { { 2 , 3 , 2 }, { 1 , 2 , 6 }, { 2 , 4 , 5 } };

Voir aussi

• Réseau irrégulier

Les classes sont des types de référence définis par l'utilisateur et autodescriptifs. Essentiellement, tous les types du .NET Framework sont des classes, y compris les structures et les énumérations, qui sont des classes générées par le compilateur. Les membres de classe sont privatepar défaut, mais peuvent être déclarés comme publicétant visibles en dehors de la classe ou protectedcomme étant visibles par n'importe quel descendant de la classe.

La classe, ou simplement , représente une séquence immuable de caractères Unicode ( ). System.Stringstringchar

Les actions effectuées sur une chaîne renverront toujours une nouvelle chaîne.

chaîne texte = "Bonjour tout le monde !" ; chaîne substr = texte . Substring ( 0 , 5 ); chaîne [] parts = texte . Split ( nouveau char []{ ' ' });

La classe peut être utilisée lorsqu'une « chaîne » mutable est souhaitée. System.StringBuilder

var sb = new StringBuilder (); sb . Append ( 'H' ); sb . Append ( "el" ); sb . AppendLine ( "lo!" );

Les interfaces sont des structures de données qui contiennent des définitions de membres sans implémentation réelle. Une variable d'un type d'interface est une référence à une instance d'une classe qui implémente cette interface. Voir #Interfaces.

C# fournit des pointeurs de fonction orientés objet de type sécurisé sous la forme de délégués .

classe Programme { // Type de délégué : délégué int Operation ( int a , int b );
statique int Add ( int i1 , int i2 ) { retour i1 + i2 ; }
statique int Sub ( int i1 , int i2 ) { retour i1 - i2 ; }
static void Main () { // Instanciez le délégué et assignez-lui la méthode. Opération op = Add ;
// Appelez la méthode vers laquelle pointe le délégué. 
int result1 = op ( 2 , 3 ); // 5
op = Sub ; int résultat2 = op ( 10 , 2 ); // 8 } }

Initialisation du délégué avec une méthode anonyme.

addition = délégué ( int a , int b ) { retour a + b ; };

Initialisation du délégué avec l'expression lambda.

addition = ( a , b ) => a + b ;

Les événements sont des pointeurs qui peuvent pointer vers plusieurs méthodes. Plus précisément, ils lient des pointeurs de méthode à un identifiant. Cela peut donc être considéré comme une extension des délégués . Ils sont généralement utilisés comme déclencheurs dans le développement d'interface utilisateur. La forme utilisée dans C# et le reste de l' infrastructure de langage commun est basée sur celle du Visual Basic classique .

délégué void MouseEventHandler ( objet expéditeur , MouseEventArgs e );
classe publique Button : System . Windows . Controls . Control { événement privé MouseEventHandler _onClick ;
/* Fonction de déclenchement imaginaire */ 
void Click () { _onClick ( this , new MouseEventArgs ( data )); } }

Un événement nécessite un gestionnaire d'événements associé qui est créé à partir d'un délégué spécial qui, dans une bibliothèque spécifique à une plate-forme comme dans Windows Presentation Foundation et Windows Forms, prend généralement deux paramètres : l'expéditeur et les arguments d'événement . Le type de l'objet-argument d'événement dérive de la classe EventArgs qui fait partie de la bibliothèque de base de la CLI.

Une fois déclaré dans sa classe, le seul moyen d'invoquer l'événement est depuis l'intérieur du propriétaire. Une méthode d'écoute peut être implémentée à l'extérieur pour être déclenchée lorsque l'événement est déclenché.

classe publique MainWindow : System . Windows . Controls . Window { private Button _button1 ;
public MainWindow () { _button1 = new Button ( ); _button1.Text = " Cliquez sur moi !" ;
/* S'abonner à l'événement */ 
_button1 . ClickEvent += Button1_OnClick ;
/* Syntaxe alternative considérée comme ancienne : 
 _button1.MouseClick += new MouseEventHandler(Button1_OnClick); */ 
}
protected void Button1_OnClick ( objet expéditeur , MouseEventArgs e ) { MessageBox . Show ( "Clic !" ); } }

L'implémentation d'événements personnalisés est également possible :

Gestionnaire d'événements privé _clickHandles = ( s , e ) => { };
événement public EventHandler Cliquez sur { ajouter { // Du code à exécuter lorsque le gestionnaire est ajouté... ...
_clickHandles += value ; } remove { // Du code à exécuter lorsque le gestionnaire est supprimé... ...
_clickHandles -= valeur ; } }

Voir aussi

• Programmation pilotée par événements

Il s'agit d'une fonctionnalité de C# 2.0 .

Les types Nullable ont été introduits dans C# 2.0 dans un premier temps pour permettre aux types de valeur d'être nuls (utile lorsque l'on travaille avec une base de données).

int? n = 2 ; n = null ;
Console . WriteLine ( n . HasValue );

En réalité, c'est la même chose que d'utiliser la structure. Nullable<T>

Nullable < int > n = 2 ; n = null ;
Console . WriteLine ( n . HasValue );

C# possède et autorise les pointeurs vers des types sélectionnés (certains primitifs, énumérations, chaînes, pointeurs et même tableaux et structures s'ils ne contiennent que des types qui peuvent être pointés ) dans un contexte non sécurisé : méthodes et blocs de code marqués unsafe. Ceux-ci sont syntaxiquement les mêmes que les pointeurs en C et C++. Cependant, la vérification à l'exécution est désactivée à l'intérieur unsafedes blocs.

static void Main ( string [] args ) { non sécurisé { int a = 2 ; int * b = &a a ;
Console . WriteLine ( "Adresse de a : {0}. Valeur : {1}" , ( int ) &a a , a ); Console . WriteLine ( "Adresse de b : {0}. Valeur : {1}. Valeur de *b : {2}" , ( int ) & b , ( int ) b , * b );
// Affichera quelque chose comme : 
// Adresse de a : 71953600. Valeur : 2 // Adresse de b : 71953596. Valeur : 71953600. Valeur de *b : 2 } }

Les structures doivent uniquement être des structures pures sans membres d'un type de référence géré, par exemple une chaîne ou toute autre classe.

public struct MyStruct { public char Caractère ; public int Entier ; }
public struct MyContainerStruct { public byte Byte ; public MyStruct MyStruct ; }

Utilisé:

MonConteneurStruct x ; MonConteneurStruct * ptr = & x ;
valeur d'octet = ptr -> Octet ;

Il s'agit d'une fonctionnalité de C# 4.0 et de .NET Framework 4.0 .

Le type dynamicest une fonctionnalité qui permet une recherche dynamique à l'exécution en C# de manière statique. Dynamic désigne une variable avec un objet dont le type est résolu à l'exécution, par opposition à la compilation, comme cela se fait normalement.

Cette fonctionnalité tire parti du Dynamic Language Runtime (DLR) et a été conçue spécifiquement dans le but d'interopérer avec des langages typés dynamiquement comme IronPython et IronRuby (implémentations de Python et Ruby pour .NET).

Le support dynamique facilite également l'interopérabilité avec les objets COM .

dynamic x = new Foo (); x . DoSomething (); // Sera compilé et résolu à l'exécution. Une exception sera levée si elle n'est pas valide.

Il s'agit d'une fonctionnalité de C# 3.0 .

Les types anonymes sont des classes sans nom générées par le compilateur. Elles sont uniquement consommables et pourtant très utiles dans un scénario comme celui où l'on a une requête LINQ qui renvoie un objet selectet où l'on veut simplement renvoyer des valeurs spécifiques. Ensuite, définissez un type anonyme contenant des champs en lecture seule générés automatiquement pour les valeurs.

Lors de l'instanciation d'une autre déclaration de type anonyme avec la même signature, le type est automatiquement déduit par le compilateur.

var carl = new { Name = "Carl" , Age = 35 }; // Le nom du type n'est connu que du compilateur. var mary = new { Name = "Mary" , Age = 22 }; // Même type que l'expression ci-dessus

La boxe est l'opération de conversion d'une valeur d'un type de valeur en une valeur d'un type de référence correspondant. La boxe en C# est implicite.

Le déballage est l'opération de conversion d'une valeur d'un type de référence (précédemment encadré) en une valeur d'un type de valeur. Le déballage en C# nécessite un cast de type explicite.

Exemple:

int foo = 42 ; // Type de valeur. objet bar = foo ; // foo est encadré dans bar. int foo2 = ( int ) bar ; // Déballé pour revenir au type de valeur.

C# prend directement en charge la programmation orientée objet .

Un objet est créé avec le type comme modèle et est appelé une instance de ce type particulier.

En C#, les objets sont soit des références, soit des valeurs. Aucune autre distinction syntaxique n'est faite entre ceux-ci dans le code.

Tous les types, même les types de valeur sous leur forme encadrée, héritent implicitement de la classe, la classe de base ultime de tous les objets. Cette classe contient les méthodes les plus courantes partagées par tous les objets. Certaines d'entre elles sont et peuvent être remplacées. System.Objectvirtual

Les classes héritent directement ou indirectement via une autre classe de base. System.Object

Membres
Certains des membres de la classe Object :

• Equals- Prend en charge les comparaisons entre objets.
• Finalize- Effectue des opérations de nettoyage avant qu'un objet ne soit automatiquement récupéré. (Destructeur par défaut)
• GetHashCode- Obtient le numéro correspondant à la valeur de l'objet pour prendre en charge l'utilisation d'une table de hachage.
• GetType- Obtient le type de l'instance actuelle.
• ToString- Crée une chaîne de texte lisible par l'homme qui décrit une instance de la classe. Elle renvoie généralement le nom du type.

Les classes sont des éléments fondamentaux d'un langage orienté objet tel que C#. Elles servent de modèle pour les objets. Elles contiennent des membres qui stockent et manipulent des données de manière réaliste.

Bien que les classes et les structures soient similaires dans la manière dont elles sont déclarées et utilisées, il existe quelques différences significatives. Les classes sont des types référence et les structures sont des types valeur. Une structure est allouée sur la pile lorsqu'elle est déclarée et la variable est liée à son adresse. Elle contient directement la valeur. Les classes sont différentes car la mémoire est allouée sous forme d'objets sur le tas. Les variables sont plutôt des pointeurs gérés sur la pile qui pointent vers les objets. Ce sont des références.

Les structures diffèrent des classes de plusieurs autres manières. Par exemple, bien que les deux offrent un constructeur implicite par défaut qui ne prend aucun argument, on ne peut pas le redéfinir pour les structures. Définir explicitement un constructeur paramétré différemment supprimera le constructeur implicite par défaut dans les classes, mais pas dans les structures. Tous les champs d'une structure doivent être initialisés dans ces types de constructeurs. Les structures n'ont pas de finaliseurs et ne peuvent pas hériter d'une autre classe comme le font les classes. Implicitement, elles sont scellées et héritent de (qui hérite de ). Les structures sont plus adaptées aux petites quantités de données. System.ValueTypeSystem.Object

Voici un bref résumé des différences :

Déclaration

classe Foo { // Déclarations de membres }

Cours partiel

// Classe partielle File1.cs Foo { ... }
// Classe partielle File2.cs Foo { ... }

Initialisation

var foo = nouveau Foo ();

Initialiseurs d'objets

var personne = nouvelle personne { Nom = "John Doe" , Âge = 39 };
// Égal à 
var person = new Person (); person . Name = "John Doe" ; person . Age = 39 ;

Initialiseurs de collection

var liste = nouvelle liste < int > { 2 , 5 , 6 , 6 };
// Égal à 
var list = new List < int > (); list . Add ( 2 ); list . Add ( 5 ); list . Add ( 6 ); list . Add ( 6 );

Accéder aux membres

chaîne foo = "Bonjour" ; chaîne fooUpper = foo . ToUpper ();

int r = chaîne . Compare ( foo , fooUpper );

POINT p ; p . X = 2 ; p . Y = 6 ; POINT * ptr = & p ; ptr -> Y = 4 ;

Modificateurs

Modificateurs de classe

Modificateurs des membres de la classe

staticmodificateur

public class Foo { public static void Something () { ... } } // Appel de la méthode de classe. Foo . Something ();

Modificateurs d'accès

classe publique Foo { public int Do () { renvoie 0 ; }
classe publique Bar {
} 
}

Constructeurs

classe Foo { Foo () { ... } }

Destructeur

classe Foo { ...
~ Foo () 
{ ... } }

Méthodes

classe Foo { int Bar ( int a , int b ) { renvoie a % b ; } }

Foo foo = nouveau Foo (); int r = foo . Bar ( 7 , 2 );
Console . WriteLine ( r );

refet outparamètres

void PassRef ( ref int x ) { si ( x == 2 ) x = 10 ; } int Z = 7 ; PassRef ( ref Z );
void PassOut ( out int x ) { x = 2 ; } int Q ; PassOut ( out Q );

Paramètres optionnels

void Incrément ( ref int x , int dx = 1 ) { x += dx ; }
int x = 0 ; Increment ( ref x ); // dx prend la valeur par défaut de 1 Increment ( ref x , 2 ); // dx prend la valeur 2

Stream OpenFile ( chaîne nom , FileMode mode = FileMode . Open , FileAccess access = FileAccess . Read ) { ... }
OpenFile ( "file.txt" ); // utiliser les valeurs par défaut pour "mode" et "access" OpenFile ( "file.txt" , mode : FileMode . Create ); // utiliser la valeur par défaut pour "access" OpenFile ( "file.txt" , access : FileAccess . Read ); // utiliser la valeur par défaut pour "mode" OpenFile ( name : "file.txt" , access : FileAccess . Read , mode : FileMode . Create ); // nommer tous les paramètres pour une meilleure lisibilité, // et utiliser un ordre différent de celui de la déclaration de méthode

objet fileName = "Test.docx" ; objet manquant = System . Reflection . Missing . Value ;
doc . SaveAs ( ref fileName , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing ) ; console . writeline ( " Fichier enregistré avec succès " ) ;​​

doc . SaveAs ( ref nom_fichier );

extern

[DllImport("win32.dll")] 
statique externe double Pow ( double a , double b );

Champs

classe Foo { double foo ; }

classe Foo { double foo = 2.3 ; }

Propriétés

classe publique Personne { chaîne privée _name ;
chaîne Nom { obtenir { renvoyer _name ; } définir { _name = valeur ; } } }
// Utilisation d'une propriété 
var person = new Person (); person . Name = "Robert" ;

Propriétés automatiques

public double Largeur { obtenir ; privé ensemble ; }

Indexeurs

classe interne IntList { privé int [] _items ;
int ceci [ int index ] { obtenir { retourner _items [ index ]; } définir { _items [ index ] = valeur ; } } }
// Utilisation d'un indexeur 
var list = new IntList (); list [ 2 ] = 2 ;

Héritage

classe A { }
classe B : A {
}

virtual

classe Opération { public virtual int Do () { return 0 ; } }
classe NewOperation : Operation { public override int Do () { return 1 ; } }

new

classe Opération { public int Do () { return 0 ; } }
classe NewOperation : Opération { public new double Do () { return 4.0 ; } }

var opération = new NewOperation ();
// Appellera "double Do()" dans NewOperation 
double d = operation . Do ();
Opération opération_ = opération ;
// Appellera "int Do()" dans l'opération 
int i = operation_ . Do ();

abstract

classe abstraite Mammifère { public abstract void Walk (); }
classe Humain : Mammifère { public override void Walk () {
}
... 
}

sealed

classe interne scellée Foo { //... }
classe publique Bar { public virtual void Action () { //... } }
classe publique Baz : Bar { public sealed override void Action () { //... } }

Interfaces

interface IBinaryOperation { double A { obtenir ; définir ; } double B { obtenir ; définir ; }
double Obtenir le résultat (); }

Implémentation d'une interface

classe publique Adder : IBinaryOperation { public double A { obtenir ; définir ; } public double B { obtenir ; définir ; }
public double GetResult () { renvoie A + B ; } }
classe publique Multiplicateur : IBinaryOperation { public double A { obtenir ; définir ; } public double B { obtenir ; définir ; }
public double GetResult () { renvoie A * B ; } }

IBinaryOperation op = null ; double résultat ;
// Adder implémente l'interface IBinaryOperation.
op = nouvel additionneur (); op . UNE = 2 ; op . B = 3 ;
résultat = op . Obtenir le résultat (); // 5
// Multiplier implémente également l'interface.
op = nouveau multiplicateur (); op . A = 5 ; op . B = 4 ;
résultat = op . Obtenir le résultat (); // 20

classe publique Adder : IBinaryOperation { double IBinaryOperation . A { obtenir ; définir ; } double IBinaryOperation . B { obtenir ; définir ; }
double IBinaryOperation.GetResult ( ) { return (( IBinaryOperation ) this ) .A + ( ( IBinaryOperation ) this ) .B ; } }

Additionneur ajouter = nouvel additionneur ();
// Ces membres ne sont pas accessibles : 
// add.A = 2 ; 
// add.B = 3 ; 
// double result = add.GetResult();
// Convertir en type d'interface pour y accéder : 
IBinaryOperation add2 = add ; add2 . A = 2 ; add2 . B = 3 ;
double résultat = add2 . GetResult ();

classe MaClasse : IInterfaceA , IInterfaceB { ... }

interface IInterfaceC : IInterfaceA , IInterfaceB { ... }

Interfaces vs. classes abstraites

Génériques

// Déclarer la classe générique.
classe publique GenericList < T > { void Add ( T input ) { } }
classe TestGenericList { classe privée ExampleClass { } static void Main () { // Déclarer une liste de type int. var list1 = new GenericList < int > ();
// Déclarer une liste de type chaîne. 
var list2 = new GenericList < string > ();
// Déclarer une liste de type ExampleClass. 
var list3 = new GenericList < ExampleClass > (); } }

Utilisation des génériques

Classes génériques

classe publique Liste < T > { ... public void Ajouter ( T élément ) { ... } }
var liste = nouvelle Liste < int > (); liste . Ajouter ( 6 ); liste . Ajouter ( 2 );

Interfaces génériques

interface IEnumerable < T > { ... }

Délégués génériques

délégué R Func < T1 , T2 , R > ( T1 a1 , T2 a2 );

Méthodes génériques

public static T [] CombineArrays < T > ( T [] a , T [] b ) { T [] newArray = new T [ a . Length + b . Length ]; a . CopyTo ( newArray , 0 ); b . CopyTo ( newArray , a . Length ); return newArray ; }
chaîne [] a = nouvelle chaîne [] { "a" , "b" , "c" }; chaîne [] b = nouvelle chaîne [] { "1" , "2" , "3" }; chaîne [] c = CombineArrays ( a , b );
double [] da = nouveau double [] { 1,2 , 2,17 , 3,141592 }; double [] db = nouveau double [] { 4,44 , 5,6 , 6,02 }; double [] dc = CombineArrays ( da , db );
// c est un tableau de chaînes contenant { "a", "b", "c", "1", "2", "3"} 
// dc est un tableau double contenant { 1.2, 2.17, 3.141592, 4.44, 5.6, 6.02}

Paramètres de type

Covariance and contravariance

interfaceIEnumerable<outT>
{
IEnumerator<T>GetEnumerator();
}

voidPrintAll(IEnumerable<object>objects)
{
foreach(objectoinobjects)
{
System.Console.WriteLine(o);
}
}
IEnumerable<string>strings=newList<string>();
PrintAll(strings);// IEnumerable<string> is implicitly converted to IEnumerable<object>

publicinterfaceIComparer<inT>
{
intCompare(Tx,Ty);
}

IComparer<object>objectComparer=GetComparer();
IComparer<string>stringComparer=objectComparer;

Enumerators

// explicit version
IEnumerator<MyType>iter=list.GetEnumerator();
while(iter.MoveNext())
Console.WriteLine(iter.Current);
// implicit version
foreach(MyTypevalueinlist)
Console.WriteLine(value);

Generator functionality

// Method that takes an iterable input (possibly an array)
// and returns all even numbers.
publicstaticIEnumerable<int>GetEven(IEnumerable<int>numbers)
{
foreach(intiinnumbers)
{
if(i%2==0)
yieldreturni;
}
}
// using the method to output only even numbers from the array
staticvoidMain()
{
int[]numbers={1,2,3,4,5,6};
foreach(intiinGetEven(numbers))
Console.WriteLine(i);//outputs 2, 4 and 6
}

LINQ

Query syntax

varlist=newList<int>{2,7,1,3,9};
varresult=fromiinlist
wherei>1
selecti;

Anonymous methods

Anonymous delegates

Func<int,int>f=delegate(intx){returnx*2;};

Lambda expressions

// [arguments] => [method-body]
// With parameters
n=>n==2
(a,b)=>a+b
(a,b)=>{a++;returna+b;}
// With explicitly typed parameters
(inta,intb)=>a+b
// No parameters
()=>return0
// Assigning lambda to delegate
Func<int,int,int>f=(a,b)=>a+b;

(a,b)=>{a++;returna+b;}

varlist=stringList.Where(n=>n.Length>2);

Extension methods

publicstaticclassStringExtensions
{
publicstaticstringLeft(thisstrings,intn)
{
returns.Substring(0,n);
}
}
strings="foo";
s.Left(3);// same as StringExtensions.Left(s, 3);

Local functions

staticvoidMain(string[]args)
{
intSum(intx,inty)
{
returnx+y;
}
Console.WriteLine(Sum(10,20));
Console.ReadKey();
}

Miscellaneous

Closure blocks

publicvoidFoo()
{
using(varbar=File.Open("Foo.txt"))
{
// do some work
thrownewException();
// bar will still get properly disposed.
}
}

Thread synchronization

privatestaticStreamWriter_writer;
publicvoidConcurrentMethod()
{
lock(_writer)
{
_writer.WriteLine("Line 1.");
_writer.WriteLine("Followed by line 2.");
}
}

Attributes

[CompilerGenerated]
publicclass$AnonymousType$120
{
[CompilerGenerated]
publicstringName{get;set;}
}

publicclassEdibleAttribute:Attribute
{
publicEdibleAttribute():base()
{
}
publicEdibleAttribute(boolisNotPoisonous)
{
this.IsPoisonous=!isNotPoisonous;
}
publicboolIsPoisonous{get;set;}
}

[Edible(true)]
publicclassPeach:Fruit
{
// Members if any
}

Preprocessor

publicclassFoo
{
#region Constructors
publicFoo(){}
publicFoo(intfirstParam){}
#endregion
#region Methods
publicvoidIntBar(intfirstParam){}
publicvoidStrBar(stringfirstParam){}
publicvoidBoolBar(boolfirstParam){}
#endregion
}

Code comments

publicclassFoo
{
// a comment
publicstaticvoidBar(intfirstParam){}// Also a comment
}

publicclassFoo
{
/* A multi-line
 comment */
publicstaticvoidBar(intfirstParam){}
}

// Can put /* */ */ */ /* /*

/* Can put /* /* /* but it ends with */

/// <summary>
/// This class is very classy.
/// </summary>

XML documentation comments

publicclassFoo
{
/// <summary>A summary of the method.</summary>
/// <param name="firstParam">A description of the parameter.</param>
/// <remarks>Remarks about the method.</remarks>
publicstaticvoidBar(intfirstParam){}
}

publicclassFoo
{
/** <summary>A summary of the method.</summary>
 * <param name="firstParam">A description of the parameter.</param>
 * <remarks>Remarks about the method.</remarks> */
publicstaticvoidBar(intfirstParam){}
}

/**
 * <summary>
 * A summary of the method.</summary>*/

/**
 * <summary>
 A summary of the method.</summary>*/

Async-await syntax

publicstaticclassSomeAsyncCode
{
publicstaticTask<XDocument>GetContentAsync()
{
varhttpClient=newHttpClient();
returnhttpClient.GetStringAsync("https://www.contoso.com/").ContinueWith((task)=>{
stringresponseBodyAsText=task.Result;
returnXDocument.Parse(responseBodyAsText);
});
}
}
vart=SomeAsyncCode.GetContentAsync().ContinueWith((task)=>{
varxmlDocument=task.Result;
});
t.Start();

publicstaticclassSomeAsyncCode
{
publicstaticasyncTask<XDocument>GetContentAsync()
{
varhttpClient=newHttpClient();
stringresponseBodyAsText=awaithttpClient.GetStringAsync("https://www.contoso.com/");
returnXDocument.Parse(responseBodyAsText);
}
}
varxmlDocument=awaitSomeAsyncCode.GetContentAsync();
// The Task will be started on call with await.

Dialects

Spec#

staticvoidMain(string![]args)
requiresargs.Length>0
{
foreach(stringarginargs)
{
}
}

Non-nullable types

string!input

publicTest(string!input)
{
...
}

Preconditions

publicTest(inti)
requiresi>0;
{
this.i=i;
}

Postconditions

publicvoidIncrement()
ensuresi>0;
{
i++;
}

Checked exceptions

publicvoidDoSomething()
throwsSomeException;// SomeException : ICheckedException
{
...
}