Quoi de neuf ?

Le tant attendu SP1 est désormais disponible pour tout le monde !

Bon download

On attendait cette fonctionnalité depuis longtemps, là voilà arrivée. On peut maintenant synchroniser son calendrier Outlook avec son Google Calendar automatiquement et dans les 2 sens. Une excellente nouvelle car même si il existait quelques logiciels pour effectuer la synchro, ils n’étaient pas toujours excellent et la plupart du temps, ils étaient payants. A présent, on n’aura plus à penser à rajouter manuellement un rdv rentré sur Google agenda ou inversément, tout sera fait automatiquement.

Pour utiliser ce service c'est ici

Le service Live de Microsoft est désormais disponible en France et dans 37 autres pays.

Vous pouvez désormais bénéficier d' un espace de stockage de 5 Go :) afin de partager des fichiers avec d' autres personnes.

Pour y accéder c' est ici

Il est parfois utile d’avoir recours à l’héritage lors de l’utilisation de DataContract :

Prenons le cas d’une société de location de véhicule louant des véhicules utilitaire et de tourisme :

Implémentation des classes au niveau du service WCF :

[DataContract]
public abstract class Vehicule
{
    private string _immatriculation;

    [DataMember]
    public string Immatriculation
    {
        get { return this._immatriculation; }
        set { this._immatriculation = value; }
    }
}

[DataContract]
public class Utilitaire :Vehicule
{
    private string _Superficie;

    [DataMember]
    public string Superficie
    {
        get { return this._Superficie; }
        set { this._Superficie = value; }
    }
}

[DataContract]
public class Tourisme : Vehicule
{
    private string _modele;
    [DataMember]
    public string Modele
    {
        get { return this._modele; }
        set { this._modele = value; }
    }
}

Le service WCF exposera une méthode simple qui permettra de récupérer les véhicules :

Le contrat :

[ServiceContract]
public interface IVehiculeService
{
    [OperationContract(IsTerminating = false, 
			     IsInitiating = true, 
			     IsOneWay = false, 
			     AsyncPattern = false, 
			     Action = "GetVehicules")]
    Vehicule[] GetVehicules();
}

Et son implémentation :

public class VehiculeService : IVehiculeService
{

    public Vehicule[] GetVehicules()
    {
        List<Vehicule> lstVehicule = new List<Vehicule>();

        Utilitaire utilitaire = new Utilitaire();
        utilitaire.Immatriculation = "1234AB56";
        utilitaire.Superficie = "9 m²";

        Tourisme tourisme = new Tourisme();
        tourisme.Modele = "207 CC";
        tourisme.Immatriculation = "9876CD21";

        lstVehicule.Add(utilitaire);
        lstVehicule.Add(tourisme);

        return lstVehicule.ToArray();

    }
}

Le service est hébergé dans cet exemple sous IIS :

<%@ ServiceHost Language="C#" Debug="true" Service="VehiculeService" 
CodeBehind="~/App_Code/Service.cs" %>

Le client :

il faut ajouter la "web reference" à ce service précédemment crée dans une application de type console par exemple et ajouter le code suivant :

VehiculeServiceClient clt = null;
try
{
  clt = new VehiculeServiceClient();
  Vehicule[] lstVehicule = clt.GetVehicules();

  foreach (Vehicule vehicule in lstVehicule)
  {
     if (vehicule.GetType() == typeof(Utilitaire))
     {
        Console.WriteLine(String.Format("Utilitaire :
            immatriculation : {0} - Superficie : {1}",
            ((Utilitaire)vehicule).Immatriculation, 
            ((Utilitaire)vehicule).Superficie));
     }
     else
     {
        if (vehicule.GetType() == typeof(Tourisme))
        {
            Console.WriteLine(String.Format("Tourisme :
            Immatriculation : {0} - Superficie : {1}",
            ((Tourisme)vehicule).Immatriculation,
            ((Tourisme)vehicule).Modele));
        }
     }
   }

   Console.WriteLine();
   clt.Close();
}
catch (Exception ex)
{
   if (clt != null)
      clt.Abort();
   Console.WriteLine(ex.Message);
} 

