Développer en C#
Mots clés modificateurs
Modification d’accès
public
protected
Visible uniquement à partir des classes dérivées. Un modificateur protected indique que l'accès est limité à l'intérieur de la classe conteneur ou des classent qui en dérivent.private
Visible uniquement à l'intérieur de la classe donnée. Un modificateur private signifie que l'accès est possible uniquement à partir de l'intérieur du type conteneur. En C#, le modificateur d'accès par défaut est privé.internal
protected internal
Modificateur sealed
Définition de Constante readonly et const
Mots clés virtual et override
Le mot virtual permet de définir une méthode dans une classe mère qui peut être changé dans la classe fille à l'aide du mot clé override.Mot clé new
Le mot clé new permet de masquer l’implémentation héritée d’une classe parente.
- new Operator : Used to create objects and invoke constructors.
- new Modifier : Used to hide an inherited member from a base class member.
- new Constraint : Used to restrict types that might be used as arguments for a type parameter in a generic declaration. Generic type must have a parameter less constructor
Délégués
Un délégué est un type qui référence une méthode. Une fois qu'une méthode est assignée à un délégué, ce dernier se comporte exactement comme cette méthode. La méthode du délégué peut être utilisée comme n'importe quelle autre méthode, avec des paramètres et une valeur de retour.On peut l'assimiler aux pointeurs fonction C++, mais sont de type sécurisé.
Méthodes d’extension
Les méthodes d'extension permettent d'ajouter des méthodes à des types existants sans créer un type dérivé ou modifier le type d'origine.Conditions d’implémentations ?
Définissez une classe statique pour contenir la méthode d'extension. La classe doit être visible par le code client.
Le premier paramètre de la méthode spécifie le type sur lequel fonctionne la méthode ; il doit être précédé du modificateur this.
Implémentation
BackGroundWorker (DoWork / RunWorkerCompleted / ProgressChanged / WorkerReportsProgress / WorkerSupportsCancellation)
Thread, ThreadWorker
Synchronisation
- lock (a code block that is to be executed by only one thread at a time) The argument provided to the lock keyword must be an object based on a reference type, and is used to define the scope of the lock.In the example above, the lock scope is limited to this function because no references to the object lockThis exist outside the function.If such a reference did exist, lock scope would extend to that object.
- Mutex Objects
Interblocage
Opérateurs
L’opérateur unaire d’incrément ++
opérateur, ?., qui s'utilise de la même manière que le point pour accéder aux membres d'un objet, mais avec une différence importante : il ne lève pas deNullReferenceException dans le cas où l'objet est null sinon l'expression renvoie null.
New Création d'objet et de délégué
default (T)
!x Négation logique
opérateur ??
L'opérateur ?? est appelé l'opérateur de fusion Null. Il retourne l'opérande de partie gauche si ce dernier n'est pas Null ; dans le cas contraire, il retourne l'opérande de partie droite.
Surchage d’Opérateur
La surcharge d'un opérateur sur une classe personnalisée requiert la création d'une méthode sur la classe avec la signature correcte. La méthode doit être nommée "operator X" où X est le nom ou le symbole de l'opérateur qui est surchargé. Les opérateurs unaires ont un seul paramètre et les opérateurs binaires en ont deux.Dans chaque cas, un seul paramètre doit être du même type que la classe ou le struct qui déclarent l'opérateur.
C#
public static Complex operator +(Complex c1, Complex c2)
{
Return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}
Il est courant d'avoir des définitions qui retournent tout simplement immédiatement le résultat d'une expression.Il existe un raccourci de syntaxe qui utilise => pour ces situations.
C#
public static Complex operator +(Complex c1, Complex c2) =>
new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
Les opérateurs de comparaisons doivent être surcharges par paire.
Types Génériques
introduisent dans le .NET Framework le concept de paramètres de type, qui rendent possible la création de classes et méthodes dont la spécification d'un ou de plusieurs types est reportée jusqu'à ce que la classe ou la méthode soit déclarée et instanciée par code client
Utilisez les types génériques pour optimiser la réutilisation de code, la sécurité du type et les performances.
- L'utilisation la plus courante de génériques consiste à créer des classes de collection.
- La bibliothèque de classes .NET Framework contient plusieurs nouvelles classes de collection de génériques dans l'espace de noms System.Collections.Generic.Ceux-ci doivent être utilisés chaque fois que possible à la place de classes telles queArrayList dans l'espace de noms System.Collections.
- Vous pouvez créer vos propres interfaces, classes, méthodes, événements et délégués génériques.
- Les classes génériques peuvent être contraintes pour activer l'accès aux méthodes sur des types de données particuliers.
- Les informations sur les types qui sont utilisés dans un type de données générique peuvent être obtenues par réflexion lors de l'exécution.
Contraintes sur les paramètres de type
Lorsque vous définissez une classe générique, vous pouvez appliquer des restrictions aux genres de types que le code client peut utiliser pour les arguments de type lorsqu'il instancie votre classe.Si le code client essaie d'instancier votre classe à l'aide d'un type qui n'est pas autorisé par une contrainte, il en résultera une erreur de compilation.Ces restrictions sont appelées des contraintes.Les contraintes sont spécifiées à l'aide du mot clé contextuel where.Le tableau suivant répertorie les six types de contraintes :|
Contrainte |
Description |
|
where T : struct |
L'argument de type doit être un type valeur.Tout type valeur, excepté Nullable, peut être spécifié. |
|
where T : class |
L'argument de type doit être un type référence ; cela concerne également les types de classe, d'interface ou de tableau et les types délégués. |
|
where T : new() |
L'argument de type doit avoir un constructeur sans paramètre public.Lorsque vous utilisez la contraintenew() avec d'autres contraintes, elle doit être spécifiée en dernier : |
|
where T : <nom de classe de base> |
L'argument de type doit être ou dériver de la classe de base spécifiée. |
|
where T : <nom d'interface> |
L'argument de type doit être ou implémenter l'interface spécifiée.Plusieurs contraintes d'interface peuvent être spécifiées.L'interface qui impose les contraintes peut également être générique. |
|
where T : U |
L'argument de type fourni pour T doit être ou dériver de l'argument fourni pour U. |
Attributs
Les attributs fournissent une méthode performante pour associer des métadonnées, ou des informations de déclaration, au code (assemblies, types, méthodes, propriétés, etc.).Une fois qu'il est associé à une entité de programme, l'attribut peut être interrogé au moment de l'exécution au moyen d'une technique appelée réflexion.Les attributs ont les propriétés suivantes :
- Les attributs ajoutent des métadonnées à votre programme.Les métadonnées sont des informations sur les types définis dans un programme.Tous les assemblys .NET contiennent un ensemble spécifique de métadonnées décrivant les types et les membres de type définis dans l'assembly.Vous pouvez ajouter des attributs personnalisés pour spécifier toutes les informations supplémentaires nécessaires.
- Vous pouvez appliquer un ou plusieurs attributs à des modules ou à des assemblys tout entiers, ou à des éléments de programme plus petits, comme les classes et les propriétés.
- Les attributs peuvent accepter des arguments, de la même façon que les méthodes et les propriétés.
- Votre programme peut examiner ses propres métadonnées ou celles dans d'autres programmes au moyen de la réflexion.
dynamic
Le type dynamic est un type statique mais qui échappe au contrôle de type. A la compilation, le type statique est considéré comme supportant n’importe quelle opération. (Utilisé notamment pour le COM, les API dynamiques ou le DOM)Nullable
Les types Nullable sont des instances du struct System.Nullable<T>. Un type Nullable peut représenter la plage correcte de valeurs pour son type valeur sous-jacent, plus une valeur null supplémentaire.Mot clé using
A quoi ça sert ? Utiliser une ressource (ouvrir et fermer) et en disposer proprementCondition pour être utilisée => implémentation IDisposable
Gestion des Exceptions
Try, catchGestion spécifiques des exceptions ? (filtres d’exceptions c#6)
Finalize ?
Que pensez-vous de l’utilisation des exceptions ?
Positif, gère les différentes erreurs qui peuvent survenir
Négatif, le codage par exception est très couteux, interrompt la pile
Différence entre « throw » et « throw ex » ?
Throw préserve la pile d’appel, et transmet donc une exception plus précise
Interfaces
Définition d’un contrat à l’aide de signatures de méthodes et de propriétés.C’est équivalent à une classe abstraite dont toutes les méthodes seraient abstraites : aucune méthode n’est implémentée, seule sa signature est définie.
Différence entre une classe abstraite et une interface ?
Une classe abstraite peut contenir des méthodes abstraites (elle en a au moins une) mais aussi des méthodes pleinement définies. Une interface ne définit que les propriétés et les signatures de méthodes que devra posséder la classe qui l’implémentera.Pourquoi ne pas utiliser des classes abstraites (dans lesquelles aucune méthode ne serait implémentée) en lieu et place des interfaces ?
Dans la plupart des langages actuels, il n’est possible pour une classe d’hériter que d’une seule classe parente (abstraite ou non), mais d’implémenter plusieurs interfaces.
Assembly
Fichier contenant ensemble d’éléments compilés regroupé par service fonctionnel.Types valeur et référence
Quel est le type de base du framework ? objectQuel type pour des montants financiers ?
|
byte |
0 .. 255 |
|
sbyte |
-128 .. 127 |
|
short |
-32,768 .. 32,767 |
|
ushort |
0 .. 65,535 |
|
int |
-2,147,483,648 .. 2,147,483,647 |
|
uint |
0 .. 4,294,967,295 |
|
long |
-9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807 |
|
ulong |
0 .. 18,446,744,073,709,551,615 |
|
float |
-3.402823e38 .. 3.402823e38 |
|
double |
-1.79769313486232e308 .. 1.79769313486232e308 |
|
decimal |
-79228162514264337593543950335 .. 79228162514264337593543950335 |
|
char |
A Unicode character. |
|
string |
A string of Unicode characters. |
|
bool |
True or False. |
|
object |
An object. |
C# possède deux variétés de types de données : valeur et référence.
Lorsqu'une variable est déclarée à l'aide d'un des types de données intégrées de base ou d'une structure définie par l'utilisateur, il s'agit d'un type valeur. Une exception est constituée par le type de données string, qui est un type référence.
Un type valeur stocke son contenu dans la mémoire allouée sur la pile. Par exemple, dans ce cas la valeur 42 est stockée dans une zone de mémoire appelée la pile.int x = 42;
Lorsque la variable x sort de la portée parce que la méthode dans laquelle elle a été définie a terminé son exécution, la valeur est rejetée de la pile.
Utiliser la pile est efficace, mais la durée de vie limitée des types valeur les rend moins bien adaptés au partage de données entre différentes classes.
Par opposition, un type référence, comme une instance de classe ou de tableau, est alloué dans une zone de mémoire différente appelée tas. Dans l'exemple ci-dessous, l'espace requis pour les dix entiers qui composent le tableau est alloué sur le tas.
Conversions boxing et unboxing
La conversion boxing est le nom donné au processus par lequel un type valeur est converti en type référence. Lorsque vous opérez une conversion boxing sur une variable, vous créez une variable de référence qui pointe vers une nouvelle copie sur le tas. La variable de référence étant un objet, elle peut utiliser toutes les méthodes héritées par chaque objet, comme ToString(). C'est ce qui se passe dans le code suivant :
int i = 67; // i is a value type object o = i; // i is boxed System.Console.WriteLine(i.ToString()); // i is boxed
Vous rencontrerez la conversion unboxing lorsque vous ferez appel à des classes conçues pour être utilisées avec des objets : par exemple, en utilisant ArrayList pour stocker des entiers. Lorsque vous stockez un entier dans ArrayList, celui-ci est soumis à une conversion boxing. Lorsque vous récupérez un entier, il doit être soumis à une conversion unboxing.
System.Collections.ArrayList list = new System.Collections.ArrayList(); // list is a reference type int n = 67; // n is a value type list.Add(n); // n is boxed n = (int)list[0]; // list[0] is unboxed
Considérations de Performances
Lorsque les données sont passées dans des méthodes sous forme de paramètres de type valeur, une copie de chaque paramètre est créée sur la pile. Il est clair que si le paramètre en question est un type de données volumineuses, comme une structure définie par l'utilisateur comportant un grand nombre d'éléments, ou si la méthode est exécutée de nombreuses fois, les performances pourront en être affectées.
Dans ces situations, il peut être préférable de passer une référence au type, à l'aide du mot clé ref. Ceci est l'équivalent dans C# de la technique C++ consistant à passer un pointeur à une variable dans une fonction. Comme dans la version C++, cette méthode peut modifier le contenu de la variable, lequel peut ne pas toujours être sûr. Le programmeur doit trouver un compromis entre sécurité et performances.int AddTen(int number) // parameter is passed by value { return number + 10; } void AddTen(ref int number) // parameter is passed by reference { number += 10; }
Le mot clé out est comparable au mot clé ref, mais il indique au compilateur que la méthode doit affecter une valeur au paramètre, sous peine de provoquer une erreur de compilation.void SetToTen(out int number) { // If this line is not present, the code will not compile. number = 10; }
Commentaires
Enregistrer un commentaire