Programmation en C#

présenter les principaux éléments du .NET Framework et expliquer la place de C# au sein de la plate-forme .NET ;

analyser la structure de base d'une application C# et documenter, déboguer, compiler et exécuter une application simple ;

créer et nommer des variables et leur attribuer des valeurs ;

utiliser des instructions courantes pour implémenter le contrôle de flux, le bouclage et la gestion des exceptions ;

créer des méthodes (fonctions et sous-routines) capables de renvoyer des valeurs et de prendre des paramètres ;

créer, initialiser et utiliser des tableaux ;

expliquer les concepts de base et la terminologie de la programmation orientée objet ;

utiliser les objets et les types référence courants ;

créer, initialiser et détruire des objets dans une application C# ;

créer des classes C# à partir de classes existantes ;

créer des classes autonomes et des infrastructures dans une application C# ;

définir des opérateurs, utiliser des délégués et ajouter des spécifications d'événements ;

implémenter des propriétés et des indexeurs ;

utiliser des attributs prédéfinis et personnalisés.

avoir de l'expérience en matière de programmation en C, C++, Visual Basic, Java ou autre langage de programmation ;

être familiarisés avec la stratégie Microsoft .NET décrite sur le site Web de Microsoft .NET à l'adresse suivante : http://www.microsoft.com/france/net

http://msdn.microsoft.com/msdnmag/issues/0900/Framework/Framework.asp

http://msdn.microsoft.com/msdnmag/issues/1000/Framework2/Framework2.asp

Présentation de la plate-forme .NET

Vue d'ensemble du .NET Framework

Avantages du .NET Framework

Composants du .NET Framework

Langages du .NET Framework

décrire la plate-forme .NET ;

citer les principaux éléments de la plate-forme .NET ;

expliquer la prise en charge des langages de programmation par le .NET Framework ;

décrire le .NET Framework et ses composants.

Structure d'un programme en C#

Opérations élémentaires d'entrée/sortie

Méthodes conseillées

Compilation, exécution et débogage

expliquer la structure d'un programme simple en C# ;

utiliser la classe Console de l'espace de noms System pour effectuer des opérations d'entrée/sortie élémentaires ;

gérer les exceptions dans un programme C# ;

créer une documentation en XML (Extensible Markup Language) pour une application C# ;

compiler et exécuter un programme en C# ;

utiliser le débogueur Microsoft Visual Studio pour suivre l'exécution d'un programme.

Système de types communs (CTS, Common Type System)

Attribution de noms aux variables

Utilisation de types de données intégrés

Création de types de données définis par l'utilisateur

Conversion de types de données

décrire les types de variables pouvant être utilisés dans les applications C# ;

nommer vos variables en respectant les conventions d'affectation de noms C# standard ;

déclarer des variables en utilisant des types de données intégrés ;

attribuer des valeurs aux variables ;

convertir des variables existantes d'un type de données à un autre ;

créer et utiliser vos propres types de données.

Introduction aux instructions

Utilisation des instructions conditionnelles

Utilisation des instructions d'itération

Utilisation des instructions de saut

Gestion des exceptions fondamentales

Levée d'exceptions

décrire les différents types d'instructions de contrôle ;

utiliser des instructions de saut ;

utiliser des instructions conditionnelles ;

utiliser des instructions d'itération ;

gérer et lever des exceptions.

Utilisation des méthodes

Utilisation des paramètres

Utilisation de méthodes surchargées

créer des méthodes statiques qui acceptent des paramètres et retournent des valeurs ;

passer des paramètres à des méthodes, par différents moyens ;

déclarer et utiliser des méthodes surchargées.

Vue d'ensemble des tableaux

Création de tableaux

Utilisation des tableaux

créer, initialiser et utiliser des tableaux de rangs différents ;

utiliser des arguments de ligne de commande dans un programme en C# ;

décrire la relation entre une variable de tableau et une instance de tableau ;

utiliser des tableaux comme paramètres pour les méthodes ;

renvoyer des tableaux à partir de méthodes.

Classes et objets

Utilisation de l'encapsulation

C# et l'orientation objet

Définition de systèmes orientés objet

définir les termes objet et classe dans le contexte de la programmation orientée objet ;

décrire les trois principales caractéristiques d'un objet : l'identité, l'état et le comportement ;

décrire l'abstraction et la façon dont elle permet de créer des classes réutilisables faciles à gérer ;

utiliser l'encapsulation pour associer des méthodes et des données dans une seule classe et appliquer l'abstraction ;

expliquer les concepts d'héritage et de polymorphisme ;

créer et utiliser des classes en C#.

Utilisation des variables de type référence

Utilisation des types référence courants

Hiérarchie des objets

Espaces de noms du .NET Framework

Conversion de données

décrire les principales différences entre les types référence et les types valeur ;

utiliser des types référence courants, tels que string ;

expliquer comment le type object fonctionne et vous familiariser avec les méthodes qu'il propose ;

décrire les espaces de noms courants du .NET Framework ;

définir si les différents types et objets sont compatibles ;

convertir explicitement et implicitement des types de données entre des types référence ;

effectuer des conversions boxing/unboxing entre des références et des valeurs.

Utilisation de constructeurs

Initialisation de données

Objets et mémoire

Gestion des ressources

utiliser des constructeurs pour initialiser des objets ;

créer des constructeurs surchargés acceptant des paramètres qui varient ;

décrire la durée de vie d'un objet et ce qu'il se passe lors de sa destruction ;

créer des destructeurs ;

implémenter la méthode Dispose.

Dérivation de classes

Implémentation de méthodes

Utilisation de classes scellées (Sealed)

Utilisation d'interfaces

Utilisation de classes abstraites (Abstract)

dériver une nouvelle classe d'une classe de base et appeler des membres et des constructeurs de la classe de base à partir de la classe dérivée ;

déclarer des méthodes comme étant virtual et override ou les masquer le cas échéant ;

sceller une classe pour qu'il soit impossible d'en dériver une autre ;

implémenter des interfaces à l'aide de méthodes implicites et explicites ;

décrire l'utilisation des classes abstraites et leur implémentation d'interfaces.

Utilisation de classes, de méthodes et de données internes

Utilisation de l'agrégation

Utilisation des espaces de noms

Utilisation des modules et des assemblys

utiliser l'accès interne pour autoriser les classes à avoir un accès privilégié les unes aux autres ;

utiliser l'agrégation pour implémenter des modèles performants, tels que les fabriques (ou Factories) ;

utiliser les espaces de noms pour organiser les classes ;

créer des modules et des assemblys simples.

Introduction aux opérateurs

Surcharge d'opérateurs

Création et utilisation de délégués

Définition et utilisation d'événements

définir des opérateurs afin de simplifier l'utilisation d'une classe ou d'un struct ;

utiliser des délégués pour dissocier l'appel à une méthode de l'implémentation de cette méthode ;

ajouter des spécifications d'événements à une classe pour permettre d'avertir les classes abonnées des changements d'état de l'objet.

Utilisation des propriétés

Utilisation des indexeurs

créer des propriétés pour encapsuler des données dans une classe ;

définir des indexeurs permettant d'avoir accès à des classes à l'aide d'une notation de type tableau.

Vue d'ensemble des attributs

Définition d'attributs personnalisés

Extraction de valeurs d'attributs

utiliser des attributs prédéfinis courants ;

créer des attributs personnalisés simples ;

lancer des requêtes pour obtenir des informations sur les attributs au moment de l'exécution