Programmation événementielle Ing4 SI

1. Programmation événementielleIng4 SI • Cyril CAGNET • Mail: cyril.cagnet@adp.fr • Déroulement des séances de cours: • 4 cours de 3 Heures. • 4 tp de 3 Heures. • 1 Examen sous forme de QCM + 3-4 questions ouvertes.

2. L’Initiative .net

3. Historique des version du framework • 1.0 version beta. • 1.1 premiere version officielle, fourni avec visual studio 2003. • 2.0 • 3.0 Integration des composants de Vista WPF, WCF, WF, card, … • 3.5 Integration de link

4. Volonté de créer un environnement de développement: • Cohérent, • Portable, • Sécurisé, • Extensible.

5. Bibliographie

6. Le .Net Framework Deux principaux composants: • Le CLR (Comon Language Runtime). • Machine virtuelle: Gestion mémoire, compilation du code, gestion des threads, … • La FCL (Framework Class Library). • Bibliothèque de classe: Composants graphiques, Accès aux fichiers XML, Composants web et asp, … Une partie du CLR et de la FCL fut portée comme standard par l’ECMA (European Computer Manufacturers Association) le 13 décenmbre 2001.

7. Fonctionnalités apportées par le couple CLR/FCL • Modèle de programmation cohérent et simplifié. • Garantie d’exécution. • Déploiement simplifié. • Extension aux plates-formes. • Utilisation de types forts (CTS Common Type System) • Ré-utilisation du code simplifié. • Objets auto descriptifs. • Vérification de la fiabilité des types. • Rapports d’échec par exceptions. • Sécurité d’exécution. • Interopérabilité.

8. Interaction entre CLR/CTS et CLS • Le CLS (Common Language Specification) sert à assurer la compatibilité entre les différents langage .Net. • Il s’agit des spécifications minimum que doivent prendre en charge les compilateurs .Net. • CLS est un sous ensemble de CLR/CTS

9. Le langage MSIL • MSIL OU IL (Microsoft Intermediate Language). • Langage de bas niveau conçu pour être interprété par le CLR. • Tous les fichiers compilés génèrent du code IL. • Le code natif n’est créé qu’à l’exécution du code IL.

10. Les Assemblys Les assemblys sont les blocs de construction des applications .NET Framework, ils forment l'unité fondamentale: • De déploiement, • de contrôle de version, • de ré-utilisation, • de portée d'activation et • d'autorisation de sécurité. Un assembly est une collection de types et de ressources qui est générée pour fonctionner ensemble et former une unité logique de fonctionnalités. Un assembly fournit au CLR les informations dont il a besoin pour connaître les implémentations des types. Pour le runtime, un type n'existe pas en dehors du contexte d'un assembly.

11. Structures d’Assemblys Mono et Multi Fichier. Assembly Multi Fichier Assembly mono fichier

12. Etapes de compilation/exécution

13. Les Types • Tous les types sont dérivés de System.Object. • Chaque objet de chaque type dispose donc d’un ensemble minimal de méthodes définies dans Object. • Equals • GetHashCode • ToString • GetType • MemberwiseClone • Finalize

14. Les types Primitifs • Se sont les types les plus courants pour lesquels des alias ont été écrit pour simplifier la lecture et l’écriture du code. • System.Int32 i = new System.Int32(); • Int i = 0; • Attention: tous les types primitifs de C# ne sont pas forcement Compatibles avec le CLS.

15. Liste des Types Primitifs C#

16. Types références • Les types références sont toujours alloués par l’opérateur new qui retourne l’adresse mémoire de l’objet. • La mémoire doit être allouée dans le heap managé. • Il est associé, à chaque objet alloué dans le heap, plus des membres additionnels de marge qui sont initialisés. • L’allocation d’un objet dans le heap peut forcer le nettoyage de la mémoire. Les objets de type classe sont toujours par référence.

