David REI

Ma playlist des Techdays 2008 :)

Les webcasts des techdays 2008 sont dispo !

http://www.microsoft.com/france/vision/mstechdays08/

Sinon personnellement au niveau des webcasts, ma playlist J :

Décisionnel :

            Reporting d'entreprise avec Reporting Services 2008

Découverte d'Analysis Services 2008

Extraire, Transformer, charger les données avec SQL Server Integration Services 2008

Microsoft Office PerformancePoint Server / Planning - Principes, Architecture & Conception d'une application

Linq : Linq, session avancée

Développement Web :

            IIS 7 pour les développeurs

            Développement d'applications avancées avec Silverlight 1.0

ASP.NET : ce que vous avez peut-être manqué...

Office Communications Server :

            Développez des application autour de Office Communications Server et exemple avec Dassault Systèmes

Retour d'expérience du déploiement de Office Communications Server 2007 chez Microsoft

Et demain ? :

         Introduction à F#

           F# et la parallélisation

ASP.NET MVC Preview 2

La version 2 des Asp.Net Extensions est disponible et embarque des nouvelles versions de notre ASP.NET MVC, mais aussi ADO.NET Services, ...

Je vous invite à consulter le site de Sébastien Carrière, pour plus d'infos !

ASPECTDNG et Concept

La programmation orientée objet est un concept très connu de nous tous, mais elle a cependant des inconvénients. L'héritage ne permet pas d'éviter complètement la duplication du code. Certains éléments de code sont même parfois impossible à centraliser, ce qui rend les choses beaucoup moins élégante et maintenable.

La programmation orientée ASPECT (AOP Programming) permet d'enrichir un modèle objet.

Prenons l'exemple d'une classe métier qui va gérer des produits.

public static class Product
{
public static void Order(...) { }

public static void Remove(...) { }

public static void Add(...) { }

public static void Update(...) { }
}

Nous souhaitons implémenter sur cette classe, l'aspect sécurité, la trace des actions effectuées, bref tout un tas de fonction de second plan par rapport à la fonctionnalité même! Oui oui la sécurité c'est important aussi, mais c'est pas le but de notre classe finalement... Alors certain me diront ok, très bien alors on fait une classe static, on la référence et on fait nos vérifications. Si on suit cette règle, notre classe métier référencera des composants techniques, chose qui n'est pas très très élégante, même si on trouve beaucoup de projet ainsi. La solution consiste à introduire deux aspects à notre classe, l'aspect sécurité, ainsi que l'aspect logging.

Réalisation avec ASPECTDNG pour la partie logging :

Le fonctionnement est sympa, il suffit de décrire dans un fichier les méthodes à tisser, ici nous allons tisser toutes les méthodes pour la trace.

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="xml" encoding="iso-8859-1" />

  <xsl:template match="node()">

   <xsl:copy>

    <xsl:copy-of select="@*" />

    <xsl:apply-templates select="node()" />

 </xsl:copy>

</xsl:template>

  <xsl:template match="Method">

   <xsl:copy>

    <xsl:copy-of select="@*" />

     <xsl:apply-templates select="Parameter" />

     <xsl:apply-templates select="Local" />

     <Instruction offset="-2" code="ldstr" operand="Ma Trace" />

     <Instruction offset="-1" code="call" operand="System.Console WriteLine(System.String)" />

    <xsl:apply-templates select="node()" />

 </xsl:copy>

</xsl:template>

</xsl:stylesheet>

 

Après la compilation, ASPECTDNG patch le code existant afin de réaliser les actions conformément au fichier ci dessus.

On a donc aucune dépendance dans notre code source, le code est plus élégant et plus maintenable .. Il nous faut juste déclarer nos actions dans le fichier ASPECTDNG.

 

La programmation par aspect est vraiment puissante lorsqu'on l'utilise de pair avec notre modèle objet classique, je vous invite fortement à étudier

ces concepts, pour ceux qui ne l'on pas déjà fait.

 

D'autant plus que ce n'était vraiment qu'un aperçu très très mince de ses fonctionnalités.

ASP.Net 3.5 Extensions

L'ASP.Net 3.5 Extensions est désormais en CTP !

