Classes et objets

Les termes classe et objet sont parfois employés indifféremment, mais en réalité, les classes

décrivent le type des objets, alors que les objets sont des instances utilisables des classes. Cela
explique pourquoi l’opération de création d’un objet est appelée instanciation. Si l'on reprend
l'analogie avec un plan de construction, une classe est un plan, et un objet est un bâtiment
construit à partir de ce plan.

Pour définir une classe :

class ExempleClasse
{
}

C# fournit également une version basique de classes, appelée structures, qui sont utiles pour
créer un grand tableau d’objets sans utiliser trop de mémoire pour cette opération.

Pour définir une structure :

struct ExempleStruct
{
}

Membres de classe
Chaque classe peut avoir différents membres de classe : des propriétés qui décrivent les données
de classe, des méthodes qui définissent le comportement de classe et des événements qui
permettent la communication entre les différents objets et classes.

Propriétés et champs
Les propriétés et les champs sont des informations contenues dans un objet. Les champs sont
similaires aux variables, car ils peuvent être lus ou définis directement.
Pour définir un champ :

Class ExempleClasse
{
public string ExempleChamps;
}

Les propriétés comportent des procédures Get et Set qui apportent davantage de contrôle sur le
mode de définition ou de retour des valeurs.
C# vous permet de créer un champ privé pour le stockage de la valeur de propriété, ou d’utiliser
des propriétés implémentées automatiquement qui créent ce champ de façon automatique en
arrière-plan et fournissent la logique de base des procédures de propriété.

Le mot clé get définit une méthode Accessor dans une propriété ou un indexeur qui retourne la
valeur de la propriété ou l’élément de l’indexeur.
Le mot clé set définit une méthode accessor dans une propriété ou un indexeur qui assigne une
valeur à l’élément de la propriété ou de l’indexeur

Pour définir une propriété implémentée automatiquement :

class ExempleClasse
{
public int Exemple { get; set; }
}

Si vous devez exécuter des opérations supplémentaires pour la lecture et l'écriture de la valeur de
propriété, définissez un champ pour le stockage de la valeur de propriété et fournissez la logique
de base pour son stockage et son extraction :

class ExempleClasse
{
private int _exemple;
public int Exemple ;
{
// Renvoie la valeur stockée dans un champ.
get { return _exemple; }
// Stocker la valeur dans le champ.
set { _exemple = value; }
}
}

La plupart des propriétés disposent de méthodes ou de procédures destinées à la fois à définir et à

obtenir la valeur de propriété. Toutefois, vous pouvez créer des propriétés en lecture seule ou en
écriture seule pour empêcher qu'elles soient modifiées ou lues. En C#, vous pouvez omettre la
méthode de propriété get ou set. Toutefois, les propriétés implémentées automatiquement ne
peuvent pas être en lecture seule ni en écriture seule.
Méthodes
Une méthode correspond à une action qu’un objet peut effectuer.
Pour définir une méthode de classe :

class NomClasse
{
public int NomMéthode (string paramètres)
{
// Insérer le code source ici  
}
}

Une classe peut avoir plusieurs implémentations, ou surcharges, de la même méthode qui
diffèrent du point de vue du nombre de paramètres ou des types de paramètres.

Pour surcharger une méthode :

public int NomMéthode (string paramètres) {};

public int NomMéthode (int paramètres) {}

Dans la plupart des cas, vous déclarez une méthode dans une définition de classe. Toutefois, C#
prend également en charge des méthodes d’extension, qui vous permettent d’ajouter des
méthodes à une classe existante hors de la définition réelle de la classe.

Constructeurs
Les constructeurs sont des méthodes de classe qui s'exécutent automatiquement
lorsqu'un objet d'un type donné est créé. Les constructeurs initialisent habituellement
les données membres du nouvel objet. Un constructeur ne peut s'exécuter qu'une seule
fois lorsqu'une classe est créée. En outre, le code figurant dans le constructeur s'exécute
toujours avant tout autre code dans une classe. Toutefois, vous pouvez créer plusieurs
surcharges de constructeur de la même façon que vous le faites pour toute autre
méthode.

Pour définir un constructeur pour une classe :

public class NomClasse

{
public SampleClass()
{
// Insérer le code source ici  
}
}