A la première vue, tout se passe bien. Par contre au niveau de l’éxécution, la runtime va lever une exception car les types « tourisme » et « utilitaire » sont inconnus. (Si l’on regarde de plus prêt dans le proxy généré, les classes ne sont pas présentes).

Afin de remédier à ce problème, il faut retourner au niveau de notre service WCF et rajouter comme attribut à la classe Vehicule la définition des « types enfants »

[KnownType(typeof(Utilitaire))]
[KnownType(typeof(Tourisme))]
[DataContract]
public abstract class Vehicule{

Après avoir mis a jour la référence du service, le code s’éxécute correctement :

Pré requis : FrameWork 3.0 ou supérieur / IIS 6 ou supérieur / SQL Server 2000 ou supérieur

Pour vista : composants Windows :
   - WCF http Activation (MS Framework 3.0)
   - Extension ASP.NET / Extensibilité .NET (Service WWW)

Les services web sont aujourd’hui un standard de développement notamment dans les architectures de type SOA.

De nombreuses applications exposent leurs services à travers Internet afin d’être consommés de part le monde.

Ce petit tutoriel explique comment sécuriser un service WCF exposé sur internet en utilisant SSL pour le cryptage du transport et l’api membership d’ASP.NET 2.0 pour gérer l’authentification et les habilitations des utilisateurs.

Dans un premier temps, il est nécessaire de configurer votre serveur SQL ainsi que IIS (nous allons prendre dans notre exemple une configuration pour IIS 7 avec une base SQL Server 2005 et Visual Studio 2008).

1 Configuration d’IIS pour la gestion de SSL

En premier lieu, il faut créer un certificat qui va nous servir à la mise en place de SSL via IIS.

- Depuis la console d’administration d’IIS 7 : Placez-vous sur le nœud principal (serveur IIS)
  et choisissez dans le menu de droite « Certificats de serveur »
- Via le panel de droite, choisir « Créer un certificat auto signé ».

-

Il est possible également de le créer en ligne de commande via le prompt Visual Studio

Ex: C:\Program Files\Microsoft Visual Studio 9.0\VC>makecert -ss local -sr LocalMachine -n "CN=My Certificat"

Le certificat créé, il va falloir modifier les bindings afin d’autoriser SSL dans IIS :

Il faut se rendre sur le nœud « Site Web par défaut » et sélectionnez dans le menu contextuel « Modifier les liaisons »

Et ajouter la liaison comme dans l’image ci-dessous

SSL est prêt à l’emploi pour IIS

Une fois IIS configuré passons du coté de Visual Studio 2008 afin de créer un niveau Site Web avec comme Template « service WCF ».

Choisir comme hébergement http et cliquez sur le bouton parcourir afin d’avoir une nouvelle fenêtre qui s’ouvre.

Choisir IIS et ajouter un nouveau répertoire virtuel. Une fois le répertoire créé, cochez la check Box pour utiliser des sockets sécurisés.  

Une fois le Template du service WCF créé, retournez dans la console d’administration d’IIS et rendez vous sur le nœud de votre nouveau répertoire virtuel.

Dans le panel du milieu, sélectionner les paramètres SSL et activer la check Box « exiger SSL »

La configuration IIS est terminée.

2 Mise en place de la configuration ASP.NET pour la gestion de la sécurité :

Rendez-vous sur la page de configuration ASP.NET de votre service

Dans l’onglet fournisseur, Sélectionner le fournisseur « AspNetSqlProvider » et testez la connexion.

Si le test ne fonctionne pas, vérifier si la base aspnetdb existe dans SQL Server sinon utiliser l’outil aspnet_regiis.exe depuis le prompt Visual Studio pour la créer.

Vérifier également la chaîne de connexion présente dans le fichier web.config de votre l’application

Si elle n’est pas présente, rajoutez-la

<connectionStrings>
   <add name="LocalSqlServer"
    connectionString="server=DBServerName;database=aspnetdb;integrated security=sspi;"/>
</connectionStrings>

Une fois la connexion opérationnelle, rendez-vous sur l’onglet sécurité :

Au niveau de l’onglet Rôle, activez la gestion de ces derniers.

Dans notre exemple, nous allons créer deux rôles :

Ensuite nous allons créer deux utilisateurs :

Chaque utilisateur sera associé à son groupe (rôle) créé précédemment.

NB : vous pouvez définir également des règles d’accès mais faites attention qu’elles ne rentrent pas en conflit avec vos règles de sécurité WCF car elles seront prioritaires.

3 Le service WCF :

Retournons sous Visual Studio afin d’implémenter notre service WCF.

Dans un premier temps, supprimez le code généré dans App_Code

Rajoutez un nouveau projet à la solution de type bibliothèque de classes :

Dans ce projet ajoutez deux nouveaux fichiers :

Une interface (le contrat du service) : IMyService.cs

[ServiceContract] 
public interface IMyService 
{ 
  [OperationContract] 
  String HelloAdmin();
 