17. Les types par valeurs • Les types par valeurs sont généralement alloués dans la pile du thread. • La variable de l’instance ne contient pas de pointeur sur une valeur mais la valeur elle-même. • Les instances de type valeur ne sont pas sous le contrôle du garbage collector. Les objets de type struct et enum sont des objets de type valeur, et sont dérivés System.ValueType. Le passage d’un type valeur en paramètre oblige le CLR à faire une copie de la valeur.

18. Choisir entre un type référence ou valeur • Utiliser les types par valeur ssi toutes les déclarations suivantes sont vérifiées: • Le type agit comme un type primitif. • Le type ne nécessite pas d’héritage d’un autre type. • Aucun autre type n’est dérivé de ce type. • Les instances de ce type ne sont pas fréquemment fournies en paramètres à une méthode. • Les instances de ce type ne sont pas fréquemment retournées par des méthodes. • Les instances de ce type ne sont pas fréquemment utilisées dans des ArrayList, Hashtable,…

19. Compartimentation et décompartimentation • La compartimentation permet de transformer un objet de type valeur en type référence. • Allocation dans le heap managé de l’espace nécessaire pour l’objet valeur + la marge additionnelle. • Copie des champs du type valeur dans la mémoire du heap. • Renvoie de l’adresse de l’objet. Le compilateur C# ce charge de générer automatiquement le code de compartimentation. • La décompartimentation est l’inverse de la compartimentation, mais elle est moins coûteuse car il s’agit uniquement de recopier les champs de la référence dans la pile.

20. Les membre de types • La conception de types avec les différents types de membres qui peuvent être utilisés. • Constantes • Champs • Méthodes • Constructeurs d’instance • Constructeurs de types • Propriétés • Evénements • Types

21. Constantes • La constante est un symbole qui identifie une valeur qui ne change jamais. • Les constantes sont utilisées pour rendre plus lisible le code. • Une constante ne peut prendre qu’un type de type primitif. • Le compilateur remplace le symbole par sa valeur au moment de la compilation. • Une constante prend une valeur dès sa déclaration. • Attention: L’utilisation des constantes doit se limiter au sein de l’assembly, sinon cela risque de causer des effets de bords conséquents.

22. Champs • Un champ est une donnée qui contient une instance de valeur ou de référence. • Le CLR permet l’utilisation de champs statiques et non statiques. • L’utilisation des champs statiques résout le problème rencontré avec les constantes. • Un champ peut être de n’importe quel type. • Le CLR prend en charge les champs en lecture seul.

23. Les méthodes • Types de méthodes: • Constructeurs d’instances. • Constructeurs de types. • Méthodes de surcharge d’opérateur. • Passage de paramètres: • Passage par référence. • Nombre de paramètres variable.

24. Constructeurs d’instance • Méthode qui permet l’initialisation d’une instance. • Tous les champs non initialisés prennent une valeur 0 ou null. • Au moins une méthode constructeur doit être définie. Celle-ci peut être privée. • La majorité des compilateurs crée un constructeur public sans paramètres pour les types références (classe) si aucun constructeur n’est défini. • Un type valeur ne peut définir de constructeur sans arguments.

25. Constructeurs de types • Les constructeurs de types sont des constructeurs statiques (aussi nommés constructeurs de classes). • Les constructeurs de types ne prennent jamais d’arguments. • Les constructeurs de types sont invoqués dés le premier accès au type. • Le constructeur de type ne peut être invoqué qu’une seule fois.

26. Passage de paramètres • Par défaut le CLR ne prend en compte que le passage de paramètres par valeur. • Dans le cas du passage d’un type par référence, le CLR prend en fait la valeur de l’adresse. • L’utilisation des mots clés ref et out indique au CLR que les paramètres sont passés par références.

27. Passage d’un nombre variable de paramètre • Utilisé pour des méthodes pour lesquelles on ne peut définir un nombre fixe de paramètres à passer. • Par exemple System.String fournit des méthodes qui permettent de concaténer un nombre aléatoire de chaînes de caractères. • Pour spécifier au CLR qu’une méthode accepte un nombre variable de paramètres, il faut utiliser le mot clé params dans la définition de la méthode. • Params est obligatoirement appliqué au dernier paramètre de la méthode.

