Qu'est ce que le C# (Csharp) ?

Le C# est un langage orienté objet qui utilise des syntaxes issues du C++ et très proches du Java, il est commercialisé par Microsoft en 2002. Le C# permet de faire du typage fort. Il offre entre autres possibilités des techniques d'encapsulation, de polymorphisme et d'héritage de classe. Le Csharp permet également de gérer la surcharge des opérateurs, les délégués, et les indexeurs. Il permet de faire du simple thread, et du multithreads (voir notre publication sur OPEN CL.Net et C#) ce qui en fait un langage extrêmement puissant et performant. Le Csharp permet de développer aussi bien des applications web (via l'ASP .NET) que des clients lourds (console, winform,etc), des librairies de fonctions (DLL).

Points abordés dans ce tutoriel sur le Csharp :

 

  1. Installer un environnement de développement visual studio community
  2. Créer son premier projet avec le c#.
  3. Tour d'horizon rapide de visual studio community fonctionnalités principales pour débuter en C#
  4. Les bases théoriques du Csharp
    1. Les instructions et les fins d'instruction en Csharp
    2. Les commentaires (ou données non interprétées) en Csharp
    3. Les variables et les constantes en Csharp
    4. Les types de données en Csharp
      1. Les tableaux, listes et dictionnaires en C#.
    5. Les conditions ou instructions conditionnelles et opérateurs logiques en Csharp
      1. Les opérateurs de comparaisons en Csharp
      2. L'instruction conditionnelle IF en Csharp
      3. L'instruction conditionnelle SWITCH en Csharp
    6. Les boucles en Csharp
      1. L'instruction for et foreach en Csharp
    7. Les méthodes : fonction et void en Csharp
    8. Les niveaux d'accessibilités en Csharp
    9. Les classes en Csharp
      1. L'abstraction et l'héritage des classes en Csharp
      2. Les interfaces de classe en Csharp
    10. Les espaces de noms en Csharp
    11. La gestion des erreurs TRY-CATCH en Csharp

Installer un environnement de développement visual studio community

L'environnement de développement est un outil qui permet aux développeurs de gagner en productivité et de réduire ses erreurs lors du processus de développement. Nous allons voir comment déployer l'outil spécifique de Microsoft, qui nous permettra de développer, de débogueur et de compiler nos projets en Csharp. Le tout en automatisant un maximum de tâches.

  1. Télécharger visual studio community.
  2. Dans votre dossier téléchargement, exécutez : vs_community.exe. 
  3. Accepter les termes du contrat de licence Microsoft pour Visual Studio Community ainsi que la politique de confidentialité.
  4. Personnaliser votre installation en sélectionnant les ensembles de fonctionnalités (aussi appelées charges de travail)
  5. Cochez en haut à droite de chaque blocs : .NET desktop development (pour créer des clients lourds) et ASP.Net and web developpement (pour créer des sites internets).

Puis dans l'onglet "Language Packs" sélectionner la langue française, enfin cliquez sur install.

 visual-studio-csharp-ide-install-pack-langue-fr

L'utilitaire va ainsi télécharger l'ensemble des charges de travail puis s'installer.

Une fois l’installation de Visual Studio Community terminée, lancer l'IDE (environnement de développement) pour commencer le développement avec Visual Studio.

Créer son premier projet avec le Csharp

Visual Studio est maintenant installé sur votre ordinateur. Vous êtes prêts à passer aux choses sérieuses en C#. Nous allons créer votre premier projet en Csharp.

Cliquer sur "Créer un projet".

Créer un nouveau projet en csharp avec visual studio

Dans le premier champ séléctionnez C#, dans le second "Windows" et dans le dernier "console". Dans la liste des types d'applications "Application console (.NET Framework), enfin cliquer sur suivant.Créer un projet type console en c#

Dans le champ "nom du projet" saisissez le nom de votre projet ici ConsoleApp3. Dans le champ 2 le nom de la solution, une solution est un conteneur qui regroupe les projets.Dans le champs 3 choisissez le dernier Framework. Enfin cliquer sur "créer".

Configuration d'un projet en C#

Tour d'horizon rapide de visual studio community fonctionnalités principales pour débuter en C#

