De Java à .NET

3,022 views
2,989 views

Published on

Des slides de présentation de .NET 4.0 et de divers outils :
- Visual Studio 2010
- C#
- Linq
- Entity Framework
- Windows Phone 7

Published in: Technology, Business
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
3,022
On SlideShare
0
From Embeds
0
Number of Embeds
1,557
Actions
Shares
0
Downloads
69
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

De Java à .NET

  1. 1. .NET Des bases au Framework .NET 4.0
  2. 2. Introduction • Couvre les bases jusqu’à certaines fonctionnalités de .NET 4.0 • Destiné aux habituées de la POO avec de préférence une expérience poussée en C++ ou en Java • Inclus quelques bonus : • Introduction à Linq • Introduction à Entity Framework 4.0 • Introduction à Windows Phone 7 • Introduction au MVVM
  3. 3. GÉNÉRALITÉS
  4. 4. Notion de projet, de solution • Ici la solution est QCMService. • Elle contient 2 projets : • Un projet Data de type ADO.NET EntityFramework • Un projet QCMService de type WCF Service • A la compilation chaque projet est compilé de manière indépendante, puis le projet par défaut est lancé : • Ainsi on peut avoir une solution avec des projets de différents types et langages • Une dll (librairie) est donc générée par projet • Un projet n’est pas au courant du contenu d’un autre projet.
  5. 5. Dépendance de librairie • Pour résoudre les dépendances entre les projet (un projet a besoin de classes d’un autre projet), on utilise la partie Références : • Ici on a référence les dll : • De Microsoft (System.*) • Du projet Data
  6. 6. Dépendance de namespace • Chaque code trouve sa place dans un namespace • Quand écrit un fichier, on utilise le mot clé using pour signifier les namespace dont on dépant • Sans ces using, une classe ne connait que son namespace hôte • Tips • Si on utilise un code dépendant d’un autre namespace, VS ne pourra pas identifier ce code, en revanche il pourra proposer de rajouter automatiquement un using adapté tant que la dépandance de librairie est renseignée • Un clic droit dans le fichier permet de trier et de nettoyer les using qui peuvent s’accumuler
  7. 7. Environnement : VS 2010 • Quelques tips : • Les watchs ou espions • La fenêtre d’exécution • Extensions utiles (impératives) : • Productivity power tools
  8. 8. Environnement : VS 2010 • Quelques raccourcis • On peut définir des régions de code avec : #region ma région // mon code #endregion F1 sur une classe Documentation MSDN CTRL + K,C Commenter CTRL + K,U Décommenter CTRL + K,D Formater « for » + TAB Boucle for « ctor » + TAB Constructeur « prop » + TAB Propriété … …
  9. 9. C# De C++/Java à C#
  10. 10. C# : Conventions • Case Camel/Pascal : • Les mots sont collés et se différentient par l’utilisation de la majuscule • Ce qui est public commence par une Majuscule • class String • public int Value • public void MyFunction() • Un champ privé commence par un underscore et une minuscule • private int _value • Une fonction privée ou une variable locale commence par une minuscule • private void myFunction(int integer)
  11. 11. C# : Commentaires • On n’utilise par les commentaires bloc : /* … */ • On utilise les commentaire // • TOUTE FONCTION DOIT ETRE COMMENTEE à l’aide des commentaires de fonction : /// <summary> /// Return a list of category with the specified parent. /// So, null is for the roots /// </summary> /// <param name="parent">The id of the parent</param> /// <returns>The list of children categories</returns> IEnumerable<CategoryDTO> GetCategories(int? parent); • Astuce : entrez /// au dessus d’une fonction et le commentaire se génère automatiquement
  12. 12. C# : Propriété • C’est un mécanisme souple d’accession à une donnée • On l’apparente à un couple d’accesseurs get/set private bool _loaded; public bool Loaded { get { return _loaded; } set { _loaded = value; } } • On peut même aller plus loins dans la custo public string name { get; private set; }
  13. 13. C# : Typage implicite • On peut éviter la redondance des types à la déclaration grâce au typage implicite var context = new QCMEntities(); • Ici le type est déduit implicitement : context est de type QCMEntities • La compilation remplacera var par le type explicite
  14. 14. C# : le mot clé as • Pour le cast dynamique on pourrait faire : var context = new QCMEntities(); ObjectContext objectContext = null; if (context is ObjectContext) { objectContext = (ObjectContext)context; } • Mais il y a mieux : var context = new QCMEntities(); var objectContext = context as ObjectContext; • Attention, objectContext vaut null si le cast n’est pas possible.
  15. 15. C# : Les types nullables • Un type nullable est un type qui supporte l’assignement à null: • int? a = null; • Nullable<bool> b = null; • MyClass? C = null; • Un type nullable dispose de deux propriétés : • HasValue • Value
  16. 16. C# : Opérateur ?? • Au lieu de : • variable != null ? variable : 1; • Ecrivez : • variable ?? 1;
  17. 17. C# : Initialisation d’objet • On pourrait avoir : var myObject = new MyClass(); myObject.Value = 12; myObject.Name = "Hello"; • On pourrait éviter une telle redondance : var myObject = new MyClass(12, "Hello"); • Mais cela impose la création d’un constructeur adapté à chaque besoins
  18. 18. C# : Initialisation d’objet • En C# on utilisera plutôt cette syntaxe pour éviter de créer trop de constructeurs : var myObject = new MyClass(){ Value = 12, Name = "Hello" } • On peut l’utiliser pour l’initialisation d’éléments énumérables : var tab = new int[]{ 2, 5, 10 }; var list = new List<MyClass>(){ new MyClass(), new MyClass() };
  19. 19. C# : les classes partielles • En C# on peut définir une même classe dans deux fichier différents avec le mot clé partial • Cela sert, par exemple, à avoir une classe partiellement autogénéré mais également spécialisée • Une page WP7 est un exemple de classe partielle • Le xaml d’un coté qui va être interprété pour donner une partie • Le .cs de l’autre qui donne l‘autre partie
  20. 20. C# : Les méthodes d’extension • On peut vouloir ajouter une méthode à une classe sans s’occuper de la dériver car : • Opération couteuse forçant à utiliser manuellement le nouveau type • Nuit à la lisibilité et à la simplicité des classes • Ajouter au type String une méthode de slug public static class Extension { public string Slug(this String s) { s = Regex.Replace(s, @"[^a-z0-9s-]", ""); s = Regex.Replace(s, @"s+", " ").Trim(); s = Regex.Replace(s, @"s", "-"); return s; } } • Il suffit alors que la classe Extension soit chargée pour que la classe String obtienne la méthode Slug (via using)
  21. 21. C# : les méthode d’extension • La classe précédente était statique, ainsi chaque fonction de la classe est statique également : une méthode d’extension doit être statique, peut importe la classe • Il doit toujours y avoir un premier argument, il inclue le mot clé this ainsi que le type qui est étendu • Le prototype complet est donc public static string Slug(this String);
  22. 22. C# : Events • Un évènement basique se déclare comme suit : public event EventHandler LoadingStep; • Il se lance comme ceci : LoadingStep(this, new EventArgs()); • Quand l’évènement est lancé, il va déclencher toutes les fonctions qui lui sont attachées. Celles-ci doivent avoir le prototype suivant : void maFonction(object sender, EventArgs arguments); • On peut modifier le type de l’évènement EventHandler pour supporter un prototype plus spécialisé avec autre chose que EventArgs
  23. 23. C# : Events • On peut s’attacher à un évènement comme ceci : _client.LoadingStep += new EventHandler(Client_LoadingStep); • Ou bien : _client.LoadingStep += Client_LoadingStep; • Ici la fonction Client_LoadingStep sera lancée • On se détache avec l’opérateur -= • Tips, utilisez TAB deux fois successives après avoir tappé += pour créer automatiquement l’attachement ainsi que la fonction
  24. 24. C# : Attributs • Ils servent à ajouter des informations de déclaration au code (classes, méthodes) • Mécanisme similaire aux annotations en Java • Exemple : [System.Serializable] public class SampleClass { // Objects of this type can be serialized. } • Cet objet se voit conféré des propriétés de sérialisation • On peut créer ses propres attributs
  25. 25. C# : les expressions lambda • Une expression lambda est une déclaration allégée d’une fonction anonyme (ou closure) • On la stocke donc dans une délégué (pointeur de fonction) • Example : delegate int del(int i); static void Main(string[] args) { del myDelegate = x => x * x; int j = myDelegate(5); //j = 25 }
  26. 26. C# : les expressions lambda • Stoker une lambda dans une délégué n’est pas toujours pratique • Pour palier on utilise les classes Func<…> et Action<…> qui encapsulent des délégués • Func<…> retourne une valeur • Action<…> ne retourne rien // int comme paramètre, string comme retour Func<int,string> exp1 = (s) => { return s.ToString(); }; // int comme paramètre Action<int> exp2 = (b) => { Console.Out.WriteLine(b); };
  27. 27. C# : les expressions lambda • Une expression lambda tient compte du contexte de déclaration : int a = 20; Action<int> exp = (b) => { a *= b ; }; exp(10); Console.Out.WriteLine(a); // print 200 • Plein de fonctions du Framework attendent une expression lambda : var a = "hello"; var eNumber = a.Count(c => c == 'e'); // eNumber = 1
  28. 28. C# : les expressions lambda • Un autre exemple : var a = "hello"; var vowels = new char[]{ 'a','e','i','o','u','y'}; // numberOfVowels = 2 var numberOfVowels = a.Count(c => vowels.Contains(c));
  29. 29. LINQ Language Integrated Query
  30. 30. Linq : Définition • Linq est une bibliothèque de requêtage amenée par le Framework .NET 3.5 • Elle fonctionne essentiellement par méthodes d’extension sur un type de base IEnumerable<T> • Int[] est un IEnumerable<int> • List<String> est un IEnumerable<String> • Utilisation extensive des expression lambda • La librairie de méthodes d’extension est dans System.Linq
  31. 31. Linq : Select • Sélectionne les éléments d’un objet selon un prédicat • Sélectionner la longueur des chaines de caractère : var tab = new List<String>{ "abc", "Hello", "World" }; var lenghts = tab.Select(s => s.Length); • Mapper : // map : DTO > entity var categories = new List<CategoryDTO>() { new CategoryDTO(), new CategoryDTO() }; var entities = categories.Select(c => new Category() { ID = c.ID, Name = c.Name, Parent_ID = c.ParentID });
  32. 32. Linq : Where • Sélectionne des objets dans l’énumération selon un prédicat • Sélectionner les nombres pairs : var even = tab.Where(i => i % 2 == 0); • Truc compliqué : var entities = categories.Where(c => c.HasChildren && c.P arentID == 3);
  33. 33. Linq : Autres fonctions • OrderBy • ThenBy • Count • First • FirstOrDefault • Join • Single • SingleOrDefault • ToArray • ToList • Contains • …
  34. 34. Linq : Exemple var result = context .Questions .Where(q => q.Questionary_ID == questionary) .Select(q => new QuestionDTO() { Id = q.ID, Label = q.Label, Responses = q.ResponseJeus .Select(r => new ResponseDTO() { Id = r.ID, Label = r.Label, Value = r.Value, IdQuestion = r.Question_ID }) .AsEnumerable(), IdQuestionnary = q.Questionary_ID }) .AsEnumerable();
  35. 35. Linq : syntaxe dédiée • Linq apporte également une syntaxe dédiée var result = from q in context.Questions where q.Questionary_ID == questionary select q; • Cette syntaxe est moins verbeuse • Elle se rapproche du SQL • Elle reste typée et vérifiée à la compilation
  36. 36. ENTITY FRAMEWORK 4.0 ORM
  37. 37. EF4 : Introduction • C’est l’ORM de Microsoft BDD • T-SQL ORM • Entity Framework POO • C#
  38. 38. EF4 : Premiers pas • Créer un EDMX
  39. 39. EF4 : Structure de l’implémentation • C’est un fichier Entity Data Model (le X signifie que c’est un fichier de génération de code) • On trouve donc : • *.edmx fichier représentant le model et le mappage • *.Designer.cs fichier auto-généré depuis le *.edmx • App.Config contient la configuration de la BDD, dont la chaine de connexion • *emdx.sql contient le SQL auto-généré
  40. 40. EF4 : EDMX • Peut être peuplé depuis la ToolBox • Offre deux options : • Générer la base • Générer depuis la base • Supporte : • Héritage • Entity spliting • …
  41. 41. EF4 : Designer • C’est le code généré par le *.edmx • Ne jamais le modifier manuellement ! • Les classes sont partielles • On peut donc les spécialiser sans les dériver
  42. 42. EF4 : Architecture • QCMEntities est un ObjectContext • Il contient les collections des types d’objets présents en base : • Categories • Questions • Questionnaries • Responses • Ce sont des entitées
  43. 43. EF4 : Lecture // get the data context var context = new QCMEntities(); var categories = context.Categories; • Categories est IEnumerable, on peut donc utiliser LinqToSql // get the data context var context = new QCMEntities(); var categories = context.Categories.Where(c => c.ID == 1);
  44. 44. EF4 : Ajout // get the data context var context = new QCMEntities(); context.Categories.AddObject(new Category() { Name = "Ma catégorie" }); context.SaveChanges();
  45. 45. EF4 : SaveChanges • Le contexte traque toute modification sur les entitées qu’il contient • Les entitées sont marqués • Inchangé • Nouveau • Modifié • Supprimé • Les propriétés sont également marqués • SaveChanges met à jour la base de données en rapport avec les modifications traquées sur ses entitées • On essaye de limiter/factoriser son utilisation
  46. 46. EF4 : Modification var context = new QCMEntities(); var category = context.Categories.FirstOrDefault(); if (category != null) category.Name = "New Name"; context.SaveChanges();
  47. 47. EF4 : Supression var context = new QCMEntities(); var category = context.Categories.Single(c => c.Name.Equals("Delete Me") ); context.Categories.DeleteObject(category); context.SaveChanges();
  48. 48. EF4 : LinqToSql • C’est l’implémentation de Linq qui transforme une requête Linq en SQL • La requête SQL est faite tardivement, lors de l’évaluation du résultat • Cela se remarque quand la collection n’est plus IQueryable • Cela permet de spécialiser la requête tardivement et en plusieurs fois, tout en optimisant la transaction
  49. 49. WINDOWS PHONE 7 Silverlight for Windows Phone 7
  50. 50. WP7 : Silverlight and XAP • L’interface est en Silverlight • Le code behind est en C# • Le SDK spécialise Silverlight et l’ensemble du Framework • Une appli WP7 est packagée dans un XAP qui est un zip des sources et des dll
  51. 51. WP7 : WPF • Windows Présenter Fundation se base sur le language XAML (prononcé zammel) • Se base sur le marckup XML • Il permet de : • produire un code intelligible pour un designer • empêcher l’introduction de logique dans la vue • Le XAML est compilé en C# pour produire des classes partielles complétées par le code behind
  52. 52. WP7 : Performance, Threading • Dans un soucis de performance, la pluparts des opérations « couteuses » sont threadées par le Framework • Présence des fonction Async var service = new ServiceReference.ServiceClient(); service.GetCategoriesCompleted += service_GetCategoriesCompleted; service.GetCategoriesAsync(id); • Seul le thread UI peut accéder à l’interface • Présence du Dispatcher void service_GetQuestionariesCompleted(object s, GetQuestionariesCompletedEventArgs e) { Dispatcher.BeginInvoke(() => { QuestionnaryList.ItemsSource = e.Result; }); var service = s as ServiceReference.ServiceClient; service.CloseAsync(); }
  53. 53. WP7 : Demo • Overview • Présentation des contrôles • Création de contrôle personnalisé • Explication des xmlns • Tilt effect • Transition
  54. 54. MVVM Design Pattern
  55. 55. MVVM : Retour sur le MVC • Le MVC divise le code en 3 ensembles logiques • Le modèle manage et contient les données • La vue les affiche • Le contrôleur, organise, accède, sécurise et coordonne Modèle VueContrôleur
  56. 56. MVVM : Les défauts du MVC • Dans les applications à interface riches, des données agrégées par un contrôleur pour un vue sont : • De source multiple • De type multiple • Rendues différemment • Cela amène de la confusion dans le contrôleur, comme dans la vue • De plus, les codes de la vue et du contrôleur deviennent perméables et directement dépendants
  57. 57. MVVM : Apport du modèle de Vue • MVVM : Modèle / Vue / Modèle de Vue • Le modèle de vue est une « spécialisation » du contrôleur, il a entre autre à sa charge de : • Définir les données échangées entre le modèle et la vue • Définir leur formatage • Définir les méthodes d’extraction et de mise à jour
  58. 58. MVVM : Application pratique • .NET 4.0 et Silverlight apportent des interfaces afin d’appliquer le pattern • Le binding : OnTime, OnWay, TwoWay • Associe les champs du modèle de vue à la vue • INotifyPropertyChanged • Permet au modèle de vue de notifier la vue en cas de modification • ObservableCollection<T> • Permet à une collection du modèle de vue de notifier la vue • Présence des Converters
  59. 59. MVVM : Demo • Exemple d’une application Silverlight for Windows Phone 7

×