De Java à .NET

.NETDes bases au Framework .NET 4.0

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

GÉNÉRALITÉS

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.

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

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épandancede librairie est renseignée

• Un clic droit dans le fichier permet de trier et de nettoyer les usingqui peuvent s’accumuler

Environnement : VS 2010

• Quelques tips :

• Les watchs ou espions

• La fenêtre d’exécution

• Extensions utiles (impératives) :

• Productivity power tools

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é

… …

C#De C++/Java à C#

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)

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

C# : Propriété

• C’est un mécanisme souple d’accession à une donnée

• On l’apparente à un couple d’accesseurs get/setprivate bool _loaded;

public bool Loaded {

get { return _loaded; }

set { _loaded = value; }

}

• On peut même aller plus loins dans la custopublic string name { get; private set; }

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

C# : le mot clé as

• Pour le cast dynamique on pourrait faire :


ObjectContext objectContext = null;

if (context is ObjectContext)

{

objectContext = (ObjectContext)context;

}

• Mais il y a mieux :


var objectContext = context as ObjectContext;

• Attention, objectContext vaut null si le cast n’est pas possible.

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

C# : Opérateur ??

• Au lieu de :

• variable != null ? variable : 1;

• Ecrivez :

• variable ?? 1;

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

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()

};

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

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 slugpublic static class Extension{

public string Slug(this String s){

s = Regex.Replace(s, @"[^a-z0-9\s-]", "");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)

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 doncpublic static string Slug(this String);

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 EventHandlerpour supporter un prototype plus spécialisé avec autre chose que EventArgs

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

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

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

}


• 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); };


• 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


• 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));

LINQLanguage Integrated Query

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

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 > entityvar 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

});

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);

Linq : Autres fonctions

• OrderBy

• ThenBy

• Count

• First

• FirstOrDefault

• Join

• Single

• SingleOrDefault

• ToArray

• ToList

• Contains

• …

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();

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

ENTITY FRAMEWORK 4.0ORM

EF4 : Introduction

• C’est l’ORM de Microsoft

BDD

• T-SQL

ORM

• EntityFramework

POO

• C#

EF4 : Premiers pas

• Créer un EDMX

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é

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

• …

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

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

EF4 : Lecture

// get the data context


var categories = context.Categories;

• Categories est IEnumerable, on peut donc utiliser

LinqToSql



var categories = context.Categories.Where(c => c.ID == 1);

EF4 : Ajout



context.Categories.AddObject(new Category()

{

Name = "Ma catégorie"

});

context.SaveChanges();

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

EF4 : Modification


var category = context.Categories.FirstOrDefault();

if (category != null)

category.Name = "New Name";


EF4 : Supression


var category = context.Categories.Single(c =>

c.Name.Equals("Delete Me")

);

context.Categories.DeleteObject(category);


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

WINDOWS PHONE 7Silverlight for Windows Phone 7

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

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

WP7 : Performance, Threading

• Dans un soucis de performance, la pluparts des opérations « couteuses » sont threadées par le Framework

• Présence des fonction Asyncvar service = new ServiceReference.ServiceClient();service.GetCategoriesCompleted += service_GetCategoriesCompleted;service.GetCategoriesAsync(id);

• Seul le thread UI peut accéder à l’interface

• Présence du Dispatchervoid service_GetQuestionariesCompleted(object s, GetQuestionariesCompletedEventArgs e){

Dispatcher.BeginInvoke(() =>{

QuestionnaryList.ItemsSource = e.Result;});var service = s as ServiceReference.ServiceClient;service.CloseAsync();

}

WP7 : Demo

• Overview

• Présentation des contrôles

• Création de contrôle personnalisé

• Explication des xmlns

• Tilt effect

• Transition

MVVMDesign Pattern

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

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

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

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

MVVM : Demo

• Exemple d’une application Silverlight for Windows Phone

7

De Java à .NET

Technology

Transcript of De Java à .NET