  [OperationContract] 
  String HelloContrib();
 
  [OperationContract] 
  String HelloAll(); 
} 

Et une Classe pour l’implémentation du service : MyService.cs

[AspNetCompatibilityRequirements
(RequirementsMode=AspNetCompatibilityRequirementsMode.Allowed)] 
public class MyService: IMyService 
{


 [PrincipalPermission(SecurityAction.Demand, Authenticated = true, 
 Role = "Administrateur")] 
 public string HelloAdmin() 
 { 
   return "Hello Admins"; 
 }
 
 [PrincipalPermission(SecurityAction.Demand, Authenticated = true, 
 Role = "Contributeur")] 
 public string HelloContrib() 
 { 
   return "Hello Contribs"; 
 }

 
 [PrincipalPermission(SecurityAction.Demand, Authenticated = true)] 
 public string HelloAll() 
 { 
   return "Hi All"; 
 } 
} 

Au niveau du fichier Service.svc :

Il suffit de rajouter cette ligne afin d’héberger le service WCF dans IIS

<%@ ServiceHost Language="C#" Debug="true" Service="MyServiceSSL.MyService" %> 

4  Fichier de configuration du Service :

Ouvrir le fichier web.config avec « service configuration editor » ("C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\SvcConfigEditor.exe")

Au niveau du la configuration du end point, laissez l’adresse vide (c’est IIS qui prend en charge cette partie).

Mettre le binding en : wsHttpBinding

Et Choisir votre contrat : MyServiceSSL.IMyService

Définir un nouveau Binding configuration :

- Dans l’onglet sécurité choisir :

o Mode : Transport

o MessageClientCredentialType : UserName

Dans la section avancée, au niveau du service Behavior , Ajoutez serviceAuthorization et serviceCredentials.

Au niveau de serviceCredential, définir le membershipProvideName à AspNetSqlMembershipProvider et le UserNamePasswordValidationMode à MembershipProvider.

Dans la section serviceAuthorization :

Définir la propriété PrincipalPermissionMode à UseAspNetRoles et la propriété RoleProviderName à AspNetSqlRoleProvider

Au niveau des méta-datas, désactivez le mex http et activez le mex HTTPS

Le service est normalement prêt à être consommé à travers Internet sous SSL.

4 Les Clients :

Lancer un naviguateur Web et taper l’adresse de votre répertoire virtuel afin de récupérer le service (reminder => httpS)

Ex : https://localhost/WCFandSSL/service.svc

Si tout se passe bien vous devriez tomber sur une page qui vous alerte que le certificat n’est pas valide : poursuivez (le certificat n'est pas validé par un tiers reconnu).

Récupérez l’adresse du WSDL https://monserveur/WCFandSSL/Service.svc?wsdl

Ensuite, créez une nouvelle application de type console (qui représentera un client pour ce service) et ajoutez un « service reference » en saisissant l’adresse du WSDL. Un proxy va être automatiquement généré pour notre service WCF.

Rajoutez un fichier de configuration et l’ouvrir avec l’éditeur de configuration :

Vérifier que la configuration du binding est en corrélation avec celle côté serveur (Mode à transport et messageClientCredentialtype à userName)

Voici le code de l’application cliente :

try 
{ 
  MyWCFSecureService.MyServiceClient test = new
  MyWCFSecureService.MyServiceClient(); 

  test.ClientCredentials.UserName.UserName = "Administrateur"; 
  test.ClientCredentials.UserName.Password = "P@ssword"; 

  Console.WriteLine(test.HelloAll()); 
  Console.WriteLine(test.HelloAdmin()); 
  Console.WriteLine(test.HelloContrib()); 
} 
catch (SecurityAccessDeniedException) 
{ 
  Console.WriteLine("Acces Interdit"); 
} 
catch (Exception ex) 
{ 
  Console.WriteLine(ex.Message); 
} 

Voici donc comment créer un service WCF prêt à être consommé via Internet en utilisant une sécurité de cryptage SSL pour le transport ainsi qu’une authentification et une habilitation basée sur l’api Membership.

Une petite vidéo qui nous montre quelques possibilité de "l' ordinateur familiale de demain" ;)

Tout est dans le titre, Voici deux projets open source qui proposent d'étendre le "Loggin Application Block" des Enterprise Library.

SMS Logger for enterprise Library 2.0 (and 3.0)

Cet add-in va permettre d'ajouter un nouveau trace listener afin de recevoir des notifications par SMS.

MSN Messenger Log Listener  développé par Bill Pierce

Cet add-in permet d'ajouter un nouveau trace listener pour être notifié via MSN

Retrouvez un article de Sophiane dans le hors serie de programmez de Décembre sur les Softwares Factories et l'industrialisation.

Au programme :
 - Web Service Software Factory (WSSF)
 - Smart Client Software Factory & UI Application Block (CAB)
 - ...

Tout est dans le titre :) ce service pack 1 pour Windows Vista (Qui apporte pas mal de modifications sur le dernier OS de Microsoft) est enfin disponible pour tout le monde en attendant la version finale prévue pour Février 2008.

