Remerciez-le!

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

BTS SIO SI4 Support de cours C# Date Révision Août 2018 Création (v95) 09/10/20

BTS SIO SI4 Support de cours C# Date Révision Août 2018 Création (v95) 09/10/2018 Simplification (suppression algorithmie) 22/11/2018 Ajout exemple Split() + toString(a,b) + autres conversions + affichage avec {0} + saisie David ROUMANET 28/11/2018 (v.107) 1 SUPPORT DE COURS C# SI4 - SLAM2 BTS SIO SI4 Support de cours C# TABLE DES MATIÈRES 1 Programmation C#.................................................................................................................5 1.1 Vue générale "hello world"..............................................................................................5 1.1.1 Commentaires /* et */..............................................................................................5 1.1.2 Blocs { et }................................................................................................................5 1.1.3 Bibliothèques (using)...............................................................................................6 1.2 En résumé.......................................................................................................................6 1.3 Syntaxe d’écriture...........................................................................................................7 1.4 Les instructions...............................................................................................................7 1.5 Auto-évaluation chapitre 1..............................................................................................8 2 Types de données..................................................................................................................9 2.1 Les types primitifs...........................................................................................................9 2.1.1 Déclaration...............................................................................................................9 2.1.2 affectation................................................................................................................9 2.2 Les classes conteneurs................................................................................................10 2.2.1 Déclaration.............................................................................................................10 2.2.2 affectation..............................................................................................................10 2.3 Les constantes..............................................................................................................10 2.4 Déclaration d’une variable sans type : var....................................................................11 2.5 Les conversions............................................................................................................12 2.5.1 Conversions implicites...........................................................................................12 2.5.2 Conversions explicites (cast).................................................................................12 2.5.3 Conversions de chaîne vers nombre.....................................................................12 2.5.3.1 La méthode ‘Convert.’.......................................................................................................12 2.5.3.2 La méthode 'Parse' et 'TryParse'.......................................................................................13 2.5.4 Conversions de nombre vers chaîne.....................................................................13 2.5.4.1 La méthode ‘toString’.........................................................................................................13 2.5.4.2 La méthode par addition....................................................................................................13 3 Les opérations......................................................................................................................14 3.1 Les opérations arithmétiques........................................................................................14 3.1.1 Opérations simples................................................................................................14 3.1.2 Opérations complexes...........................................................................................14 3.1.3 Opérations particulières.........................................................................................14 3.2 Les opérations binaires.................................................................................................15 3.3 Les opérations de chaînes............................................................................................15 3.3.1 Formatage des affichages.....................................................................................17 4 Les tableaux.........................................................................................................................18 4.1.1 déclaration.............................................................................................................18 4.1.2 affectation..............................................................................................................18 5 Les entrées-sorties standards..............................................................................................20 5.1 Mode console................................................................................................................20 5.1.1 Affichage................................................................................................................20 5.1.1.1 Affichage simple................................................................................................................20 5.1.1.2 Affichage formaté...............................................................................................................21 5.1.2 Debug....................................................................................................................21 5.1.3 Saisie.....................................................................................................................22 David ROUMANET 28/11/2018 (v.107) 2 BTS SIO SI4 Support de cours C# 5.1.3.1 Saisie de chaîne de caractères.........................................................................................22 5.1.3.2 Saisie de nombres.............................................................................................................22 5.1.3.3 Vérification de saisies........................................................................................................22 5.2 Fichiers..........................................................................................................................24 6 Exercice................................................................................................................................27 6.1 Enregistrer un fichier contenant une fiche contact.......................................................27 6.2 Source fichier................................................................................................................27 7 Boucles et conditions...........................................................................................................28 7.1 Boucles.........................................................................................................................28 7.1.1 Boucle for ou Foreach...........................................................................................28 7.1.2 Boucle while...........................................................................................................28 7.1.3 Boucle Do… while.................................................................................................29 7.2 Conditions.....................................................................................................................29 7.2.1 Conditions IF - ELSE.............................................................................................29 7.2.2 Conditions SWITCH - CASE.................................................................................30 7.2.3 Portée de variables................................................................................................30 8 Les fonctions........................................................................................................................31 8.1 Création d’une fonction.................................................................................................32 8.2 Appel d’une fonction......................................................................................................32 8.3 Entraînez-vous : fonction SaisirNombre(int min, int max)............................................33 9 Les exceptions.....................................................................................................................34 9.1 Arborescence des exceptions.......................................................................................34 9.1.1 Exemple de code avec erreur...............................................................................34 9.2 Gestion des exceptions rencontrées............................................................................35 9.2.1 Exemple de code avec gestion d’erreur................................................................35 10 Les interfaces graphiques..................................................................................................36 10.1 Fonctionnement..........................................................................................................36 10.2 Visual Studio et projet Windows Forms......................................................................37 10.2.1 Les fichiers...........................................................................................................38 10.2.2 Les morceaux de code........................................................................................38 10.2.2.1 Program.cs......................................................................................................................38 10.2.2.2 Form.Designer.cs............................................................................................................39 10.2.2.3 Form1.cs..........................................................................................................................40 10.3 Ce qui faut retenir en programmation événementielle...............................................40 11 Les objets...........................................................................................................................41 11.1 Vocabulaire..................................................................................................................41 11.2 Représentation............................................................................................................41 11.2.1 instanciation.........................................................................................................42 11.2.2 Accesseurs et mutateurs.....................................................................................43 11.2.3 Portées et modificateurs......................................................................................43 11.2.3.1 pour les classes...............................................................................................................43 11.2.3.2 Pour les méthodes...........................................................................................................43 11.2.3.3 Pour les attributs..............................................................................................................44 11.2.4 Analyse d’un programme.....................................................................................44 11.3 Résumé.......................................................................................................................45 11.4 Héritage.......................................................................................................................46 11.4.1 Exemple...............................................................................................................46 11.4.2 Déclaration...........................................................................................................46 David ROUMANET 28/11/2018 (v.107) 3 BTS SIO SI4 Support de cours C# 11.4.3 Utilisation.............................................................................................................47 11.4.4 Exemple de codage (TD à reproduire)................................................................47 11.4.5 Exercice...............................................................................................................49 12 Les classes abstraites et interfaces...................................................................................50 12.1 Classe abstraite..........................................................................................................50 12.1.1 Exercice...............................................................................................................51 12.1.2 Exercice...............................................................................................................51 12.2 Les interfaces..............................................................................................................51 13 Annexes..............................................................................................................................53 13.1 Les caractères d'échappements.................................................................................53 David ROUMANET 28/11/2018 (v.107) 4 BTS SIO SI4 Support de cours C# 1 PROGRAMMATION C# 1.1 VUE GÉNÉRALE "HELLO WORLD" Le premier code de base en C# se présente comme suit : /* Voici le code d'exemple de base : Hello World */ using System; using System.Text; // le double slash permet d'écrire un commentaire sur une ligne namespace HelloWorld { class Program { static void Main(string[] args) { Console.WriteLine("Hello World"); Console.ReadKey(); } } } Ce code est constitué de plusieurs parties, dont certaines resteront faiblement décrites pour le moment : 1.1.1 COMMENTAIRES /* ET */ Pour C#, les lignes comprises entre /* et */ ne sont pas lues : cela permet au programmeur de placer des commentaires avant un code complexe, ou bien décrire rapidement ce que fait l’application. Il est important de comprendre qu’il faut une convention d’écriture commune à tous les programmeurs. On utilise donc des balises ouvrantes et fermantes, un peu comme en français, les symboles ‟ et ” indique que le texte contenu entre les deux symboles et dit à haute voix par exemple. Sur une ligne seulement (ou bien après une instruction) C# accepte le double symbole //. 1.1.2 BLOCS { ET } L’utilisation de blocs, permet à l’interpréteur C# de comprendre que l’ensemble des instructions comprises entre { et } vont ensemble et constituent un bloc non-sécable. Ici, namespace contient tout le programme qui n’est constitué que d’une seule classe ‘Program’ qui elle-même ne contient qu’une fonction ‘Main’. Cette structure permet de découper un programme en section logique (on regroupe ensemble, les classes et fonctions qui agissent de manière similaire ou qui ont un lien commun sur les données ou les interfaces). Si vous ne comprenez pas cette phrase, c’est tout à fait normal lorsque l’on commence à programmer avec un langage comme celui-ci… David ROUMANET 28/11/2018 (v.107) 5 BTS SIO SI4 Support de cours C# 1.1.3 BIBLIOTHÈQUES (USING) En programmation, il existe de nombreuses instructions et fonctions qui ne nécessitent pas d’être écrites, car les programmeurs ont déjà fait ce travail. En bricolage, on utilise des outils existants et un bricoleur n’a pas à ré-inventer le tournevis ou la pince. En programmation, ces outils sont des bibliothèques de fonctions (ou méthodes). Pour éviter d’avoir une boite à outils trop lourde, C# demande de préciser en début de programme les bibliothèques qui seront utilisées. Par défaut Visual Studio propose d’utiliser 5 bibliothèques, mais ce n’est pas nécessaire pour un programme aussi simple. 1.2 EN RÉSUMÉ Le schéma ci-après donne un exemple d’analogie possibles David ROUMANET 28/11/2018 (v.107) 6 BTS SIO SI4 Support de cours C# 1.3 SYNTAXE D’ÉCRITURE C# utilise une syntaxe simple mais très codifié : • Les instructions se terminent par un point-virgule ( ; ) comme une phrase en français se termine par un point. • Les noms de classes commencent par une majuscule. Pour le moment, une classe est un regroupement de commandes, un peu comme une pochette transparente dans un classeur, qui contient plusieurs feuilles • Les fonctions (appelées aussi méthodes) et variables ne commencent pas par une majuscule. Considérez qu’une fonction est un regroupement d’instructions qui seront exécutées lignes après lignes, jusqu’à la fin du bloc fonction. • C# utilise la notation "camel" à l’exception des règles sur la première lettre. Ainsi, une méthode (fonction) pour colorier un rectangle s’écrira "colorierRectangle". Seules les classes s’écrivent avec la première lettre en majuscule • Les variables peuvent utiliser tous les caractères alphabétiques (accentués compris) mais ne peuvent commencer par un chiffre, ou porter le nom d’un mot-clé de C# • Les conditions seront encadrées par des parenthèses (). • Les blocs d’instructions seront encadrés par des crochets {} • Un commentaire d’une ligne commencera par deux ‘slash’ // • Un bloc de commentaires (plusieurs lignes) s’écrit entre /* et */ • Un bloc de commentaires pour C#doc s’écrit entre /** et */ • Les crochets carrés sont utilisés pour les tableaux [ ] • Le point ( . ) est généralement utilisé pour lier les méthodes (fonctions) aux variables (objets), c’est le lien entre le sujet et le verbe (moi.Écrire(quelquechose) ou document.Imprimer(), etc.) 1.4 LES INSTRUCTIONS Voici enfin les instructions : Console.WriteLine("Hello World"); Console.ReadKey(); En français, nous pourrions dire "sur l'objet console, écrire ‘Hello Word’ puis sur l'objet console, lire une touche du clavier". C'est une écriture des langages orientés objet (POO). En cliquant sur Démarrer, une console doit s’ouvrir et afficher notre message. ► David ROUMANET 28/11/2018 (v.107) 7 BTS SIO SI4 Support de cours C# 1.5 AUTO-ÉVALUATION CHAPITRE 1 Voici quelques questions pour valider votre compréhension et approfondir vos connaissances… Question ou affirmation Vrai ou Faux À la fin de chaque ligne, on ajoute un point Les instructions sont regroupées dans un paquet L’espace de nom contient les classes qui contiennent les méthodes (fonctions) La variable RdV_de_l’Heure est possible en C# Le mot-clé "using" est une instruction d’affichage Console.ReadKey() applique la fonction ReadKey() sur la console ouverte Réponses : Faux c’est point-virgule ; Faux c’est regroupé dans un bloc ; Vrai ; Faux car contient un symbole (‘) ; Faux using intègre les bibliothèques ; Vrai. David ROUMANET 28/11/2018 (v.107) 8 BTS SIO SI4 Support de cours C# 2 TYPES DE DONNÉES Dans les langages de programmation typés, c’est le programmeur qui choisit l’espace de valeurs pour les variables. En Python ou PHP (qui ne sont pas typés), l’interpréteur suppose le type automatiquement. En C#, C++, Java et de nombreux autres langages, le programmeur peut optimiser son code (pour le rendre plus performant en vitesse et occupation mémoire) en choisissant lui-même le type de ses variables. 2.1 LES TYPES PRIMITIFS Seules les données numériques sont des types primitifs, avec deux exceptions : le caractère et le booléen. Les types primitifs sont déclarés avec un mot-clé en minuscule devant le nom de la variable. Type Représente Plage Valeur par défaut bool bololéen True ou False False byte 8 bits non signés 0 à 255 0 char 16 bits Unicode U +0000 à U +FFFF '\0' decimal 128 bits -7.9x1028 à +7.9x1028 0.0M double 64 bits +/- 5x10-324 à +1.7*10308 0.0D float 32 bits -3.4 x 1038 à +3.4 x 1038 0.0F int 32 bits signés -2147483648 à +2147483647 0 long 64 bits signés +/- 9223372036854775808 environ 0L sbyte 8 bits signés -128 à uploads/Litterature/ si4-support-c.pdf