28. Propriétés • Les propriétés permettent au code source d’invoquer une méthode avec une syntaxe simplifiée. • Les propriétés permettent de contrôler les accès aux variables. • Il existe 2 types de propriétés: • Celles sans paramètres qui sont nommées les propriétés. • Celles avec paramètres qui sont nommées les indexeurs en C#;

29. Les Indexeurs Assimilés à des tableaux de propriétés permettant l’accès aux champs d’une classe par index et non par nom. • Une classe peut définir plusieurs indexeurs s’ils ont des prototypes différents. • Utiles pour contrôler le type d’un objet lors d’une affectation.

30. Enumérations et drapeaux Permettent de spécifier une liste de nom fixe au type de l’énumération et de les affecter à un entier. • Rend le code plus facile à maintenir. • Rend le code plus lisible. • Prise en charge par l’intelliSense de VisualStudio.

31. Héritage en c# L’héritage est un mécanisme qui permet d’entendre et d’enrichir des éléments existants afin de les rendre mieux adaptées à un problème donné. • Pas d’héritage multiple en C#. • Seule les classes bénéficient de l’héritage. • Toute classe hérite au moins de Object.

32. Surcharge de méthodes La surcharge de méthode est utilisée pour modifier le comportement par défaut d’une méthode définie dans une classe mère. • Seule les méthodes ‘virtual’ des classes mère peuvent être Surchargées. • La méthode de surcharge doit avoir le même nom et prototype que la méthode mère. • La méthode de surcharge doit être déclarée comme ‘override’. • Les éléments statiques ne peuvent pas être surchargés.

33. Modificateurs d’accessibilité La modification de l’accessibilité permet de définir le comportement et la porté d’un élément avec son environnement (dans la classe ou dans les classes dérivées) • Tous les éléments sont définis avec des modificateurs d’accessibilités. • Si aucun modificateur n’est précisé l’élément est défini comme ‘privé’. • Les modificateurs disponibles sont: • Virtual, // Indique que l’élément surcharge une définition de la classe mère. • Override, // Indique que l’élément peut être surchargé dans une classe fille. • Abstract, // Seul le prototype de l’élément est définie il doit être surchargé dans la classe fille. • Sealed, // Interdit la surcharge de l’élément (par défaut pour les méthodes, mais peut être utilisé dans la surcharge d’une méthode virtual). • Public, // L’élément est accessible de partout. • Private, // L’élément n’est accessible qu’en interne du type dans lequel il est définit (par défaut). • Internal, // Accessible uniquement depuis le même assemblage que l’élément. • Protected. // Accessible uniquement au type qui le défini mais aussi aux types dérivés. • Certain modificateur ne s’utilise pas avec tout les types.

34. Interfaces Les interfaces sont utilisées pour palier le fait que C# ne gère pas l’héritage multiple. Une interface décrit un ‘contrat’ que doivent remplir les classes qui héritent de l’interface. Le contrat défini un ensemble de prototype que doit obligatoirement implémenter la classe qui utilise l’interface. • Contrairement aux classes abstraites les interfaces ne peuvent définir le corps d’un élément. • Une interface n’a pas de constructeur. • Les membres d’une interface sont toujours public. • Ne contient que des signatures (prototypes) de ses membres. • Par convention les noms des interfaces commences par un ‘I’ ex:IEnumerable. • Une classe peut hériter de plusieurs interfaces.

35. destructeurs L’operation de destruction des objets est normalement a la charge du ramasse miettes. Mais elle peut etre forcee par developpeur pour liberer une importante zone memoire inutilisee. • La classe doit implementer la methode Dispose(). • La methode Dispose doit etre appelee explicitement par le code client. • IL faut implementer un destructuteur pour le code non manage. • IL est possible de forcer le GC avec la methode GC.Collect().