Pour plus d'infos :
http://www.blogtech.fr/post/2007/12/RoadMap--AspNet-35.aspx
http://weblogs.asp.net/scottgu/archive/2007/12/09/asp-net-3-5-extensions-ctp-preview-released.aspx

WSS, MOSS 2007 : SP1

Du nouveau sur WSS et SharePoint Server 2007, les SP1 sont en preview !!

On y retrouve notamment :

• Une compatibilité avec Microsoft AJAX 1.0 Control toolkit et AJAX 1.0 Extensions
• La possibilité de réaliser des WebPart en utilisant Microsoft AJAX
• Le support pour Windows Server 2008
• Plus de 60 correctifs sur les produits
• Des nouvelles commandes STSAdm
  
• ...
  

Le Binding avec WPF

Le binding est possible avec WPF grâce à l'objet Binding, contenu dans le namespace "System.Windows.Data.Binding".
On peut l'utiliser pour mettre en adéquation deux propriétés.

Prenons deux TextBox  :

1
 

<TextBox x:Name=?txtName? Text=""/> 

<TextBox x:Name=?txtBlog? Text=""/>

Nous souhaitons associer la propriété Text du contrôle txtName à celle de txtBlog,
on pourra utiliser cette méthode dans le fichier cs :

1
2
3
4
5
6
7
 

Binding binding = new Binding();
// Déclarer la source du binding
binding.Source = txtName;
// Déclarer la propriété utilisée

binding.Path = new PropertyPath("Text");
// Attacher au contrôle
txtBlog.SetBinding(TextBox.TextProperty, binding);

ou plus largement dans le xaml..

1
2
3
4
 

 
<TextBox x:Name=?txtName? Text=""/> 
<TextBox x:Name=?txtBlog? 

   Text="{Binding Text, ElementName=txtName}"/>
 

Les deux méthodes permettent à chaque modification du contenu du contrôle txtName, 
la modification de la propriété Text du txtBlog.

Pour effacer un binding existant, rien de plus simple;

1
 

BindingOperations.ClearBinding(txtBlog, TextBlock.TextProperty);

On peut ensuite, comme l'a evoqué Thomas LEBRUN dans son article, utiliser le binding avec un DataTemplate pour une ListBox par exemple;

1
2
3
4
5
6
7
8
 

<ListBox x:Name="itemList" 

   ItemsSource="{Binding Source={StaticResource listItems}}">
   <ListBox.ItemTemplate>
      <DataTemplate>
         <TextBox Text="{Binding Path=text}"/>
      </DataTemplate>
   </ListBox.ItemTemplate>
</ListBox>

A présent, nous souhaitons contrôler l'évenement déclencheur du binding. Pour cela, il est souhaitable d'attribuer à la propriété "UpdateSourceTrigger" de l'objet Binding, la valeur UpdateSourceTrigger.Explicit. Dés lors, lorsque nous souhaitons rafraichir la propriété Text, nous pourrons ordonner sa mise à jour grâce à l'appel :

1
 

txtBlog.GetBindingExpression(TextBox.TextProperty).UpdateSource();

Avec WPF tout est possible... ou presque

Mini-Projet SNCF avec WCF, WPF, Linq

Bonsoir à tous !

Pour illustrer quelques possibilités offertes par WCF et Linq To SQL dans un projet .NET 3.5, j'ai choisis la thématique SNCF.