Pour le récupérer c'est ici

La deuxième édition est en ligne : ici

Arno présente notamment la plateforme Team System avec un retour d'expérience au sein des entreprises ...

Bon visionnage ;)

Ressource:

Présentation Team System Powered by Arnaud
Exakis : centre de compétences Team System

"Il faut rendre à César ce qui appartient à César"

J'aurai du mal à remplacer Google en moteur de recherche comme je ne pourrai jamais remplacer Visual Studio comme environnement de développement.
C’est pour moi LA référence en thermes d’ergonomie et de productivité.

Comme tout développeur, mon but est d’écrire le moins de code possible pour atteindre mes objectifs. Je vous donne donc un listing de mes différents outils que j’utilise aux quotidiens :

EDI :

Visual Studio 2005 (le 2008 est installé mais en attente de compatibilité avec certains add-in)

Visual Studio Add-In :

GAT (Guidance Automation Toolkit) : lien
Enterprise Library 3.0 : lien
Web Service Software Factory : lien

CoolCommands : Un add-in dont je ne peux plus me passer (Thomas le détail dans ce post)
Les fonctions que j’utilise le plus étant les copy de référence entre les projets et l’ « open container folder »

Ghost Doc : lien
Qui permet un gain de temps dans la saisie des commentaires XML dans le code.

Property Manager : lien
Un outil qui vous permettra d'encapsuler vos Fields "Attributs" dans des propriétés en un simple clic.

Soft & Utilitaires :

Reflector : lien
programme gratuit permettant de décompiler des exécutable ou dll .net

SandCastle : lien
Permet de générer une documentation à partir de la documentation XML du code

Outils perso :

Quick service deploy : lien
Mapping entre le répertoire de la solution Visual Studio & le répertoire d’installation d’un service NT afin de facilité les déploiements

Data Access Code Generator : lien
Cette application permet : apres avoir sélectionner le serveur de base de données, la base de donnée et la table , de générer le code pour pouvoir avoir acces aux données :
  - Génération des procédures stockées Insert / Update / Select
  - Génération de la couche d'acces aux données (prerequis : Enterprise Library)
  - Génération des business entities
  - Génération des dataContract (pour WCF)
  - Mapping entre les business entities et les datacontracts

Voici donc la liste des outils que j'utilise le plus lors de mes développements et je suis preneur de ce genre de soft qui permettent de gagner du temps :) donc si vous en connaissez d'autres, n'hésitez pas à m'en faire part.

