Simon Boigelot

Une page Facebook pour Heode

simon.boigelot.nospam@nospam.heode.com (Togis) — Tue, 07 Apr 2009 06:22:10 -0400

Depuis peu Heode est présent sur Facebook.

Silverlight 3 – First look

simon.boigelot.nospam@nospam.heode.com (Togis) — Tue, 07 Apr 2009 06:03:00 -0400

Avant propos

Voici un article sur Silverlight 3 que j’ai du écrire pour un magasine. Veuillez me pardonner s’il n’est pas exhaustif mais j'ai eu tant de chose à dire et si peu de place pour le dire…

J’espère néanmoins qu’il sera utile à l’un ou l’autre d’entre vous.

Installation sur machine cliente et travail en mode offline

Alors que Silverlight 2 ne fonctionne qu’en mode online et à l’intérieur d’un navigateur, la version 3 de la plateforme ne respecte plus ces limitations.

En effet, lors de la visite d’un utilisateur sur une application Silverlight 3, ce dernier à l’opportunité de télécharger et installer cette application sur son système d’opération. Ainsi cette application lui deviendra accessible même lorsqu’il ne sera pas connecté à internet.

Bien sur, nous devons prendre en compte que si l’application doit récupérer des données sur un serveur, cela restera impossible en mode offline. Cependant, une bonne gestion d’un cache de données et de la concurrence lors des mises à jour pourra tout de même permettre un travail offline sur des données online.

Dans cet article nous allons apprendre à :

- Rendre une application Silverlight 3 téléchargeable
- Détecter si l’application est :
  - Installée sur le bureau ou sous navigateur
  - Online ou offline.
- Récupérer des données à partir du site hôte de l’application

Avant de commencer, notez que les pré-requis pour cet article sont :

- Connaître les bases de la plateforme .Net
- Installer Visual Studio 2008 (dont la version express est gratuite)
  Attention, installez la version anglaise, les Tools et SDK n’existent que en anglais pour l’instant !
