Nouveau blog

Vous pouvez désormais me suivre sur mon nouveau blog :

http://blogs.msdn.com/b/audrey

A bientôt !


Classé sous

[WCF RIA Services] Sortie de WCF RIA Services v1.0 SP1


Le 8 Mars fut la sortie (pour les abonnés MSDN, le 10 mars pour le grand public) du Service Pack 1 de Visual Studio 2010. Il faut savoir que ce SP1 comprend aussi la RTM du SP1 de WCF RIA Services v1.0 !

Voici la liste des nouvelles fonctionnalités de ce SP1 :
  • Complex type property validation
  • Code generation with shared files in class libraries
  • VB code generation of complex types
  • VB code generation of EF POCO entities
  • Performance of POST operations
  • Service Activation with both HTTP and another protocol enabled
  • Entity association regressions from V1
  • Entity conflict resolution handling of Timestamp properties
  • IntelliSense Localization into 9 languages
  • Silverlight Business Application project template now uses the Complex Types feature for RegistrationData

Pour plus d'infos je vous conseille d'aller voir le post du blog de Jeff Handley concernant ce SP1 !

Et voici le lien pour télécharger le SP1 de WCF RIA Services v1.0 : ici !



Classé sous

[TechDays 2011] WCF RIA Services de A à Z


Cette année aux TechDays 2011, vous pourrez me retrouver lors de la session WCF RIA Services de A à Z que je co-animerais avec Nicolas Clerc, le mardi 8 février 2011 de 17h30 à 18h30 en salle 251.



En voici un petit résumé : WCF RIA Services est un framework de haut niveau permettant une forte productivité dans l'écriture d'applications RIA métier basées sur Siverlight. Cette session d'introduction vise ainsi les personnes qui n'ont pas encore touché à WCF RIA Services et qui veulent en savoir plus. Vous verrez ainsi la présentation de son fonctionnement et de son architecture, son utilisation avec Silverlight 4 et Entity Framework 4, des exemples ajout/modification/suppression de données, le codage unique des règles de validation, une interface maître-détail, etc. Le tout avec un hébergement possible dans les nuages !

Au programme, des slides, des démos et de la bonne humeur pour finir cette première journée des TechDays !!! Alors venez nombreux ! Smile



[WP7] Utiliser un WrapPanel dans une application Windows Phone 7


Lors de la réalisation de ma 2ème application Windows Phone 7, j'ai souhaité utiliser un WrapPanel pour afficher plusieurs photos. Mais le contrôle WrapPanel ne fait pas parti de la liste des contrôles inclus dans le SDK de la version Beta des outils pour développer sur Windows Phone 7. La version de Silverlight utilisée  est une sorte "d'hybride" entre la version 3 et la version 4. Par conséquent le toolkit de Silverlight 4 ne peut pas fonctionner, il faut donc se tourner vers le toolkit pour Silverlight 3 qui est disponible sur Codeplex.

Pour ceux qui n'ont pas le toolkit pour Silverlight 4 d'installé, voici le lien pour télécharger le toolkit pour Silverlight 3.
Mais pour ceux qui ont déjà installé le toolkit pour Silverlight 4 sur leur PC, ils verront apparaître ce message d'erreur s'ils tentent d'installer le toolkit pour Silverlight 3 :



Deux solutions, soit vous avez la dll du toolkit pour Silverlight 3 qui traine dans un coin, soit vous téléchargez les sources et utiliser les classes correspondant au WrapPanel ou alors vous compilez les sources dans votre Visual Studio préféré, et vous obtiendrez la dll suivante System.Windows.Controls.Toolkit.dll. Cette dll doit être ajoutée au projet Windows Phone 7.
Ensuite, on ajoute une référence à cette dll dans le fichier XAML où l'on souhaite utiliser le WrapPanel :

xmlns:toolkit="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Toolkit"

Puis il suffit d'ajouter le WrapPanel dans le code XAML :

<toolkit:WrapPanel />

Dans mon cas, j'ai utilisé ce contrôle avec une ListBox afin de pouvoir lister des images et les sélectionner :

<phone:PhoneApplicationPage.Resources>
    <DataTemplate x:Key="DataTemplatePhoto">
      <Grid Width="150" Height="150">
        <Image x:Name="imageItem" Margin="5"/>
      </Grid>
    </DataTemplate>
    <ItemsPanelTemplate x:Key="PanelTemplatePhoto">
      <toolkit:WrapPanel />
    </ItemsPanelTemplate>
</phone:PhoneApplicationPage.Resources>

<ListBox x:Name="collectionPhoto" ItemTemplate="{StaticResource DataTemplatePhoto}" ItemsPanel="{StaticResource PanelTemplatePhoto}" />

Et voici le résultat :


[RIA Services] Utilisation des classes Shared pour les metadatas


Avec WCF RIA Services et les DomainServices, le fichier contenant les metadatas est généré à partir des entités choisies dans l'ADO.NET Entity Data Model. Mais si l'on souhaite y ajouter une propriété "FullAddress", par exemple, on se retrouve confronté à l'erreur suivante :

