C# Michel RIVEILL riveill@unice.fr - http://www.essi.fr/~riveill Laboratoire I3S Ecole d’Ingénieur en Sciences Informatiques (ESSI)

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes et Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Hello World using System; class Hello { static void Main( ) { 07/11/2018 Hello World using System; class Hello { static void Main( ) { Console.WriteLine("Hello world"); Console.ReadLine(); // Hit enter to finish } The Hello World application is very simple in C#. Some key points: In C# there are no global methods. Everything belongs to a class. A method named Main is the entry point for a C# application. Note that Main is spelled with a capital “M”, which is different than C and C++. The reason is that for consistency, all method names start with a capital letter in the .NET Framework The line using System; means that we’ll be accessing members of the System namespace. In a very rough comparison, a namespace could be translated to a Unit in Turbo Pascal/Delphi or a .LIB file in C/C++. So in the Hello World example, the class Console, which contains the method WriteLine belongs to the System namespace. We could avoid the “using” statement by writing the complete path of the method: System.Console.WriteLine(“Hello World”); csc HelloWorld.cs /reference:System.Windows.Forms.dll 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes et Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

07/11/2018 C# Orienté composant C# est le premier langage orienté composant dans la famille C/C++ Composant? Un module indépendant, réutilisable Plus gros grain que des objets (qui sont des constructions langages) Incluent de multiple classes Généralement indépendant d’un langage Celui qui écrit un composant, ne connaît pas celui qui va l’utiliser (entreprises différentes, langages de programmation différents) Les composants sont des objets de première classe Propriétés, méthodes, évènements Attributs au moment de la conception et à l’exécution Génération de documentation au format XML Programmation en une étape Pas de fichiers d’entête (.h), de description IDL, etc. Peut être embarqué dans des pages ASP First of all, C# was designed from the ground up to support components concepts like events, methods and properties. Second, everything is an object, which allows us to create some really clean designs. Third, it was designed to make it easy to create robust and maintainable software And finally, it should be able to integrate easily with everything that already exists, preserving your investment. 07/11/2018

C# Tout est object Vue traditionnelle 07/11/2018 C# Tout est object Vue traditionnelle C++, Java : types primitifs sont ‘magiques’ et ne peuvent pas interopérer avec des objets Smalltalk, Lisp : types primitifs sont des objets mais avec un important surcoût à l’exécution C# unifie les deux approches, avec de bonne performance Simplicité utilisée partout dans le framework Augmente l’extensibilité et la réutilisabilité Nouveaux types primitifs : Décimal, SQL… Collections, etc., fonctionnent pour tous les types Everything is an Object There are two different schools here: the purists like Smalltalk where everything is an object and C++ or Java, where primitive types are treated differently for performance reasons. Typically, when everything is an object, it means that every time that you do a simple operation like adding to numbers, it will incur on a heap allocation, which is quite expensive from the CPU standpoint compared to a stack allocated piece of memory. On the other hand, when languages threat primitive types as magic types, it means that if you implement a generic class, like a collection or array, it is not truly generic, because you either have to implement one version for each primitive type or you have to write wrapper classes to each of the primitive types so they can behave as an object. In C#, it is possible if you declare a primitive type, it is created on the stack, with all performance benefits that this brings. However it is possible to assign an integer to an object, and the runtime will automatically allocate the memory on the heap to accommodate the integer and threat it as an object. This happens automatically without requiring the programmer to write an wrapper class. Just as a side note for VB programmers: you can compare a stack allocation to a stack of paper where you can only write to the top page. As soon as you enter a function or sub you get a new page and you’re done (exit the function) you just throw away the top page. Let’s say that garbage management is really simple in this scenario. Heap allocation is like having multiple pages at your disposal and also they don’t necessary vanish when your function ends. You can imagine that it is a lot more complex, because a piece of data on page 2 could be disposed, but another piece on the same page could still be needed by a different part of the code. In other words, a lot more management is necessary. 07/11/2018

C# Logiciel robuste Ramassage des miettes (Garbage collection) 07/11/2018 C# Logiciel robuste Ramassage des miettes (Garbage collection) Pas de perte de mémoire et de gestion de pointeur Exceptions Contrôle de type Pas de variables non initialisée Les ‘cast’ sont contrôlés Gestion de versions Prévient des erreurs usuelles i.e. if (x = y) ... Programmation en une étape Moins de ‘copier-coller’, source d’erreur Prevent common mistakes from other languages C# has a lot of features to make it easier to create robust software. Every C++ programmer knows how easy is to have a pointer to an object that was already de-allocated. C# provides automatically garbage collection through the Common Language Runtime. Also, if you think about how error were handle in most of the code today, they’re mostly based on checking return codes. Exceptions provides a way to write a less code while at the same time providing a much more robust error handling mechanism. Not only exception handling is implemented in the language but it is also a inherent part of the .NET Framework Another point is that all variables are automatically initialised and it is impossible to do unsafe casts. Finally, C# is one of the first languages that provides a versioning semantics to easily support old and new clients. 07/11/2018

C# Préserver les acquis 07/11/2018 C# Préserver les acquis Hérite de C++ Espace de nom (Namespaces), pointeurs (dans le code ‘non-sûr’ - unsafe code), unsigned types, etc. Quelques changements, mais aucun pour le plaisir  Intéroperabilité C# parle avec XML, SOAP, COM, DLLs ainsi que tous les langage du framework .NET Augmente la productivité Facile à apprendre Des millions de lignes de C# sont dans .NET Leverage C++ knowledge, interoperability and rich class library First of all, since C# was based on C++, C++ programmers will adapt really quick. Second, interoperability is a key theme in the .NET Framework. So it is really easy to integrate C# code with existing applications Finally, the .NET Framework provides a very, very rich set of services that will make developers really productive. 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Types Un programme C# est une collection de type 07/11/2018 Types Un programme C# est une collection de type Classes, structures, énumérations, interfaces, delegates C# fournis un ensemble de types prédéfinis i.e. int, byte, char, string, object, … Chaque programmeur peut créer ses propres types Chaque donnée et portion de code est défini par un type Pas de variables globales, pas de fonctions globales Les types sont : Des données membres : champs, constantes, tableaux, évènements Des fonctions membres : Méthodes, opérateurs, constructeurs, destructeurs, propriétés, indexeurs D’autres types : classes, structures, énumérations, interfaces, delegates Les types peuvent être instancié… …et après être utilisés : appel de méthode, get et set de propriétés, etc. Les types peuvent être convertis, implicitement ou explicitement Les types sont organisé en espace de noms, fichiers et assemblies l’ensemble forme une hiérarchie Il y a 2 catégories de types : valeur et référence In most other purely object-oriented languages one would say that a program is a collection of classes. Not all types have all capabilities; e.g. enums are fairly constrained. 07/11/2018

Types Un seul système de type 07/11/2018 Types Un seul système de type Type valeur Contient des données Ne peut être ‘null’ Primitives int i; float x; Enumératios enum State { Off, On } Structures struct Point {int x,y;} Type référence Contient des références vers des objets Peut être ‘null’ Racine object Chaîne string Classes class Foo: Bar, IFoo {...} Interfaces interface IFoo: IBar {...} Tableau string[] a = new string[10]; Delegates delegate void Empty(); int i = 123; string s = "Hello world"; 123 i s "Hello world" In C# you have value types that directly hold the data on the stack and reference types that keeps a reference on the stack, but allocates the real memory on the heap. Also have pointer types in unsafe code. Will discuss those in Part 2. 07/11/2018

Types Un seul système de type Value (Struct) Reference (Class) Variable holds Actual value Memory location Allocated on Stack, member Heap Nullability Always has value May be null Default value null Aliasing (in a scope) No Yes Assignment means Copy data Copy reference 07/11/2018

Types Un seul système de type Bénéfice des types valeurs Pas d’allocation dans le tas, moins de travail pour le GC Meilleure utilisation de la mémoire Moins de référence indirecte Un seul système de type Pas de dichotomie type primitif/objet 07/11/2018

Types Conversions Conversion implicite Fonctionne automatiquement et sans possibilité d’échec Pas de perte de précision/d’information Conversion explicite Nécessite un ‘cast’ Peu être refusée De l’information/précision peut être perdue Conversion implicite et explicite sont précisées par le programmeur int x = 123456; long y = x; // implicit short z = (short)x; // explicit double d = 1.2345678901234; float f = (float)d; // explicit long l = (long)d; // explicit 07/11/2018

Types Un système de type unifié 07/11/2018 Types Un système de type unifié Tout est objet Tous les types héritent du type objet Toute donnée peut être sauvegardée, échangée et manipulée de la même manière Everything inherits from object, including primitive types, structs or classes. 07/11/2018

Types Un système de type unifié 07/11/2018 Types Un système de type unifié Polymorphisme Capacité d’effectuer une opération sur un objet sans connaître le type précis de l’objet (et donc le code qui sera réellement exécuter) S’appuie sur les interfaces de objets et sur les relations de conformité entre les types void Poly(object o) { Console.WriteLine(o.ToString()); } The example shows a function, Poly(), that is called with different types of arguments. Poly(42); Poly(“abcd”); Poly(12.345678901234m); Poly(new Point(23,45)); 07/11/2018

Types Un système de type unifié Question : Comment peut-on traiter les valeur et les références de la même manière ? Comment un int (type valeur) peut être converti en un objet (type référence) ? Réponse : Boxing! Seulement les types valeurs peuvent être ‘boxed’ (encapsulé) Les types références n’ont pas à être ‘boxed’ Boxing Copie un type valeur dans un type référence (objet) Chaque type valeur à une correspondance “cachée” dans un type référence Une copie d’un type référence est interprétée comme une copie du type valeur Les types valeurs n’ont jamais de synonyme (d’alias) Un type valeur est converti de manière implicite dans un type référence (objet) “up cast” 07/11/2018

Types Unified Type System Unboxing Inverse operation of boxing Copies the value out of the box Copies from reference type to value type Requires an explicit conversion May not succeed (like all explicit conversions) Essentially a “down cast” 07/11/2018

Types Un système de type unifié 07/11/2018 Types Un système de type unifié Unboxing Opération inverse du boxing Extrait la valeur de la ‘boite’ Copies depuis une référence type to value type Requiert une conversion explicite Peut ne pas être acceptée (comme toute les autres conversions explicites) “down cast” Boxing et unboxing i 123 int i = 123; object o = i; int j = (int)o; o System.Int32 123 j 123 07/11/2018

Types Un système de type unifié 07/11/2018 Types Un système de type unifié Benefice du boxing Permet le polymorphisme pour tous les types (y compris les types valeurs) Les classes ‘collections’ fonctionnent avec tous les types Elimine la nécessité de construire manuellement des classes d’encapsulation On trouve plein d’exemple d’utilisation dans le Framework .NET Désavantage du boxing Performance La nécessité du boxing est moindre quand le CLR supportera la généricité (C++ templates) Main benefits of the Unified Type System: No need of wrapper code to use base types in collections or arrays No Variants anymore Hashtable t = new Hashtable(); t.Add(0, "zero"); t.Add(1, "one"); t.Add(2, "two"); string s = string.Format( "Your total was {0} on {1}", total, date); 07/11/2018

Types prédéfinis Valeur Référence Type entier Type réel decimal bool char Référence object string Signed sbyte, short, int, long Unsigned byte, ushort, uint, ulong Character char Floating point float, double, decimal Logical bool 07/11/2018

Types prédéfinis C# Type System Type Size (bytes) Signed? sbyte System.Sbyte 1 Yes short System.Int16 2 int System.Int32 4 long System.Int64 8 byte System.Byte No ushort System.UInt16 uint System.UInt32 ulong System.UInt64 07/11/2018

Predefined Types char Escape sequence characters (partial list) Char Meaning Value \’ Single quote 0x0027 \” Double quote 0x0022 \\ Backslash 0x005C \0 Null 0x0000 \n New line 0x000A \r Carriage return 0x000D \t Tab 0x0009 07/11/2018

Predefined Types Reference Types 07/11/2018 Predefined Types Reference Types Root type object Character string string 07/11/2018

Predefined Types object 07/11/2018 Predefined Types object Root of object hierarchy Storage (book keeping) overhead 0 bytes for value types 8 bytes for reference types An actual reference (not the object) uses 4 bytes C# Type System Type Size (bytes) object System.Object 0/8 overhead 07/11/2018

Predefined Types object Public Methods public bool Equals(object) protected void Finalize() public int GetHashCode() public System.Type GetType() protected object MemberwiseClone() public void Object() public string ToString() 07/11/2018

Predefined Types string An immutable sequence of Unicode characters Reference type Special syntax for literals string s = “I am a string”; C# Type System Type Size (bytes) String System.String 20 minimum 07/11/2018

Predefined Types string Normally have to use escape characters Verbatim string literals Most escape sequences ignored Except for “” Verbatim literals can be multi-line string s1= “\\\\server\\fileshare\\filename.cs”; string s2 = @“\\server\fileshare\filename.cs”; 07/11/2018

Types Types définis par l’utilisateur Enumerations enum Arrays int[], string[] Interface interface Reference type class Value type struct Function pointer delegate 07/11/2018

07/11/2018 Types Enums An enum defines a type name for a related group of symbolic constants Choices must be known at compile-time Strongly typed No implicit conversions to/from int Can be explicitly converted Operators: +, -, ++, --, &, |, ^, ~, … Can specify underlying type byte, sbyte, short, ushort, int, uint, long, ulong All enums derive from System.Enum Provides methods to determine underlying type test if a value is supported initialize from string constant retrieve all values in enum … Enums in C# are strongly typed, which means that you can’t assign a int enum to a long, or vice versa, avoiding some typical conversion mistakes. 07/11/2018

Types Enums enum Color: byte { Red = 1, Green = 2, Blue = 4, Black = 0, White = Red | Green | Blue } Color c = Color.Black; Console.WriteLine(c); // 0 Console.WriteLine(c.Format()); // Black 07/11/2018

07/11/2018 Types Arrays Un tableau permet à un groupe d’éléments d’un type particulier d’être stocker dans des blocks contigus de mémoire Les tableaux sont de types références Dérivé de System.Array Premier élément du tableau ‘0’ Les tableaux peuvent être multidimentionel Chaque tableau connaît sa longueur et son rang Les bornes sont vérifiées 07/11/2018

Types Arrays Déclaration Allocation Initialisation Accès Enumération int[] primes; int[] primes = new int[9]; int[] prime = new int[] {1,2,3,5,7,11,13,17,19}; int[] prime = {1,2,3,5,7,11,13,17,19}; prime2[i] = prime[i]; foreach (int i in prime) Console.WriteLine(i); 07/11/2018

Types Arrays Tableau multidimensional Régulier Irrégulier int[,] matR = new int[2,3]; Il peut être initialisé de manière déclarative int[,] matR = new int[2,3] { {1,2,3}, {4,5,6} }; Irrégulier Un tableau de tableaux int[][] matJ = new int[2][]; Doit être initialisé par programme 07/11/2018

Types Interfaces Une interface définie un contrat 07/11/2018 Types Interfaces Une interface définie un contrat Elle contient méthodes, propriétés, indexeurs, évènements Chaque classe or structure implémentant une interface doit supporter toute les parties du contrat Les interfaces permettent le polymorphisme Plusieurs classes et structures peuvent implémenter la même interface Un interface ne contient pas d’implémentation Elle doit être implémenté par une classe ou une structure In scenarios where completely different objects need to support some kind of shared functionality like, let’s say, persist to XML, classes can implement interfaces that make then compatible with even if they don’t share the same base class. This provides most of the benefits of multiple class inheritance without the nasty side-effects that this usually brings. 07/11/2018

Types Classes Type référence défini par l’utilisateur 07/11/2018 Types Classes Type référence défini par l’utilisateur Similaire aux classes C++ ou Java Héritage simple sur les classe Peuvent implémenter de multiples interfaces Membres Constantes, champ (fields), méthodes, opérateurs (constructeurs et destructeurs) Propriétés, indexeurs, évènements Membres par classe (static) ou par instance Contrôle d’accès public, protected, private, internal, protected internal Le mode par défaut est private Instantancié par l’opérateur new Classes in C# allow single inheritance and multiple interface inheritance. Each class can contain methods, properties, events, indexers, constants, constructors, destructors, operators and members can be static (can be accessed without an object instance) or instance member (require you to have a reference to an object first) 07/11/2018

Types Structs Similaire aux classes, mais 07/11/2018 Types Structs Similaire aux classes, mais Type valeur défini par l’utilisateur Hérite toujours d’objet Ideal pour des objets ‘légers’ int, float, double, etc., sont des structures Permet la définition de type primitifs par l’utilisateur Complex, point, rectangle, color, rational Héritage multiple des interfaces Même membres que les classes Contrôle d’accès public, internal, private Instancié par l’opérateur new To provide a really high performance object type, C# provides structs, which are stack allocated. They’re ideal for small objects and are really fast since they don’t depend on dynamic memory allocation and the garbage collector. It is also important to notice that it is not possible to inherit from an struct. No protected access because there is no inheritance. 07/11/2018

Types Classes and Structs 07/11/2018 Types Classes and Structs struct SPoint { int x, y; ... } class CPoint { int x, y; ... } SPoint sp = new SPoint(10, 20); CPoint cp = new CPoint(10, 20); 10 sp 20 Again, comparing classes and structs, it is the memory layout of a struct is just a direct representation of its members directly on the stack. On a class, a reference is stored on the stack, while the object itself is stored in the heap. cp CPoint 10 20 07/11/2018

07/11/2018 Types Delegates Un délégué (delegate) est un type référence qui défini la signature d’une méthode Quand il est instancié, un délégué peut faire référence à une ou plusieurs méthodes De manière intuitive : un pointeur sur une fonction dans le modèle objet Sert de base pour la gestion des évènements 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Structure d’un programme Survol Organisation des types Espaces des noms Références Méthode principale (main) Syntaxe 07/11/2018

Structure d’un programme Organisation des types Organisation physique Les types sont définis dans des fichiers Un fichier peut contenir plusieurs types Un type est défini une seule fois Pas d’ordre dans les déclarations Les fichiers sont compilés en modules Un module est un fichier DLL ou EXE Un module peut être le résultat de la compilation de plusieurs fichiers Les modules sont regroupés en assemblage Assembly Module File Type 07/11/2018

Structure d’un programme Espaces de noms Un nom de type doit être unique au sein d’un espace de nom (Namespace) Permet l’organisation logique des types Il n’y a pas de relation entre les espaces de noms et les fichiers (différence avec Java) un assemblage peut définir plusieurs espaces de nom Un espace de nom peut être commun à plusieurs assemblages La désignation d’un type par son nom qualifié implique l’inclusion de tout l’espace de nom dans lequel il est défini 07/11/2018

Structure d’un programme Espaces de noms 07/11/2018 Structure d’un programme Espaces de noms namespace N1 {     // N1 class C1 {   // N1.C1 class C2 {   // N1.C1.C2 }     namespace N2 {    // N1.N2 class C2 { // N1.N2.C2     } Il est toujours possible d’utiliser le nom qualifié La directive using permet de s’en passer Note that it is N1.C1, not N1::C1 The using statement is scoped by the namespace and/or compilation module containing it. using N1; C1 a; // The N1. is implicit N1.C1 b; // Fully qualified name C2 c; // Error! C2 is undefined N1.N2.C2 d; // One of the C2 classes C1.C2 e; // The other one 07/11/2018

Structure d’un programme Espaces de noms La directive using permet aussi de créer des synonymes Quelques règles de bon usage : Mettre tous ses types dans un unique espace de noms Avoir un espace de nom par projet Regarder comment le framework .NET est organisé using C1 = N1.N2.C1; using N2 = N1.N2; C1 a; // Refers to N1.N2.C1 N2.C1 b; // Refers to N1.N2.C1 07/11/2018

Structure d’un programme Références Chaque référence identifie un assemblage Utiliser les directives /r ou /reference dans le compilateur C# L’espace de nom défini les noms au niveau langage Permet de ne pas qualifier chaque type La référence précise quel assemblage utiliser csc HelloWorld.cs /reference:System.WinForms.dll 07/11/2018

Structure d’un programme Méthode Main L’éxecution d’un programme démarre à la méthode statique Main() Une seule méthode avec une de ces signatures par assemblage static void Main() static int Main() static void Main(string[] args) static int Main(string[] args) 07/11/2018

Structure d’un programme Syntaxe Identificateurs Noms pour les types, les méthodes, les champs, etc. Un seul mot sans espace Caractère Unicode Le premier caractère est soit une lettre soit ‘_’ Sensible à la casse Ne doit pas être un mot clé Sauf si préfixé par ‘@’ 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Instructions Survol Fidèle à C++ if, while, do Goto switch 07/11/2018 Instructions Survol Fidèle à C++ if, while, do nécessite une expression booléenne Goto ne peut sauter à travers les blocks switch Chaque entrée doit être terminée par un break ou return ou goto Foreach, checked, unchecked Ça c’est nouveau Les expressions ne peuvent pas être utilisée à la place des instructions In the Statements and Expressions area C# is just like C++ with some key differences to improve code robustness. Other than solving the old assignment problem in if statements, goto usage is limited to safer scenarios and switch statements require break between each options avoiding the infamous fall through bug. Also C# has a foreach statement to iterate through arrays and collections void Foo() { i == 1; // error } 07/11/2018

Instructions Survol Expressions checked, unchecked lock using 07/11/2018 Instructions Survol Expressions checked, unchecked lock using Conditionnels if Switch Boucles while do for foreach Sauts break continue goto return throw Exceptions try 07/11/2018

Instructions syntaxe Instructions terminées par ‘;’ static void Main() { F(); G(); { // Start block H(); ; // Empty statement I(); } // End block } Instructions terminées par ‘;’ Bloc d’instruction ‘{‘ ... ‘}’ ne nécessite pas de ‘;’ Commentaires // commentaire sur une seule ligne /* Commentaire sur plusieurs lignes */ 07/11/2018

Intructions Variables et constantes static void Main() { const float pi = 3.14f; const int r = 123; Console.WriteLine(pi * r * r); int a; int b = 2, c = 3; a = 1; Console.WriteLine(a + b + c); } Règle de portée des déclarations usuelles Mais impossibilité de redéfinir une variable à l’intérieur d’un bloc { int x; int x; // Error: can’t hide variable x } 07/11/2018

Instructions Variables Une variable doit être initialisée avant d’être lue Explicitement ou automatiquement Un passage en paramètre est assimilé à une lecture L’initialisation automatique est possible pour des champs statiques, des variables de classes ou des éléments de tableaux void Foo() { string s; Console.WriteLine(s); // Error } 07/11/2018

07/11/2018 Instructions goto goto permet de tranferer le contrôle à la fin du bloc ou hors du bloc, jamais à un bloc interne static void Find(int value, int[,] values, out int row, out int col) { int i, j; for (i = 0; i < values.GetLength(0); i++) for (j = 0; j < values.GetLength(1); j++) if (values[i, j] == value) goto found; throw new InvalidOperationException(“Not found"); found: row = i; col = j; } Also used in switch statements 07/11/2018

Instructions Expression 07/11/2018 Instructions Expression Affectation, appel de méthode, ++, --, new static void Main() { int a, b = 2, c = 3; a = b + c; a++; MyClass.Foo(a,b,c); Console.WriteLine(a + b + c); a == 2; // ERROR! } Expression statements must do work. 07/11/2018

instructions if if (expression booléenne) int Test(int a, int b) { 07/11/2018 instructions if if (expression booléenne) int Test(int a, int b) { if (a > b) return 1; else if (a < b) return -1; else return 0; } Like C, C++ and Java, beware of dangling elses! 07/11/2018

Instructions switch int Test(string label) { int result; switch(label) { case null: goto case “runner-up”; case “fastest”: case “winner”: result = 1; break; case “runner-up”: result = 2; break; default: result = 0; } return result; 07/11/2018

Instructions while La aussi il faut une expression booléenne int i = 0; while (i < 5) { ... i++; } int i = 0; do { ... i++; } while (i < 5); while (true) { ... } 07/11/2018

Instructions for for (int i=0; i < 5; i++) { ... } for (;;) { ... } 07/11/2018 Instructions for for (int i=0; i < 5; i++) { ... } for (;;) { ... } Just like C++ and Java. 07/11/2018

Instructions foreach Permet de parcourir un tableau 07/11/2018 Instructions foreach Permet de parcourir un tableau Permet de parcourir une collection Implémenté par l’interface IEnumerable public static void Main(string[] args) { foreach (string s in args) Console.WriteLine(s); } No need to have loops with explicit bounds checking. Just use foreach. foreach (Customer c in customers.OrderBy("name")) { if (c.Orders.Count != 0) { ... } 07/11/2018

Instructions Sauts break continue goto <label> 07/11/2018 Instructions Sauts break Termine la boucle continue Termine l’itération de la boucle en cours goto <label> Transfert l’exécution au label return [<expression>] Termine la méthode throw Lève une exception There is no break <label> or continue <label>. 07/11/2018

Instructions Exception Une exception est une instance de la classe System.Exception ou d’une classe dérivée Contient des informations à propos de l’exception Propriétés Message StackTrace InnerException try...catch...finally try permet de lever une exception catch permet de traiter les exceptions Il est possible d’avoir plusieurs bloc catch pour différentes exceptions finally contient le code qui doit toujours être executé Il n’est pas possible de sortir d’un bloc finally par un saut (e.g. goto) 07/11/2018

Instructions Exception 07/11/2018 Instructions Exception Il est possible de relever la même exception ou de la capturer (bloc catch) pour en lever une autre try { Console.WriteLine("try"); throw new Exception(“message”); } catch (ArgumentNullException e) { Console.WriteLine(“caught null argument"); catch { Console.WriteLine("catch"); finally { Console.WriteLine("finally"); You can define your own exceptions by deriving it from System.Exception. 07/11/2018

instructions Synchronisation 07/11/2018 instructions Synchronisation Lock Mutuelle exclusion Mis en oeuvre à l’aide de la classe System.Threading.Monitor public class CheckingAccount { decimal balance; public void Deposit(decimal amount) { lock (this) { balance += amount; } } public void Withdraw(decimal amount) { balance -= amount; } } } Unlike Java, you cannot specify that an entire method be locked. Experience has shown that usually an entire method does not have to be locked. Since you want to hold locks as short a period of time as possible, C# doesn’t allow you to specify it for a method. 07/11/2018

Instuctions using C# possède un ramassage des miettes (garbage collection) Ce mécanisme ne permet pas de déterminer le moment auquel la mémoire sera libérée Et donc de contrôler l’exécution des destructeurs Les objects qui nécessitent d’être nettoyer lors de leur destruction doivent implémenter l’interface System.IDisposable Méthode : Dispose() L’instruction using permet de créer une instance, de l’utiliser et de la détruire en étant certain que la méthode Dispose soit appelée à la fin de l’instruction. 07/11/2018

Statements using Statement public class MyResource : IDisposable { public void MyResource() { // Acquire valuble resource } public void Dispose() { // Release valuble resource public void DoSomething() { ... using (MyResource r = new MyResource()) { r.DoSomething(); } // r.Dispose() is called 07/11/2018

Instructions checked et unchecked Les instructions checked et unchecked permettent de contrôler le débordement dans les expressions arithmétique et les affectations checked force le contrôle unchecked supprime le contrôle Peut être utilisé pour une expression ou pour un bloc d’instruction Le mode par défaut est unchecked L’utilisation de la directive /checked du compilateur permet d’utiliser le mode checked par défaut 07/11/2018

Instructions Entrée / sortie Entrée/sortie console System.Console.WriteLine(); System.Console.ReadLine(); Appel windows System.WinForms.MessageBox.Show(); string v1 = “some value”; MyObject v2 = new MyObject(); Console.WriteLine(“First is {0}, second is {1}”, v1, v2); 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

07/11/2018 Opérateurs Survol C# défini un ensemble d’opérateurs aillant une sémantique précise pour les types prédéfinis Quelques opérateurs peuvent être surchargés (e.g. +) Les tableaux suivants présentent les opérateurs Par catégories triées par priorité À l’intérieur d’une catégorie tous les opérateurs ont la même priorité The + operator is overloaded to mean addition for numbers and concatenation for strings. 07/11/2018

Opérateurs Précédence Category Operators Primary Grouping: (x) Member access: x.y Method call: f(x) Indexing: a[x] Post-increment: x++ Post-decrement: x— Constructor call: new Type retrieval: typeof Arithmetic check on: checked Arithmetic check off: unchecked 07/11/2018

Opérateurs Précédence Category Operators Unary Positive value of: + Negative value of: - Not: ! Bitwise complement: ~ Pre-increment: ++x Post-decrement: --x Type cast: (T)x Multiplicative Multiply: * Divide: / Division remainder: % 07/11/2018

Opérateurs Précédence Category Operators Additive Add: + Subtract: - Shift Shift bits left: << Shift bits right: >> Relational Less than: < Greater than: > Less than or equal to: <= Greater than or equal to: >= Type equality/compatibility: is Type conversion: as 07/11/2018

Opérateurs Précédence Category Operators Equality Equals: == Not equals: != Bitwise AND & Bitwise XOR ^ Bitwise OR | Logical AND && Logical OR || 07/11/2018

Opérateurs Précédence Category Operators Ternary conditional ?: Assignment =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |= 07/11/2018

Opérateurs Associativité Affectation et affectation conditionelle sont associatives à droite x = y = z est évalué x = (y = z) Les autres opérateurs sont associatifs à gauche x + y + z est évalué (x + y) + z Si l’évaluation ne convient pas, il faut utiliser les ‘(‘ …’)’ 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Using Visual Studio.NET Types of projects Console Application Windows Application Web Application Web Service Windows Service Class Library ... 07/11/2018

Using Visual Studio.NET Windows Solution Explorer Class View Properties Output Task List Object Browser Server Explorer Toolbox 07/11/2018

Using Visual Studio.NET Building Debugging Break points References Saving 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Using .NET Framework SDK Compiling from command line csc /r:System.WinForms.dll class1.cs file1.cs 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Review Key Object-Oriented Concepts 07/11/2018 Review Key Object-Oriented Concepts Objects, instances and classes Identity Every instance has a unique identity, regardless of its data Encapsulation Data and function are packaged together Information hiding An object is an abstraction User should NOT know implementation details The term object sometimes refers to an instance and sometimes to a class. It’s meaning can usually be determined by context. 07/11/2018

Review Key Object-Oriented Concepts 07/11/2018 Review Key Object-Oriented Concepts Interfaces A well-defined contract A set of function members Types An object has a type, which specifies its interfaces and their implementations A variable also can have a type Inheritance Types are arranged in a hierarchy Base/derived, superclass/subclass Interface vs. implementation inheritance An interface is a well-defined set of methods (functions). Interfaces do not contain data members. Type is different from class. The type specifies the interfaces, the class specifies the implementation. 07/11/2018

Review Key Object-Oriented Concepts 07/11/2018 Review Key Object-Oriented Concepts Polymorphism The ability to use an object without knowing its precise type Three main kinds of polymorphism Inheritance Interfaces Late binding Dependencies For reuse and to facilitate development, systems should be loosely coupled Dependencies should be minimized Polymorphism is achieved through: Inheritance: a base type can have multiple derived types Interfaces: multiple types can implement a given interface Late binding: you can use any object, as long as it implements the methods you want to call. In C# you can use reflection to dynamically determine if an object implements a method, and then call it. Interfaces can also be used in a late-bound manner. In order to handle multiple types without polymorphism you have to write conditional code (using if or switch statements) that tests the type of an instance and then runs the appropriate code. Such code is brittle and not easily extended. Many Object-Oriented design concepts are motivated by minimizing dependencies. You want to be able to develop independent modules, so that making a change to one doesn’t force you to have to go back and change others. 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Interfaces An interface defines a contract 07/11/2018 Interfaces An interface defines a contract An interface is a type Includes methods, properties, indexers, events Any class or struct implementing an interface must support all parts of the contract Interfaces provide no implementation When a class or struct implements an interface it must provide the implementation Interfaces provide polymorphism Many classes and structs may implement a particular interface In scenarios where completely different objects need to support some kind of shared functionality like, let’s say, persist to XML, classes can implement interfaces that make them compatible with even if they don’t share the same base class. This provides most of the benefits of multiple class inheritance without the nasty side-effects that this usually brings. Interface members are implicitly public and abstract. 07/11/2018

Interfaces Example public interface IDelete { void Delete(); } 07/11/2018 Interfaces Example public interface IDelete { void Delete(); } public class TextBox : IDelete { public void Delete() { ... } public class Car : IDelete { TextBox tb = new TextBox(); IDelete iDel = tb; iDel.Delete(); Car c = new Car(); iDel = c; 07/11/2018

Interfaces Multiple Inheritance 07/11/2018 Interfaces Multiple Inheritance Classes and structs can inherit from multiple interfaces Interfaces can inherit from multiple interfaces interface IControl { void Paint(); } interface IListBox: IControl { void SetItems(string[] items); } interface IComboBox: ITextBox, IListBox { } 07/11/2018

Interfaces Explicit Interface Members 07/11/2018 Interfaces Explicit Interface Members If two interfaces have the same method name, you can explicitly specify interface + method name to disambiguate their implementations interface IControl { void Delete(); } interface IListBox: IControl { void Delete(); } interface IComboBox: ITextBox, IListBox { void IControl.Delete(); void IListBox.Delete(); } If there’s no ambiguity then you do not have to specify the name of the interface. 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes et structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Classes et Structures Similarités 07/11/2018 Classes et Structures Similarités Chacune Est un type défini par l’utilisateur Peut implémenter plusieurs interfaces Peut contenir Données Champs, constantes, événements, tableaux Fontions Méthodes, propriétés, indexeurs, opérateurs, constructeurs Définition de types Classes, structures, énumérations, interfaces, delegates Classes and structs provide a way to create user-defined types. 07/11/2018

Classes et Structures Différences 07/11/2018 Classes et Structures Différences Class Structure Reference type Value type Can inherit from any non-sealed reference type No inheritance (inherits only from System.ValueType) Can have a destructor No destructor Can have user-defined parameterless constructor No user-defined parameterless constructor 07/11/2018

Classes et Structures C# Structures vs. C++ Structures 07/11/2018 Classes et Structures C# Structures vs. C++ Structures Différent des structures C++ C++ Struct C# Struct Same as C++ class, but all members are public User-defined value type Can be allocated on the heap, on the stack or as a member (can be used as value or reference) Always allocated on the stack or as a member Members are always public Members can be public, internal or private The C++ and C# structs are alike in name only. 07/11/2018

Classes et Structures Classes 07/11/2018 Classes et Structures Classes public class Car : Vehicle { public enum Make { GM, Honda, BMW } Make make; string vid; Point location; Car(Make m, string vid; Point loc) { this.make = m; this.vid = vid; this.location = loc; } public void Drive() { Console.WriteLine(“vroom”); } Car c = new Car(Car.Make.BMW, “JF3559QT98”, new Point(3,7)); c.Drive(); 07/11/2018

Classes et Structures Structures 07/11/2018 Classes et Structures Structures public struct Point { int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public int X { get { return x; } set { x = value; } } public int Y { get { return y; } set { y = value; } } Point p = new Point(2,5); p.X += 100; int px = p.X; // px = 102 07/11/2018

Classes et Structures Static vs. Instance Par défaut, les variables sont créées par instance Chaque instance a ses propres champs Les méthodes sont appliquées à une instance Les variables statiques sont associées à des types Les méthodes statique ne peuvent pas accéder aux données de l’instance Pas de variable this dans les méthodes statiques Ne pas abuser des membres statiques Static est essentiellement utilisé pour des données et des fonctions globales 07/11/2018

Classes and Structs Directives d’accès Les directives d’accès permettent de spécifier qui peut utiliser un type ou un membre Les directives d’accès permettent de contrôler l’encapsulation Les types au niveau haut (ceux associés à un namespace) peuvent être public ou internal Les membres des classes peuvent être public, private, protected, internal ou protected internal Les membres des structures peuvent public, private ou internal If the access modifier is Then a member defined in type T and assembly A is accessible public to everyone private within T only (the default) protected to T or types derived from T internal to types within A protected internal to T or types derived from T or to types within A 07/11/2018

Classes et Structures Classes abstraites et classes finales Une classe abstraite ne peut pas être instantiée Prévue pour être utilisée comme une classe de base Peuvent contenir des fonctions membres abstraites et non abstraites Similaire à une interface Ne peut être finale (‘sealed’) Une classe finale (sealed) ne peut être utilisé comme une classe de base Une classe finale ne peut être abstraite Une structure est implicitement finale Pourquoi des classes finales ? Pour empêcher une dérivation non souhaitée Pour optimiser le code L’appel des fonctions virtuellee peut être résolu à la compilation 07/11/2018

Classes et Structures this Le mot clé this est une variable prédéfinie accessible dans chaque fonction membre non statique Utilisé pour supprimer les ambiguïtés lors de l’accès aux données ou aux fonctions membres class Person { string name; public Person(string name) { this.name = name; } public void Introduce(Person p) { if (p != this) Console.WriteLine(“Hi, I’m “ + name); 07/11/2018

Classes et Structures base Le mot clé base est utilisé pour accéder aux membres de classes masqués par un nom similaire de la classe courante class Shape { int x, y; public override string ToString() { return "x=" + x + ",y=" + y; } class Circle : Shape { int r; return base.ToString() + ",r=" + r; 07/11/2018

Classes et Structures Constantes Une constante est une donnée membre qui est évaluée à la compilation Elle est implicitement statique i.e. Math.PI public class MyClass { public const string version = “1.0.0”; public const string s1 = “abc” + “def”; public const int i3 = 1 + 2; public const double PI_I3 = i3 * Math.PI; //ERROR public const double s = Math.Sin(Math.PI); ... } 07/11/2018

Classes et Structures Champs non modifiable (‘read-only’) Similaire à une constante, mais initialisé à l’exécution Une fois initiatisé, il ne plus être modifié Différents à une constante Initialisé à l’exécution (vs. à la compilation) Il n’est pas nécessaire de re-compiler les client de la classe/struct qui le défini Il peut être statique (et partagé par les différentes instances) ou propre à chaque instance public class MyClass { public static readonly double d1 = Math.Sin(Math.PI); public readonly string s1; public MyClass(string s) { s1 = s; } } 07/11/2018

Classes et Structures Propriétés Une propriété est un champ virtuel Ressemble à un champ, mais est implémenté par du code Peut être read-only, write-only ou read/write public class Button: Control { private string caption; public string Caption { get { return caption; } set { caption = value; Repaint(); } } Button b = new Button(); b.Caption = "OK"; String s = b.Caption; 07/11/2018

Classes et Structures Indexeurs Un indexeur permet à une instance d’être un tableau virtuel Peut être surchargé (i.e. indexé par int et par string) Peut être read-only, write-only ou read/write public class ListBox: Control { private string[] items; public string this[int index] { get { return items[index]; } set { items[index] = value; Repaint(); } } ListBox listBox = new ListBox(); listBox[0] = "hello"; Console.WriteLine(listBox[0]); 07/11/2018

Classes et Structures Méthodes Tout code est exécuté par une méthode Constructeurs, destructeurs et operateurs sont des types particuliers de méthodes Propriétés et indexeurs sont implémentés par des méthodes get/set Une méthode peut recevoir des paramètres Passage par valeur Ou par référence : ref (dans la signature de la méthode et dans l’appel) Permet à une méthode de modifier la variable La variable doit avoir une valeur avant l’appel void RefFunction(ref int p) { p++; } int x = 10; RefFunction(ref x); // x is now 11 07/11/2018

Classes et Structures Méthodes Une méthode peut recevoir des paramètres (suite) Et avoir des paramètres retours out (dans la signature de la méthode et dans l’appel) La méthode doit initialiser l’argument avant de terminer Et des paramètres résultats void OutFunction(out int p) { p = 22; } int x; OutFunction(out x); // x is now 22 07/11/2018

Classes et Structures Surcharge des méthodes Il est possible de surcharger le type d’une méthode, i.e. avoir plusieurs méthodes avec le même nom Chacune doit avoir une signature unique La signature est construite uniquement sur les arguments (la valeur de retour est ignorée) void Print(int i); void Print(string s); void Print(char c); void Print(float f); // Error: duplicate signature int Print(float f); 07/11/2018

Classes et Structures Paramètres variables 07/11/2018 Classes et Structures Paramètres variables Une méthode peut avoir un nombre variable de paramètres Déclaré par le mots clé : params Doit être le dernier argument int Sum(params int[] intArr) { int sum = 0; foreach (int i in intArr) sum += i; return sum; } In the example, the Add function can be called with a variable number of arguments. Here, there are 3 arguments. Each is put into the intArr array. The function then iterates over the array, producing the sum of the 3 numbers. int sum = Sum(13,87,34); 07/11/2018

Classes et Structures Méthodes non-virtuelles 07/11/2018 Classes et Structures Méthodes non-virtuelles Méthodes non-virtuelles par défaut Ne sont pas polymorphes Elles ne peuvent pas être surchargées Elles ne peuvent pas être abstraites When you call a non-virtual method M (DoSomething) on a class C (Foo), you are guaranteed that C.M (Foo.DoSomething) will be called. class Foo { public void DoSomething(int i) { ... } Foo f = new Foo(); f.DoSomething(); 07/11/2018

Classes et Structures Méthodes virtuelles Définie dans une classe de base Peuvent être surchargées dans une classe dérivée Chaque classe fourni sa propre implémentation de la méthode Peut contenir une implémentation par défaut Si l’on ne souhaite par de méthode par défaut, utiliser une méthode abstraite Une forme de polymorphism Propriétés, indexeurs et évènements peut aussi être virtuel 07/11/2018

Classes et Structures Méthodes virtuelles class Shape { public virtual void Draw() { ... } } class Box : Shape { public override void Draw() { ... } class Sphere : Shape { void HandleShape(Shape s) { s.Draw(); ... } HandleShape(new Box()); HandleShape(new Sphere()); HandleShape(new Shape()); 07/11/2018

Classes et Structures Méthodes abstraites une méthode abstraite est une méthode virtuelle qui n’a pas d’implémentation Doit être dans une classe abstraite Doit être implémentée dans une classe dérivée 07/11/2018

Classes et Structures Méthodes abstraites abstract class Shape { public abstract void Draw(); } class Box : Shape { public override void Draw() { ... } class Sphere : Shape { void HandleShape(Shape s) { s.Draw(); ... } HandleShape(new Box()); HandleShape(new Sphere()); HandleShape(new Shape()); // Error! 07/11/2018

Classes et Structures Surcharge de méthode La surcharge doit être explicite : override ou new Supprimer les surcharges accidentelle Les méthodes sont non virtuelles par défaut class Base { // version 2 public virtual void Foo() { Console.WriteLine("Base.Foo"); } class Base { // version 1 } class Derived: Base { // version 2b public override void Foo() { base.Foo(); Console.WriteLine("Derived.Foo"); } class Derived: Base { // version 2a new public virtual void Foo() { Console.WriteLine("Derived.Foo"); } class Derived: Base { // version 1 public virtual void Foo() { Console.WriteLine("Derived.Foo"); } 07/11/2018

Classes et Structures Constructeurs 07/11/2018 Classes et Structures Constructeurs Un constructeur peut en appeler un autre this(...) dans la même classe base(...) pour la classe de base Le constructeur par défaut est base() class B { private int h; public B() { } public B(int h) { this.h = h; } } class D : B { private int i; public D() : this(24) { } public D(int i) { this.i = i; } public D(int h, int i) : base(h) { this.i = i; } B.B() is needed because once B.B(int h) was defined, the default parameterless constructor is no longer created. Can’t call both : base() and : this() because it would then be ambiguous as to how the base class is constructed. 07/11/2018

Classes et Structures Destructeurs Un destructeur est une méthode appelé par lors de la destruction de l’objet (par GC) Permet d’éliminer les objets liés Les structures ne peuvent pas avoir de destructeurs class Foo { ~Foo() { Console.WriteLine(“Destroyed {0}”, this); } 07/11/2018

Classes et Structures Surcharge d’opérateur Opérateur défini par les utilisateurs Toujours une méthode statique class Car { string vid; public static bool operator ==(Car x, Car y) { return x.vid == y.vid; } 07/11/2018

Classes et Structures Surcharge d’opérateur Opérateur unaire surchargeable + - ! ~ true false ++ -- Opérateur binaire surchargeable + - * / ! ~ % & | ^ == != << >> < > <= >= 07/11/2018

Classes et Structures Surcharge d’opérateur Tous les opérateurs ne sont pas surchargeable Accès aux membres, appel de méthodes, affectation sizeof, new, is, as, typeof, checked, unchecked, &&, ||, and ?: La surcharge d’un opérateur binaire (e.g. *) surcharge implicitement l’opérateur d’affectation correspondant (e.g. *=) 07/11/2018

Classes et Structures Surcharge d’opérateur struct Vector { int x, y; public Vector(x, y) { this.x = x; this.y = y; } public static Vector operator +(Vector a, Vector b) { return Vector(a.x + b.x, a.y + b.y); } ... 07/11/2018

Classes et Structures Opérateur de conversion Explicite et implicite conversion définies par l’utilisateur class Note { int value; // Convert to hertz – no loss of precision public static implicit operator double(Note x) { return ...; } // Convert to nearest note public static explicit operator Note(double x) { Note n = (Note)442.578; double d = n; 07/11/2018

Classes et Structures Implementation des interfaces Peuvent implémenter plusieurs interfaces Doivent implémenter toutes les méthodes de l’interface héritée public interface IDelete { void Delete(); } public class TextBox : IDelete { public void Delete() { ... } public class Car : IDelete { TextBox tb = new TextBox(); IDelete iDel = tb; iDel.Delete(); Car c = new Car(); iDel = c; 07/11/2018

Classes et Structures Implementation des interfaces Implémentation explicite des interfaces en cas de collision des noms public interface IDelete { void Delete(); } public interface IFoo { public class TextBox : IDelete, IFoo { public void IDelete.Delete() { ... } public void IFoo.Delete() { ... } 07/11/2018

Classes et Structures Type interne 07/11/2018 Classes et Structures Type interne Déclaré à l’interieur d’un autre type Bénéfice Un type interne peut accéder à tous les membres du type qui le défini Un type interne est inconnu à l’extérieur du type qui le défini Java inner classes implicitly have access to the instance of their containing class that created them. C# nested types have no such implicit relationship. However, such a relationship can easily be implemented by passing a reference to the containing class to the nested class, which then saves that in a field. 07/11/2018

Classes et Structures is L’opérateur is permet de tester à l’exécution le type d’un objet static void DoSomething(object o) { if (o is Car) ((Car)o).Drive(); } A utiliser avec modération Coûteux en temps… 07/11/2018

Classes et Structures as L’opérateur as converti une variable (si c’est possible) dans le type demandé Si ce n’est pas possible le résultat est null static void DoSomething(object o) { Car c = o as Car; if (c != null) c.Drive(); } Test et conversion en une seule opération A utiliser avec modération 07/11/2018

Classes et Structures typeof L’opérateur typeof retourne le type de l’objet désigné (appel de System.Type) Utilise la réflexion pour obtenir dynamiquement le type Console.WriteLine(typeof(int).FullName); Console.WriteLine(typeof(System.Int).Name); Console.WriteLine(typeof(float).Module); Console.WriteLine(typeof(double).IsPublic); Console.WriteLine(typeof(Car).MemberType); 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Delegates Un ‘delegate’ est une référence sur une signature de méthode 07/11/2018 Delegates Un ‘delegate’ est une référence sur une signature de méthode Une instance de ‘delegate’ instance défini une ou plusieurs méthodes C’est un pointeur sur une fonction dans le monde objet Les méthodes peuvent être statique ou non Les méthodes peuvent retourner une valeur Permet le polymorphisme sur les fonctions/méthodes La base pour la programmation par évènement Delegates are essentially function pointers. This is the mechanism used to implement event in the frameworks. In the example we first declare a delegate for a function that returns double and receives a double as a parameter. We then instantiate the delegate, telling it to use Math.Sin as the function. Finally we invoke the delegate we created. The power is in the fact that once instantiated, a delegate can be passed around and then invoked at some later time. delegate double Del(double x); // Declare static void DemoDelegates() { Del delInst = new Del(Math.Sin); // Instantiate double x = delInst(1.0); // Invoke } 07/11/2018

Delegates multicast Un delegate peut appeler plusieurs méthodes Les delegates multicast ne contiennent pas de fonction le paramètre de retour est void Chaque delegate possède sa propre liste d’appel Les méthodes sont appelées séquentiellement, dans leur ordre d’ajout Opérateurs += et -= Utilisés pour insérer supprimer une méthode à la liste du delegate Fonctionnent correctement avec les threads 07/11/2018

Delegates Multicast Delegates delegate void SomeEvent(int x, int y); static void Foo1(int x, int y) { Console.WriteLine("Foo1"); } static void Foo2(int x, int y) { Console.WriteLine("Foo2"); public static void Main() { SomeEvent func = new SomeEvent(Foo1); func += new SomeEvent(Foo2); func(1,2); // Foo1 // and Foo2 are called func -= new SomeEvent(Foo1); func(2,3); // Only Foo2 is called 07/11/2018

Delegates et interfaces Il est toujours possible d’utiliser des interfaces à la place des delegates Interfaces sont plus puissantes Appel à de multiples méthodes Mécanisme d’héritage Delegates sont plus élégant pour la gestion des événements Moins de code Implémentation facile de plusieurs traitants d’événement dans une seule classe/structure 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Evénements Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

07/11/2018 Evènements La programmation par évènement permet à un objet de prévenir un ensemble d’objets en attente de la production d’un évènement Modèle ‘publish-subscribe’ Basé sur un mécanisme de ‘call-back’ Le programmeur se concentre sur les réactions a exécuter et non pas sur le lien évènement-réaction Code plus lisible Les évènement sont très utilisés lors de la construction d’IHM L’utilisateur fait une action (click sur un bouton, déplace la souris, change une valeur, etc.) et le programme réagit Il existe de nombreuses autres utilisation, i.e. Évènements temporels Gestion des exécutions asynchrones (prévenir qu’un email est arrivé, qu’une session Web a démarré) C# supporte les évènements Basé sur la notion de délégué L’émetteur de l’événement, défini le délégué Les clients de l’évènement enregistre le traitement à associer à l’évènement Appel de += et de -= sur les délégués Il ne peuvent pas créer les évènements Les délégués multicast permettent à plusieurs objets de s’enregistré pour le même évènement 07/11/2018

Evènements Exemple coté composant (émetteur) 07/11/2018 Evènements Exemple coté composant (émetteur) Définir la signature de l’événement comme un délégué Définir l’événement et sa logique d’emission public delegate void EventHandler(object sender, EventArgs e); public class Button { public event EventHandler Click; protected void OnClick(EventArgs e) { // This is called when button is clicked if (Click != null) Click(this, e); } } 07/11/2018

Evènements Exemple : coté utilisateur de l’évènement 07/11/2018 Evènements Exemple : coté utilisateur de l’évènement Définir le traitement à associer à l’évènement et l’enregistrer public class MyForm: Form { Button okButton; static void OkClicked(object sender, EventArgs e) { ShowMessage("You pressed the OK button"); } public MyForm() { okButton = new Button(...); okButton.Caption = "OK"; okButton.Click += new EventHandler(OkClicked); 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Attributs Les attributs permettent de décorer les différentes parties du code (assembly, module, type, member, return value and parameter) avec des informations additionnelles L’URL contenant la documentation pour les classes Le mode d’activation des transaction pour les méthodes Le mapping XML pour la persistance COM ProgID pour une class Les attributs sont Intégrés au code sans modification de la syntaxe d’origine Extensibles Ils permettent d’ajouter des informations non supportées par C# Pour en créer de nouveau, il suffit d’écrire une classe qui hérite de System.Attribute Sûr : le type des arguments est vérifié lors de la compilation Pris en charge par le framework.NET Framework Ils ne sont pas propre à un seul langage de programmation Sauvegardé dans l’assembly metadata Utilisés dans tous le framework .Net XML, services Web, sécurité, serialisation, modèle de composant, intéroperabilité avec COM, configuration du code… Les attributs peuvent être Associés aux types et aux fonctions membres Examiné à l’exécution en utilisant la réflexion 07/11/2018

Attributs [HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)] class SomeClass { [Obsolete(“Use SomeNewMethod instead”)] public void SomeOldMethod() { ... } public string Test([SomeAttr()] string param1) { 07/11/2018

Attributs Quelques uns des attributs prédéfinis du framework .NET 07/11/2018 Attributs Quelques uns des attributs prédéfinis du framework .NET Attribute Name Description Browsable Should a property or event be displayed in the property window Serializable Allows a class or struct to be serialized Obsolete Compiler will complain if target is used ProgId COM Prog ID Transaction Transactional characteristics of a class 07/11/2018

Attributs [HelpUrl("http://SomeUrl/MyClass")] class Class1 {} HelpUrl("http://SomeUrl/MyClass”, Tag=“ctor”)] class Class2 {} Type type = typeof(MyClass); foreach (object attr in type.GetCustomAttributes() ) { if ( attr is HelpUrlAttribute ) { HelpUrlAttribute ha = (HelpUrlAttribute) attr; myBrowser.Navigate( ha.Url ); } 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Directives pour le préprocesseur 07/11/2018 Directives pour le préprocesseur C# permet de préciser des directives au préprocesseur A la différence de C/C++, le préprocesseur est intégré au processeur Le préprocesseur de C++ supprime les include : #include Pas vraiment utile de les supprimer lors des compilations en une seule étape ; par contre, compilation plus rapide #define Supprimé pour rendre le résultat plus lisible Assertions permettent de rendre le code plus lisible Une assertion est essentiellement une unité de test Assertions peuvent tester des préconditions, postconditions et invériants Assertions sont activées uniquement en mode de mise au point Pour plus d’information : “Writing Solid Code”, by Steve Maguire, Microsoft Press, ISBN 1-55615-551-4 07/11/2018

Directives pour le pré processeur Description #define, #undef Define and undefine conditional symbols #if, #elif, #else, #endif Conditionally skip sections of code #error, #warning Issue errors and warnings #region, #end Delimit outline regions #line Specify line number 07/11/2018

Directives pour le pré processeur Compilation conditionnelle 07/11/2018 Directives pour le pré processeur Compilation conditionnelle #define Debug public class Debug { [Conditional("Debug")] public static void Assert(bool cond, String s) { if (!cond) { throw new AssertionException(s); } void DoSomething() { ... // If Debug is not defined, the next line is // not even called Assert((x == y), “X should equal Y”); Compiler directives are supported just like in C++ with a notable exception of Macros. The reason is that macros can change the behavior of the code just by changing a define. It also makes debugger really harder and also makes a lot more difficult to make proper optimizations. However, there is a attribute called Conditional that can be used to suppress methods based on a define. This is how a type-safe Assert is implemented in C# without macros. 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Commentaires en XML Les programmeurs n’aiment pas documenter le code, C# donne la possibilité de produire de la documentation en lien avec le code compilé La javadoc de C# C# permet d’écrire ces commentaires en XML Début du commentaire : /// Fin du commentaire : fin de ligne Un document XML est généré lors de la compilation du code avec l’argument /doc S’appuie sur un schéma XML prédéfini Il est aussi possible d’ajouter ses propres balises Certains commentaires sont ‘vérifiés’ : paramètres, exceptions, types 07/11/2018

Commentaires en XML XML Tag Description <summary>, <remarks> Type or member <param> Method parameter <returns> Method return value <exception> Exceptions thrown from method <example>, <c>, <code> Sample code <see>, <seealso> Cross references <value> Property <paramref> Use of a parameter <list>, <item>, ... Formatting hints <permission> Permission requirements 07/11/2018

Commentaires en XML class XmlElement { /// <summary> 07/11/2018 Commentaires en XML class XmlElement { /// <summary> /// Returns the attribute with the given name and /// namespace</summary> /// <param name="name"> /// The name of the attribute</param> /// <param name="ns"> /// The namespace of the attribute, or null if /// the attribute has no namespace</param> /// <return> /// The attribute value, or null if the attribute /// does not exist</return> /// <seealso cref="GetAttr(string)"/> /// public string GetAttr(string name, string ns) { ; } Csc XmlElement.cs /doc 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Code ‘unsafe’ Parfois, le contrôle de la mémoire est nécessaire 07/11/2018 Code ‘unsafe’ Parfois, le contrôle de la mémoire est nécessaire Gain en performance Accès à des structures binaires définies de manière externe Accès à du code existant Accès à des composants COM, importation de DLL C# permet d’indiquer les portions ou le programmeur souhaite contrôler la gestion mémoire. Il peut alors utiliser : Le type pointer et l’arithmétidque sur les pointers Les opérateurs ->, * Les cast entre données Pas de ramassage de miettes (GC) À utiliser chaque fois qu’un programme inclue du code C/C++ Mode opératoire Utiliser l’instruction fixed pour indiquer les données qui ne doivent pas être affectée par le GC Utiliser l’opérateur stackalloc pour allouer la mémoire dans le tas If you need to do some real low level memory manipulation, you can declare a method unsafe and then you have access to full C pointer syntax. You can think of unsafe methods as inline C. 07/11/2018

Code ‘unsafe’ unsafe void Foo() { char* buf = stackalloc char[256]; 07/11/2018 Code ‘unsafe’ unsafe void Foo() { char* buf = stackalloc char[256]; for (char* p = buf; p < buf + 256; p++) *p = 0; ... } class FileStream: Stream { int handle; public unsafe int Read(byte[] buffer, int index, int count) { int n = 0; fixed (byte* p = buffer) { ReadFile(handle, p + index, count, &n, null); } return n; [dllimport("kernel32", SetLastError=true)] static extern unsafe bool ReadFile(int hFile, void* lpBuffer, int nBytesToRead, int* nBytesRead, Overlapped* lpOverlapped); Just declare the unsafe keyword and you can do full memory manipulation 07/11/2018

Code ‘Unsafe’ C# et les pointers 07/11/2018 Code ‘Unsafe’ C# et les pointers Le pouvoir a un prix ‘Unsafe’ veut dire non vérifiable Code exécuté avec plus de précaution Avant d’exécuter le code Lors du chargement 07/11/2018

Plan Introduction Notions complémentaires Pour aller plus loin 07/11/2018 Plan Introduction Hello World Objectifs de C# Types Structure d’un programme Instruction Opérateurs Utilisation de Visual Studio.NET Utilisation du SDK Notions complémentaires Quelques rappels sur les objets Interfaces Classes and Structures Delegates Events Attributs Directives pour le préprocesseur Commentaires en XML Code Unsafe Pour aller plus loin 07/11/2018

Quelques ressources http://msdn.microsoft.com http://windows.oreilly.com/news/hejlsberg_0800.html http://www.csharphelp.com/ http://www.csharp-station.com/ http://www.csharpindex.com/ http://msdn.microsoft.com/msdnmag/ issues/0900/csharp/csharp.asp http://www.hitmill.com/programming/dotNET/csharp.html http://www.c-sharpcorner.com/ http://msdn.microsoft.com/library/ default.asp?URL=/library/dotnet/ csspec/vclrfcsharpspec_Start.htm Le site d’un étudiant de l’ESSI (merci Alain) http://www.essisharp.ht.st/ 07/11/2018