- Installer les Silverlight 3 Tools et SDK ainsi que les .Net RIA services (http://www.silverlight.net/GetStarted/silverlight3)

Bases de l’application

- Démarrez Visual Studio 2008
- Ouvrez le menu File à New Project …
- Dans la boîte de dialogue « New Project » qui apparait, choisissez « .Net Framework 3.5 » et sous le type de projet « Silverlight » : « Silverlight Application »
- N’oubliez pas de lui donner un nom, dans ce cas-ci : « OutOfBrowser »
- Cliquez sur Ok.
- Une nouvelle boîte de dialogue apparaît : « New Silverlight Application ». Prenez soin de cocher l’option « Link to ASP.Net server project ». Cette option activera le lien .Net RIA Services entre l’application Silverlight et son site ASP.NET host.
- Cliquez sur Ok.
- Visual Studio va générer automatiquement toute la structure de la solution.
- Dans le fichier MainPage.xaml du projet Silverlight, ajouter un texte « Hello World ».
  
  [code:xml]
  <Grid x:Name="LayoutRoot" Background="White">
  <TextBlock>HelloWorld</TextBlock>
  </Grid>
  [/code]
Voici le résultat obtenu lors d’un débogage de la solution crée ci-dessus :

Rendre cette application téléchargeable
Grâce au bouton fournit par la plateforme

Permettre à vos utilisateurs d’installer votre application sur leurs machines se fait dans son fichier manifeste.

Ce fichier se trouve dans le dossier « Properties » de votre application.

Pour procéder, décommentez le nœud «Deployement.ApplicationIdentity ».

public MainPage()
{
    InitializeComponent();
    if (App.Current.RunningOffline)
    {
        WebOrDeskTextBlock.Text = "Bureau";
        DownAndInstallBtt.Visibility = Visibility.Collapsed;
    }
    else
    {
        WebOrDeskTextBlock.Text = "Navigateur";
        DownAndInstallBtt.Visibility = Visibility.Visible;
    }
}

Détecter si le pc est online ou offline

Dans le même état d’esprit, il est utile de connaître l’état de la connexion internet de la machine sur laquelle tourne l’application.

Mais dans ce cas-ci, le travail est un peu plus complexe. En effet, cette connexion n’a pas un état statique, il est possible que son état change durant l’exécution de l’application.

Un évènement est envoyé à l’application par la plateforme lorsque cela arrive. Il suffit donc de s’y abonner et de revérifier l’état de la connexion quand il est lancé.

- Ouvrez MainPage.xaml dans le projet Silverlight.
- Ajoutez une nouvelle zone de texte et nommez-la « OnOrOffTextBlock»
  
  [code:xml]
  <Grid x:Name="LayoutRoot" Background="White">
  <StackPanel>
  <…>
  <TextBlock
  Name="OnOrOffTextBlock"
  Margin="5"
  Text="HelloWorld"/>
  </StackPanel>
  </Grid>
  [/code]
- Ouvrez MainPage.xaml.cs
- Dans le constructeur de la page, juste après l’initialisation des composants, ajoutez ce code :
  
  [code:c#]
  public MainPage()
  {
      InitializeComponent();
      (…)
      OnOrOff();
      NetworkChange.NetworkAddressChanged +=
          new NetworkAddressChangedEventHandler
              (NetworkChange_NetworkAddressChanged);
  }
  
  void NetworkChange_NetworkAddressChanged(object sender,
                                                                       EventArgs e)
  {
      OnOrOff();
  }
  
  void OnOrOff()
  {
      if (NetworkInterface.GetIsNetworkAvailable())
      {
          OnOrOffTextBlock.Text = "Online";
          OnOrOffTextBlock.Foreground =
               new SolidColorBrush(Colors.Green);
      }
      else
      {
          OnOrOffTextBlock.Text = "Offline";
          OnOrOffTextBlock.Foreground =
                  new SolidColorBrush(Colors.Red);
      }
  }
  [/code]

La fonction NetworkInterface.GetIsNetworkAvailable() retourne un booléen donnant cette information.

Lorsque l’ordinateur client perd la connexion internet, l’application le remarque en quelques secondes.

Récupérer des données à partir du site hôte de l’application

Silverlight 3 et les .Net RIA Services simplifie grandement la vie fastidieuse des développeurs. Auparavant, pour consommer des données d’un serveur dans une application Silverlight, la méthode la plus couramment utilisée était de connecter cette application Silverlight à un service WCF (Windows communication foundation) lui-même correctement configuré pour que sa sécurité lui permette de dialoguer avec l’application. *gasp* Rien que de le dire, ca fait mal.

Aujourd’hui, le paradis nous ouvre ses portes. En effet, il est possible de créer une communication entre un site ASP.NET et une application Silverlight 3 qu’il héberge, et ce, en quelque cliques mais tout en gardant une grande liberté de configuration.

Ainsi, la plateforme nous offre de la simplicité, sans nous faire payer en généricité.

· Pour les besoin de la démo, créons rapidement une petite base de données des employés de Heode dont voici la structure :

- Retournez dans Visual Studio
- Cliquez avec le bouton droit de la souris sur le projet « OutOfBrowser.Web » (le site web ASP.NET)
- Sélectionnez le menu Add new à new Item …
- Dans la boîte de dialogue « New Item », sélectionnez le template « LINQ to SQL Classes » et donnez lui le nom : SuperHeroDB.
  Les classes LINQ to SQL sont un moyen simple et rapide de vous connecter à une base de données.
- Ouvrez le fichier SuperHeroDB.dbml
- Naviguez dans l’explorateur de serveur de Visual Studio jusqu’à trouver la table SuperHero et glissez là sur la surface de dessin des classes LINQ to SQL.
- Compilez le projet ASP.NET
- Sélectionnez une foi de plus le menu Add new à new Item …
- Dans la boîte de dialogue « New Item », sélectionnez le template « Domain Service » et donnez lui le nom : SuperHeroService.
  Un Domain Service est un service de données et d’opération qui sera accessible au site web et à tous ses composants internes. C’est à travers ce service que le site web et l’application Silverlight vont communiquer.
- Cliquez sur Ok.
- La boîte de dialogue suivante vous demande de sélectionnez à quel accès aux données vous voulez lier le Domain Service. Choisissez SuperHeroDB, ensuite cochez l’option devant la table SuperHero.
  
  Les autres options vous permettent de demander à la plateforme de générer automatiquement toute l’opération d’édition, d’insertion et de résolution de conflits mais nous n’en auront pas besoin dans cet exercice.
- Cliquez sur Ok.
- Compilez la solution au complet.

Vos données sont maintenant exposée par le site web aux clients Silverlight.

- Ajoutez la référence System.Windows.Controls.Data à votre project Silverlight
- Ouvrez MainPage.xaml dans le projet Silverlight.
- Ajoutez une nouvelle grille de données et nommez-la « MaDataGrid»
  
  [code:xml]
  <UserControl x:Class="OutOfBrowser.MainPage"
  xmlns=http://schemas.microsoft.com/winfx/2006/xaml/presentation
  xmlns:x=http://schemas.microsoft.com/winfx/2006/xaml
  xmlns:data="clr-namespace:System.Windows.Controls;assembly=
  System.Windows.Controls.Data"
  Width="400" Height="300">
  <Grid x:Name="LayoutRoot" Background="White">
  <StackPanel>
  <data:DataGrid Name="MyDataGrid" Margin="5"/>
  <…>
  </StackPanel>
  </Grid>
  </UserControl>
  [/code]
- Ouvrez MainPage.xaml.cs
- Dans le constructeur de la page, juste après l’initialisation des composants, ajoutez ce code :
  
  [code:c#]
  public MainPage()
  {
      InitializeComponent();
      (…)
      SuperHeroContext context = new SuperHeroContext();
      MyDataGrid.ItemsSource = context.SuperHeros;
      context.LoadSuperHero();
  }
  [/code]

Le résultat est directement visible :

Cette méthode passionnante d’accès aux données est bien plus complète que le peu que je viens de vous montrer, pour les intéresser je conseille grandement une lecture du document relatif aux .Net RIA Services disponible sur http://www.silverlight.net/GetStarted/silverlight3.

MDI Silverlight

simon.boigelot.nospam@nospam.heode.com (Togis) — Fri, 27 Mar 2009 05:33:00 -0400

Dans l’optique de créer un système de gestion multi-documents ou multi-fenêtres à l’intérieur d’une application Silverlight, il est utile de comprendre les base du drag and drop.

Les éléments enfants d’un canvas sont disposé dans ce dernier grâce à 3 dependency properties.

Ces propriétés sont :

Canvas.Top : axe y
Canvas.Left : axe x
Canvas.ZIndex : axe z

Pour modifier la valeur de ces propriété à partir du code behind de l’application il faut utiliser la méthode :

[code:c#]
Point? OrigineMDIMove;

private void MDISelectCanvas(object sender, MouseButtonEventArgs e)
{
    Canvas c = (Canvas)sender;
    OrigineMDIMove = e.GetPosition(MDIRoot);
    c.MouseMove += MDIMoveCanvas;

c.SetValue(Canvas.ZIndexProperty,(Int32)
MDIRoot.Children.Max(i=>i.GetValue(Canvas.ZIndexProperty))+1);
}

private void MDIUnselectCanvas(object sender, MouseButtonEventArgs e)
{
     Canvas c = (Canvas)sender;
     c.MouseMove -= MDIMoveCanvas;
     OrigineMDIMove = null;
}

private void MDIMoveCanvas(object sender, MouseEventArgs e)
{
     if (!OrigineMDIMove.HasValue) return;

     Canvas c = (Canvas)sender;
     Point DestinationMDIMove = e.GetPosition(MDIRoot);
     Point MDIMove = new Point()
     {
         X = OrigineMDIMove.Value.X - DestinationMDIMove.X,
         Y = OrigineMDIMove.Value.Y - DestinationMDIMove.Y
      };

      c.SetValue(Canvas.TopProperty,
          ((double)c.GetValue(Canvas.TopProperty) - MDIMove.Y));

       c.SetValue(Canvas.LeftProperty,
          ((double)c.GetValue(Canvas.LeftProperty) - MDIMove.X));

       OrigineMDIMove = DestinationMDIMove;
}

private void MDILeaveCanvas(object sender, MouseEventArgs e)
{
    Canvas c = (Canvas)sender;
    c.MouseMove -= MDIMoveCanvas;
    OrigineMDIMove = null;
}

Créer une communication TCP IP entre Silverlight 2 et .Net 3.5

simon.boigelot.nospam@nospam.heode.com (Togis) — Thu, 19 Mar 2009 07:57:00 -0400

Bien que Silverlight 2 permette des connexions HTTP (basicHTTP) vers un serveur WCF, l’envie peut nous prendre d’en vouloir plus.

Pour pouvoir garder une connexion ouverte entre serveur et client, recevoir à n’importe quel instant une donnée, du client au serveur, ou même du serveur au client, rien de mieux qu’une connexion TCP/IP.

Dans cet article, nous allons voir pas à pas comment créer ce type de connexion ainsi que comment en rendre les assembly génériques et réutilisables.

Nous suivrons donc la route suivante :

Comprendre TCP IP sous .Net
1. Envoyer l’heure à travers TCP IP
Comprendre le policy-file-request de Silverlight
1. Ajouter à notre serveur un port écoutant les requêtes policy-file-request et y répondant correctement
Créer un client TCP Silverlight 2
1. Créer un client TCP Silverlight qui lit un nombre primitif
2. Utiliser des DataContract et un DataContractSerializer
3. Comprendre les KnowTypes
Rendre le tout générique et réutilisable (article préview)

[Downloadez la solution complete de cette article ici]

1. Comprendre TCP IP sous .Net

La plateforme .Net offre sous le namespace System.Net.Sockets tous les outils nécessaire à une création facile de connexion TCP.

Ainsi les deux objets suivants vont être utilisé :

TcpListener : sert à ouvrir le port d’une machine en mode LISTEN. Des clients vont alors pouvoir s’y connecter. (Ceci se fait coté serveur)
TcpClient : sert autant du coté server que du coté client. Une foi connecté, le client et le serveur se référence réciproquement par un objet TcpClient donnant au programmeur un accès facile au fonctions d’envoie de donnée, de gestion de la connexion, etc.

Voici un serveur n’acceptant qu’un seul client, lui envoyant une donnée (int data = 356) et se coupant ensuite.

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace testServer
{
    class Program
    {
        /// <summary>
        /// Ce listener est utilisé pour écouter les
        /// requêtes de connexion de nouveaux clients
        /// </summary>
        TcpListener listener;

        /// <summary>
        /// Ce client représente l'unique client Tcp
        /// que nous allons accepter.
        /// C'est grâce à cet object que nous allons
        /// pouvoir envoyer une données au client
        /// </summary>
        TcpClient client;

        AutoResetEvent OperationCompleted;

        internal Program()
        {
            OperationCompleted = new AutoResetEvent(false);

            listener = new TcpListener(IPAddress.Any, 5000);
            listener.Start();
            listener.BeginAcceptSocket(OnClientConnected, null);

OperationCompleted.WaitOne();
}

        void OnClientConnected(IAsyncResult param)
        {
            int data = 356;

            client = listener.EndAcceptTcpClient(param);
            client.Client.Send(BitConverter.GetBytes(data));
            client.Close();

OperationCompleted.Set();
}

        static void Main(string[] args)
        {
            new Program();
        }

}
}

Du coté client, c’est tout aussi simple :

using System;
using System.Net.Sockets;

namespace testClient
{
    class Program
    {
        internal Program()
        {

            //Création d’un buffer pour stocker les données reçues
            //du server
            byte[] buffer = new byte[sizeof(int)];

           TcpClient client = new TcpClient();
            client.Connect("localhost", 5000);
            client.Client.Receive(buffer);

//conversion des données reçues du serveur
int data = BitConverter.ToInt32(buffer, 0);

            Console.WriteLine("Received : {0}", data);
            Console.Read();
        }

        static void Main(string[] args)
        {
            new Program();
        }
    }
}

1.1 Envoyer l’heure à travers TCP IP

Comme vous avez pu le constater, les seules choses qu’il est possible d’envoyer à travers une connexion TCP IP sont des bytes.

Pour pouvoir envoyer un objet plus complexe, tel qu’un DateTime, il va nous falloir le “sérialiser” avant l’envoie et le “désérialiser” à la réception.

La sérialisation est le procéder de transformation d’un objet en un tableau de byte. C’est en outre une bonne méthode pour sauvegarder des objets dans un fichier.

Pour pouvoir être sérialisé, la class d’un objet doit porter l’attribut ISerializable ou un attribut qui en dérive. Vous trouverez facilement plus d’info sur cet attribut sur internet. (Nous verrons plus tard que pour communiquer avec Silverlight l’attribut à utiliser est DataContract)

Les outils de sérialisation sont disponible dans le namespace System.Runtime.Serialization.

Du coté server, il nous suffit de changer la fonction OnClientConnected :

void OnClientConnected(IAsyncResult param)
{
client = listener.EndAcceptTcpClient(param);

//Recupération de l'heure
DateTime now = DateTime.Now;

    //Création d'un buffer temporaire dans lequel
    //on va sérialiser l'heure
    byte[] buffer = new byte[100];

    //Encapsulation du buffer dans un stream mémoire
    //permetant ainsi une ecriture facile
    MemoryStream stream = new MemoryStream(buffer);

    //Création d'un BinaryFormatter et Sérialisation
    //de l'heure dans le stream -> donc dans le buffer
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(stream, now);

    //Envoie du buffer au client
    client.Client.Send(buffer);
    client.Close();

OperationCompleted.Set();
}

Le client, lui, récupère le buffer et le désérialise en DateTime, de la même façon.

internal Program()
{
byte[] buffer = new byte[100];

    TcpClient client = new TcpClient();
    client.Connect("localhost", 5000);
    client.Client.Receive(buffer);
    MemoryStream stream = new MemoryStream(buffer);
    BinaryFormatter bf = new BinaryFormatter();
    DateTime received = (DateTime)bf.Deserialize(stream);

Console.WriteLine("Received : {0}", received.ToLongTimeString());
Console.Read();
}

1.2 Rappel

Nous avons :

créer un server avec TcpLisener et TcpClient
créer un client avec TcpClient
Sérialiser et désérialiser avec BinaryFormatter

Nous n’avons pas envoyé de donnée du client au server, mais le procédé est le même. Notez que vous pouvez envoyer et recevoir des données simultanément sans risque de collision.

Nous avons utiliser les fonction Send et Receive de façon synchrone, leur version asynchrone existe aussi et est beaucoup plus intéressant dans un scénario réel.

2. Comprendre le policy-file-request de Silverlight

Aie :s

La sécurité, le truc par excellence qui ne marche jamais du premier coup, surtout en Silverlight avec les policy-file.

Commençons par le début, pour changer.

Pour qu’un service WCF fonctionne avec des clients Silverlight, il doit posséder un fichier clientaccesspolicy.xml. Ce fichier permet de spécifier à partir de quel nom de domaine les applications Silverlight peuvent accéder a ce service.

Si la plateforme Silverlight ne trouve pas ce fichier, elle va alors chercher son alter-ego Flash : crossdomain.xml.

Pour vous évitez une recherche, voici le contenu d’un clientaccesspolicy.xml spécifiant la sécurité minimum : tout le monde peux utiliser ce service.

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace sl2Tcp
{
    public class PolicyFileServer
    {
        TcpListener listener;
        TcpClient client;

AutoResetEvent OperationCompleted;

        //Buffer servant à sauvegarder le contenu du fichier
        //clientaccesspolicy.xml
        byte[] PolicyByteArray;

//Requête valide
const string PolicyRequestString = "<policy-file-request/>";

        /// <summary>
        /// Crée une instance de PolicyFileServer dont
        /// le fichier policy est situé sous le chemin
        /// FilePath
        /// </summary>
        /// <param name="FilePath"></param>
        public PolicyFileServer(string FilePath)
        {
            listener = new TcpListener(IPAddress.Any, 943);
            OperationCompleted = new AutoResetEvent(false);
            InitializeData(FilePath);
        }

        /// <summary>
        /// Charge le fichier Policy dans PolicyByteArray
        /// </summary>
        /// <param name="FilePath"></param>
        private void InitializeData(string FilePath)
        {
            if (!File.Exists(FilePath))
                throw new IOException("File not found : " + FilePath);

PolicyByteArray = File.ReadAllBytes(FilePath);
}

        /// <summary>
        /// Démarre le thread principal du server
        /// </summary>
        public void StartAsync()
        {
            Thread T = new Thread(Start);
            T.Start();
        }
        /// <summary>
        /// Thread principal du server, ecoute les
        /// requete de connexion sur le port 943
        /// </summary>
        internal void Start()
        {
            listener.Start();

            while (true)
            {
                listener.BeginAcceptSocket(OnClientConnected, null);
                OperationCompleted.WaitOne();
            }
        }

        /// <summary>
        /// Lorsqu'une connexion est établie sur le port 943 :
        ///      Receptionne une requete et la compare à PolicyRequestString
        ///      Si similaire, envoie PolicyByteArray
        /// </summary>
        /// <param name="param"></param>
        void OnClientConnected(IAsyncResult param)
        {
            client = listener.EndAcceptTcpClient(param);

byte[] buffer = new byte[PolicyRequestString.Length];

client.Client.Receive(buffer);
string request = Encoding.UTF8.GetString(buffer, 0, buffer.Length);

            if (StringComparer.InvariantCultureIgnoreCase.Compare(request,
                                         PolicyRequestString) != 0)
            {
                client.Client.Close();
                OperationCompleted.Set();
                return;
            }

            //Envoie du buffer policy au client
            client.Client.Send(PolicyByteArray);
            client.Close();

            OperationCompleted.Set();
        }
    }
}

Ce nouvel objet définit, ajouter la gestion de la sécurité Silverlight 2 à un server devient un jeu d’enfant, remplaçons le constructeur de notre serveur par :

internal Program()
{
    PolicyFileServer policyFileServer =
        new PolicyFileServer(@"..\..\..\PolicyFileHolder\clientaccesspolicy.xml");
    policyFileServer.StartAsync();

OperationCompleted = new AutoResetEvent(false);

    listener = new TcpListener(IPAddress.Any, 4502);
    listener.Start();
    listener.BeginAcceptSocket(OnClientConnected, null);

OperationCompleted.WaitOne();
}

Avant de nous lancer dans l’écriture d’un client en Silverlight 2, ajoutons à notre client console un TcpClient supplémentaire se connectant au PolicyFileServer. Nous pourrons ainsi vérifier son bon fonctionnement.

Le code Program du client devient :

internal Program()
{
byte[] buffer = new byte[400];

            TcpClient sl2FakeFrameworrkClient = new TcpClient();
            sl2FakeFrameworrkClient.Connect("localhost", 943);
            byte[] PolicyRequestByteArray =
                              Encoding.UTF8.GetBytes(PolicyRequestString);
            sl2FakeFrameworrkClient.Client.Send(PolicyRequestByteArray);
            sl2FakeFrameworrkClient.Client.Receive(buffer);
            string PolicyFileReceived = Encoding.UTF8.GetString(buffer);
            Console.WriteLine("Received PolicyFile : \n{0}\n\n",
                                                                          PolicyFileReceived);

            //Ici le framework va tester si l'application Silverlight
            //a le droit d'acceder au service Tcp, dans le cas echeant
            //la connexion sera coupée

            TcpClient client = new TcpClient();
            client.Connect("localhost", 4502);
            client.Client.Receive(buffer);

            MemoryStream stream = new MemoryStream(buffer);
            BinaryFormatter bf = new BinaryFormatter();
            DateTime received = (DateTime)bf.Deserialize(stream);

            Console.WriteLine("Received : {0}", received.ToLongTimeString());
            Console.Read();
        }

3. Créer un client TCP Silverlight 2

La plateforme Silverlight 2 n’étant qu’un sous-ensemble de la plateforme .net, nous nous y retrouvons toujours le namespace System.Net.Sockets mais sans notre habituel TcpClient.

Nous allons devoir retirer une couche d’abstraction à notre programmation et utiliser le Socket de ce même namespace

Qui plus est, en Silverlight 2, toute communication doit être asynchrone.

3.1 Créer un client TCP Silverlight qui lit un nombre primitif

L’objet Socket ne garantit pas que sa fonction ReceiveAsync lise bel et bien le nombre de bytes qu’on lui a demande en paramètre.

C’est pourquoi le programmeur se doit de vérifier que toutes les données dont il a besoin ont bien été lue par le Socket avant d’essayer de les exploiter.

Pour ce faire, les arguments de l’évènement OnCompleted du Socket contiennent une propriété : BytesTransferred.

BytesTransferred représente le nombre de bytes effectivement lus par ReceiveAsync. Si ce nombre de bytes est insuffisant pour le programmeur, il faut alors relancer la fonction ReceiveAsync.

Une deuxième subtilité est à prendre en compte avec la fonction ReceiveAsync : cette fonction retourne un booléen.

Lorsque ce booléen est vrai, le framework à décider d’exécuter ReceiveAsync de manière asynchrone et un appel à l’évènement Socket.OnCompleted sera lancer.

Par contre, lorsque ce booléen est faux, la plateforme à décider d’éxécuter ReceiveAsync de manière synchrone et l’évènement Socket.OnCompleted ne sera pas lancé, il nous faudra alors nous en charger nous même.

Voici le code d’une class gérant une connexion Tcp cliente Silverlight 2 :

using System;
using System.Net;
using System.Net.Sockets;

namespace sl2NumberClient
{
    /// <summary>
    /// Delégé servant pour l'event OnDataReceived de sl2Client
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="ReceivedData"></param>
    public delegate void sl2ClientEventHandler(object sender, int ReceivedData);

    public class sl2Client
    {
        /// <summary>
        /// Lorqu'une donnée est recue par un client, il exécute
        /// ce délégué pour propager cette données à ses abonnés
        /// </summary>
        public sl2ClientEventHandler OnDataReceived;

Socket socket;
byte[] buffer = new byte[sizeof(int)];

        //Nombre de bytes commulé lu par les appels
        //successif de Socket.ReceiveAsyn(...)
        int bytesRead = 0;

        public void Start()
        {
            //Création du socket client Tcp
            socket =
                new Socket(AddressFamily.InterNetwork,
                           SocketType.Stream,
                           ProtocolType.Tcp);

            //Création du EndPoint
            //Le endpoint est l'adresse ip:port du serveur
            //utilisez 'Application.Current.Host.Source.DnsSafeHost'
            //à la place de localhost en mode production
            DnsEndPoint ep =
                new DnsEndPoint(
                    "localhost",
                    4502);

            //Création des paramètre de connexion
            //Cet EventArgs sera utilisé tout au long de la
            //communication serveur-client
            SocketAsyncEventArgs ConnectionParam =
                new SocketAsyncEventArgs()
                {
                    RemoteEndPoint = ep
                };

            //Lorsque la connexion au serveur réusit ou
            //echoue, exécuter la fonction 'OnConnected'
            ConnectionParam.Completed += OnConnected;

            //Se connecter au server définit dans les params
            socket.ConnectAsync(ConnectionParam);
        }

        void OnConnected(object sender,
            SocketAsyncEventArgs ConnectionParam)
        {
            //L'enumeration SocketError représente l'état de la
            //connexion. SocketError.Success signifie que la
            //connexion à étée établie ET que les autorisations du
            //PolicyFile sont correctes
            if (ConnectionParam.SocketError == SocketError.Success)
            {
                ConnectionParam.Completed -= OnConnected;
                ConnectionParam.Completed += SocketOperationCompleted;

                //Commencer à lire des données sur le flux Tcp
                readMoreData(ConnectionParam);
            }
            else
                throw new Exception("Connection fault : " +
                                    ConnectionParam.SocketError);
        }

        void readMoreData(SocketAsyncEventArgs ConnectionParam)
        {
            ConnectionParam.SetBuffer(buffer,
                                      bytesRead,
                                      (buffer.Length - bytesRead));
            try
            {
                //Subitilité numéro 2
                if (socket.ReceiveAsync(ConnectionParam))
                    SocketOperationCompleted(socket, ConnectionParam);
            }
            catch (InvalidOperationException)
            {
                //Tentative de lancer un ReveiveAsync alors qu'un
                //autre est déjà en cours --> on s'en moque :D
            }
            catch (Exception ex)
            {
                throw new Exception("readMoreData faild", ex);
            }
        }

        void SocketOperationCompleted(object sender,
            SocketAsyncEventArgs ConnectionParam)
        {
            if (ConnectionParam.BytesTransferred > 0)
            {
                bytesRead += ConnectionParam.BytesTransferred;

                //subtilité numéro 1
                if (bytesRead >= buffer.Length)
                {
                    int ReceivedData = BitConverter.ToInt32(buffer, 0);
                    if (OnDataReceived != null)
                        OnDataReceived(this, ReceivedData);
                    socket.Close();
                }
                else
                    readMoreData(ConnectionParam);
            }
        }

}
}

Je passe la définition de l’interface et de son code behind qui n’ont dans le cadre de cet article aucun intérêt. Si vous êtes toute foi demandeur à ce sujet, vous les trouverez tout deux dans les code sources fournit avec cet article.

3.2 Utiliser des DataContract et un DataContractSerializer

Dans le point 1.1 de cet article, nous avons envoyer l’heure par DateTime à travers une connexion Tcp entre deux client .Net 3.5.

Pour ce faire, nous avons utiliser un BinaryFormatter sérialisant l’objet DateTime possédant l’attribut ISerializable.

Les BinaryFormatter ne sont pas disponible en Silverlight 2.

Pour pouvoir sérialiser des objets sur le flux Tcp il faut utiliser un DataContractSerializer sérialisant des objet possédant l’attribut DataContract.

DateTime possède l’attribut DataContract, tout comme il possède ISerializable.

Cette modification de BinaryFormatter à DataContractSerializer est à faire coté client, mais aussi coté serveur.

Une dernière subtilité est à comprendre, le résultat d’une sérialisation par DataContractSerializer est un tableau de bytes de taille variable.

Du coté client, il est impossible de savoir à l’avance combien de bytes nous devront lire avant de pouvoir désérialiser.

Nous allons donc envoyer un nombre (UInt32) du serveur au client avant l’envoie du DateTime, Ce nombre spécifiera la taille prise par le DateTime sérialisé.

Nous allons donc devoir modifier la fonction OnClientConnected notre serveur du point 2.1 de cet article :

(Notez que dans ce cas, les fonctions de sérialisation ne sont plus Serialize et Deserialize mais WriteObject et ReadObject)

void OnClientConnected(IAsyncResult param)
{
client = listener.EndAcceptTcpClient(param);

//Recupération de l'heure
DateTime now = DateTime.Now;

    //Encapsulation du buffer dans un stream
    //permetant ainsi une ecriture facile
    MemoryStream stream = new MemoryStream();

    //Création d'un DataContractSerializer et Sérialisation
    //de l'heure dans le stream --> donc dans le buffer
    DataContractSerializer dc =
        new DataContractSerializer(typeof(DateTime));
    dc.WriteObject(stream, now);

//Récupération du buffer généré dans le MémoryStream
byte[] buffer = stream.ToArray();

    //Evoie de la taille du buffer au client
    client.Client.Send(
        BitConverter.GetBytes(
            (Int32)buffer.Length
            )
        );

    //Envoie du buffer au client
    client.Client.Send(buffer);
    client.Close();

OperationCompleted.Set();
}

Le client, doit alors :

Créer un Socket Tcp
Lire la taille du DateTime Sérialiser
Lire le DateTime

using System;
using System.Net;
using System.Net.Sockets;
using System.Runtime.Serialization;
using System.IO;

namespace sl2DateTimeClient
{
    /// <summary>
    /// Delégé servant pour l'event OnDataReceived de sl2Client
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="ReceivedData"></param>
    public delegate void sl2ClientEventHandler(object sender, DateTime ReceivedData);

Socket socket;
byte[] buffer = new byte[sizeof(UInt32)];

        //Nombre de bytes commulé lu par les appels
        //successif de Socket.ReceiveAsyn(...)
        int bytesRead = 0;

            //Lorsque la connexion au serveur réusit ou
            //echoue, exécuter la fonction 'OnConnected'
            ConnectionParam.Completed += OnConnected;

            //Se connecter au server définit dans les params
            socket.ConnectAsync(ConnectionParam);
        }

                //subtilité numéro 1
                if (bytesRead >= buffer.Length)
                {
                    if(buffer.Length == sizeof(UInt32))
                    {
                        //Lire la taille de DataTime Sérialiser
                        //qui va suivre dans le flux
                        int bufferSize = BitConverter.ToInt32(buffer,0);

                        //Réinitialiser le buffer
                        buffer = new byte[bufferSize];
                        bytesRead = 0;

                        //Recommencer la lecture du flux
                        readMoreData(ConnectionParam);
                    }
                    else
                    {
                        DataContractSerializer dc =
                            new DataContractSerializer(typeof(DateTime));

                        //Désérialiser le DateTime
                        DateTime ReceivedData = (DateTime)
                            dc.ReadObject(new MemoryStream(buffer));

                        if (OnDataReceived != null)
                            OnDataReceived(this, ReceivedData);
                        socket.Close();
                    }
                }
                else
                readMoreData(ConnectionParam);
            }
        }
    }
}