"The associated metadata type for type 'SharedInfos.Web.Customers' contains the following unknown properties or fields: FullAddress. Please make sure that the names of these members match the names of the properties on the main type."

Pour compléter ces metadatas, il existe les classes Shared. Ce fichier avec l'extension .shared.cs (ou .shared.vb) permet de déclarer la classe partielle dans laquelle on souhaite ajouter les propriétés et/ ou les méthodes. Attention le nom du namespace doit bien être celui du projet Web.

namespace SharedInfos.Web
{
  public partial class Customers
  {
     public string FullAddress
     {
       get
       {
          return Address + " " + PostalCode + " " + City;
       }
     }
  }
}


Lors de la compilation, le fichier sera répliqué à l'identique du côté client, ce qui permet de pouvoir accéder à la fois du côté serveur et du côté client aux nouvelles fonctionnalités de la classe Customers.



Et maintenant la propriété "FullAddress" de la classe Customers est accessible :



Ces fichiers sont aussi intéressant pour déclarer les méthodes qui vont permettre d'utiliser des CustomValidations dans nos metadatas par exemple (à suivre dans un prochain article Wink ).

[WP7] AskMe ! Mon application pour le concours de killers-apps Windows Phone 7

Pour ceux qui ne serait pas encore au courant, Microsoft organise un concours de killers-apps Windows Phone 7. Les 10 applications sélectionnées auront la chance d'être présentée devant un jury particulièrement impressionnant :
  • Steve Ballmer, CEO, Microsoft
  • Pierre Olivier Carles, CEO de Kipost et co-fondateur de Labotec, business angel.
  • Jacques Antoine Granjon, Fondateur de Vente-privée.com
  • Ouriel Ohayon,Co- Fondateur d’AppsFire et Co-fondateur du fonds Isai
  • Marc Simoncini, Fondateur et Président de Meetic et du fonds Jaïna
  • Bruno Vanryb, Fondateur et Président d’Avanquest Software
Pour être sélectionné, il suffit de faire une vidéo de son application, de la poster sur la page Facebook Developpeurs et de récoler le plus de "like" afin de se retrouver parmi le top 10.

Pour ma part, j'ai développé une application qui se nomme AskMe ! Cette application permet d'obtenir une réponse à une question qu'on lui pose en secouant le téléphone. La boule de billard 8 apparait à l'écran et c'est à elle qu'il faut poser la question. Ensuite, il suffit de sécouer le téléphone afin que la boule parcours l'écran, et la réponse apparaîtra. Attention, la boule a aussi ses humeurs, la réponse peut être claire comme totalement évasive Wink

Si vous aimez et que vous êtes sur Facebook, alors n'hésitez pas à "liker" la vidéo de mon application AskMe :
http://tinyurl.com/askmeappwp7

Merci ! Smile

Voici la vidéo de mon application :

[WP7] Ajouter des images dans la Media Library d'un Windows Phone 7

L'émulateur Windows Phone 7, fourni avec la version Beta des outils développeurs n'inclut aucune image dans sa bibliothèque. Pas très pratique de tester son application lorsque l'on souhaite que l'utilisateur puisse choisir une image présente dans le téléphone.
Voici un bout de code qui va vous permettre d'ajouter des images dans l'émulateur, à noter que ces images restent présentes tant que vous ne fermez pas l'émulateur.

Voici ce que l'on obtient si on regarde dans l'émulateur WP7 :



Tout d'abord dans son projet, il faut ajouter la référence à l'assembly Microsoft.Xna.Framework.Media, qui va nous permettre d'atteindre la MediaLibrary et de pouvoir sauvegarder des images avec la méthode SavePicture:

using Microsoft.Xna.Framework.Media;

Créer un répertoire "Images" dans son projet, ajouter les photos que l'on souhaite à l'intérieur et leurs attribuer les propriétés suivantes :



Ensuite, le code à ajouter dans son projet :

MediaLibrary myMediaLibrary = new MediaLibrary();
Uri myUri = new Uri(@"Images/Jellyfish.jpg", UriKind.Relative);

System.IO.Stream photoStream = App.GetResourceStream(myUri).Stream;
byte[] buffer = new byte[photoStream.Length];

photoStream.Read(buffer, 0, Convert.ToInt32(photoStream.Length));
myMediaLibrary.SavePicture("Jellyfish.jpg", buffer);


Enfin, après avoir ajouté quelques photos à l'émulateur WP7 voici ce que l'on obtient :



Classé sous , , ,

[RIA Services] HTTPS et DomainService


Comme vu dans un précédent post, il est possible avec WCF RIA Services, de gérer l'authentification Forms ou Windows pour accéder à notre application. Il faut savoir qu'il est aussi possible de sécuriser le transfert des données en les cryptant grâce au HTTPS.

De base les échanges dans le navigateur s'effectue en HTTP, mais il est possible de préciser dans le code que l'application ne peut communiquer qu'en utilisant le protocole HTTPS. Pour cela, il faut renseigner le tag EnableClientAccess au niveau du DomainService :

