Bienvenue à Blogs CodeS-SourceS Identification | Inscription | Aide

Abonnements

Comment utiliser WAQS?

Posts précédents sur WAQS :

WAQS : Introduction

 

WAQS peut être utiliser dans plusieurs cas. Certains de mes clients l’utilisent déjà dans les cas suivants:

  • Application 3-Tiers
  • Application Web application (ASP.NET MVC)
  • Web service

Dans ce post, je vais décrire le scénario 3-Tiers.

 

3-Tiers application:

Les applications 3-Tiers est le scénario par défaut pour lequel WAQS a été développé.

Architecture

La problématique du découpage en couches et de la dépendance

Un premier parti pris de WAQS, c’est d’adopter une architecture en couche (« layered architecture »), un découpage sain, grand classique en entreprise, dans lequel chaque couche a une responsabilité propre et bien définie. Les abstractions entre chaque couche assurent un couplage lâche, pour la flexibilité dans les implémentations et pour une meilleure testabilité.

Il faut insister sur le fait qu’en adoptant cette démarche, WAQS cherche également à réduire la dépendance aux technologies utilisées comme Entity Framwork ou WCF par exemple.

L’architecture de WAQS

Ainsi, l’architecture d’une application « type » réalisée avec la version actuelle de WAQS sera la suivante (avec toutes les briques en bleu foncé générées par WAQS) :

image

Comment générer le code avec WAQS ?

Comme vous pouvez le voir sur le schéma précédent, pour utiliser la version courante de WAQS vous avez besoin d’un edmx. En général c’est la première chose que nous allons faire.

Il est important de noter qu’avec la version courante de WAQS, EF6 n’est pas encore supportée. Il faudra donc utiliser un edmx EF5 ou EF4. Par ailleurs, pour utiliser WAQS, il est obligatoire de garder les deux côtés des relations et d’intégrer la FK au modèle (sauf dans le cas des relations many to many bien entendu).

De plus, malheureusement, le package NuGet actuellement public de Roslyn ne supporte pas les solutions VS 2013. Il faudra donc utiliser VS 2012.

 

Afin de pouvoir générer le code, il faut installer l’extension Visual Studio de WAQS pour la première utilisation.

Pour cela, il suffit d’aller dans le menu Tools/Extensions and Updates. Ensuite il faut rechercher WCFAsyncQueryableServices et l’installer.

 

Une fois cela fait (uniquement la première fois), vous allez pouvoir utiliser les packages NuGet de WAQS.

Pour la partie serveur, vous devez installer le package NuGet WCFAsyncQueryableServices.Server.

Pour cela, vous pouvez taper la commande suivante dans la console NuGet (Package Manager Console):

Install-Package WCFAsyncQueryableServices.Server

A noter que pour la première installation du package par version de WAQS il faut avoir lancé VS avec les droits administrateur. 

L’installation du package ne va pas changer votre projet. Elle va seulement ajouter une nouvelle commande PowerShell dans la console NuGet.

Ensuite, vous pouvez générer le code de WAQS côté serveur en utilisant la commande WCFAsyncQueryableServicesServer.

Par exemple:

WCFAsyncQueryableServicesServer '"C:\VS Projects\WAQSDemo\WAQSDemo.Web\Northwind.edmx"' All

A noter que vous bénéficiez de l’intellisense. Vous pouvez donc vous contentez de taper WCFA<tab> <tab> All.

Il y a plusieurs autres options que “All”. Nous y reviendrons une autre fois.

 

Maintenant que nous avons le code serveur, nous allons nous occuper du code client.

 

Pour le client, il existe deux versions : une version spéciale WPF et une version PCL (avec quelques restrictions mineures) qui est utilisable avec plusieurs types de projets tels que W8, WP8, WPF, SL, mais aussi iOS et Android via Xamarin (certains de mes clients font cela). A noter que WCF n’étant pas complètement supporté par Xamarin il y a des restrictions sur WAQS avec iOS et Android. Néammoins c’est possible.

WPF

Pour le tiers client, nous allons procéder de la même façon que sur le serveur.

Pour commencer nous allons installer le package NuGet :

Install-Package WCFAsyncQueryableServices.Client.WPF

Ensuite, il faut faire attention à sélectionner le bon projet dans la console :

image

 

Puis, vous pouvez lancer la génération côté client en utilisant la nouvelle commande PowerShell (toujours avec l’intellisense) :