3.3 Comprendre les KnowTypes

Le DataContractSerializer du point précédent ne sérialise que des DateTime.

DataContractSerializer dc =
new DataContractSerializer(typeof(DateTime));

Si vous essayer de lui demander de sérialiser un autre DataContract, une exception sera levée.

En effet, le DataContractSerializer ne peut convertir en bytes que ce qu’il connait. Pour lui apprendre de nouveaux DataContract, il faut lui en passer les types en paramètre lors de sa construction.

DataContractSerializer bf =
new DataContractSerializer(typeof(object),
une List<Type>);

Cette List<Type> est appelée la liste des KnowTypes.

4. Rendre le tout générique et réutilisable

Dans mon prochain article nous verrons comment créer une librairie réutilisable pour gérer toutes ces manipulations répétitives.

Nous verrons aussi comment permettre à une assembly d’être partagée (en référence) entre .Net 3.5 et Silverlight. Ceci est très utile pour la création de notre propre class ayant l’attribut DataContract.

Nous apprivoiserons correctement les possibilité duplex de ce type de connexion Tcp.

Et enfin, nous utiliserons le tout pour créer un petit chat en Silverlight.

En espérant que cette lecture vous aura été utile.

Merci.
Simon Boigelot.

Source :
Tamir Khason – Just Code