[EnableClientAccess(RequiresSecureEndpoint = true)]
public class CustomerDomainService : LinqToEntitiesDomainService<NorthwindEntities>

Pour tester notre application et vérifier qu'elle n'autorise que le protocole HTTPS, nous allons la déployer en local et modifier la configuration de IIS afin de pouvoir l'interroger en HTTPS.

Tout d'abord il faut générer un certificat auto-signé afin de pouvoir l'associer avec notre connexion HTTPS, pour cela dans IIS, cliquer sur "Server Certificates" et sur "Create Self-Signed Certificate..." :



Dans IIS après avoir sélectionné notre Web Site "DemoSL", en cliquant sur "Bindings", une fenêtre s'ouvre et indique que notre Web Site peut être atteint en HTTP via le port 80 à l'adresse www.demoSL.com :



Il faut configurer un nouveau binding afin d'autoriser l'HTTPS, en choisissant dans la liste déroulante type "https" et dans "SSL certificate" le certificat généré auparavant :



Ensuite on peut voir sur l'interface IIS de notre Web Site qu'il existe maintenant 2 chemins pour atteindre notre application Silverlight, un en HTTP et un en HTTPS :



Une dernière étape consiste à modifier les propriétés SSL de notre Web Site :



Maintenant nous pouvons tester notre application.

Si l'on appelle notre application dans un navigateur internet en HTTP, on obtient cette page avec une erreur 403.4 qui nous indique que cette page doit être interrogée en HTTPS avec du SSL :



Et si l'on teste, en appelant notre application en HTTPS, on obtient tout d'abord cette page :



Comme il s'agit du certificat auto-signé que l'on a généré auparavant et non d'un certificat délivré par une autorité de certification, le navigateur nous demande confirmation pour accéder à notre application. En cliquant sur "Continue to this website", on obtient enfin notre application :


[IIS] Déployer en local une application Silverlight 4 et WCF RIA Services


Pour les besoins de tests d'un prochain article, j'ai souhaité déployer en local sur ma machine une application Silverlight 4 utilisant WCF RIA Services. Voici les étapes à ne pas oublier avec IIS pour que ce déploiement se passe bien.

Tout d'abord il faut vérifier que votre IIS contient un Application Pool avec le Framework 4.0. Si ce n'est pas le cas et que le Framework 4.0 n'est pas disponible dans les versions proposées, il faut se positionner dans le répertoire suivant en ligne de commande : 
C:\Windows\Microsoft.NET\Framework\v4.0.30319

et exécuter cette commande (pour plus d'infos sur cet exécutable) :
aspnet_regiis.exe -iru

Il est maintenant possible de créer un Application Pool avec la version 4.0 du Framework .NET avec le mode "Integrated" pour le "Managed pipeline mode" :



Dans les propriétés de l'Application Pool, il faut modifier le "Identity" du "Process Model" et lui attribuer la valeur "LocalSystem" :



Ensuite, il faut créer le Site web dans l'interface de IIS en lui indiquant les informations suivantes :
  • son nom,
  • l'Application Pool que l'on vient de créer,
  • le répertoire dans lequel se trouvera notre application,
  • son URL (à ajouter dans le fichier hosts se trouvant dans le répertoire C:\Windows\System32\drivers\etc)


Une fois le site créé, il faut modifier le type d'authentification est mettre à la valeur "Enabled" l' "Anonymous Authentication" et à "Disabled" les 2 autres :

 

Ensuite il faut vérifier les MIME Types afin d'être sur que l'extension .xap soit bien prise en charge :



Et enfin ajouter les pages de démarrage de l'application dans les pages par défaut (ou renommer dans l'application les pages en index.html et index.aspx) :