Finaliseurs
Les finaliseurs permettent de détruire des instances de classes. Dans le .NET Framework, le
garbage collector gère automatiquement l'allocation et la libération de mémoire pour les objets
managés figurant dans votre application.Toutefois, vous pouvez avoir besoin de finaliseurs pour
nettoyer toutes les ressources non managées créées par votre application. Il ne peut y avoir qu'un
seul finaliseur pour une même classe.

Événements
Les événements permettent à une classe ou un objet de notifier d'autres classes ou objets
lorsqu'une situation intéressante se produit. La classe qui envoie (ou déclenche) l’événement est
appelée éditeur et les classes qui reçoivent (ou gèrent) l’événement sont appelées abonnés. Pour
plus d’informations sur les événements, leur déclenchement et leur gestion,
consultez Événements.

 Pour déclarer un événement dans une classe, utilisez le mot clé event.

 Pour déclencher un événement, appelez le délégué d'événement.
 Pour vous abonner à un événement, utilisez l'opérateur  +=  ; pour annuler un abonnement
à un événement, utilisez l'opérateur  -= .

Classes imbriquées
Une classe définie à l’intérieur d’une autre classe est dite imbriquée. Par défaut, une classe
imbriquée est privée.

class Container
{
class Nested
{
// Insérer le code source ici
}
}

Pour créer une instance de la classe imbriquée, utilisez le nom de la classe de conteneur suivi
d'un point, puis du nom de la classe imbriquée :

Container.Nested nestedInstance = new Container.Nested()

Modificateurs d’accès et niveaux d’accès
Toutes les classes et tous les membres de classe peuvent spécifier le niveau d’accès qu’ils
fournissent aux autres classes à l’aide des modificateurs d’accès.
Les modificateurs d’accès suivants sont disponibles :

Modificateur
C# Définition

public Tout autre code du même assembly ou d'un autre assembly qui y fait référence
peut accéder au type ou au membre.

private Seul le code de la même classe peut accéder au type ou au membre.

protected Seul le code de la même classe ou d'une classe dérivée peut accéder au type ou
au membre.

internal Tout code du même assembly, mais pas d'un autre assembly, peut accéder au
type ou au membre.

protégée Tout code du même assembly ou toute classe dérivée dans un autre assembly
interne peut accéder au type ou au membre.

protégé privé Le type ou membre accessibles par le code dans la même classe ou dans une
classe dérivée dans l’assembly de la classe de base.

Instanciation de classes
Pour créer un objet, vous devez instancier une classe ou créer une instance de classe.

SampleClass sampleObject = new SampleClass();

Après avoir instancié une classe, vous pouvez assigner des valeurs aux propriétés et champs de
l'instance et appeler des méthodes de classe.

// Définir une valeur de propriété.

sampleObject.sampleProperty = "Sample String";
// Appeler une méthode.
sampleObject.sampleMethod();
Pour assigner des valeurs aux propriétés pendant le processus d'instanciation de la classe, utilisez
des initialiseurs d'objets :

// Définir une valeur de propriété.

SampleClass sampleObject = new SampleClass
{ FirstProperty = "A", SecondProperty = "B" };

Classes et membres statiques

Un membre statique de la classe est une propriété, une procédure ou un champ que toutes les
instances d’une classe partagent.
Pour définir un membre statique :

static class SampleClass

{
public static string SampleString = "Sample String";
}

Pour accéder au membre statique, utilisez le nom de la classe sans créer d’objet de cette classe :

Console.WriteLine(SampleClass.SampleString);

Les classes statiques dans C# ont uniquement des membres statiques et ne peuvent pas être
instanciées. Les membres statiques ne peuvent pas non plus accéder aux propriétés, champs ou
méthodes non statiques

Types anonymes

Les types anonymes vous permettent de créer des objets sans écrire de définition de classe pour
le type de données. À la place, le compilateur se charge de générer une classe. La classe ne
possède pas de nom utilisable et contient les propriétés que vous spécifiez lors de la déclaration
de l'objet.

Pour créer une instance de type anonyme :

// sampleObject est une instance d'un type anonyme simple.

var sampleObject =
new { FirstProperty = "A", SecondProperty = "B" };
II.Héritage

