A fouiller la multitude de blogs des équipes Microsoft (en passant voici un bon point de départ) on trouve des choses intéressantes.
Comme ce lien vers le blog de Mike Taulty qui fournit une présentation très complète de Silverlight (incluant les features de la v4) en 77 slides très bien fait.
Téléchargement direct des slides (format zip puis pptx, ~12 MO)
Je l’avais annoncé ici : .NET RIA services est devenu WCF RIA Services.
L’objectif de ce projet est de simplifier le développement d’applications RIA.
Le principe général est assez simple :
Je développe des services de domaine (CRUD + Queries) en utilisant des conventions de nommage côté serveur.
Par exemple, la méthode
Sprint LoadSprint(int sprintId)renvoie un sprint d’une application Scrum à partir de son identifiant.
WCF RIA Services projette ce code côté client dans des classes de type DomainContext.
Dans notre exemple, j’obtiens une classe
ScrumDomainContextavec une méthodeEntityQuery<Sprint> LoadSprintQuery(int sprintId)
Projection de code
La version beta est disponible depuis le mois de Novembre. On trouve sur le Web quelques introductions, notamment celles de Brad Abrams. En revanche, on trouve très peu de choses sur comment charger une association dans notre application cliente Silverlight.
Dans mon exemple, je veux afficher une vue Master/Details qui présente un sprint et la liste de ses tâches.
Sprint association
Je dois ensuite décrire à WCF Ria services les associations entre mes entités. Pour cela, je décore les propriétés Tasks de la classe Sprint, et Sprint de la classe Task avec l’annotation AssociationAttribute. Il faut indiquer un nom pour cette association, par exemple Sprint_Tasks et préciser les clés étrangères de chacune de ses relations. Dans le sens Sprint -> Task, la clé c’est le champ Id de la classe Sprint et la clé étrangère c’est le champ SprintId de la classe Task.
public class Sprint{
[Key]
public virtual int Id { get; set; }[Association("Sprint_Task", "Id", "SprintId")]
public virtual ICollection Tasks { get; set; }
}
Quelques remarques :
Il reste enfin à indiquer explicitement que l’on souhaite sérialiser les tâches avec le sprint. Pour cela, nous devons définir une classe de méta données relative à la classe métier. Dans notre exemple, ce sera une classe SprintMetaData définissant un champ Tasks que l’on décore avec l’annotation IncludeAttribute.
public class SprintMetaData {
[Include]
public EntitySet Tasks;
}
Je vous laisse regarder le blog de Brad Adams ou un ancien billet pour les détails de la classe de méta données.
Personnellement je trouve dommage d’avoir à définir une stratégie de chargement dans un fichier de méta données. L’idée générale n’est pas mauvaise, mais présente un inconvénient majeur : la stratégie est valable pour tous les cas d’utilisation. Or il est probable que l’application ne nécessite à la fois le sprint et ses tâches que dans certains écrans …
Si vous utilisez un ORM, n’oubliez pas de récupérer la collection de tâches dans votre requête.
Avec LinqToEntities, ça donne :
public Sprint LoadSprint(int sprintId){
return this.Context.Sprints
.Include("Tasks")
.Where(sprint=>sprint.Id == sprintId);
}
Avec LinqToNhibernate, ça donne:
public Sprint LoadSprint(int sprintId)
{
var result = this.Session.Linq().Expand("Tasks")
.Where(x => x.Id == sprintId)
.ToList().First();
return result;
}
Nous avons vu en détail comment charger une association entre deux entités dans une application WCF Ria Services. Une partie de ces détails est masquée par l’outillage fourni par Microsoft et nous ferait presque oublier la complexité qui ne manquera pas de ressortir si vous souhaitez utiliser cette pile en association avec des outils tel que NHibernate
Microsoft vient publier un nouveau site communautaire dédié à la technologie .NET RIA Services. Ce site regroupe les ressources, discussions et informations indispensables pour bien utiliser ce framework.
http://silverlight.net/riaservices/
RIA Services : The Official Microsoft Silverlight Site
Je l’avais rapidement évoqué dans ce billet. David Rousset le détaille ici.
Si vous cherchez dans Bing avec la requête suivante http://www.bing.com/search?q=pizza+ind%C3%A9cis&filt=all ou dans Google avec http://www.google.fr/search?q=pizza+ind%E9cis, vous allez probablement trouver l’application de David déployée dans le Cloud : http://cloudypizza.cloudapp.net/Pizza.aspx?Name=Pizza+des+indecis#/Pizzas
Si votre navigateur ne supporte pas Silverlight, vous obtiendrez une version Web. Sinon vous obtiendrez grâce au deep-linking une page Silverlight présentant la pizza des indécis.
En fait, c’est très simple: la page Web qui est indexée fournit des informations au PlugIn Silverlight en lui demandant de charger telle ou telle page.
Pour situer le contexte, je réitère l’animation d’un séminaire à l’Université de Savoie sur le même thème que l’an passé : les tests automatisés et l’intégration continue. L’intervention aura lieu le 18 novembre prochain. Je suis donc en pleine phase de revue des différents framewoks de test abordés.
Ma bête noire c’est le test automatisé d’une application de type client lourd, écrite en Winforms, WPF ou plus léger Silverlight. Les solutions open source (et gratuites) sont soit inexistantes soit très pauvres.
Pour peut-être enfin répondre à ce besoin, je regarde actuellement le framework white qui me semble très prometteur: white encapsule la couche UI Automation, l’API d’accessibilité de Microsoft. Quelle que soit la technologie utilisée, on pourrait partir du principe qu’une application accessible est une application testable !
Les premiers tests sur une application école Winform sont assez concluants. Le prochain objectif est clairement d’éprouver cette solution sur une application grandeur nature.
La version finale de Silverlight 3 est disponible. Scott Guthrie l’a annoncé ce matin.
J’ai testé quelques fonctionnalités dans la version beta qui manquaient cruellement dans la version 2:
On peut également noter la possibilité d’utiliser .NET Ria Services.
Avec ces nouveautés, Silverlight devient une vraie alternative à Adobe Flex.
Suite à mon dernier article sur le RIA et la formation en soirée que j’ai animée, j’ai eu quelques questions sur comment exposer un modèle relationnel dans un mode REST en .NET et plus particulièrement pour un client RIA genre Silverlight.
Je vais donc vous proposer une série d’articles sur le sujet.
Le premier présentera ADO.NET Data Services, le framework de Microsoft qui à partir d’un provider LINQ peut exposer votre modèle d’entité sur HTTP dans un mode REST.
A titre d’exemple, je vais utiliser le prototype que j’ai réalisé pour une application traitant de la traçabilité des produits sanguins au CHU de Grenoble. J’ai donc le modèle d’entités suivant:
Modèle d'entités
Depuis Visual Studio, j’ai créé un service ADO.NET Data Services. Je lui ai indiqué mon modèle d’entités et j’ai ajusté les autorisations. La ligne suivante indique que les entités Etat sont accessibles en lecture seule.
config.SetEntitySetAccessRule(« Etat », EntitySetRights.AllRead);
Mon modèle est maintenant accessible sur HTTP. Je peux regarder sa description à l’URI suivante : http://mondomaine.com/DTI.svc/
Le modèle REST exposé par ADO.NET Data Services
Les connaisseurs noteront que la description de notre API utilise Atom Publishing Protocol et Atom Syndication Format.
Je peux maintenant interroger mon modèle en requêtant directement avec mon navigateur. Par exemple, pour avoir toutes les poches, je vais utiliser l’URI http://localhost:2427/DTI.svc/Poche
Personnellement, pour vérifier mes requêtes j’utilise Fiddler. Par défaut, on obtient un feed Atom contenant une collection de poches. ADO.NET Data Services supporte également le format JSON. Si dans Fiddler, vous modifiez le header HTTP Accept avec application/json vous obtiendrez un flux JSON:
Une collection de poches au format JSON
ADO.NET Data Services ne se limite pas à récupérer une collection d’entités. On peut filtrer les entités sur certains critères. Par exemple l’URI http://localhost:2427/DTI.svc/Poche?$filter=NumDon%20%eq%20%12345678 me permet de récupérer la/les poches dont le champ NumDon vaut 12345678. On peut également récupérer les entités associées aux poches. L’URI http://localhost:2427/DTI.svc/Poche?$expand=Tracabilite récupère les poches avec leurs traçabilité sachant qu’une poche peut avoir plusieurs traçabilités.
Les principales fonctionnalités de requêtage sont disponibles: filtre, tri, pagination. Le format des URI est décrit ici
Dans les applications de gestion de données, on ne se limite pas à afficher des données. On souhaite aussi ajouter, modifier, supprimer. Dans le monde REST, on utilise pour cela le verbe HTTP. Par défaut, lorsque vous saisissez une URI dans votre navigateur, c’est le verbe GET qui est utilisé. Mais on peut aussi utiliser les verbes POST, PUT ou DELETE si les conditions d’accès que nous avons définies sur le serveur le permettent.
On peut noter que toute cette API repose sur des standards reconnus: HTTP, Atom, JSON. Elle peut donc être interrogée par n’importe quel client qui supporte ces standards.
Dans le prochain article, j’expliquerai comment interroger cette API à partir d’un client Silverlight et de LINQ For ADO.NET Data Services.
Chose promise, chose due ! Je vous livre mes premières impressions sur les tests que j’ai réalisés avec .NET RIA Services, maintenant renommé WCF RIA Services. Pour l’instant j’ai beaucoup de bonnes surprises…
J’ai commencé par la validation des formulaires.
Je souhaitais vivement regarder la validation des formulaires. L’infrastructure utilisable en Silverlight 2.0 me plaisait beaucoup mais manquait d’une couche d’industrialisation. Pour rappel, cette validation nécessitait les actions suivantes:
Puisqu’on souhaite systématiquement passer dans l’état Erreur du contrôle, on pourrait avoir un contrôle conteneur écrit une fois pour toute qui supporte ce scénario. C’est le DataForm qui est disponible en Silverlight 3.0.
Redéfinir les méthodes set des propriétés des objets sources n’est pas forcément facile lorsqu’on travaille avec des proxies issus d’un WSDL ou d’un service ADO.NET Data Services. Par ailleurs, lorsqu’on a goûté à Hibernate Validator, on aime bien définir les règles de validation avec des annotations. Avec .NET RIA Services, c’est maintenant possible. Il faut définir une méta-classe dans laquelle on définit les règles de validation avec des annotations. En tirant avantage des classes partielles de .NET, on indique la méta classe à utiliser sans risque que le générateur écrase nos modifications. J’entends déjà les puristes se demander pourquoi les annotations ne sont pas directement placées sur les propriétés. C’est justement pour éviter d’avoir des conflits avec le générateur de code. Cette stratégie est très efficace.
La méta classe associée à la classe métier Project
Ces annotations sont définies coté serveur et projetées coté client pendant la phase de compilation du projet. WCF Ria services peut donc exploiter ces annotations coté client pour gérer la validation de surface sans avoir à réaliser un aller-retour sur le middle tier.
Autre dilemme lorsqu’on travaille sur une application de gestion de données en RIA : les données doivent-elles être exposées en mode RESTFull ou en mode SOAP (sous-entendu contrat de service). Très clairement, lorsqu’on travaille sur du CRUD, le RESTFull est très pertinent. Inversement, lorsque les règles métiers sont importantes, le contrat de service a toute sa place. C’est notamment le cas lorsqu’il faut implémenter des règles de validation complexes qui ne dépendent pas seulement des données fournies par l’utilisateur. Il faudrait donc pouvoir passer facilement d’un mode à l’autre. Et bien c’est exactement ce que propose .NET RIA Services. Par défaut les services proposent des CRUD pour chaque entité, et on peut rajouter des opérations taggées Custom. Toutes ces opérations sont réunies dans un service de domaine.
Je n’ai pas encore regardé l’ensemble des possibilités, mais pour l’instant, je retrouve une productivité similaire à une architecture de type client lourd (genre WPF) et ORM (genre Hibernate).
Dans le prochain article, je vous présenterai l’intégration de l’authentification et des autorisations entre Silverlight 3, .NET RIA Services et une application ASP.NET
Ceux qui ont assisté à la formation en soirée sur Silverlight ont eu un avant gout de .NET RIA Services. Ce framework risque de grandement améliorer la productivité des développements d’applications RIA en .NET.
Quelles sont les réponses apportées par ce framework aux problèmes classiques d’applications RIA ?
- Je ne veux pas réécrire des classes de mon domaine (suivant le modèle Value Object)
- Je ne veux pas écrire le code technique de synchronisation des données entre les deux tiers pour de simples manipulations de données (CRUD)
- Je veux pas réécrire des classes Helper
- Je ne veux pas réécrire mes règles de validation décrites par annotations sur les classes de mon domaine
- Je ne veux pas réécrire mes requêtes LINQ
- Je veux pouvoir travailler simplement sur du CRUD ou des services
- Je veux pouvoir me baser sur le mécanisme d’authentification/autorisation défini sur le serveur
Je présenterai plus en détails ce framework dans le wiki ou dans un autre post et vous ferai part de mes premiers essais.
La preview est disponible sur le site de Microsoft. Cette version nécessite Silverlight 3 qui est en beta 1.
Ayant également eu le plaisir de participer aux Tech Days 2009, je vous présente quelques éléments en complément de ceux apportés par Jean-François :
Sync Services for ADO.NET
Tout d’abord une petite précision sur le vocabulaire employé, car la confusion peut vite gagner. Microsoft Sync Framework (MSF) est la plateforme Microsoft de synchronisation permettant la collaboration et le travail en mode déconnecté pour les applications, services et périphériques. Plusieurs fournisseurs de synchronisation (providers) permettent de manipuler ce framework :
La session à laquelle j’ai participé présentait exclusivement le fournisseur Sync Services for ADO.NET. Nous avons pu voir comment élaborer simplement une application permettant de travailler sur une base client en déconnecté à partir d’un laptop et d’un PDA. Au programme : synchronisation des bases, change tracking et résolution des conflits. Je dois bien avouer que l’API et les assistants de Visual Studio permettent d’effectuer toutes ces tâches très simplement !
Pour clore cette session, nous avons même eu droit à une démonstration de la même solution sur un PDA en Java, renforçant ainsi la volonté affichée de Microsoft en matière d’interopérabilité.
WPF et Silverlight 2
Nouveaux fleurons de Microsoft pour le développement d’interfaces utilisateurs riches, les technologies Windows Presentation Foundation (WPF) et Silverlight 2 ont eu, comme nous pouvions nous y attendre, la part belle au cours de ces trois jours.
Comme le disait Jean-François et malgré le discours officiel il semble bien que Microsoft souhaite voir WPF succéder aux Winforms. Aussi, la plupart des démonstrations mettant en jeu une interface graphique ont été réalisées en WPF.
Côté mise eu œuvre, plusieurs sessions traitaient des bonnes pratiques pour la réalisation d’un projet avec ces technologies. De ce côté-là, rien de bien nouveau. Les préconisations sont d’utiliser des design patterns d’interface utilisateur tels que M-V-C, M-V-P et, celui qui est à priori le plus approprié : M-V-VM (Model-View-ViewModel). Ces modèles permettent entre autre de faciliter ce qui constitue la deuxième préconisation : faire des tests !
Donc vous l’aurez compris, l’objectif était surtout de convaincre les frileux et les indécis de franchir le cap du XAML.
C# et LINQ avancé (Geek inside)
Pour terminer, une session que j’ai particulièrement appréciée sur la programmation avancée avec C# et LINQ. Elle était animée par Mitsuru Furuta, une référence dans le monde Microsoft. Au programme : LINQ, generics, inférence de type et expression lambda. L’objectif était de mettre en œuvre efficacement ces concepts au travers de trois exemples utiles. Pour plus d’information, je vous renvoie à son blog où vous pourrez consulter deux de ces exemples :
Derniers commentaires