Pour publier notre application, dans Visual Studio 2010, il faut faire un clic-droit sur le projet Web de notre solution et cliquer sur "Publish". Dans la boîte de dialogue qui apparaît, "Publish method" doit être à "File System", et "Target Location" doit être renseigné avec le répertoire dans lequel on souhaite publier notre application (répertoire qui doit être le même que l'on a auparavant spécifié dans le Site web créé dans IIS) :



On peut maintenant ouvrir un navigateur web et taper l'URL : http://www.demosl.com et voir s'exécuter notre application :


[SketchFlow] Convertir des Feedbacks en Work Items pour TFS


Contenu dans Expression Blend 4, SketchFlow permet de construire (grâce à WPF ou Silverlight) des prototypes d'applications permettant de définir avec précision, en collaboration avec le client, la navigation et les fonctionnalités d'une future application.

Grâce à l'interface utilisateur qui exécute la solution SketchFlow, le client peut annoter chaque écran, et commenter grâce à des feedbacks ce qui doit être ajouté, modifié, supprimé. Le client exporte ensuite tous ces feedbacks sous la forme d'un fichier ayant pour extension .feedback et fournit ce fichier à l'équipe de développeurs. Ce fichier est alors importé dans Blend afin de pouvoir afficher toutes les remarques clientes.

Chaque feedback peut être converti en Work Item pour TFS, pour cela il faut faire un clic-droit sur chaque item et cliquer sur "Convert Feedback into TFS Work Item" :




Il faut ensuite sélectionner le type de Work Item que l'on souhaite créer ("Task" dans notre exemple) :




Il est possible de compléter les informations que va contenir ce nouveau Work Item grâce à l'interface suivante :



Et une fois que le Work Item est sauvegardé, une boîte de dialogue apparait avec son numéro d'identifiant, et un lien permettant de le visualiser :



Et si l'on regarde dans TFS, on peut effectivement afficher le Work Item issu du Feedback de SketchFlow :



Classé sous , ,

[Silverlight] Trois nouveaux templates pour les applications Silverlight

Trois nouveaux templates sont disponibles pour les applications Silverlight, à la fois pour les Silverlight Business Application et pour les Silverlight Navigation Application. De plus les éléments de style de ces nouveaux thèmes sont aussi téléchargeables pour les utiliser dans tout type d'application Silverlight. Ces nouveaux thèmes incluent aussi les nouveaux RIA Services templates.

Les trois nouveaux templates sont les suivants :




Ils sont téléchargeables à cette adresse, et ces templates sont disponibles et installables à la fois pour Visual Studio 2010 : 



et Expression Blend 4 :


[OData] Open Data Protocol Visualizer Extension pour Visual Studio 2010

Dans un de mes précédents articles, j'utilisais OData dans un projet Silverlight 4. L'ajout du flux de données était possible grâce à l'ajout d'un Service Reference. Plusieurs fichiers étaient créés dont un edmx, mais lorsque l'on souhaitait le visualiser on pouvait voir ce message s'afficher :



Une extension pour Visual Studio 2010 est disponible permettant de visualiser sous forme de diagramme les entités exposées par un flux OData, il s'agit de l'Open Data Protocol Visualizer Extension for VS2010. Elle s'installe dans Visual Studio 2010 grâce à l'Extension Manager qui se trouve dans le menu Tools :



Une fenêtre s'ouvre et permet de visualiser toutes les extensions disponibles. Dans notre cas, il faut choisir Open Data Protocol Visualizer puis cliquer sur le bouton "Download". Lorsque l'installation est terminée, cliquer sur le bouton "Restart now" qui va permettre de redémarrer Visual Studio 2010 afin d'activer l'extension installée :



Maintenant lorsque l'on souhaite ouvrir l'edmx avec l'extension installée on obtient ceci :



Un récapitulatif nous informe des différents éléments présents dans notre diagramme. Pour tout visualiser, nous allons cliquer sur "add all" pour les Namespaces. Et voici ce que l'on obtient, la totalité des entités reliées par leurs associations les unes aux autres :



Il est possible de visualiser le diagramme en entier ou seulement une partie en choisissant les entités (par du drag & drop depuis le Open Data Protocol Model Browser) que l'on souhaite afficher, comme par exemple les entités Customers et Orders :



A partir du diagramme, il est aussi possible d'accèder directement au code généré dans le fichier "reference.cs" en faisant un clic-droit  "View Generated Code" sur l'entité que l'on souhaite visualiser. Une autre fonctionnalité permet de faire un export au format XPS du diagramme présent dans la fenêtre de Visual Studio 2010.

Pour plus d'infos, voici une vidéo de la chaîne ODataPrimer :


Classé sous ,

[RIA Services] Sortie de la Release de WCF RIA Services v1.0 !

WCF RIA Services v1.0 vient de sortir en Release



Vous pouvez la télécharger avec le Silverlight 4 Tools for Visual Studio 2010  ou si vous avez déjà installer les outils pour Silverlight 4, vous pouvez seulement télécharger WCF RIA Services V1.0 for Silverlight 4 and Visual Studio 2010.

Pour plus d'infos : http://www.silverlight.net/getstarted/riaservices/ mais aussi le post de John Papa.


Classé sous

[OData] Le OData RoadShow débarque à Paris le 17 juin 2010 !


Une journée à noter sur vos agendas !

Rendez-vous le jeudi 17 juin 2010 à Paris, pour l'étape parisienne du OData RoadShow. Les speakers seront Douglas Purdy (CTO, Data and Modeling in Microsoft’s Business Platform Division) et Jonathan Carter (Technical Evangelist in Microsoft's Developer & Platform Evangelism group) pour cette journée dédiée à OData.

OData Logo

L'agenda sera décomposé en 2 parties :
  • le matin : 5 sessions autour de OData.
  • l'après-midi : des discussions autour de tables rondes, des labs permettant de coder autour de OData et la possibilité de montrer vos projets mettant en oeuvre OData.

Pour plus d'infos et pour s'inscrire à cette journée : http://www.odata.org/roadshow

Classé sous

[OData] Utiliser des données OData avec WCF Data Services et Silverlight 4


Comme vu dans un précédent post, OData (Open Data Protocol) est un protocole qui permet d'exposer des données via HTTP, qui se base sur l'architecture REST et qui fournit des données en XML formatées en ATOM ou JSON. WCF Data Services inclus dans Silverlight 4 va nous permettre d'exploiter ces données exposées par OData.

