Csharp2014

910 vues

Publié le

Publié dans : Formation
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
910
Sur SlideShare
0
Issues des intégrations
0
Intégrations
5
Actions
Partages
0
Téléchargements
101
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Csharp2014

  1. 1. C# Michel RIVEILL riveill@unice.fr - http://www.essi.fr/~riveill Laboratoire I3S Ecole d’Ingénieur en Sciences Informatiques (ESSI)
  2. 2. 12/03/2014 2 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
  3. 3. 12/03/2014 3 Hello World using System; class Hello { static void Main( ) { Console.WriteLine("Hello world"); Console.ReadLine(); // Hit enter to finish } } csc HelloWorld.cs /reference:System.Windows.Forms.dll
  4. 4. 12/03/2014 4 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
  5. 5. 12/03/2014 5 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
  6. 6. 12/03/2014 6 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
  7. 7. 12/03/2014 7 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
  8. 8. 12/03/2014 8 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
  9. 9. 12/03/2014 9 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
  10. 10. 12/03/2014 10 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
  11. 11. 12/03/2014 11 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"; 123i s "Hello world"
  12. 12. 12/03/2014 12 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 0 null Aliasing (in a scope) No Yes Assignment means Copy data Copy reference
  13. 13. 12/03/2014 13 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
  14. 14. 12/03/2014 14 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
  15. 15. 12/03/2014 15 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 MemoryStream FileStream Stream Hashtable int double object
  16. 16. 12/03/2014 16 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()); } Poly(42); Poly(“abcd”); Poly(12.345678901234m); Poly(new Point(23,45));
  17. 17. 12/03/2014 17 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”
  18. 18. 12/03/2014 18 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”
  19. 19. 12/03/2014 19 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 int i = 123; object o = i; int j = (int)o; 123i o 123j 123 System.Int32
  20. 20. 12/03/2014 20 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) 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);
  21. 21. 12/03/2014 21 Types prédéfinis  Valeur  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
  22. 22. 12/03/2014 22 Types prédéfinis C# Type System Type Size (bytes) Signed? sbyte System.Sbyte 1 Yes short System.Int16 2 Yes int System.Int32 4 Yes long System.Int64 8 Yes byte System.Byte 1 No ushort System.UInt16 2 No uint System.UInt32 4 No ulong System.UInt64 8 No
  23. 23. 12/03/2014 30 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
  24. 24. 12/03/2014 31 Predefined Types Reference Types Root type object Character string string
  25. 25. 12/03/2014 32 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
  26. 26. 12/03/2014 33 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()
  27. 27. 12/03/2014 34 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
  28. 28. 12/03/2014 35 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= “serverfilesharefilename.cs”; string s2 = @“serverfilesharefilename.cs”;
  29. 29. 12/03/2014 36 Types  Types définis par l’utilisateur Enumerations enum Arrays int[], string[] Interface interface Reference type class Value type struct Function pointer delegate
  30. 30. 12/03/2014 37 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  …
  31. 31. 12/03/2014 38 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
  32. 32. 12/03/2014 39 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
  33. 33. 12/03/2014 40 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);
  34. 34. 12/03/2014 41 Types Arrays  Tableau multidimensional  Ré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
  35. 35. 12/03/2014 42 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
  36. 36. 12/03/2014 43 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
  37. 37. 12/03/2014 44 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
  38. 38. 12/03/2014 45 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 20 sp cp 10 20 CPoint
  39. 39. 12/03/2014 46 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
  40. 40. 12/03/2014 47 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
  41. 41. 12/03/2014 48 Structure d’un programme Survol  Organisation des types  Espaces des noms  Références  Méthode principale (main)  Syntaxe
  42. 42. 12/03/2014 49 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
  43. 43. 12/03/2014 50 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
  44. 44. 12/03/2014 51 Structure d’un programme Espaces de noms  Il est toujours possible d’utiliser le nom qualifié  La directive using permet de s’en passer 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 namespace N1 { // N1 class C1 { // N1.C1 class C2 { // N1.C1.C2 } } namespace N2 { // N1.N2 class C2 { // N1.N2.C2 } } }
  45. 45. 12/03/2014 52 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
  46. 46. 12/03/2014 53 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
  47. 47. 12/03/2014 54 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)
  48. 48. 12/03/2014 55 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 ‘@’
  49. 49. 12/03/2014 56 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
  50. 50. 12/03/2014 57 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 void Foo() { i == 1; // error }
  51. 51. 12/03/2014 58 Instructions Survol  Expressions  checked, unchecked  lock  using  Conditionnels  if  Switch  Boucles  while  do  for  foreach  Sauts  break  continue  goto  return  throw  Exceptions  try  throw
  52. 52. 12/03/2014 59 Instructions syntaxe  Instructions terminées par ‘;’  Bloc d’instruction ‘{‘ ... ‘}’ ne nécessite pas de ‘;’  Commentaires  // commentaire sur une seule ligne  /* Commentaire sur plusieurs lignes */ static void Main() { F(); G(); { // Start block H(); ; // Empty statement I(); } // End block }
  53. 53. 12/03/2014 60 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 } }
  54. 54. 12/03/2014 61 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 }
  55. 55. 12/03/2014 62 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; }
  56. 56. 12/03/2014 63 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! }
  57. 57. 12/03/2014 64 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; }
  58. 58. 12/03/2014 65 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; }
  59. 59. 12/03/2014 66 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) { ... }
  60. 60. 12/03/2014 67 Instructions for for (int i=0; i < 5; i++) { ... } for (;;) { ... }
  61. 61. 12/03/2014 68 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); } foreach (Customer c in customers.OrderBy("name")) { if (c.Orders.Count != 0) { ... } }
  62. 62. 12/03/2014 69 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
  63. 63. 12/03/2014 70 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)
  64. 64. 12/03/2014 71 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"); }
  65. 65. 12/03/2014 72 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) { lock (this) { balance -= amount; } } }
  66. 66. 12/03/2014 73 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.
  67. 67. 12/03/2014 74 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
  68. 68. 12/03/2014 75 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
  69. 69. 12/03/2014 76 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);
  70. 70. 12/03/2014 77 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
  71. 71. 12/03/2014 78 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é
  72. 72. 12/03/2014 79 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
  73. 73. 12/03/2014 80 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: %
  74. 74. 12/03/2014 81 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
  75. 75. 12/03/2014 82 Opérateurs Précédence Category Operators Equality Equals: == Not equals: != Bitwise AND & Bitwise XOR ^ Bitwise OR | Logical AND && Logical OR ||
  76. 76. 12/03/2014 83 Opérateurs Précédence Category Operators Ternary conditional ?: Assignment =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
  77. 77. 12/03/2014 84 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 ‘(‘ …’)’
  78. 78. 12/03/2014 85 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
  79. 79. 12/03/2014 86 Using Visual Studio.NET  Types of projects  Console Application  Windows Application  Web Application  Web Service  Windows Service  Class Library  ...
  80. 80. 12/03/2014 87 Using Visual Studio.NET  Windows  Solution Explorer  Class View  Properties  Output  Task List  Object Browser  Server Explorer  Toolbox
  81. 81. 12/03/2014 88 Using Visual Studio.NET  Building  Debugging  Break points  References  Saving
  82. 82. 12/03/2014 89 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
  83. 83. 12/03/2014 90 Using .NET Framework SDK  Compiling from command line csc /r:System.WinForms.dll class1.cs file1.cs
  84. 84. 12/03/2014 91 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
  85. 85. 12/03/2014 92  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 Review Key Object-Oriented Concepts
  86. 86. 12/03/2014 93 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
  87. 87. 12/03/2014 94 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
  88. 88. 12/03/2014 95 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
  89. 89. 12/03/2014 96 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
  90. 90. 12/03/2014 97 public interface IDelete { void Delete(); } public class TextBox : IDelete { public void Delete() { ... } } public class Car : IDelete { public void Delete() { ... } } TextBox tb = new TextBox(); IDelete iDel = tb; iDel.Delete(); Car c = new Car(); iDel = c; iDel.Delete(); Interfaces Example
  91. 91. 12/03/2014 98 interface IControl { void Paint(); } interface IListBox: IControl { void SetItems(string[] items); } interface IComboBox: ITextBox, IListBox { } Interfaces Multiple Inheritance  Classes and structs can inherit from multiple interfaces  Interfaces can inherit from multiple interfaces
  92. 92. 12/03/2014 99 interface IControl { void Delete(); } interface IListBox: IControl { void Delete(); } interface IComboBox: ITextBox, IListBox { void IControl.Delete(); void IListBox.Delete(); } Interfaces Explicit Interface Members  If two interfaces have the same method name, you can explicitly specify interface + method name to disambiguate their implementations
  93. 93. 12/03/2014 100 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
  94. 94. 12/03/2014 101 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
  95. 95. 12/03/2014 102 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 Classes et Structures Différences
  96. 96. 12/03/2014 103 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 Classes et Structures C# Structures vs. C++ Structures  Différent des structures C++
  97. 97. 12/03/2014 104 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(); Classes et Structures Classes
  98. 98. 12/03/2014 105 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 Classes et Structures Structures
  99. 99. 12/03/2014 106 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
  100. 100. 12/03/2014 107 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
  101. 101. 12/03/2014 108 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
  102. 102. 12/03/2014 109 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); } } 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
  103. 103. 12/03/2014 110 class Shape { int x, y; public override string ToString() { return "x=" + x + ",y=" + y; } } class Circle : Shape { int r; public override string ToString() { return base.ToString() + ",r=" + r; } } 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
  104. 104. 12/03/2014 111 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); ... } 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
  105. 105. 12/03/2014 112 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; } }
  106. 106. 12/03/2014 113 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; 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
  107. 107. 12/03/2014 114 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]); 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
  108. 108. 12/03/2014 115 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
  109. 109. 12/03/2014 116 void OutFunction(out int p) { p = 22; } int x; OutFunction(out x); // x is now 22 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
  110. 110. 12/03/2014 117 void Print(int i); void Print(string s); void Print(char c); void Print(float f); // Error: duplicate signature int Print(float f); 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)
  111. 111. 12/03/2014 118 int Sum(params int[] intArr) { int sum = 0; foreach (int i in intArr) sum += i; return sum; } int sum = Sum(13,87,34); 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
  112. 112. 12/03/2014 119 class Foo { public void DoSomething(int i) { ... } } Foo f = new Foo(); f.DoSomething(); 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
  113. 113. 12/03/2014 120 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
  114. 114. 12/03/2014 121 class Shape { public virtual void Draw() { ... } } class Box : Shape { public override void Draw() { ... } } class Sphere : Shape { public override void Draw() { ... } } void HandleShape(Shape s) { s.Draw(); ... } HandleShape(new Box()); HandleShape(new Sphere()); HandleShape(new Shape()); Classes et Structures Méthodes virtuelles
  115. 115. 12/03/2014 122 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
  116. 116. 12/03/2014 123 abstract class Shape { public abstract void Draw(); } class Box : Shape { public override void Draw() { ... } } class Sphere : Shape { public override void Draw() { ... } } void HandleShape(Shape s) { s.Draw(); ... } HandleShape(new Box()); HandleShape(new Sphere()); HandleShape(new Shape()); // Error! Classes et Structures Méthodes abstraites
  117. 117. 12/03/2014 124 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 Derived: Base { // version 1 public virtual void Foo() { Console.WriteLine("Derived.Foo"); } } class Base { // version 1 } class Base { // version 2 public virtual void Foo() { Console.WriteLine("Base.Foo"); } } class Derived: Base { // version 2a new public virtual void Foo() { Console.WriteLine("Derived.Foo"); } } class Derived: Base { // version 2b public override void Foo() { base.Foo(); Console.WriteLine("Derived.Foo"); } }
  118. 118. 12/03/2014 125 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; } } 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()
  119. 119. 12/03/2014 126 class Foo { ~Foo() { Console.WriteLine(“Destroyed {0}”, this); } } 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
  120. 120. 12/03/2014 127 class Car { string vid; public static bool operator ==(Car x, Car y) { return x.vid == y.vid; } } Classes et Structures Surcharge d’opérateur  Opérateur défini par les utilisateurs  Toujours une méthode statique
  121. 121. 12/03/2014 128 Classes et Structures Surcharge d’opérateur + - ! ~ true false ++ --  Opérateur unaire surchargeable  Opérateur binaire surchargeable + - * / ! ~ % & | ^ == != << >> < > <= >=
  122. 122. 12/03/2014 129 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. *=)
  123. 123. 12/03/2014 130 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); } ... }
  124. 124. 12/03/2014 131 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) { return ...; } } Note n = (Note)442.578; double d = n; Classes et Structures Opérateur de conversion  Explicite et implicite conversion définies par l’utilisateur
  125. 125. 12/03/2014 132 public interface IDelete { void Delete(); } public class TextBox : IDelete { public void Delete() { ... } } public class Car : IDelete { public void Delete() { ... } } TextBox tb = new TextBox(); IDelete iDel = tb; iDel.Delete(); Car c = new Car(); iDel = c; iDel.Delete(); Classes et Structures Implementation des interfaces  Peuvent implémenter plusieurs interfaces  Doivent implémenter toutes les méthodes de l’interface héritée
  126. 126. 12/03/2014 133 public interface IDelete { void Delete(); } public interface IFoo { void Delete(); } public class TextBox : IDelete, IFoo { public void IDelete.Delete() { ... } public void IFoo.Delete() { ... } } Classes et Structures Implementation des interfaces  Implémentation explicite des interfaces en cas de collision des noms
  127. 127. 12/03/2014 134 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
  128. 128. 12/03/2014 135 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…
  129. 129. 12/03/2014 136 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
  130. 130. 12/03/2014 137 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);
  131. 131. 12/03/2014 138 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
  132. 132. 12/03/2014 139 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 delegate double Del(double x); // Declare static void DemoDelegates() { Del delInst = new Del(Math.Sin); // Instantiate double x = delInst(1.0); // Invoke }
  133. 133. 12/03/2014 140 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
  134. 134. 12/03/2014 141 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 }
  135. 135. 12/03/2014 142 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
  136. 136. 12/03/2014 143 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
  137. 137. 12/03/2014 144 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
  138. 138. 12/03/2014 145 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); } }
  139. 139. 12/03/2014 146 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); } }
  140. 140. 12/03/2014 147 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
  141. 141. 12/03/2014 148 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
  142. 142. 12/03/2014 149 Attributs [HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)] class SomeClass { [Obsolete(“Use SomeNewMethod instead”)] public void SomeOldMethod() { ... } public string Test([SomeAttr()] string param1) { ... } }
  143. 143. 12/03/2014 150 Attributs 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  Quelques uns des attributs prédéfinis du framework .NET
  144. 144. 12/03/2014 151 Attributs [HelpUrl("http://SomeUrl/MyClass")] class Class1 {} [HelpUrl("http://SomeUrl/MyClass"), 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 ); } }
  145. 145. 12/03/2014 152 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
  146. 146. 12/03/2014 153  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 Directives pour le préprocesseur
  147. 147. 12/03/2014 154 Directives pour le pré processeur Directive 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
  148. 148. 12/03/2014 155 #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”); ... } } Directives pour le pré processeur Compilation conditionnelle
  149. 149. 12/03/2014 156 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
  150. 150. 12/03/2014 157 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
  151. 151. 12/03/2014 158 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
  152. 152. 12/03/2014 159 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) { ; } } Commentaires en XML Csc XmlElement.cs /doc
  153. 153. 12/03/2014 160 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
  154. 154. 12/03/2014 161 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
  155. 155. 12/03/2014 162 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); } Code ‘unsafe’ unsafe void Foo() { char* buf = stackalloc char[256]; for (char* p = buf; p < buf + 256; p++) *p = 0; ... }
  156. 156. 12/03/2014 163 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
  157. 157. 12/03/2014 164 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
  158. 158. 12/03/2014 165 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/

×