Blog Update

simon.boigelot.nospam@nospam.heode.com (Togis) — Mon, 16 Mar 2009 15:56:00 -0400

Bonjour à tous,

J'ai eu un légé problème lors de la mise à jour de mon blog. Pour super résultat, je viens de perdre mes posts du mois passé.

Enfin... il sont toujours en backup ^^ Mais ne sont plus compatible avec cette nouvelle version de mon blog.
Je les transforme dés demain, et vous les rend.

Quelques erreurs de style sont encore présente dans cette nouvelle version, mais celà ne devrait plus durer longtemps, merci de votre compréhension.

Bien à vous,
Simon Boigelot.

Methodes Anonymes - Simplifier votre code

simon.boigelot.nospam@nospam.heode.com (Togis) — Wed, 04 Mar 2009 18:14:00 -0400

L'ajout d'une fonction au call d'un évènement a toujours été quelque chose de laid, de difficile à lire pour quelqu'un de différent de celui qui l'a définie.

Les méthodes anonymes de c# 3.5 simplifie grandement l'écriture de ces fonctions.

Pour exemple :
Un simple évènement "OnMyEvent" qui, une foi appellé, incrémente la variable entière "NombreDeCall".

Sans les méthodes anonymes, voici ce que celà donne :

[code:c#]
event EventHandler OnMyEvent;
int NombreDeCall = 0;
public void FonctionQuelconque()
{
OnMyEvent += new EventHandler(Program_OnMyEvent);
}

public void FonctionCallEvent()
{
if (OnMyEvent != null)
OnMyEvent(this, null);
}

void Program_OnMyEvent(object sender, EventArgs e)
{
NombreDeCall++;
}
[/code]

Avec les méthodes anonymes, nous n'avons plus à décrire le prototype de la fonction "Program_OnMyEvent".
En effet, cette fonction n'ayant pour but que d'être appellé par l'évènement "OnMyEvent", le programmeur n'a aucune utilité de la nommer.

Le code devient ainsi :

[code:c#]
event EventHandler OnMyEvent;
int NombreDeCall = 0;

public void FonctionQuelconque()
{
    OnMyEvent += (sender, e) =>
    {
        NombreDeCall++;
    };
}

public void FonctionCallEvent()
{
if (OnMyEvent != null)
OnMyEvent(this, null);
}
[/code]

Cette méthode anonyme est écrite de la facon suivante :

[code:c#]
( liste des noms donné aux paramètres dont les types sont déduit par le compilateur ) =>
{
//corp de la fonction
};
[/code]

Livre Silverlight 2

simon.boigelot.nospam@nospam.heode.com (Togis) — Wed, 04 Mar 2009 17:27:00 -0400

Ca y est!

Enfin ca fait déjà quelques jours maintenant, mais je n'ai pas pris le temps d'en parler.

En coopération avec Loic Bar, je viens de sortir mon premier livre. Ce dernier est en vente dans toutes les bonnes épiceries

Vous y retrouverez tout ce que vous devez savoir pour créer une application Silverlight complete, de l'écriture de l'interface au accès au données.

Envoyer un mail en utilisant System.Net.Mail et le SMTP de gmail

simon.boigelot.nospam@nospam.heode.com (Togis) — Mon, 02 Mar 2009 16:33:00 -0400

Envoyer un mail en .Net, rien de plus simple :

Ajoutez à votre projet une référence vers l'assembly System.Net.Mail
Créez un SmtpClient :

[code:c#]
SmtpClient smtp = new SmtpClient("smtp.gmail.com");
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true;
smtp.Port = 587;
[/code]
Configurez votre login si neccesaire. Voici un exemple de login sur le smtp de gmail :

[code:c#]
NetworkCredential cred = new NetworkCredential("Simon.Boigelot@heode.com", "*******");
smtp.Credentials = cred;
[/code]
Créez et envoyez votre mail :

[code:c#]
MailMessage email = new MailMessage(
"mailto:CoffeeCup@heode.com">"From",
"mailto:Simon.Boigelot@wipus.com">"To",
"Title",
"Body");
email.Priority = MailPriority.High;
email.IsBodyHtml = false;

try
{
smtp.Send(email);
}
catch (Exception ex)
{
Console.WriteLine("Exception caught : {0}",ex.ToString());
}
[/code]

Pour envoyer un email à plusieurs destinataires simultanément le principe reste le même :

[code:c#]
MailMessage email = new MailMessage();
email.From = new MailAddress("CoffeeCup@heode.com","CoffeeCup");
email.To.Add(new MailAddress(""mailto:Simon.Boigelot@heode.com">Simon.Boigelot@heode.com"));
email.To.Add(new MailAddress(""mailto:SBoigelot@gmail.com">SBoigelot@gmail.com"));
email.Subject = "Multi 'To' mail";
email.Body = "Have you seen my Body ;)";
email.Priority = MailPriority.High;
email.IsBodyHtml = false;
[/code]

Architecture simplifiée de BizTalk

simon.boigelot.nospam@nospam.heode.com (Togis) — Mon, 14 Jul 2008 22:41:35 -0400

Dans cet article vous trouverez une première compréhension générale de l'architecture de BizTalk.

Cette compréhension est nécessaire avant de nous plonger dans le développement.

BizTalk permet de mettre en place des flux de données à partir d’une origine A vers un destination B. Mais que ce passe-t-il entre ces deux points ? Tel est la question à laquelle nous allons répondre.

Voici une vue très simplifiée de l’architecture de BizTalk :

1. Les données sont reçues par un Receive Port. Les receive ports ne font que transmettre les données en format binaire, sans se soucier du contenu de ce qu’ils transportent.
2. Elles sont acheminées vers une base de données centrale par une Receive Pipeline. C’est lors de cette phase du transport que le mapping sera appliqué aux données binaires pour fournir un format XML comprenant des promoted properties.
3. Ensuite, si des orchestrations sont configurées pour agir sur le type de message reçu, elles seront instanciées. Une orchestration est une étape du processus métier qui est prise en charge par BizTalk.
4. Les Send Pipelines sont l’exact opposé des Receive Pipelines. Ces pipelines vont prendre les données sous format XML et les convertir dans le format destination désiré. Encore une foi grâce à un mapping.
5. Les données sont enfin envoyées au destinataire par un Send Port qui ne se charge que de transmettre les informations binaires au bon endroit.

Pour savoir quelle est l’étape à appliquer à un message à un moment donné, BizTalk garde un fichier supplémentaire, le fichier de contexte.

Ce fichier de contexte possède de nombreuses information tel que :

· Le type du fichier message
· L’historique complet du fichier à travers le processus BizTalk
· Les erreurs éventuelles survenues
· Les différentes promoted properties

C’est sur les valeurs contenues dans ce fichier de contexte que les différentes parties du flux BizTalk, les artefacts, peuvent souscrire.

Ainsi nous allons pouvoir créer, par exemple, une Send Pipeline et la souscrire aux messages ayant un schéma correspondant au XSD « monSchema.xsd » et provenant de l’orchestration « monOrchestration ».

Le moteur interne de BizTalk créera alors toutes les suscriptions T-SQL nécessaire pour instancier cette Send Pipeline à chaque foi que des données correspondante seront insérée dans la MessageBox.

La MessageBox est le cœur de BizTalk. Elle repose sous SQL-Server ce qui nous offre beaucoup de possibilité quand à la fragmentation de cette base de donnée.

Lorsque qu’un fichier est reçu par BizTalk on parle de message. Les messages peuvent-être dupliqué, ainsi si plusieurs artefacts ont une suscription qui correspond à un même message, chacun de ces artefacts recevra une copie autonome du message.

Maintenant que nous avons une vue globale de l’architecture de BizTalk, nous allons pouvoir nous intéresser en détail à chaque artéfact.

Port

Un port est la représentation logique d’une communication physique par laquelle BizTalk reçoit et envoi des messages.

Chaque port est un conteneur qui possède toutes les informations nécessaires à l’établissement d’un canal de communication.

L’élément principal d’un port est l’adaptateurs qu’il utilise. Chaque type de communication possède son adaptateur.

Par exemple, un Send Port utilisant le protocole FTP possèdera un adaptateur FTP ainsi que les configurations suivantes :

· Ip de contact
· Login
· Password

Pour ne citer que les plus évidentes.

Receive Port

Les receive ports ont pour particularité d’être des conteneurs de Port. Ainsi un unique reveive port peut en faite être associé à plusieurs configurations différentes, nommée Receive Location.

Ainsi un receive port attendant des ordres d’achat pourra être composé de plusieurs receive locations :

· La première attendant des fichiers sur un FTP
· La seconde sur le système de fichier d’un serveur
· La troisième par mail

Quelque soit l’origine du fichier reçu, il sera traité de la même manière dans la suite du flux de donnée.

Send Port

En contradiction avec les receive port, les send ports eux ne peuvent contenir qu’un unique port de destination.

Pour palier à ce désavantage, BizTalk offre la possibilité de crée des SendPortGroup, contenant plusieurs Send Port.

Logical Port

Lors de la création d’une orchestration, le programmeur ne sait pas forcément d’où lui viendra les données, ni où il devra les envoyer ensuite.

C’est dans ces cas précis qu’interviennent les ports logiques.

Les ports logiques ne doivent être liés à des ports physiques qu’au moment du déploiement de l’application.

Dynamic Send Port

Ces send ports particulier permettent de définir la destination des messages au moment de l’exécution au lieu de le faire lors déploiement de l’application.

Cette destination doit être définie par déduction sur des promoted properties.

Adaptateur

Les adaptateurs sont les interfaces de communication de BizTalk autant en entrée qu’en sortie.

La plupart du temps, les adaptateurs ne sont que des interfaces de communication basée sur un protocole de transport donné. Ils n’ont donc aucune compréhension interne des données qu’ils transportent.

Leur unique utilité est de nourrir et de délester la machinerie de BizTalk.

Dans le cas d’adaptateur de réception, deux modes principaux existent :

· Le pooling : de temps à autre l’adaptateur vérifie le contenu d’un répertoire (ou autre) pour vérifier si des messages attendu par BizTalk ne s’y trouve pas. C’est le cas du « File System Adaptater ».
· L’écoute : l’adaptateur est en attente d’un événement en provenance su monde extérieur pour se réveiller.

Lorsqu’un message est reçu par un adaptateur, contrairement à ce que l’on dessine habituellement, il n’est pas envoyé directement à une receive pipeline mais passe d’abord par la MessageBox.

C’est le « Message Engine » de BizTalk qui à la charge de transmettre ce message de la MessageBox a la receive pipeline appropriée.

Un adaptateur des plus important est le « SQL Adaptater », en effet, la MessageBox reposant sur une base de données SQL Server, chaque communication interne à BizTalk repose sur cet adaptateur.

Pipeline

Les pipelines ont pour fonction d’effectuer des traitements de données sur les messages entrants ou les messages sortants. Cet aussi cet artéfact qui à comme responsabilité la validation de ces messages.

Par traitements de données ont entent principalement tout ce qui est sécurité (cryptage/décryptage, signature).

BizTalk fournit 4 pipelines basiques qui permettent de remplir toutes les fonctions les plus couramment utilisées :

· Receive Pipeline

o XmlReceive : permet de recevoir des messages XML et de les valider
o PassThruReceive : permet de recevoir des messages sous format flat file

· SendPipeline

o XmdTransmit : permet d’envoyer des messages XML et de les valider
o PassThruTransmit : permet d’envoyer des messages sous format flat file

Comme son nom l’indique, un pipeline est un suivit d’opérations les unes aux suites des autres. Dans un pipeline l’ordre des opérations est très important, en effet, a quoi bon par exemple essayer de valider un fichier XML qui n’a pas été décrypté.

Pour simplifier la mise en place de pipeline, BizTalk à séparé en grands groupes les type d’opérations pouvant être effectuée sur un message.

Receive Pipeline Operation Group :

1. Décode : cette étape sert à décoder les messages d’un format externe à un format lisible par les autres composants. Le plus commun des cas de décode est sans nul doute le décryptage.
2. Désassemble : en fonction du type de message, cette étape va soit traduire le message d’origine en un message XML, soit découper le message en plusieurs sous-messages plus conforme à l’implémentation du flux.
3. Validation : valide un message à partir d’un schéma.
4. Résoudre les partenaires : cette étape est principalement utilisée pour certifier la provenance des messages reçus.

Send Pipeline Operation Group :

1. Pré-assemble : cette étape et le dernier point de modifications des données par le flux BizTalk, généralement utilisée pour faire des transformations de dernière minute sur le XML interne de BizTalk avant qu’il ne soit transformé en flat file.
2. Assemble : utilisation d’un schéma pour transformer un ou plusieurs messages en un message respectant le format convenant au destinataire.
3. Encore : à l’inverse de décode, cette phase est utilisée pour crypter les données. (Un autre exemple est la compression des données)

De nombreux composant de pipelines effectuant ce genre d’opération sont inclus dans BizTalk mais il est toujours possible d’écrire nos propres composants ou d’en acheter de nouveau, comme d’habitude.

Orchestration

Les orchestrations permettent au développeur BizTalk d’implémenter un processus métier à travers un outil de dessin : l’Orchestration Designer.

Cet outil permet d’exprimer le processus métier via une série de forme glissée sur la surface de dessin à partir de la boîte à outil de Visual Studio.

A travers ces dessins, tout le framework .Net ainsi que le framework BizTalk sont accessible.

Il est ainsi possible de laisser libre cours à son implémentation du processus métier sans pour autant devoir écrire plusieurs programmes fastidieux pour gérer chaque étape de ce processus.

Les orchestrations, tout comme les autres artéfacts de BizTalk, souscrivent à certain messages arrivant dans la MessageBox et sont instanciée par celle-ci lorsque l’un deux arrive.

Ces orchestrations sont alors capable, par exemple de gérer des exception tel que : « A la réception d’un ordre d’achat j’envoie une facture, mais si je n’ai pas d’accusé de réception avant 2 jours, j’annule l’ordre »

Encore une foi, les « shape d’orchestration », ces fameuses formes servant à dessiner sont nombreuses mais il est toujours possible de créer les nôtre.

Créer une orchestration BizTalk avec Visual Studio

simon.boigelot.nospam@nospam.heode.com (Togis) — Mon, 14 Jul 2008 22:12:00 -0400

Dans cet exercice nous allons apprendre à créer des orchestrations grâce à l’Orchestration Designer de BizTalk.

L’orchestration que nous allons créer va faire exactement la même chose que les filtres des Send Ports du chapitre précédent. Cependant gardez à l’esprit que les orchestrations ont bien plus de capacités, mais il faut bien commencer petit.

· Ouvrez Visual Studio

· Créer un nouveau projet « Empty Biztalk Server Project » du nom de « LabOrchestration »

· N’oubliez pas de directement changer le nom de déploiement du projet pour « LabOrchestration » et de lui assigner une clef de signature.

· Ajoutez 1 schéma au projet :

· Pour des raisons éducative, ne faites pas de « NombrePage » un « xs :int » mais gardez le en « xs :string »

· Pour pouvoir utiliser ce champ lors d’une orchestration, il doit recevoir une promotion particulière nommée « Distinguished Field ».

· Pour ce faire, cliquez sur le champ avec le bouton droit de la souris et sélectionnez « Promote à Show Promotion »

· Dans la boîte de dialogue qui s’ouvre vous trouvez la possibilité d’ajouter le champ « NombrePage » aux « Distinguished Fields ».

· Cliquez avec le bouton droit de la souris sur votre projet, sélectionnez « Add à New Item… »

· Dans la boîte de dialogue « Add New Item », sous « Orchestration Files » choisissez « BizTalk Orchestration » et nommez la « OrchestrationTrieLivre »

· L’éditeur d’orchestration s’ouvre dans Visual Studio.

Une orchestration commence toujours par la réception d’un message, soit par suscription, soit par appel à partir d’une autre orchestration.

Dans la boîte à outil de Visual Studio vous trouverez tous les « Shapes » de base utilisés lors de la création d’une nouvelle orchestration.

Passons en revue les plus intéressants :

Shape	Explication
	Action d’envoyer un message à travers un Send Port
	Action de recevoir un message en provenance d’un Receive Port.
	Représentation d’un port au niveau d’une orchestration, il s’agit ici d’un port logique qui devra être lié à un port physique lors de la configuration de l’orchestration. (Après déploiement)
	Permet d’appliquer un map XSLT sur un message
	Action de construire un nouveau message sur base d’un schéma
	Permet à une orchestration d’en invoquer d’autre. Call est synchrone, Start asynchrone.
	Permet de faire appel au Business Rule Engine.
	Permet l’appel d’un script .Net
	Représentation d’un « If-then-else »
	Permet à l’orchestration de marquer un temps de pause
	Multithreading interne aux orchestrations
	Représentation d’un boucle « Tant que (condition) »
	Shapes utilisée pour la gestion des erreurs
	Met une Orchestration en attentent de l’action d’un administrateur.
	Met fin à l’orchestration

Notre orchestration doit recevoir un Livre et l’envoyer à deux ports différents selon le nombre de Page qu’il contient.

Pour ce faire, il nous faudra donc :

Ø 3 Ports Logique (1 receive, 2 send)

Ø 1 Receive Shape

Ø 2 Send Shapes

Ø 1 Decide Shape

Ajoutez le premier Port Logique à l’orchestration en le glissant sur le « Port Surface » de gauche du designer.

· Un assistant de configuration de ce port s’ouvre. Cliquez sur Next.

· Le nom de ce port est « OrchRcvPortLivre ». Cliquez sur Next.

· L’assistant nous demande de choisir ou de crée un « Type de port » pour notre nouveau port logique. En effet, on ne peut lier un port physique à un port logique que si, et seulement si, ses caractéristiques son similaire. Le « Type de port » est le conteneur des caractéristiques de notre port logique. N’en ayant encore jamais créé auparavant dans ce projet, créons en un.

· Choisissez « OrchRcvPortLivreType » comme nom de Type

· « One-Way » et « Internal » comme caractéristiques. Cliquez sur Next.

Dans la page suivante de cet assistant, on nous propose de spécifier le sens du port et on nous offre le choix entre plusieurs possibilités quant-à son implémentation physique.

« Port binding » offre 3 possibilités :

Ø Spécify now: crée directement un port physique sur base des informations du port logique

Ø Spécify later : permet au développeur de lier ce port logique à un port physique plus tard, après le déploiement.

Ø Direct : Ce port logique prend sa source soit directement sur la MessageBox de BizTalk, soit d’une autre Orchestration, soit de cette orchestration elle-même. (Cette dernière option peut paraître étrange mais il ne s’agit en faite que de la possibilité de créer des Orchestration récursives)

· Choisissez « Spécify later ». Cliquez sur Next.

Cliquez sur le port nouvellement ajouté et ouvrez ses propriétés.

· Remarquez que BizTalk demande que vous lui spécifier quel schéma sera utilisé pour la validation des message entrant par ce port.

· Choisissez « LabOrchestration.Live »

· Ajouter un « Receive Shape » à l’Orchestration en le glissant sur la surface de dessin.

· Liez ce « Receive Shape » à votre port « OrchRcvPortLivre »

· Ajoutez un « Decide Shape » à l’orchestration :

· Sélectionnez le point d’exclamation et cliquez sur « No Expression, Click… »

· Une boîte de script .Net s’ouvre, c’est ici que nous allons définir la condition de notre « if-then-else ».

· Remplissez-la par :
« System.Int32.Parse(Message_1.NombrePage) < 500 »
il s’agit de notre condition.

·Ajoutez un Port logique dans le « Port Surface » de gauche.

· Ajoutez un Port logique dans le « Port Surface » de droite.

· Ajouter un « Send Shape » sur chaque branche de « Decide Shape » et liez les aux Send Port que vous venez de créer.

· Au final votre orchestration devrait ressembler à ceci :

· Avant de pouvoir enfin déployer, il faut spécifier à cette orchestration qu’elle peut-être automatiquement instanciée à la réception d’un Livre.

· Ouvrez les propriétés du « Receive Shape » et faites-y passer la propriété « Activate » à true.

· Deployer votre projet

· Lier les ports logiques de cette orchestration avec des ports physique se fait dans BizTalk Server Administration.

Simon Boigelot

Une page Facebook pour Heode

Silverlight 3 – First look

Avant propos

Installation sur machine cliente et travail en mode offline

Bases de l’application

Rendre cette application téléchargeable Grâce au bouton fournit par la plateforme

Détecter si le pc est online ou offline

Récupérer des données à partir du site hôte de l’application

MDI Silverlight

Créer une communication TCP IP entre Silverlight 2 et .Net 3.5

1. Comprendre TCP IP sous .Net

1.1 Envoyer l’heure à travers TCP IP

1.2 Rappel

2. Comprendre le policy-file-request de Silverlight

3. Créer un client TCP Silverlight 2

3.1 Créer un client TCP Silverlight qui lit un nombre primitif

3.2 Utiliser des DataContract et un DataContractSerializer

3.3 Comprendre les KnowTypes

4. Rendre le tout générique et réutilisable

Blog Update

Methodes Anonymes - Simplifier votre code

Livre Silverlight 2

Envoyer un mail en utilisant System.Net.Mail et le SMTP de gmail

Architecture simplifiée de BizTalk

Port

Receive Port

Send Port

En contradiction avec les receive port, les send ports eux ne peuvent contenir qu’un unique port de destination.

Logical Port

Dynamic Send Port

Adaptateur

Pipeline

Orchestration

Créer une orchestration BizTalk avec Visual Studio

Rendre cette application téléchargeable
Grâce au bouton fournit par la plateforme