Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

http://www.labo-dotnet.com Auteur : Ary Quloré et Mathieu Szablowski Version 2.

http://www.labo-dotnet.com Auteur : Ary Quloré et Mathieu Szablowski Version 2.0 – 10 novembre 2004 Nombre de pages : 83 Ecole Supérieure d’Informatique de Paris 23. rue Château Landon 75010 – PARIS www.supinfo.com Programmation en C# SUPINFO DOT NET TRAINING COURSE Programmation en C# 2 / 83 http://www.labo-dotnet.com Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs Table des matières 1. VUE D’ENSEMBLE DE LA PLATE-FORME MICROSOFT .NET .......................................................... 6 1.1. PRESENTATION DE LA PLATE-FORME .NET................................................................................................... 6 1.1.1. .NET Framework................................................................................................................................... 6 1.1.2. .NET My Services.................................................................................................................................. 6 1.1.3. Serveurs .NET Entreprise Server .......................................................................................................... 7 1.1.4. Visual Studio .NET................................................................................................................................ 7 1.2. VUE D’ENSEMBLE DU FRAMEWORK .NET..................................................................................................... 7 1.2.1. .NET Framework................................................................................................................................... 7 1.2.2. Substrat de la plate-forme..................................................................................................................... 7 1.2.3. Services d’application........................................................................................................................... 7 1.2.4. Common Laguage Runtime................................................................................................................... 7 1.2.5. Bibliothèque de classe........................................................................................................................... 7 1.2.6. ADO.NET.............................................................................................................................................. 7 1.2.7. ASP.NET ............................................................................................................................................... 7 1.2.8. Services Web XML ................................................................................................................................ 8 1.2.9. Interfaces utilisateur ............................................................................................................................. 8 1.2.10. Langages............................................................................................................................................... 8 1.3. AVANTAGES FRAMEWORK .NET .................................................................................................................. 8 1.3.1. S'appuyer sur les normes et les pratiques du Web ................................................................................ 8 1.3.2. Utiliser des modèles d'application unifiés............................................................................................. 9 1.3.3. Facile d'emploi pour les développeurs.................................................................................................. 9 1.3.4. Classes extensibles................................................................................................................................ 9 1.4. COMPOSANTS DU FRAMEWORK .NET........................................................................................................... 9 1.4.1. Common Language Runtime................................................................................................................. 9 1.4.2. Bibliothèque de classes du .NET Framework...................................................................................... 10 1.4.3. ADO.NET : données et XML............................................................................................................... 10 1.4.4. Formulaires Web et services Web XML.............................................................................................. 11 1.4.5. Interface utilisateur pour Windows..................................................................................................... 12 1.5. LANGAGES DU .NET FRAMEWORK ............................................................................................................. 12 2. VUE D’ENSEMBLE DU C#........................................................................................................................... 14 2.1. STRUCTURE DU PROGRAMME C#................................................................................................................. 14 2.1.1. Hello World......................................................................................................................................... 14 2.1.2. La classe.............................................................................................................................................. 14 2.1.3. La méthode Main................................................................................................................................. 14 2.1.4. La directive using et l'espace de noms System .................................................................................... 15 2.2. OPERATIONS ELEMENTAIRES D’ENTREE/SORTIE.......................................................................................... 16 2.2.1. La classe Console................................................................................................................................ 16 2.3. METHODES CONSEILLEES............................................................................................................................ 17 2.3.1. Commentaire d’applications............................................................................................................... 17 2.3.2. Création d’une documentation XML................................................................................................... 17 2.3.3. Gestion des exception.......................................................................................................................... 19 2.4. COMPILATION, EXECUTION ET DEBOGAGE .................................................................................................. 19 2.4.1. Appel au compilateur.......................................................................................................................... 20 2.4.2. Exécution de l’application .................................................................................................................. 20 2.4.3. Débogage ............................................................................................................................................ 20 3. UTILISATION DES VARIABLES DE TYPE VALEUR............................................................................ 22 3.1. SYSTEME DE TYPES COMMUNS (CTS, COMMON SYSTEM TYPE) ................................................................. 22 3.1.1. Vue d’ensemble du système de types communs ................................................................................... 22 3.1.2. Comparaison des types valeur et référence......................................................................................... 22 3.1.3. Comparaison des types valeur définis par l’utilisateur et des types valeur intégrés .......................... 22 3.1.4. Types simples ...................................................................................................................................... 22 3.2. ATTRIBUTION DE NOMS AUX VARIABLES .................................................................................................... 23 3.2.1. Règles et recommandations pour l’affectation de noms aux variables ............................................... 23 3.2.2. Mots clés en C#................................................................................................................................... 24 Programmation en C# 3 / 83 http://www.labo-dotnet.com Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs 3.3. UTILISATION DE TYPES DE DONNEES INTEGRES........................................................................................... 24 3.3.1. Déclaration de variables locales......................................................................................................... 24 3.3.2. Attribution de valeurs aux variables ................................................................................................... 25 3.3.3. Assignation composé........................................................................................................................... 25 3.3.4. Opérateurs courants............................................................................................................................ 26 3.4. CREATION DE TYPES DE DONNEES DEFINIS PAR L’UTILISATEUR .................................................................. 26 3.4.1. Types énumération (enum).................................................................................................................. 26 3.4.2. Types Structure (struct)....................................................................................................................... 27 3.5. CONVERSION DE TYPES DE DONNEES........................................................................................................... 27 3.5.1. Conversion implicite de types de données........................................................................................... 27 3.5.2. Conversion explicite de types de données ........................................................................................... 28 4. INSTRUCTIONS ET EXCEPTIONS............................................................................................................ 29 4.1. INTRODUCTION AUX INSTRUCTIONS............................................................................................................ 29 4.1.1. Blocs d'instructions............................................................................................................................. 29 4.1.2. Types d'instructions............................................................................................................................. 29 4.2. UTILISATION DES INSTRUCTIONS CONDITIONNELLES .................................................................................. 30 4.2.1. L'instruction if..................................................................................................................................... 30 4.2.2. L'instruction switch ............................................................................................................................. 30 4.3. UTILISATION DES INSTRUCTIONS D'ITERATION............................................................................................ 31 4.3.1. L'instruction while............................................................................................................................... 31 4.3.2. L'instruction do ................................................................................................................................... 32 4.3.3. L'instruction for................................................................................................................................... 32 4.3.4. L'instruction foreach ........................................................................................................................... 34 4.4. UTILISATION DES INSTRUCTIONS DE SAUT................................................................................................... 34 4.4.1. L'instruction goto ................................................................................................................................ 34 4.4.2. Les instructions break et continue....................................................................................................... 35 4.5. GESTION DES EXCEPTIONS FONDAMENTALES.............................................................................................. 35 4.5.1. Objets exception.................................................................................................................................. 35 4.5.2. Utilisation des blocs try et catch......................................................................................................... 36 4.5.3. Blocs catch multiples........................................................................................................................... 37 4.6. LEVEE D'EXCEPTIONS.................................................................................................................................. 38 4.6.1. L'instruction throw.............................................................................................................................. 38 4.6.2. La clause finally.................................................................................................................................. 38 5. METHODES ET PARAMETRES................................................................................................................. 39 5.1. UTILISATION DES METHODES ...................................................................................................................... 39 5.1.1. Définition des méthodes ...................................................................................................................... 39 5.1.2. Appel de méthodes............................................................................................................................... 40 5.1.3. Utilisation de l'instruction return........................................................................................................ 40 5.1.4. Retour de valeurs ................................................................................................................................ 41 5.2. UTILISATION DES PARAMETRES................................................................................................................... 41 5.2.1. Déclaration et appel de paramètres.................................................................................................... 41 5.2.2. Mécanismes de passage de paramètres............................................................................................... 42 5.2.3. Passage par valeur.............................................................................................................................. 42 5.2.4. Passage par référence......................................................................................................................... 43 5.2.5. Paramètres de sortie ........................................................................................................................... 43 6. TABLEAUX..................................................................................................................................................... 45 6.1. VUE D'ENSEMBLE DES TABLEAUX ............................................................................................................... 45 6.1.1. Qu'est ce qu'un tableau ? .................................................................................................................... 45 6.1.2. Notation de tableau en C#................................................................................................................... 45 6.1.3. Rang de tableau................................................................................................................................... 45 6.1.4. Accès aux éléments d'un tableau......................................................................................................... 45 6.1.5. Vérification des limites de tableau...................................................................................................... 46 6.2. CREATION DE TABLEAUX ............................................................................................................................ 47 6.2.1. Création d'instances de tableau .......................................................................................................... 47 6.2.2. Initialisation d'éléments de tableau..................................................................................................... 47 6.2.3. Initialisation d'éléments de tableaux multidimensionnels................................................................... 47 7. NOTIONS FONDAMENTALES DE LA PROGRAMMATION ORIENTEE OBJET............................ 48 Programmation en C# 4 / 83 http://www.labo-dotnet.com Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs 7.1. CLASSES ET OBJETS..................................................................................................................................... 48 7.2. QU’EST-CE QU’UNE CLASSE ?...................................................................................................................... 48 7.3. QU’EST QU’UN OBJET ? ............................................................................................................................... 48 7.4. COMPARAISON ENTRE UNE CLASSE ET UNE STRUCTURE.............................................................................. 48 7.5. UTILISATION DE L’ENCAPSULATION............................................................................................................ 49 7.6. DONNEES DE L’OBJET, DONNEES STATIQUES ET METHODES STATIQUES ...................................................... 49 7.7. C# ET L’ORIENTATION OBJET ...................................................................................................................... 49 7.7.1. Définition de classes simples............................................................................................................... 49 7.7.2. Instanciation de nouveaux objets ........................................................................................................ 50 7.7.3. Utilisation du mot clé this ................................................................................................................... 50 7.7.4. Classes imbriquées.............................................................................................................................. 51 7.8. DEFINITION DE SYSTEMES ORIENTES OBJET................................................................................................. 51 7.8.1. Héritage .............................................................................................................................................. 51 7.8.2. Hiérarchie des classes......................................................................................................................... 51 7.8.3. Héritage simple et multiple ................................................................................................................. 51 7.8.4. Polymorphisme.................................................................................................................................... 52 7.8.5. Classes de base abstraites................................................................................................................... 52 7.8.6. Interfaces............................................................................................................................................. 52 7.8.7. Liaison anticipée et tardive................................................................................................................. 52 8. UTILISATION DE VARIABLES DE TYPE REFERENCE...................................................................... 53 8.1. COMPARAISON ENTRE LES TYPES VALEUR ET LES TYPES REFERENCE.......................................................... 53 8.2. DECLARATION ET LIBERATION DES VARIABLES REFERENCE........................................................................ 53 8.3. COMPARAISON DE VALEURS ET COMPARAISON DE REFERENCES ................................................................. 54 8.4. UTILISATION DE REFERENCES COMME PARAMETRES DE METHODE.............................................................. 55 8.5. UTILISATION DE TYPE REFERENCE COURANTS............................................................................................. 57 8.5.1. System.Exception................................................................................................................................. 57 8.5.2. System.String....................................................................................................................................... 58 8.6. HIERARCHIE DES OBJETS............................................................................................................................. 58 8.6.1. Méthode ToString................................................................................................................................ 58 8.6.2. Méthode Equals................................................................................................................................... 58 8.6.3. Méthode GetType ................................................................................................................................ 59 8.6.4. Méthode Finalize................................................................................................................................. 59 8.6.5. Méthode GetType ................................................................................................................................ 59 8.6.6. Opérateur TypeOf ............................................................................................................................... 59 8.6.7. Réflexion.............................................................................................................................................. 59 8.7. ESPACE DE NOMS DU FRAMEWORK.NET .................................................................................................... 59 8.7.1. Espace de noms System.IO.................................................................................................................. 60 8.7.2. Espace de noms System.Xml................................................................................................................ 60 8.7.3. Espace de noms System.Data.............................................................................................................. 60 8.8. CONVERSION DE DONNEES.......................................................................................................................... 61 8.8.1. Conversions implicites ........................................................................................................................ 61 8.8.2. Conversions explicites......................................................................................................................... 61 8.8.3. Conversions de types référence........................................................................................................... 61 8.8.4. Boxing/Unboxing................................................................................................................................. 62 9. CREATION ET DESTRUCTION D’OBJETS............................................................................................. 63 9.1. UTILISATION DE CONSTRUCTEURS .............................................................................................................. 63 9.1.1. Constructeurs d’instances................................................................................................................... 63 9.1.2. Constructeurs statiques....................................................................................................................... 64 9.1.3. Constructeurs de structures ................................................................................................................ 65 9.2. OBJETS ET MEMOIRE ................................................................................................................................... 65 9.3. GESTION DES RESSOURCES.......................................................................................................................... 65 9.3.1. Finalize................................................................................................................................................ 66 9.3.2. Destructeurs........................................................................................................................................ 66 9.3.3. IDisposable et Dispose........................................................................................................................ 66 10. HERITAGE DANS C#......................................................................................................................... 67 10.1. DERIVATION DE CLASSE.............................................................................................................................. 67 10.1.1. Syntaxe ................................................................................................................................................ 67 Programmation en C# 5 / 83 http://www.labo-dotnet.com Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs 10.1.2. Utilisation du mot clé protected.......................................................................................................... 67 10.1.3. Appel de constructeurs de classe de base ........................................................................................... 67 10.2. IMPLEMENTATION DE METHODES................................................................................................................ 68 10.2.1. Utilisation de virtual et override......................................................................................................... 68 10.2.2. Utilisation de new ............................................................................................................................... 68 10.3. UTILISATION D’INTERFACES........................................................................................................................ 68 10.4. UTILISATION DES CLASSES ABSTRAITES ET SCELLEES ................................................................................. 70 11. OPERATEURS, DELEGUES ET EVENEMENTS .......................................................................... 72 11.1. SURCHARGE D’OPERATEURS ....................................................................................................................... 72 11.2. DELEGATIONS............................................................................................................................................. 73 11.3. EVENEMENTS.............................................................................................................................................. 73 12. PROPRIETES ET INDEXEURS........................................................................................................ 77 12.1. PROPRIETES................................................................................................................................................. 77 12.2. INDEXEURS ................................................................................................................................................. 80 13. ATTRIBUTS ......................................................................................................................................... 82 Programmation en C# 6 / 83 http://www.labo-dotnet.com Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs 1. Vue d’ensemble de la plate-forme Microsoft .NET 1.1. Présentation de la plate-forme .NET La plate-forme Microsoft® .NET fournit l'ensemble des outils et technologies nécessaires à la création d'applications Web distribuées. Elle expose un modèle de programmation cohérent, indépendant du langage, à tous les niveaux d'une application, tout en garantissant une parfaite interopérabilité avec les technologies existantes et une migration facile depuis ces mêmes technologies. La plate-forme .NET prend totalement en charge les technologies Internet basées sur les normes et indépendantes des plates-formes, telles que http (Hypertext Transfer Protocol), XML (Extensible Markup Language) et SOAP (Simple Object Access Protocol). C# est un nouveau langage spécialement conçu pour la création d'applications .NET. En tant que développeur, il vous sera utile de comprendre le fondement et les fonctionnalités de la plate-forme Microsoft .NET avant d'écrire du code C#. La plate-forme .NET offre plusieurs technologies de base. Ces technologies sont décrites dans les rubriques suivantes. 1.1.1. .NET Framework La technologie du .NET Framework se fonde sur un nouveau Common Language Runtime. Celui-ci fournit un ensemble commun de services pour les projets créés dans Microsoft Visual Studio® .NET, indépendamment du langage. Ces services fournissent des blocs de construction de base pour les applications de tous types, utilisables à tous les niveaux des applications. Microsoft Visual Basic®, Microsoft Visual C++® et d'autres langages de programmation de Microsoft ont été améliorés pour tirer profit de ces services. Microsoft Visual J#™ .NET a été créé pour les développeurs Java qui souhaitent créer des applications et des services à l'aide du .NET Framework. Les langages tiers écrits pour la plate-forme .NET ont également uploads/Litterature/ tlangcdiez.pdf