En ces temps de grève, on peut imaginer (avec un peu d'effort), que le nom des trains change fréquemment. Cette solution contiendra donc une interface WPF, avec laquelle nous pourrons modifier les noms des trains et ... c'est déjà pas mal. 

Encore une fois le but du jeu est de tester et de réfléchir sur l'architecture que l'on peut mettre en place.

I Architecture de la solution :

• Un projet SNCF.DataAccessLayer avec LinqToSQL.
• Un projet SNCF.BusinessLayer avec les méthodes métiers.
• Un projet SNCF.Common pour les objets communs aux projets.
• un projet SNCF.WCFInterfaces qui définit les contrats.
• Un projet SNCF.WCFServices qui implémente les méthodes grâce à une classe.
• Un projet SNCF.WCFHost qui démarre le service WCF.
• et pour finir, le projet SNCF.UI.WPF qui consommera le service.

II Aperçu de l'interface WPF :

III DataAccess et LinqToSQL

Pour le projet d'accès aux données, il me suffit d'ajouter un fichier dbml, d'y ajouter ma table et les différentes procédures stockées, et le tour est joué.

C'est très physique le "glisser déplacer".

III Business Layer

La couche métier définit trois méthodes statiques.

1
2
3
4
5
 

public static SNCF.Common.Train Get(Guid idTrain);

public static List<SNCF.Common.Train> GetAll();

public static bool Update(SNCF.Common.Train t);

IV WCFInterfaces

Le projet WCFInterfaces va permettre de définir les contrats, on y trouve une interface IServices.

On va déclarer les services que l'on veut utiliser et on y ajoute l'assembly ServiceModel qui va nous permettre de définir les contrats.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 

using System.ServiceModel;
using SNCF.Common;

namespace SNCF.WCFInterfaces
{
    [ServiceContract(Namespace = "http://localhost/WCF/TrainServices")]
    public interface IServices
    {
        [OperationContract]
        Train Get(Guid idTrain);

        [OperationContract]
        List<Train> GetAll();

        [OperationContract]
        bool Update(Train t);
    }
} 

VI WCFServices

Après avoir défini les contrats, on va créer une classe qui va implémenter l'interface, j'ai choisi "TrainServices.cs".

Cette classe associe, les méthodes déclarées dans le contrat à la couche BusinessLayer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 

using SNCF.WCFInterfaces;
using SNCF.BusinessLayer;
using SNCF.Common;

namespace SNCF.WCFServices
{
    public class TrainServices : IServices
    {
        public Train Get(Guid idTrain)
        {
            return TrainDAO.Get(idTrain);
        } 

        public List<Train> GetAll()
        {
            return TrainDAO.GetAll();
        } 

        public bool Update(Train t)
        {
           return TrainDAO.Update(t);
        }
    }
} 

VII WCFHost

Une fois l'ensemble (DataAccessLayer, BusinessLayer, WCFServices et WCFInterfaces) terminé, nous pouvons démarrer le service WCF.

C'est l'objectif de cette application console.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 

using System.ServiceModel;
using SNCF.WCFServices;
using SNCF.WCFInterfaces;

namespace SNCF.WCFHost
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = 
                new ServiceHost(typeof(TrainServices));

            host.AddServiceEndpoint(typeof(IServices),
                new BasicHttpBinding(),
                "http://localhost/WCF/TrainServices");

            host.Open();

            Console.WriteLine("Service Disponible");
            Console.ReadLine();

            host.Close();
        }
    }
}

VIII WPF UserInterface

L'interface WPF peut à présent se connecter au service.

1
2
3
 

ChannelFactory<IServices> myFactory;

IServices myService;
public MainWindow(){   

   InitializeComponent();               

   myFactory = new ChannelFactory<IServices>(new BasicHttpBinding(),

               http://localhost/WCF/TrainServices);

   myService = myFactory.CreateChannel();            
   // ComboBox DataSource   

   cboTrain.ItemsSource = myService.GetAll();

}

Conclusion :

Cette solution est très intéressante pour exposer très facilement toute la structure métier de son application sans se préoccuper de la nature, et de la localisation de l'interface utlisateur qui l'interroge. Si vous avez des remarques sur l'architecture, n'hésitez pas à intervenir, je suis friand de vos idées. 

L'intégralité de la solution est disponible à cette adresse. (La solution est réalisée avec Visual Studio 2008 béta 2).

PS : Cet article peut être amené à évoluer suivant vos remarques.

.NET autour d'un bon vieux BlackJack ? :)

Microsoft After Dark est une sorte de "causerie" entre gens de bonne compagnie.
On y retrouve des développeurs de la firme de Redmond en pleine distraction,
me direz-vous ?
Eh bien non, pas tout à fait ! On parle boulot.

Pour ma part, je pense que c'est une manière assez originale et sympathique, d'échanger de l'information.
A quand le CodeS-SourceS After Dark ?