WCFAsyncQueryableServicesClientWPF '"C:\VS Projects\WAQSDemo\WAQSDemo.Web\Northwind.edmx"' '"C:\VS Projects\WAQSDemo\WAQSDemo.Web\Northwind.svc"' All

Une fois la génération effectuée, vous pouvez créer une classe pour votre ViewModel.

Par défaut, elle devrait ressembler à ça:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WAQSDemo.Client.WPF
{
    class MainWindowViewModel
    {
    }
}

Le package NuGet a également ajoutée deux autres commandes : WCFAsyncQueryableServicesGlobalClientWPF que nous verrons plus tard et WCFAsyncQueryableServicesApplyViewModelWPF.

Nous allons utiliser cette dernière (toujours avec l’intellisense):

WCFAsyncQueryableServicesApplyViewModelWPF "Northwind" '"C:\VS Projects\WAQSDemo\WAQSDemo.Client.WPF\MainWindow.xaml"'

Après l’avoir exécutée, le code du ViewModel a été mis à jour :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WpfApplication1;
using WpfApplication1.ClientContext;
using WpfApplication1.ClientContext.Interfaces;
using WpfApplication1.ClientContext.Interfaces.Errors;
using WCFAsyncQueryableServices.ClientContext;
using WCFAsyncQueryableServices.ClientContext.Interfaces;
using WCFAsyncQueryableServices.ClientContext.Interfaces.Errors;
using WCFAsyncQueryableServices.ClientContext.Interfaces.Querying;
using WCFAsyncQueryableServices.ComponentModel;
 
namespace WAQSDemo.Client.WPF
{
     public class MainWindowViewModel : ViewModelBase
     {
         private INorthwindClientContext _context;
         public MainWindowViewModel(INorthwindClientContext context): base (context)
         {
             _context = context;
         }
     } }

Et le constructeur de la classe MainWindow (MainWindow.xaml.cs) intègre maintenant le ViewModel :

public MainWindow(WAQSDemo.Client.WPF.MainWindowViewModel vm)
{
     InitializeComponent();
     DataContext = vm; }

Dès lors, depuis le ViewModel, vous pouvez utiliser le champ de type INorthwindClientContext afin de requêter vos données ou persister vos changements et plusieurs autres choses que nous verrons dans des posts futurs.

 

A noter que toutes les requêtes supportées par LINQ To Entities sont utilisables en LINQ To WAQS (vous pouvez même faire plus avec LINQ To WAQS).

LINQ To WAQS est asynchrone. Pour exécuter une requête LINQ To WAQS, vous devez utiliser deux méthodes : AsAsyncQueryable et Execute.

var customers = await (from c in _context.Customers.AsAsyncQueryable()
                       select c).Execute();

PCL

Avec la version courante de WAQS PCL, vous devez obligatoirement sélectionner SL5 et .NET 4.5 (et potentiellement d’autres comme WP8 ou WP7.5 et W8).

Ensuite, c’est encore le même process :

Install-Package WCFAsyncQueryableServices.Client.PCL

WCFAsyncQueryableServicesClientPCL '"C:\VS Projects\WAQSDemo\WAQSDemo.Web\Northwind.edmx"'
'"C:\VS Projects\WAQSDemo\WAQSDemo.Web\Northwind.svc"' All

La seule différence par rapport à l’utilisation de WAQS avec WPF est sur la commande ApplyViewModel car, avec les PCL, elle ne peut pas être associée à une vue :

WCFAsyncQueryableServicesApplyViewModelPCL "Northwind"

Ensuite, il faut gérer soit-même la configuration WCF (qui avait été généré par WAQS dans la version WPF). Si vous avez un App.config sur votre client, vous pouvez l’utiliser pour définir la configuration WCF sinon vous pouvez également le faire par code. Voici un exemple utilisable avec W8 :

Ajouter une méthode SetContext sur la MainPage:

public void SetDataContext(PCLViewModel viewModel)
{
     DataContext = viewModel; }