Le but est de faire une application Silverlight 4 de type Maître - Détail avec une ComboBox qui permet de choisir un client et une DataGrid qui permet d'afficher les commandes de ce client. Pour cela, nous allons utiliser les tables Customers et Orders du flux OData de Northwind qui se trouve à cette adresse : http://services.odata.org/Northwind/Northwind.svc/

Voici ce qu'expose le flux OData de Northwind :

OData Northwind

On crée une solution Silverlight 4, et on ajoute au projet Client une référence au service contenant le flux de données OData de Northwind. Pour cela, nous allons utiliser WCF Data Services. Un clic-droit sur le projet Silverlight, puis cliquer sur "Add Service Reference". Une boîte de dialogue apparait et dans le champ "Address", on renseigne l'adresse de notre flux OData mentionné plus haut et on clique sur le bouton "Go" pour vérifier ce qu'expose ce service.

Add Service Reference

Après avoir cliqué sur le bouton "Ok", on peut observer les éléments de notre solution et en afficher les fichiers cachés. On constate que WCF Data Services nous a ajouté 3 nouveaux fichiers :
  • Reference.datasvcmap : qui est un fichier de configuration rassemblant les informations concernant notre service.
  • Reference.cs : qui contient toutes les propriétés et méthodes générées à partir de notre flux.
  • service.edmx : qui contient sous la forme d'un Entity Data Model toutes les informations de notre base de données contenues dans notre flux.
Solution OData

Ensuite on peut construire notre interface en XAML qui va nous permettre d'afficher nos données avec un contrôle ComboBox et un contrôle DataGrid :

<UserControl.Resources>
  <DataTemplate x:Key="DataTemplateComboBoxItelCustomers">
    <TextBlock Text="{Binding ContactName}" />
  </DataTemplate>
</UserControl.Resources>

<Grid x:Name="LayoutRoot" Background="White" >
  <Grid.RowDefinitions>
    <RowDefinition Height="40" />
    <RowDefinition Height="*" />
  </Grid.RowDefinitions>
  <ComboBox Grid.Row="0" ItemTemplate="{StaticResource DataTemplateComboBoxItelCustomers}" Name="cbCustomers"     
   SelectionChanged="cbCustomers_SelectionChanged" />

  <sdk:DataGrid AutoGenerateColumns="True" Grid.Row="1" Name="dgOrders" />
</Grid>

Du côté du code-behind, on déclare les membres suivant qui vont nous permettre d'utiliser les données de notre service :

private DataServiceCollection<Customer> _customers;
private DataServiceCollection<Order> _orders;
private Customer _selectedCustomer;
private NorthwindEntities _context;



Puis dans le Loaded de notre User Control, on initialise notre context avec notre service et on initialise les objets qui vont nous permettre de stocker les données concernant les Customers et Orders avec des DataServiceCollection grâce à WCF Data Services. Une requête Linq va sélectionner tous les Customers et les ordonner par leur ContactName. Et enfin on appelle la méthode LoadSync afin de récupérer les données grâce à notre requête Linq :

_context = new NorthwindEntities(new Uri("http://services.odata.org/Northwind/Northwind.svc/"));

_customers = new DataServiceCollection<Customer>();
_customers.LoadCompleted += new EventHandler<LoadCompletedEventArgs>(_customers_LoadCompleted);

_orders = new DataServiceCollection<Order>();
_orders.LoadCompleted += new EventHandler<LoadCompletedEventArgs>(_orders_LoadCompleted);

var query = from g in _context.Customers
            orderby g.ContactName
            select g;
_customers.LoadAsync(query);



Lorsque la méthode LoadAsync est appelée, l'événement LoadCompleted est appelé ce qui va nous permettre de savoir lorsque le chargement des données est terminé afin de binder les données à nos contrôles :

void _customers_LoadCompleted(object sender, LoadCompletedEventArgs e)
{
  if (_customers.Continuation != null)
  {
     _customers.LoadNextPartialSetAsync();
  }
  else
  {
     cbCustomers.ItemsSource = _customers;
     cbCustomers.UpdateLayout();
     cbCustomers.SelectedIndex = 0;
  }
}

void _orders_LoadCompleted(object sender, LoadCompletedEventArgs e)
{
  if (_orders.Continuation != null)
  {
     _orders.LoadNextPartialSetAsync();
  }
  else
  {
     dgOrders.ItemsSource = _orders;
     dgOrders.UpdateLayout();
  }
}



Ensuite dans le SelectionChanged de la ComboBox contenant les Customers, lorsque l'utilisateur choisi un client, son CustomerID va nous servir dans une requête Linq pour sélectionner les commandes lui correspondant. La méthode LoadAsync va nous permettre de charger ses données :

_orders.Clear();
_selectedCustomer = cbCustomers.SelectedItem as Customer;

if (_selectedCustomer != null)
{
   var query = from g in _context.Orders
               where g.CustomerID == _selectedCustomer.CustomerID
               select g;
   _orders.LoadAsync(query);
}



Et voici ce que l'on obtient au final :


[RIA Services] Authentication Domain Service et Authentification Windows