Il vous permet de créer une nouvelle classe qui réutilise, étend et modifie le comportement défini
dans une autre classe.La classe dont les membres sont hérités porte le nom de classe de base et la
classe qui hérite de ces membres porte le nom de classe dérivée. Toutefois, toutes les classes
dans C# héritent implicitement de la classe Object qui prend en charge la hiérarchie de
classes .NET et fournit des services de bas niveau à toutes les classes.

Note
C# ne prend pas en charge l’héritage multiple. Vous pouvez donc spécifier une seule classe de
base pour une classe dérivée.

Pour hériter d'une classe de base :

class ClasseDérivée:ClasseDeBase{}

Par défaut, toutes les classes peuvent être héritées. Toutefois, vous pouvez spécifier si une classe
ne doit pas être utilisée comme classe de base ou créer une classe qui peut être utilisée
uniquement comme classe de base.

Pour spécifier qu'une classe ne peut pas être utilisée comme classe de base :

public sealed class A { }

Pour spécifier qu'une classe peut être utilisée uniquement comme classe de base et ne peut pas
être instanciée :

public abstract class B { }

Substitution de membres
Par défaut, une classe dérivée hérite de tous les membres de sa classe de base. Si vous souhaitez
modifier le comportement du membre hérité, vous devez le substituer. Autrement dit, vous
pouvez définir une nouvelle implémentation de la méthode, de la propriété ou de l'événement
dans la classe dérivée.

Les modificateurs suivants sont utilisés pour contrôler la façon dont les propriétés et les
méthodes sont substituées :

Modificateur C# Définition

virtual Autorise la substitution d'un membre de classe dans une classe

dérivée.

override Substitue un membre virtuel (substituable) défini dans la classe de

base.

abstract Requiert qu'un membre de classe soit substitué dans la classe

dérivée.

new, modificateur Masque un membre hérité d'une classe de base.

Interfaces
Tout comme les classes, les interfaces définissent un ensemble de propriétés, méthodes et
événements. Cependant, contrairement aux classes, les interfaces n'assurent pas
l'implémentation. Elles sont implémentées par les classes et définies en tant qu'entités distinctes
des classes. Une interface représente un contrat, dans le sens où une classe qui implémente une
interface doit implémenter tous les aspects de cette interface exactement telle qu'elle a été
définie.

Pour définir une interface :

interface ISampleInterface
{
void doSomething();
}
Pour implémenter une interface dans une classe :

class SampleClass : ISampleInterface

{
void ISampleInterface.doSomething()
{
// Implémentation de méthode
}
}

Génériques

Les classes, les structs, les interfaces et les méthodes dans le .NET Framework peuvent inclure
des paramètres de type, qui définissent les types d’objets qu’ils peuvent stocker ou
utiliser. L’exemple le plus commun de génériques est une collection dans laquelle vous pouvez
spécifier le type d’objets à stocker dans une collection.

Pour définir une classe générique :

Public class SampleGeneric<T>

{
public T Field;
}

Pour créer une instance de classe générique :

SampleGeneric<string> sampleObject = new SampleGeneric<string>();

sampleObject.Field = "Sample string";

Délégués

Un délégué est un type qui définit une signature de méthode et peut fournir une référence à toute
méthode avec une signature compatible. Vous pouvez appeler la méthode par le biais du
délégué. Les délégués sont utilisés pour passer des méthodes comme arguments à d'autres
méthodes.

Pour créer un délégué :

public delegate void SampleDelegate(string str);

Pour créer une référence à une méthode qui correspond à la signature spécifiée par le délégué :

class SampleClass
{
// Method that matches the SampleDelegate signature.
public static void sampleMethod(string message)
{
// Add code here.
}
// Method that instantiates the delegate.
void SampleDelegate()
{
SampleDelegate sd = sampleMethod;
sd("Sample string");
}
}

Conclusion
C # est un langage orienté objet commun et facile à comprendre par les programmeurs C et C ++
existants. De plus, sa syntaxe propre et son modèle de programmation simple (beaucoup plus
simple que le C ++) en font un langage facile à apprendre, même si vous n'utilisez pas
actuellement C ou C ++. En plus il permet aux programmeurs de créer rapidement et facilement
des solutions pour la plate-forme Microsoft .NET.