Dans certain cas il est utile de pouvoir passer un tableau de paramètres à une procédure stockée. Il n’existe pas de type « Array » en SQL mais grâce à la prise en charge d’XML, nous avons la possibilité de simuler ce type :

Exemple :

Prenons la table Livre :

Dans cet exemple, le but est de requêter cette table afin de récupérer tous les livres en fonction d’une liste d’éditeurs variable  :

Procédure stockée :

CREATE Procedure [dbo].[GetBookByEditeur]
(
     @editeurs    xml
)
AS begin



SELECT 
        *
FROM 
        dbo.Livre

WHERE
   dbo.Livre.Editeur
     in (
            SELECT 
                ParamValues.Code.value('.','VARCHAR(50)')
            FROM 
                @editeurs.nodes('/Editeur/Code') as ParamValues(Code)
        ) 

Cette procédure prend un paramètre d’entrée de type Xml et nous allons requêter dessus afin de récuperer tous les livres des différents éditeurs contenues dans la liste.

Du coté de dot net :

Au niveau de la business logic layer :

 1 public class BookManager
 2     {
 3         public DataSet GetBookByEditor(List<String> lstEditor)
 4         {
 5             List<String> lstEditor = new List<string>();
 6             lstEditor.Add("Hachette");
 7             lstEditor.Add("Publibook ");
 8 
 9 
10             DataAccess da = new DataAccess();
11             return da.GetBookByEditor(XmlBuilder.BuildXmlString(
12                                               "Editeur", "Code", lstEditor));
13         }
14 
15 
16     }
17 
18     public static class XmlBuilder
19     {
20         public static String BuildXmlString(String root, 
21                                                              String key,
22                                                              List<String> values)
23         {
24             StringBuilder xmlString = new StringBuilder();
25             xmlString.AppendFormat(
26             "<{0}>", root);
27             if (values != null)
28             {
29                 foreach (String value in values)
30                 {
31                     if (value != null)
32                         xmlString.AppendFormat(
33                         "<{0}>{1}</{0}>", key, value);
34                 }
35             }
36             xmlString.AppendFormat(
37             "</{0}>", root);
38             return xmlString.ToString();
39         }
40     }
41 

Nous allons créer une liste générique de String comportant les différents éditeurs. Cette liste va ensuite être traitée par la classe XmlBuilder afin de retourner une chaine XML« well formed »

Au niveau de la data access layer (en utilisant l’application bloc des enterprise library):

using Microsoft.Practices.EnterpriseLibrary.Data;
using System.Data.Common;

        public DataSet GetBookByEditor(String tblEditors)
        {
            Database db = null;
            DbCommand cmd = null;

            db = DatabaseFactory.CreateDatabase("dbTstCnx");
            cmd = db.GetStoredProcCommand("dbo.GetBookByEditeur");

            db.AddInParameter(cmd, "@editeurs", DbType.String, tblEditors);

            return db.ExecuteDataSet(cmd);

        }