Lors du développement d'une application Silverlight pour un client, s'est posé la question de l'authentification. La grande majorité de leurs applications fonctionnent avec une authentification Windows suivant les rôles attribués aux utilisateurs dans l'Active Directory. Pour en faire de même avec mon application Silverlight, j'ai utilisé l'Authentication Domain Service.

Dans le projet Web, il faut ajouter un nouvel élément, un Authentication Domain Service :



Deux classes sont alors créées :

[EnableClientAccess]
public class AuthenticationDomainService : AuthenticationBase<User>
{
   // To enable Forms/Windows Authentication for the Web Application,
   // edit the appropriate section of web.config file.
}

public class User : UserBase
{
   // NOTE: Profile properties can be added here
   // To enable profiles, edit the appropriate section of web.config file.

   // public string MyProfileProperty { get; set; }
}
  • AuthenticationDomainService (qui hérite de AuthenticationBase<User>) : qui va contenir les informations d'authentification
  • User (qui hérite de UserBase) : qui va contenir les informations de l'utilisateur
Il faut alors compiler le projet Web, afin que le code soit généré du côté Silverlight.

Ensuite il faut modifier le Web.config de notre projet Web pour lui indiquer que l'on souhaite faire de l'authentification Windows, et ajouter le provider "WindowsTokenRoleProvider" pour récupérer les informations concernant les rôles des utilisateurs Windows :

<system.web>

  <authentication mode="Windows" />

  <roleManager defaultProvider="WindowsProvider" enabled="true" cacheRolesInCookie="false">
     <providers>
         <add name="WindowsProvider" type="System.Web.Security.WindowsTokenRoleProvider" />
     </providers>
  </roleManager>

</system.web>


Puis modifier, le App.xaml.cs du côté du projet Silverlight pour lui indiquer que l'on souhaite utiliser notre WebContext avec une authentification Windows :

WebContext webContext = new WebContext();
webContext.Authentication = new WindowsAuthentication();
this.ApplicationLifetimeObjects.Add(webContext);

Et enfin, on peut récupérer les informations de l'utilisateur dans notre MainPage.xaml.cs en utilisant la méthode "LoadUser", et ensuite la méthode "IsInRole" pour vérifier si l'utilisateur possède le rôle souhaité :

WebContext.Current.Authentication.LoadUser().Completed += (s, args) =>
{
   User myUser = WebContext.Current.User;
   if (myUser.IsInRole("Everyone"))
   {
       string name = myUser.Name;
   }

}

Et voici les informations que l'on obtient pour l'utilisateur authentifié dans cette session Windows :


[OData] Créer et exposer son propre flux OData

OData (Open Data Protocol) est un protocole qui permet d'exposer des données via HTTP pour différents types de clients (RIA, Web, Mobile, etc...) afin de pouvoir utiliser et modifier ces données à distance. Ces données sont alors requêtable avec Linq depuis le client.

Grâce à WCF RIA Services, il est possible d'exposer ses propres données facilement. Lors de l'ajout d'un DomainService, il suffit de cocher la case "Expose OData endpoint", et les données des tables sélectionnées pourront être exposées. Dans notre exemple, on utilise les tables Customers et Orders de la base de données Northwind.




Le fait de cocher cette case apporte les modifications suivantes à notre code :
  • Dans le DomainService, chaque méthode sans paramètre possède désormais un tag :
[Query(IsDefault = true)]
public IQueryable<Customers> GetCustomers()
{
  return this.ObjectContext.Customers;
}


  • Dans le Web.Config, un endpoints est ajouté dans les domainServices :
<system.serviceModel>
  <domainServices>
      <endpoints>
         <add name="OData"
              type="System.ServiceModel.DomainServices.Hosting.ODataEndpointFactory,
                    System.ServiceModel.DomainServices.Hosting.OData,
                    Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
/>
      </endpoints>
  </domainServices>
</system.serviceModel>



Il suffit ensuite de lancer l'application, et dans le navigateur Internet d'appeler l'adresse qui est composée de cette façon :

http://localhost:1234/NomDeLaSolution-Web-NomDuDomainService.svc/OData/

A noter que si le nom de votre solution et/ou de votre DomainService contiennent des points ".", il faut les remplacer par des tirets "-".

Dans notre exemple cela donne cette adresse : http://localhost:2321/RIAOData-Web-NorthwindService.svc/OData/

Et l'on obtient la liste de l'ensemble de tables que l'on avait sélectionné auparavant :




Si l'on souhaite consulter les données d'une table, Customers par exemple, il suffit de compléter l'adresse avec le nom de la table que l'on souhaite parcourir : 

http://localhost:1234/NomDeLaSolution-Web-DomainService.svc/OData/CustomersSet/

Comme les données sont formatées au format ATOM, le navigateur essaye de les afficher comme un flux RSS. Il suffit alors de faire un clic-droit sur la page et de demander à afficher la source de la page pour voir apparaître les données de la table Customers :



Pour voir plusieurs types de données exposés grâce à OData, une liste de quelques flux est disponible sur le site OData.

[RIA Services] DomainDataSource et Insert / Update / Delete des données