Vous vous retrouvez avec une interface avec de nombreux boutons partout, pas de paniques suivez le guide !

 

  1. La zone d'édition du code qui va vous servir à rédiger vos instructions.
  2. Le bouton de sauvegarde (Raccourcie : CTRL + S).
  3. Le bouton de démarrage de votre programme avec debug (Raccourcie : F5).
  4. Le fichier Program.cs qui correspond au fichier contenant le code prévisualisé dans la zone d'édition (voir zone 1).
  5. Les références (comprenez : dépendances) nécessaires au bon fonctionnement de votre application.

Visual Studio Community C# les bases de l'IDE

 

Les bases théoriques du Csharp :

Les instructions et les fins d'instruction en Csharp

 

Une instruction est un conglomérat de code qui manipule des variables, ou effectue des contrôles conditionnels, des appels à des fonctions, initialise des objets, etc. Certains blocs d'instruction sont délimités par des accolades ouvrante et fermante. C'est le cas des fonctions, des voids, des classes, des espaces de nom et des conditions.

 

Les commentaires (ou données non interprétées) en Csharp

 

En Csharp, un commentaire est indiqué en début de ligne grâce aux caractères // ou /***/ un commentaire est une donnée non interprétée par le compilateur. Il sert au développeur pour s'y retrouver dans son code. Dans l'exemple ci-après, la première ligne de code est une information, la seconde est un fragment de code désactivé. Bien que cette technique soit déconseillée, il n'est pas rare de voir dans des applications des fragments de code désactivés. Ils peuvent servir pour réaliser des tests, ou être des fragments obsolètes.

 

//Information sur mon code
//Console.WriteLine("hello word");
Les variables et les constantes en Csharp

Les variables sont des conteneurs de données qui servent à assigner un mot  (aussi appelée clé) à une donnée. Leur contenu peut changer suivant l'exécution des instructions. Elle s'assigne en respectant la syntaxe : type nom = contenu

string une_variable = "le csharp c'est super mais ça peu changer";
int une_seconde_variable = 100;

Les constantes sont des conteneurs de données qui servent également à assigner un mot à une donnée, sauf que cette donnée ne peut pas changer. Elle s'assigne en respectant la syntaxe : const type nom = contenu le mot const permet définir que c'est une constante.

const string une_constante = "le csharp c'est super ! Définitivement";
Les types de données en Csharp

Il existe deux genres de types de données en Csharp : les types valeurs qui entreposent directement la valeur des données (un entier, une structure, et toutes primitives) et les types de références qui permettent de définir une référence vers la valeur des données.