Puis dans l’App.xaml.cs, vous pouvez utiliser le code suivant :

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
     Frame rootFrame = Window.Current.Content as Frame;
     if (rootFrame == null)
     {
         rootFrame = new Frame();
         Window.Current.Content = rootFrame;
     }
     if (rootFrame.Content == null)
     {
         if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))
         {
             throw new Exception("Failed to create initial page");
         }
         ((MainPage)rootFrame.Content).SetDataContext(GetMainPageDataContext());     }
    Window.Current.Activate(); } private PCLViewModel GetMainPageDataContext() {
     IUnityContainer expressionUnityContainer = new UnityContainer();
     expressionUnityContainer.RegisterType<IExpressionTransformer, ExpressionTransformer>();
     ExpressionTransformerFactory.Factory = () => expressionUnityContainer.Resolve<IExpressionTransformer>();
     IUnityContainer unityContainer = new UnityContainer();
     InitWCFAsyncQueryableServicesModules(unityContainer);
     return unityContainer.Resolve<PCLViewModel>(); } private void InitWCFAsyncQueryableServicesModules(IUnityContainer unityContainer) {
     var binding = new CustomBinding();
     var binaryMessageEncodingBindingElement = new BinaryMessageEncodingBindingElement { MaxSessionSize = int.MaxValue };
     binaryMessageEncodingBindingElement.ReaderQuotas.MaxArrayLength = int.MaxValue;
     binaryMessageEncodingBindingElement.ReaderQuotas.MaxBytesPerRead = int.MaxValue;
     binaryMessageEncodingBindingElement.ReaderQuotas.MaxDepth = int.MaxValue;
     binaryMessageEncodingBindingElement.ReaderQuotas.MaxNameTableCharCount = int.MaxValue;
     binaryMessageEncodingBindingElement.ReaderQuotas.MaxStringContentLength = int.MaxValue;
     binding.Elements.Add(binaryMessageEncodingBindingElement);
     var httpBindingElement = new HttpTransportBindingElement { MaxBufferSize = int.MaxValue,
MaxReceivedMessageSize = int.MaxValue };
     binding.Elements.Add(httpBindingElement);
     var endPointAddress = new EndpointAddress(http://localhost:13117/Northwind.svc);
     unityContainer.RegisterType<INorthwindService, NorthwindServiceClient>(
new InjectionConstructor(binding, endPointAddress));
     unityContainer.RegisterType<INorthwindClientContext, NorthwindClientContext>(); }

 

Si vous avez des commentaires / problèmes, vous pouvez utiliser le site de WAQS sur CodePlex : https://waqs.codeplex.com/

Ce post vous a plu ? Ajoutez le dans vos favoris pour ne pas perdre de temps à le retrouver le jour où vous en aurez besoin :

Publié mardi 17 décembre 2013 10:50 par Matthieu MEZIL

Commentaires

Pas de commentaires

Les commentaires anonymes sont désactivés

Les 10 derniers blogs postés

- Office 365: Script PowerShell pour auditer l’usage des Office Groups de votre tenant par Blog Technique de Romelard Fabrice le 04-26-2019, 11:02

- Office 365: Script PowerShell pour auditer l’usage de Microsoft Teams de votre tenant par Blog Technique de Romelard Fabrice le 04-26-2019, 10:39

- Office 365: Script PowerShell pour auditer l’usage de OneDrive for Business de votre tenant par Blog Technique de Romelard Fabrice le 04-25-2019, 15:13

- Office 365: Script PowerShell pour auditer l’usage de SharePoint Online de votre tenant par Blog Technique de Romelard Fabrice le 02-27-2019, 13:39

- Office 365: Script PowerShell pour auditer l’usage d’Exchange Online de votre tenant par Blog Technique de Romelard Fabrice le 02-25-2019, 15:07

- Office 365: Script PowerShell pour auditer le contenu de son Office 365 Stream Portal par Blog Technique de Romelard Fabrice le 02-21-2019, 17:56

- Office 365: Script PowerShell pour auditer le contenu de son Office 365 Video Portal par Blog Technique de Romelard Fabrice le 02-18-2019, 18:56

- Office 365: Script PowerShell pour extraire les Audit Log basés sur des filtres fournis par Blog Technique de Romelard Fabrice le 01-28-2019, 16:13

- SharePoint Online: Script PowerShell pour désactiver l’Option IRM des sites SPO non autorisés par Blog Technique de Romelard Fabrice le 12-14-2018, 13:01

- SharePoint Online: Script PowerShell pour supprimer une colonne dans tous les sites d’une collection par Blog Technique de Romelard Fabrice le 11-27-2018, 18:01