36. Exceptions Les exceptions sont un mécanisme utilisé pour garantir au développeur, que tous comportements anormaux du code sera signalé. • Toutes les Exceptions sont dérivées de la classe System.Exception. • Par convention les classes derivees de System.Exception ce nommes MaClasseException. • Il existe deux domaines d’utilisation des exceptions • La levee d’une exception • Et la capture d’une exception • Permet de remettre de systeme dans un etat stable. • Une exception levee ne peut pas etre ignoree sans mettre fin a l’application.

37. La levee d’une exception • Lever une exception signifie que votre programme a effectue une operation non autorisee. • Le programmeur peut declancher la levee d’une exception (throw). • Il est possible de definir un type personnalise d’exception en creant une nouvelle classe derivee de System.Exception

38. la capture d’une exception • Pour traiter une exception il faut la capturer. • La capture d’une exception s’effectue dans un bloque try. • Et le traitement dans un bloque catch • Il peut y avoir plusieurs bloques catch successif.

39. Délégués Les délégués peuvent être vus comme des pointeurs de fonctions. Ils permettent ainsi de définir dynamiquement le comportement de l’application. Pour déclarer un délégué il suffit de spécifier son prototype puis de l’instancier au même titre qu’une classe. • Un délégué peut pointer sur une ou plusieurs fonctions. • Une fonction peut être ajoutée et supprimée à un délégué. • Les délégués sont utilisés par certaines méthodes de classes pour définir le comportement utiliser. (méthodes de tries) • Les délégués sont utilisés pour attacher un comportement à un événement.

40. Evénements Les événements sont le moyen habituel par lequel une application est prévenue lorsqu’une action ou un fait intéressant se produit. • Les événements sont découpés en deux parties: • La partie coté client contient le code répondant à l’émission de l’événement. • La partie coté composant qui se charge de déclancher l’événement. • Il est possible de s’abonner plusieurs fois à un même événement. • Les événements permettent une indépendance entre le code du composant et le code de l’application.

41. Directives processeur Les directives du pré processeur n’interviennent pas dans le comportement du code exécutable, mais affectent le processus de compilation. Cette technique est utilisée pour générer a partir d’un même code source différente version du programme. • #define //Permet de définir un symbole (s’utilise avec #if) • #undef // effet inverse de #define • #if // Si le symbole existe le code sera compilé • #elif // sinon il n’apparaîtra pas dans le code • #else // exécutable comme s’il n’avait pas été écrit. • #endif // Indique la fin d’un bloque #if #elif #else • #warning // Lorsque le compilateur lit cette ligne il va générer un warning dans la console de sortie. • #error // Comme le warning mais génère une erreur de compilation. • #region // Permet dans VisualStudio de définir une zone de • #endregion //code pouvant être réduite, simplifiant du même coups la lisibilité du code source. • #line // Permet de modifier les informations retournée par le compilateur en cas de warning et d erreur.

42. Le multi Threading Un thread est une séquence d’exécution dans un programme. Un même programme peut utiliser plusieurs threads mais un seul thread est créé au lancement du programme par la méthode main. Il est à la charge de développeur de gérer les threads supplémentaires. • Permet l’exécution ‘simultanée’ de plusieurs séquences de code. • Windows gère le multitâche dit préemptif. • Le framework offre des possibilités de contrôles des threads: • Création/ démarrage/ arrêt/ suspension. • Gestion des priorités (5 niveaux définis dans l’enumération ThreadPriority). • Processus de synchronisation (utilisation du mot clé ‘lock’).

43. Accès à la base de registre La base de registre est le point centrale de toutes les informations liées à la configuration de Windows, aux préférences utilisateurs et configuration logiciel. • Les classes utilisant la base de registre sont situées dans le namespace ‘Microsoft.Win32’. • Le framework donne accès au registre au même titre que ‘regedit’ et ‘regedt32’. • L’utilisation de .net a tendance à réduire l’accès au registre (déploiement Xcopy). • Il existe 7 ruches de registres (accessible par la classe ‘Registry’).