Parmi les primitives, on trouve

  • bool (true ou false)
  • byte (valeur de 0 à 255)
  • short (valeur de -32,768 à 32,767)
  • int (valeur de -2,147,483,648 à 2,147,483,647)
  • long  (valeur de -9223372036854775808 à9223372036854775807
  • float (valeur de -3.402823e38 à 3.402823e38)
  • double (valeur de -1.79769313486232e308 à 1.79769313486232e308)
  • decimal (valeur de ±1.0 × 10e?28 à ±7.9 × 10e28)
  • char (symbole unicode utilisé dans un texte)

Parmi les types par références on trouve principalement (liste non exhaustive) :

  • objet (l'objet est une représentation abstraite non typé)
  • string (chaine de caractère ex : "apprendre le Csharp !")
  • list (une liste d'objet)
  • array (une liste d'objet)
  • dictionnary (une liste de couple clé valeur où la valeur comme la clé peut être une primitive ou un objet)
  • xelement (des données répondant au standard du XML)
Les tableaux, listes et dictionnaires en Csharp

Trois types d'objets sont particulièrement importants en Csharp : les tableaux, les listes et les dictionnaires. Ces objets servent à regrouper diverses données d'un même type.
Ils intègrent tous l'interface Ienumerable qui permet de simplifier l'ensemble des manipulations de recherche (triage, filtrage, calcul,etc.).

Les tableaux en c# :

Un tableau sert à regrouper diverses données d'un même type. Ces données sont ordonnées et accessibles grâce à leur index. L'index de base d'un tableau commence systématiquement à zéro. Le dernier index d'un tableau correspond à la taille totale du tableau -1.

//Création d'un tableau en c#
string[] mon_tableau = new string[] { "coder", "csharp", "développement", "tutoriel" };

//Démonstration des valeurs assignées à chaque index du tableau
string coder = mon_tableau[0];
string csharp = mon_tableau[1];
string developpement = mon_tableau[2];

//Modification de la valeur de l'index 0
mon_tableau[0] = "modifier";

string modifier = mon_tableau[0];

//Création d'un tableau complexe contenant divers objets, chaine de caractères, entier, boolean
object[] mon_tableau_dobjets = new object[] { "csharp", 512, false };

Le tableau à l'énorme avantage de pouvoir gérer un état dit « multidimensionnel » ce qui est impératif dans le cadre de développement d'application de dessin industriel, de jeu vidéo, ou de tout référentiel nécessitant de la 3D.

Les listes en c# :

Une liste un tableau bien plus évolué. Elle se comporte de la même façon à l'exception qu'elle est spécialement conçue pour évoluer facilement en taille et qu'elle ne permet pas la gestion multidimensionnelle. Elle est donc à préférer pour manipuler des données simples (liste de clients, des fichiers, etc.).
Par ailleurs les listes peuvent être converties en tableau très facilement comme dans l'exemple suivant :

//Création d'une liste simple
List<string> list_1 = new List<string>() { "coder", "csharp", "c#" };

//Ajoute microsoft à la liste
list_1.Add("microsoft");

//Création d'une seconde liste simple
List<string> list_2 = new List<string>() { "apprendre", "à", "developper", "en", "c#" };

//Ajout de la liste 2 à la liste 1
list_1.AddRange(list_2);

//Supprime chaque occurence de c#
list_1.Remove("c#");

//Convertion de la liste en tableau
string[] mon_tableau_2 = list_1.ToArray();

//Vide l'ensemble de la liste
list_1.Clear();
Les dictionnaires en csharp :

Un dictionnaire est une liste qui stocke une liste de couple clé/valeur accessible grâce à leur index, la clé, ou la valeur. Chaque clé est unique et ne peut être présente deux fois dans le dictionnaire. 

//Création d'un dictionnaire avec deux clé vie et fatigue.
Dictionary<string, int> dic_competences = new Dictionary<string, int>() { { "c#", 70 }, { "php", 100 }, { "python", 10 } };

//Modification de la valeur de vie
dic_competences["c#"] = 100;

//Ajout d'une nouvelle clé avec une valeur
dic_competences.Add("c++", 50);

//Suppression du couple clé valeur de la clé : python
dic_competences.Remove("python");
Les conditions ou instructions conditionnelles et opérateurs logiques en Csharp
Les opérateurs de comparaisons en Csharp

Les conditions se bâtissent à l'aide des opérateurs de comparaison. Les principaux opérateurs de comparaisons en Csharp sont :

  • == Egalité (sans contrôle du typage)
  • === Egalité (avec contrôle du typage)
  • != Différence
  • > Supérieur à
  • < Inférieur à
  • >= Supérieur ou égal
  • <= Inférieur ou égal
  • && Et (pour effectuer une condition multi factoriel)
  • || Ou (pour effectuer une condition multi factoriel)
  • ! Négation stricte

En Csharp il existe deux instructions pour réaliser un contrôle conditionnel IF et SWITCH. Sachez que le résultat sera toujours une primitive booléenne.

L'instruction conditionnelle IF en Csharp

L'instruction IF permet de réaliser une action si une condition est remplie (vrai). Il existe de nombreuses syntaxes, mais nous ne verrons que la première pour le moment dans un souci de simplicité.

 

int version = 6;
if (version >= 5)
{
	//Si numéro de version supérieur ou égal à 5 faire quelque chose
}
else if(version <= 3){
	//Si numéro de version inférieur ou égal à 3 faire autre chose
}
else
{
	//Dans tous les autres cas faire autre chose 
}
L'instruction conditionnelle SWITCH en Csharp

L'instruction SWITCH s'utilise principalement pour éviter d'écrire des instructions IF avec de nombreux cas de figure. Reprenons l'exemple de notre gestion de version.

int version = 6;
switch (version)
{
	case 6:
	case 5:
		//Si numéro de version égal à 5 ou 6
		break;
	case 3:
	case 2:
	case 1:
	case 0:
		//Si numéro de version égal à 3,2,1,0
		break;
	default:
		//Autre cas (ici 4)
		break;
}
Les boucles en Csharp

Les boucles servent à parcourir des listes, des tableaux, ou à réaliser des compteurs. Il existe trois boucles, for, foreach, while (nous n'aborderons pas ce troisième cas pour le moment).

L'instuction for et foreach en Csharp

Sur l'exemple suivant nous réalisons une boucle de 10 occurences, de 0 à 9. A chaque itération, la variable i est incrémenté de +1.

for (int i = 0; i < 10; i++)
{
	//faire quelque chose
}

Sur l'exemple ci-dessous nous réalisons une boucle en csharp de 3 occurences, de 0 à 15 avec une progression de +5 à chaque itération.

for (int i = 0; i < 15; i+=5)
{
	//Sur 3 occurence faire quelque chose
}

Maintenant nous allons voir comment parcourir une simple liste de mots. Notre liste contient différent nom de véhicule, et nous souhaitons la parcourir et quitter la boucle quand le vehicule concerné sera "sous marin".

var list_vehicules = new List<string>() { "voiture", "bateau", "sous marin", "avion" };
foreach (string vehicule in list_vehicules)
{
	if(vehicule == "sous marin")
	{
		break;
	}
}

Nous pouvons également arriver au même procédé en utilisant la boucle incrémentale en utilisant l'index des objets dans la liste.

var list_vehicules = new List<string>() { "voiture", "bateau", "sous marin", "avion" };
int max_vehicules = list_vehicules.Count();

for (int i = 0; i < max_vehicules; i++)
{
	if (list_vehicules[i] == "bateau")
	{
		break;
	}
}

Par souci de performance, nous réalisons le comptage du nombre d'index dans list_vehicules grâce à la fonction Count(). Puis nous bouclons de 0 au nombre d'index.

Les méthodes : fonction et void en Csharp

Une fonction est un regroupement d'instruction qui prend en entrée des paramètres puis effectue un traitement et restitue une donnée (grâce au mot return). La fonction prend l'engagement de retourner un résultat correspondant à son typage. Dans l'exemple suivant, elle prend un paramètre d'entrée un entier (ici, appelé a), effectue une multiplication puis retourne le résultat sous la forme d'un entier.

 

int multiplication_fois_2(int a)
{
	int b = a * 2;
	return b;
}

En Csharp une void se comporte comme une fonction, mais ne restitue aucune donnée en sortie, les voids sont relativement rare dans les développements, il est toujours préférable d'utiliser une fonction qui retourne à minima une valeur booléenne pour définir si le traitement à réussi ou à échouer.

 

void ma_boite_noire(int in_ma_value)
{
	//Faire quelque chose sans nécessité de donnée de contrôle en sortie
}
Les niveaux d'accessibilités en Csharp

Les modificateurs d'accessibilités permettent de définir et de limiter la portée et l'accessibilité des diverses propriétés et méthodes d'une classe. En Csharp il existe six niveaux d'accessibilités.

  • public (l’accès n’est pas limité).
  • protected (l'accès est limité à la classe, où aux classes dérivées/hérités de l'objet).
  • internal (l'accès est limité au bloc de construction réutilisable actuel).
  • protected internal (l’accès est limité au bloc de construction réutilisable actuel, ou aux classes dérivées/hérités de l'objet).
  • private (l’accès est limité en interne de la classe).
  • private protected (l’accès est limité à la classe ou à ses types dérivés, mais uniquement dans le bloc de construction réutilisable actuel).
Les classes en Csharp

Une classe est un objet qui se constitue de méthodes (constructeur, fonction ou void, destructeur) de propriétés (variables). Il peut répondre à une promesse de développement grâce aux interfaces. Prenons pour exemple un objet "voiture", celui-ci à des roues, des portes, et une couleur.
Dans l'exemple de code Csharp ci-après nous constatons qu'en Csharp une classe est toujours encapsulée par des accolades et que le nom de notre classe "voiture" est préfixé du mot réservé "class".

class voiture
{
	
}

Nous allons maintenant lui rajouter un constructeur. Le constructeur est une fonction appelée pour créer l'objet. Comme toute fonction en Csharp, elle peut ou non prendre des paramètres. La seule spécificité de cette fonction est qu'elle doit avoir pour nom le nom de la classe (ici voiture).

 

class voiture
{
	public voiture()
	{
		
	}
}

Ensuite nous allons lui rajouter des propriétés (les roues, les portes, la couleur, etc.). Pour ça nous lui rajoutons des propriétés accessibles uniquement en interne de la classe (voir le mot clé private). Ces propriétés sont préfixées par convention d'un underscore.

class voiture
{
	private string _couleur;
	private int _roues;
	private int _portes;
	
	public voiture()
	{

	}
}

Pour pouvoir manipuler ces propriétés dans le constructeur nous allons lui rajouter quatre paramètres.

 

class voiture
{
	private string _couleur;
	private int _roues;
	private int _portes;
	
	public voiture(string in_couleur,int in_nombre_roues,int in_nombre_portes)
	{
		this._couleur = in_couleur;
		this._roues = in_nombre_roues;
		this._portes = in_nombre_portes;
	}
}

Maintenant lors de la création de notre objet en Csharp nous devrons définir ces différents paramètres pour créer l'objet : voiture. Ici trois voitures différentes avec des paramètres différents.

 

var voiture_0 = new voiture("rouge",4,5);
var voiture_1 = new voiture("bleu",4,5);
var voiture_2 = new voiture("vert",4,3);

Le fait est que les données de mes propriétés sont pour le moment inaccessible en dehors de la classe elle-même. Donc si nous sommes amenés à devoir trier les voitures à 5 portes uniquement ou par leur couleur, c'est impossible. Il faut donc s'appuyer sur les mutateurs qui permettent d'accéder proprement aux propriétés d'un objet. Les mutateurs sont des fonctions, qui servent de techniques d'encapsulage des propriétés et qui permettent d'effectuer un contrôle ou de conditionner la restitution d'une propriété pour des accès externes à la classe.

 

class voiture
{
	private string _couleur;
	public string couleur { get => _couleur; set => _couleur = value; }

	private int _roues;
	public int roues { get => _roues; set => _roues = value; }

	private int _portes;
	public int portes { get => _portes; set => _portes = value; }
	
	public voiture(string in_couleur,int in_nombre_roues,int in_nombre_portes)
	{
		this._couleur = in_couleur;
		this._roues = in_nombre_roues;
		this._portes = in_nombre_portes;
	}
}

Maintenant, nous pouvons accéder aux informations via les propriétés roues,couleur et porte.

 

var voiture_0 = new voiture("rouge",4,5);
int nombre_de_porte_voiture_0 = voiture_0.portes;

nombre_de_porte_voiture_0 à maintenant pour valeur 5.

Si nous souhaitons modifier la couleur :

var voiture_0 = new voiture("rouge", 4, 5);
voiture_0.color = "bleu";

Supposons qu'une fois notre objet instancier, nous ne souhaitons pas permettre de modifier le nombre de roues. Il suffit alors de supprimer le bloc d'instruction : set => _roues = value;.

Autre cas pratique, envisageons de ne permettre que des voitures de deux couleurs, rouge ou bleu et en cas d'une autre couleur forcer le rouge. Je modifie ma classe en conséquence à deux endroits. Dans le constructeur je supprime le underscore devant "this.color". Pour définir l'appel via le mutateur et non plus via la propriété.

Et je rajoute mes conditions dans le bloc d'instruction color set en modifiant l'appel.

namespace mon_projet
{
    class voiture
    {
        private string _color;
        public string color
        {
            get
            {
                return _color;
            }
            set
            {
                if(value == "rouge" || value == "bleu")
                {
                    _color = value;
                }
                else
                {
                    _color = "rouge";
                }
               
            }
        }

        private int _roues;
        public int roues { get => _roues; set => _roues = value; }

        private int _portes;
        public int portes { get => _portes; set => _portes = value; }

        public voiture(string in_color, int in_nombre_roues, int in_nombre_portes)
        {
            this.color = in_color;
            this._roues = in_nombre_roues;
            this._portes = in_nombre_portes;
        }
    }
}
L'abstraction et l'héritage des classes en Csharp

L'abstraction en Csharp vise à séparer les propriétés d'un groupe d'objet.

L'exemple le plus accessible restant celui du véhicule : une voiture, un avion, un bateau sont autant de véhicules à un niveau de pensée légèrement abstrait. Ils répondent tous à un type de moyen de transport (aérien, terrestre, naval). Ils sont tous équipés d'un moyen mécanique de propulsion, ils utilisent tous du carburant, etc. En Csharp une classe abstraite se contextualise par le mot clé abstract en préfixe de la classe. Une classe ainsi créée ne peut être appelée directement dans notre code.

 

abstract class vehicule
{
	protected int _places = 0;
	protected string _method = "";

	public vehicule(int in_places, string in_method = "terrestre")
	{
		this._places = in_places;
		this._method = in_method;
	}
}

Le seul moyen de faire usage de cette classe, de ses méthodes et de ses propriétés étant d'en faire appel grâce à une classe dite "descendante".

class avion : vehicule
{
	public avion(int in_places) : base(in_places, "aérien")
	{

	}
}


Dans l'exemple ci dessus nous constatons l'ajout de : vehicule après le déclaration de la classe en première ligne.

Et à la suite du constructeur de l'objet avion : base (in_places,"aérien"). Ce qui sert à appeler le constructeur de la classe abstraite vehicule, en lui communiquant des paramètres du constructeur de l'objet hérité (avion).

class voiture : vehicule
{
	public voiture(int in_places) : base(in_places, "terrestre")
	{

	}
}

class bateau : vehicule
{
	public bateau(int in_places) : base(in_places, "naval")
	{

	}
}

Le mot réservé base permet d'accèder à la classe ancètre. Le mot réservé this quand à lui permet d'accèder à la classe active.

Les interfaces de classe en Csharp

Les interfaces servent à répondre à des promesses de développement et à savoir quelles fonctions seront d'un niveau d'accessibilité public. Dans le processus de développement, les interfaces servent au développeur à cadrer son projet. Les interfaces sont rédigées en amont du reste du logiciel. Dans l'exemple ci-après l'interface Ivehicule est préfixé du mot clé interface. Elle exige deux fonctions des objets qui l'utiliseront get_propulsion et get_carburant.

interface Ivehicule
{
	bool get_propulsion();
	string get_carburant();
}

Pour déployer une interface sur une classe il suffit de suffixer la classe de :Ivehicule, puis de répondre à la promesse en rajoutant les deux fonctions public.

abstract class vehicule : Ivehicule
{
	protected int _places = 0;
	protected string _method = "";
	private string _carburant = "diesel";
	private bool _propulsion = true;

	public vehicule(int in_places, string in_method = "terrestre")
	{
		this._places = in_places;
		this._method = in_method;
	}

	public string get_carburant()
	{
		return _carburant;
	}

	public bool get_propulsion()
	{
		return _propulsion;
	}
}
Les espaces de noms en Csharp

Un espace de nom permet de contrôler l’étendue (comprenez la portée) des noms des classes dans un code important. Il est possible que deux classes portent le même nom dans deux espaces de nom différent.

Supposons un fichier "mon_projet.cs" :

namespace mon_espace_de_nom_un
{
    static class ma_class_demo
    {
        public static int version()
        {
            return 1;
        }
    }
}

namespace mon_espace_de_nom_deux
{
    static class ma_class_demo
    {
        public static int version()
        {
            return 2;
        }
    }
}

namespace mon_projet
{
    class mon_program
    {
        public void ma_fonction()
        {
            int test_1 = mon_espace_de_nom_un.ma_class_demo.version();
            int test_2 = mon_espace_de_nom_deux.ma_class_demo.version();
        }
    }
}

Dans l'ensemble de code Csharp ci dessus, test_1 vos 1 et test_2 vos 2.

La gestion des erreurs TRY-CATCH en Csharp

Le try catch est un bloc permettant d'essayer d'exécuter le code qu'il contient. Il permet en cas d'erreur lors de l'exécution des instructions de capter l'erreur pour réaliser une nouvelle instruction. Il est impératif d'utiliser systématiquement les blocs d'instructions try catch pour garantir que toutes défaillances sera gérée par votre programme.

Concrètement l'instruction consiste en un bloc try, qui est suivie d'une clause (ou de plusieurs) catch.

Chacune permettant de définir les gestionnaires des différentes exceptions possibles (erreur d'accès à un fichier, erreur réseau, etc.). Le gestionnaire générique d'erreur étant Exception.

 

try
{
	int t = 0;

	//Provoquer une erreur division par 0
	int x = 10 / t;
}
catch (Exception ex)
{
	//Captation de l'erreur et affichage du message dans la console.
	Console.WriteLine(ex.Message);

	//Retransmet l'erreur à la fonction appelante
	throw;
}

En cas de multiple catch l'ordre est important, car les clauses catch sont examinées par le gestionnaire d'erreur dans l'ordre. Il est préférable de capter les exceptions les plus spécifiques (ex : FileNotFoundException) en amont, jusqu'a l'erreur générique (exception).

 

try
{
  //Vos instructions en C#
}
catch (FileNotFoundException fex)
{
	//Erreur d'accès à un fichier inéxistant
}
catch (IOException ioe)
{
	//Erreur d'accès à un fichier verrouillé par un autre programme, ou droit manquant
}
catch (InvalidCastException iex)
{
	//Erreur de convertion d'un type de donnée vers un autre 
}
catch (Exception ex)
{
	//Toutes les autres erreurs
}