Nous allons appeler notre procédure stockée avec un paramètre de type String (cette chaine de caractère étant du XML « well formed », elle sera bien interprétée en type XML du coté SQL Server.

Voici donc une solution simple est rapide pour faire des requêtes dynamiques multicritères.

Nouvelle Realease sur codeplex des Web Service Software Factory qui inclue la modélisation via DSL (ce qui facilite son utilisation)

http://www.codeplex.com/servicefactory/Release/ProjectReleases.aspx?ReleaseId=8130

Merci Kangoo pour l'info toute chaude :)

MSDN : Utilisation de GUID :

« Un GUID est un nombre binaire et son usage principal est celui d'identificateur qui doit être unique dans un réseau comportant de nombreux ordinateurs implantés dans de nombreux sites. Il est possible de générer des GUID et il est garanti qu'ils sont uniques dans le monde entier »

Voici un article intéressant qui remet en cause l’utilisation des GUID

Lien

Voici un petit test de performance basé sur l’application bloc des enterprises library :

Prenons cette table :

Avec cette procédure stockée d’insertion :

CREATE PROCEDURE [dbo].[InsertLivre]
    @titre varchar(50),
    @editeur varchar(50),
    @prix int,
    @synopsis text,
    @edition int,
    @nbExemplaires bigint,
    @dateDeSortie datetime,
    @commentaire varchar(500),
    @cover binary(1000)
AS 
 Begin 
 INSERT INTO Livre (
    Titre,
    Editeur,
    Prix,
    Synopsis,
    Edition,
    NbExemplaires,
    DateDeSortie,
    Commentaire,
    Cover
)
values
(
    @titre,
    @editeur,
    @prix,
    @synopsis,
    @edition,
    @nbExemplaires,
    @dateDeSortie,
    @commentaire,
    @cover
)
End

Premier cas 

Appel des enterprises library de facon « verbeuse »

public void InsertLivreVerbose(BELivre beLivre)
{
    if (beLivre == null)
        throw new ArgumentNullException("beLivre");
    Database bdd = null;
    DbCommand command = null;

    bdd = DatabaseFactory.CreateDatabase(CNX_DATABASE);
    command = bdd.GetStoredProcCommand("[dbo].[InsertLivre]");

    #region add parameters

    if (beLivre.Titre != null)
        bdd.AddInParameter(command, "@titre", DbType.String, beLivre.Titre);
    else
        bdd.AddInParameter(command, "@titre", DbType.String, DBNull.Value);

    if (beLivre.Editeur != null)
        bdd.AddInParameter(command, "@editeur", DbType.String, beLivre.Editeur);
    else
        bdd.AddInParameter(command, "@editeur", DbType.String, DBNull.Value);

    bdd.AddInParameter(command, "@prix", DbType.Int32, beLivre.Prix);

    if (beLivre.Synopsis!=null)
        bdd.AddInParameter(command, "@synopsis", DbType.String, beLivre.Synopsis);
    else
        bdd.AddInParameter(command, "@synopsis", DbType.String, DBNull.Value);

    bdd.AddInParameter(command, "@edition", DbType.Int32, beLivre.Edition);

    bdd.AddInParameter(command, "@nbExemplaires", DbType.Int64, beLivre.NbExemplaires);

    bdd.AddInParameter(command, "@dateDeSortie", DbType.DateTime, beLivre.DateDeSortie);

    bdd.AddInParameter(command, "@commentaire", DbType.String, beLivre.Commentaire);

    if (beLivre.Cover!=null)
        bdd.AddInParameter(command, "@cover", DbType.Binary, beLivre.Cover);
    else
        bdd.AddInParameter(command, "@cover", DbType.Binary, DBNull.Value);

    #endregion
    bdd.ExecuteNonQuery(command);
    if (command != null)
        command.Dispose();
}

Second cas :

Appel des enterprises library de facon « non verbose »

public void InsertLivreNonVerbose(BELivre livre)
{
    if (livre == null)
        throw new ArgumentNullException("beLivre");

    Database bdd = null;

    bdd = DatabaseFactory.CreateDatabase(CNX_DATABASE);

    bdd.ExecuteNonQuery("dbo.InsertLivre", new object[] { livre.Titre, livre.Editeur,          
                                          livre.Prix,livre.Synopsis,livre.Edition,
                                          livre.NbExemplaires,livre.DateDeSortie,
                                          livre.Commentaire,livre.Cover });

}

Nous allons ensuite éxécuter ce code 10 000 fois pour chaque cas :

DateTime start = DateTime.Now;

for (int i = 0; i < 10000; i++)
{
    InsertLivreNonVerbose(livre);

}

TimeSpan stepOne = DateTime.Now - start;

start = DateTime.Now;



for (int i = 0; i < 10000; i++)
{
    InsertLivreVerbose(livre);
}

TimeSpan stepTwo = DateTime.Now - start;

MessageBox.Show(String.Format("Non Verbose : {0} || Verbose {1}",
                               stepOne.ToString(), stepTwo.ToString()));

Résultat

Certes le but pour un développeur est d’écrire le moins de code possible pour arriver à ses fins mais il ne faut pas négliger la performance !

La méthode "non verbose" est beaucoup moins couteuse