Dans mes précédents articles, il a toujours été question d'afficher / sélectionner / trier des données. Maintenant nous allons voir comment insérer / mettre à jour / supprimer des données. Pour les exemples, j'ai utilisé la table Customers de la base de données Northwind.

Voici le DomainDataSource utilisé pour notre exemple qui charge tous les customers de la table avec la méthode "GetCustomersQuery" :

<riaControls:DomainDataSource AutoLoad="true" Name="customersDomainDataSource" QueryName="GetCustomersQuery" >
   <riaControls:DomainDataSource.DomainContext>
       <my:NorthwindContext />
   </riaControls:DomainDataSource.DomainContext>
</riaControls:DomainDataSource>



Insert :

Voici l'interface pour ajouter un nouveau Customer :

Add Customer

Lorsque l'utilisateur clique sur le bouton OK après avoir correctement rempli le formulaire, un nouveau customer est créé grâce à la méthode Add et ensuite il est validé avec la méthode SubmitChanges qui permet de répercuter l'ajout jusque dans la base de données :

private void OKButton_Click(object sender, RoutedEventArgs e)
{
  (customersDomainDataSource.DomainContext as NorthwindContext).Customers.Add(new Customers()
  {
     Address = addressTextBox.Text,
     City = cityTextBox.Text,
     CompanyName = companyNameTextBox.Text,
     ContactName = contactNameTextBox.Text,

     ContactTitle = contactTitleTextBox.Text,
     Country = countryTextBox.Text,
     CustomerID = customerIDTextBox.Text,
     Fax = faxTextBox.Text,
     Phone = phoneTextBox.Text,
     PostalCode = postalCodeTextBox.Text,
     Region = regionTextBox.Text
  });
 
  customersDomainDataSource.DomainContext.SubmitChanges();
}


Update :

Voici l'interface permettant de visualiser les données de notre table Customers, et un formulaire permettant de modifier ses données avec un bouton OK pour valider les modifications, un bouton Ajouter pour afficher l'interface vu ci-dessus, et un bouton Supprimer pour supprimer le customer sélectionné :

Update Delete Customer

Voici le code pour le bouton OK permettant de mettre à jour les données du customer sélectionné et modifiées dans le formulaire. La méthode SubmitChanges valide ces modifications et les appliquent dans la base de données :

private void btn_Ok_Click(object sender, RoutedEventArgs e)
{
   customersDomainDataSource.DomainContext.SubmitChanges();
}



Delete :

En appuyant sur le bouton Supprimer, on souhaite supprimer le customer sélectionné. La méthode Remove permet de le supprimer et la méthode SubmitChanges permet de valider cette modification et de propager cette modification dans la base de données.

private void btn_Supp_Click(object sender, RoutedEventArgs e)
{
   Customers myCustomer = dgCustomers.SelectedItem as Customers;

   (customersDomainDataSource.DomainContext as NorthwindContext).Customers.Remove(
myCustomer);
   customersDomainDataSource.DomainContext.SubmitChanges();
}

[RIA Services] DomainDataSource et Parameter

Comme vu dans un de mes articles précédent, il est possible d'utiliser un ou plusieurs paramètres pour la requête associée au DomainDataSource. Il est aussi possible de pouvoir passer ces paramètres via le code-behind de votre application. Pour notre exemple on utilise toujours les tables Customers et Orders de la base de données Northwind.

Côté XAML :

<riaControls:DomainDataSource x:Name="source" AutoLoad="False" >
  <riaControls:DomainDataSource.DomainContext>
    <ds:NorthwindContext/>
  </riaControls:DomainDataSource.DomainContext>
</riaControls:DomainDataSource>

<ComboBox x:Name="CbCustomers" Grid.Row="0" SelectionChanged="CbCustomers_SelectionChanged" />
<my:DataGrid x:Name="dgOrders" Grid.Row="1" ItemsSource="{Binding Data, ElementName=source}" />


Ajout du DomainDataSource et Binding avec la DataGrid.
 

Côté Code-Behind :

NorthwindContext contextCustomers;

public MainPage()
{
  InitializeComponent();
  contextCustomers = new NorthwindContext();
}

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
  CbCustomers.ItemsSource = contextCustomers.Customers;
  contextCustomers.Load(contextCustomers.GetCustomersQuery());
}

private void CbCustomers_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
  // Remise à zéro des paramètres du DomainDataSource
  source.QueryParameters.Clear();

  // Déclaration et instanciation d'un nouveau paramètre
  Parameter p = new Parameter();
 
  // Nom du paramètre (mettre le même que celui déclaré dans le prototype de la méthode contenant l'appel aux données)
  p.ParameterName = "customerId";

  // Valeur du paramètre
  p.Value = ((Customers)CbCustomers.SelectedItem).CustomerID;

  // Association de la méthode du DomainContext au DomainDataSource
  source.QueryName = "GetOrdersWithParamQuery";

  // Ajout des paramètres
  source.QueryParameters.Add(p);

  // Chargement du DomainDataSource
  source.Load();
}

Et les Orders correspondant au Customer sélectionné dans la ComboBox pourront s'afficher dans la DataGrid.


[RIA Services] DomainContext et Code-Behind


Dans mes deux articles précédents (ici et ) parlant de RIA Services, à chaque fois, je vous ai montré du code XAML, mais il faut savoir que tout cela est aussi possible avec des DomainContext en code-behind. Comme dans les deux articles précédents, pour mes exemples je vais me servir de la base de données Northwind avec les tables Customers et Orders.

Pour le DomainContext sans paramètres : 

On souhaite lister tous les clients de la table Customers dans une ComboBox.

Côté XAML on ajoute un contrôle ComboBox avec un ItemTemplate pour pouvoir afficher le ContactName pour chaque Customer :

<UserControl.Resources>
  <DataTemplate x:Key="DataTemplateComboBoxItelCustomers">
    <TextBlock Text="{Binding ContactName}" />
  </DataTemplate>
</UserControl.Resources>


<ComboBox x:Name="CbCustomers" ItemTemplate="{StaticResource DataTemplateComboBoxItelCustomers}" />

Côté code-behind, on ajoute là où l'on souhaite charger les données, le code suivant :

NorthwindContext contextCustomers;

public MainPage()
{
  InitializeComponent();
  contextCustomers = new NorthwindContext();
}

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
  CbCustomers.ItemsSource = contextCustomers.Customers;
  contextCustomers.Load(contextCustomers.GetCustomersQuery());
}


David Rousset l'explique très bien dans sa série d'articles consacrée à .NET RIA Service sur son blog.


Pour le DomainContext avec Include : 

Côté XAML on va s'abonner à l'évènement SelectionChanged sur notre ComboBox afin de savoir quand un Customer est sélectionné :

<ComboBox x:Name="CbCustomers" SelectionChanged="CbCustomers_SelectionChanged" />
<my:DataGrid x:Name="dgOrders" />


Côté Code-Behind, il faut tout d'abord ajouter le tag Include dans le fichier Metadata comme indiqué dans mon post précédent, et modifier la requête de la méthode GetCustomers pour y inclure les Orders.

Ensuite il faut ajouter le code suivant :

public MainPage()
{
  InitializeComponent();
  contextCustomers = new NorthwindContext();
}

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
  CbCustomers.ItemsSource = contextCustomers.Customers;
  contextCustomers.Load(contextCustomers.GetCustomersQuery());
}

private void CbCustomers_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
  dgOrders.ItemsSource = contextCustomers.Orders.Where(c => c.CustomerID == ((Customers)CbCustomers.SelectedItem).CustomerID);
}


Et les Orders correspondant au Customer sélectionné pourront s'afficher dans la DataGrid.


Pour le DomainContext avec paramètres : 

Côté Code-Behind, il faut tout d'abord créer une nouvelle méthode qui prend en paramètre le CustomerId afin de pouvoir sélectionner les Orders que l'on souhaite afficher :

public IQueryable<Orders> GetOrdersWithParam(string customerId)
{
  return this.ObjectContext.Orders.Where(c => c.CustomerID == customerId);
}


Ensuite il faut ajouter le code suivant :

NorthwindContext contextCustomers;
NorthwindContext contextOrders;

public MainPage()
{
  InitializeComponent();
  contextCustomers = new NorthwindContext();
  contextOrders = new NorthwindContext();
}

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
  CbCustomers.ItemsSource = contextCustomers.Customers;
  contextCustomers.Load(contextCustomers.GetCustomersQuery());
}

private void CbCustomers_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
  dgOrders.ItemsSource = contextOrders.Orders;
  contextOrders.Load(contextOrders.GetOrdersWithParamQuery(((Customers)CbCustomers.SelectedItem).CustomerID));
}


Et ici aussi les Orders correspondant au Customer sélectionné pourront s'afficher dans la DataGrid.
Plus de Messages Page suivante »

Les 10 derniers blogs postés

- SharePoint : Bug sur la gestion des permissions et la synchronisation Office par Blog Technique de Romelard Fabrice le 07-10-2014, 11:35

- SharePoint 2007 : La gestion des permissions pour les Workflows par Blog Technique de Romelard Fabrice le 07-08-2014, 11:27

- TypeMock: mock everything! par Fathi Bellahcene le 07-07-2014, 17:06

- Coding is like Read par Aurélien GALTIER le 07-01-2014, 15:30

- Mes vidéos autour des nouveautés VS 2013 par Fathi Bellahcene le 06-30-2014, 20:52

- Recherche un passionné .NET par Tkfé le 06-16-2014, 12:22

- [CodePlex] Projet KISS Workflow Foundation lancé par Blog de Jérémy Jeanson le 06-08-2014, 22:25

- Etes-vous yOS compatible ? (3/3) : la feuille de route par Le blog de Patrick [MVP SharePoint] le 06-06-2014, 00:30

- [MSDN] Utiliser l'approche Contract First avec Workflow Foundation 4.5 par Blog de Jérémy Jeanson le 06-05-2014, 21:19

- [ #ESPC14 ] TH10 Moving mountains with SharePoint ! par Le blog de Patrick [MVP SharePoint] le 06-01-2014, 11:30