Bienvenue à Blogs CodeS-SourceS Identification | Inscription | Aide

Pierrick's Blog

.Net "full power"

Another Reflector : ILSpy

Suite à une annonce de Red-Gate datant du 2/02/2011 concernant Reflector (fin de la gratuité du produit), un nouveau projet pointe le bout de son nez.

http://www.ilspy.net/ http://wiki.sharpdevelop.net/ILSpy.ashx

il supporte plusieurs versions du framework .Net en même temps :

image

nota : la recherche est un peu lente (la roadmap prévoit d’améliorer ce point)

en revanche ouvrir une assembly depuis le GAC, et bien plus rapide que dans Reflector

image

pour l’instant seuls les langages C# et IL sont supportés en décompilation. Cet outil est extensible via MEF, il donc très facile d’ajouter son langage.

1) il suffit pour créer une assembly xxx.Plugin.dll
2) Exporter une classe “language”

image

et le résultat donne :

image

un projet à suivre absolument !

si vous désirez l’essayer : http://build.sharpdevelop.net/BuildArtefacts/#ILSpy

VSIX : des signets numérotés

Comme je l’écrivais dans mon post précédent, je suis un fan des extensions Visual Studio 2010.

En tant qu’ancien “Delphiste”, il y a une fonctionnalité que j’apprécie dans l’IDE de Delphi, c’est la possibilité de placer jusqu’a 10 signets numérotés de 0 à 9.

Ces signets se définissent grâce à CTRL-SHIFT-(0 à 9), et pour se déplacer à un signet CTRL-(0 à 9)

j’ai donc reproduit cette fonctionnalité, en faisant une extension au niveau de l’éditeur de Visual Studio 2010

image

le principe est le suivant :

image

- à gauche la partie qui fournit le “Visuel” ( IGlyphFactory) pour chaque tag généré par le tagger.

- au centre la partie qui génère une liste de tags pour une view donnée (le Tagger)
  effectue une sorte mapping entre un ligne “visuelle” et un signet

- à droite la partie qui intercepte les combinaisons de touches et met à jour les signets

 

Si vous voulez écrire vos propre extensions pour Visual Studio 2010, MSDN fournit de nombreux exemples.

pour tester cette extension ?,  c’est comme pour la précédente ..

… il suffit de la télécharger via “l’extension manager” en cliquant sur cette icône dans la barre d’outils de Visual Studio

image_1E614A96[1]

selectionez ensuite “online gallery”, puis tapez “Pierrick” dans la zone de recherche

image

“have a fun” !

VSIX : Projects output path (définir les chemins de sorties d’une solution en 1 clic)

Réaliser une extension pour Visual Studio 2010, est devenu un jeu d’enfant avec l’ arrivée de l’ extension manager (surtout pour le déploiement).

Je suis devenu un fan de cet “extension manager”. Je vous propose donc une extension qui permet de définir le répertoire de sortie des projets d’une solution, le tout au sein d’une seule fenêtre.

image

seul les alias des chemins sont affichés, il suffit ensuite d’un seul clic pour choisir un répertoire de sortie ou un autre pour un projet précis. lors du “apply” seul le chemin de sortie de la configuration courante(Debug, Release,…) est changé .

la configuration des chemins/alias se fait via <<Tools-Options>>

image

dans cette première version je me suis limité à 4 chemins personnalisable.

si vous voulez l’essayer il suffit de la télécharger via “l’extension manager” en cliquant sur cette icône dans la barre d’outils de Visual Studio

image  

selectionez ensuite “online gallery”, puis tapez “Pierrick” dans la zone de recherche

image

en espérant que cette extension puisse vous aider !

bon téléchargement

Editer les fichiers Erlang dans VS2010, avec la coloration syntaxique

Visual Studio 2010 possède un nouvel éditeur, réalisé en WPF. En utilisant le SDK de Visual Studio il est possible de le personnaliser.

c’est ce que j’ai fait en réalisant une extension pour rendre la lecture des fichiers erlang (*.erl) plus agréable.

image 

La coloration syntaxique néccessite de parser le “source” de l’éditeur.

en effet :

- la mise en couleur du texte, nécessite que celui-ci soit transformé en token (String, Number, Variable, Define,….) via un scanner

- la mise en place des régions nécessite un parser, afin de transformer les tokens en arbre syntaxique –> dans cet arbre on y trouve la notion de “fonction” qui définie une region dans le cas ci-dessus.

- de même pour le matching des parenthèses, il faut que le source soit sous forme de tokens

- la mise en evidence des mots identiques peut être réalisé de trois façons :

  - recherche de mots identiques sous forme de texte

  - recherche de tokens identiques

  - recherche de tokens identiques en tenant compte de la portée (une variable d’une fonction)

 

le principe utilisé ici est simple, un parser est associé à chaque TexBuffer (buffer representant le source du fichier en cours d’édition)

image 

Les “taggers” ont la responsabilité de fournir une liste de tag contenant  :

- la position  + une longueur dans le buffer

- le formatage à appliquer sur cette zone

ces taggers, s’appuient sur le parser associé au document en cours, pour fournir leur liste de “tags”

si vous voulez en connaitre plus sur la personalisation de Visual studio, je vous conseille le sdk de visual studio

cette extension est disponible sur visualstudiogallery

ou dans “l’extension manager” de Visual Studio 2010

image

 

Bon téléchargement !

Cab + MEF

Avec l’arrivée du Framework 4, une nouvelle brique fait son apparition : MEF (Managed Extensibility Framework).

Or par le passé il existait un framework fourni par Pattern & Practices, le composition UI application block (CAB).

Le CAB(Composite UI Application Block)  est un block applicatif pour concevoir des applications modulaires. les liaisons entre modules applicatifs sont faite par injection de dépendances

MEF : Managed Extensibility Framework est un nouveau framework pour concevoir des applications modulaires, fourni avec le framework .Net 4.0. comme pour le CAB, la liaison entre module est aussi par injection de dépendances.

Ces deux frameworks ont la même finalité, mais l’un datant de 2005, et l’ autre 2010 (date de sortie du framework 4 dans sa version définitive)

le but du post est de montrer que l’on peut intégrer dans une application “CAB”, des modules utilisant MEF et le framework 4.0 sans recompiler votre application initiale.

Rappel : une application CAB de base est une “coquille vide”, appelé  “shell”. C’est ce shell qui héberge les différents modules de l’application.

voici le shell sans module applicatif (une forme vide)

image

un fichier (profilecatalog.xml) contenant les différents modules à charger est associé à cette application

<SolutionProfile xmlns="http://schemas.microsoft.com/pag/cab-profile/2.0">
  <Section Name="Services">
    <Modules>
      <ModuleInfo AssemblyFile="Infrastructure.Module.dll" />
    </Modules>
  </Section>
  <Section Name="Layout">
    <Dependencies>
      <Dependency Name="Services" />
    </Dependencies>
    <Modules>
      <ModuleInfo AssemblyFile="Infrastructure.Layout.dll" />
    </Modules>
  </Section>
  <Section Name="Core">
    <Dependencies>
      <Dependency Name="Services" />
      <Dependency Name="Layout" />
    </Dependencies>
    <Modules>
      <ModuleInfo AssemblyFile="Core.dll" />
    </Modules>
  </Section>
  <Section Name="Libraries">
    <Dependencies>
      <Dependency Name="Services" />
      <Dependency Name="Layout" />
      <Dependency Name="Core" />
    </Dependencies>
    <Modules>
    </Modules>
  </Section>
  <Section Name="Editor">
    <Dependencies>
      <Dependency Name="Core" />
      <Dependency Name="Libraries" />
    </Dependencies>
    <Modules>
      <ModuleInfo AssemblyFile="Editor.dll" />
      <ModuleInfo AssemblyFile="ErlangProject.dll" />
    </Modules>
  </Section>
</SolutionProfile>

Les différents modules sont maintenant disponible au sein de l’application.

image 
en rouge le visuel des différents modules applicatifs

Nous allons maintenant intégrer MEF dans cette application. Il faut tout d’abord quelle s’execute avec le framework .Net 4.0, pour cela il suffit de modifier le fichier app.config comme suit :

<configuration>
  ...
 

  <startup useLegacyV2RuntimeActivationPolicy="true">
    <
requiredRuntime version="4.0.21006"/>
  </
startup>
</
configuration>

l’application maintenant s’execute avec le framework 4.0, et supporte le legacy… ;-), et donc de charger des assemblies .Net  2.0

pour que notre module MEF soit prise en compte par le shell, il faut completer le “profilecatalog.xml”, et y ajouter notre nouveau module “CAB”  compilé en 4.0

<SolutionProfile xmlns="http://schemas.microsoft.com/pag/cab-profile/2.0">
    <Modules>
      <ModuleInfo AssemblyFile="Editor.dll" />
      <ModuleInfo AssemblyFile="ErlangProject.dll" />
     
<ModuleInfo AssemblyFile="WorkflowIntegration.dll" />
    </Modules>
  </Section>
</SolutionProfile>

Cette assembly contient le code d’ initialisation du container MEF, mais aussi le code pour être reconnu comme en tant que module CAB.

Pour l’exemple j’ai intégré le nouveau designer de workflow du framework 4.0, il existe plusieurs tutoriel pour cela :

http://msdn.microsoft.com/en-us/library/dd489451(VS.100).aspx
http://msmvps.com/blogs/theproblemsolver/archive/2009/12/23/rehosting-the-workflow-designer-in-wf4.aspx

je me suis basé sur le deuxième exemple, en ajoutant un pincée de “MEF” ;-) cela donne :

image

regardons un peu sous capot, comment cela s’architecture.

l’intégration du conteneur MEF dans un module CAB est très simple :

    class WorkflowIntegrationModuleController : WorkItemController
    {
       
public override void Run()
        {
           
base.Run();
            AddServices();
        }

       
private void AddServices()
        {
           
//initialisation du container MEF
           
var catalog = new AggregateCatalog();
           
var thisAssembly =
               
new AssemblyCatalog(
                    System.Reflection.
Assembly.GetExecutingAssembly());

            catalog.Catalogs.Add(thisAssembly);
            catalog.Catalogs.Add(
new AssemblyCatalog(typeof(IDesignerController).Assembly));
           
//le sous répertoire nommé MefAddin, est utilisé pour les modules MEF
           
var extensionDir = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            extensionDir = System.IO.
Path.Combine(extensionDir, "MefAddin");
           
if (System.IO.Directory.Exists(extensionDir))
                catalog.Catalogs.Add(
new DirectoryCatalog(extensionDir));     
           
var container = new CompositionContainer(catalog);
           
//ajout du container en tant que service CAB, le usercontrol hostant le designer WF est une [SmartPart] (CAB)
           
this.WorkItem.RootWorkItem.Services.Add<CompositionContainer>(container);
        }
    }

Ce modulecontroller est instancié au chargement de l’assembly, lors de la phase d’initialisation du module.

 

Coté visuel, l’hébergement du Designer de wortkflow est faite dans un usercontrol windows forms, qui lui même sera hébergé dans le shell en tant que “smartpart” (terme CAB designant une zone visuel dans le shell)

image
vous noterez au passage que l’intégration de WPF dans du windows forms fonctionne très bien dans l’ide, et cela via la classe “ElementHost”.

Ce usercontrol réalise la liaison WindowsForms<->WPF, mais aussi la liaison entre CAB et MEF.

    public partial class WfDocumentDesigner : WfDocumentGenericDesigner
    {
       
public WfDocumentDesigner()
        {
            InitializeComponent();

        }

       
public WfDocumentDesigner(WfDocument doc)
            : base(doc)
        {
            InitializeComponent();
           
this.elementHost1.HostContainer.Loaded += new System.Windows.RoutedEventHandler(HostContainer_Loaded);
        }

       
void HostContainer_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
           
if (DesignerController != null)
            {
               
var documentContent = this.Document.Content;
               
if (string.IsNullOrEmpty(documentContent))
                {
                    DesignerController.New(
new FlowchartKind());
                }
               
else
                {
                   
using (System.IO.StringReader sr = new System.IO.StringReader(documentContent))
                    {
                        DesignerController.Load(sr);
                    }
                }
            }
        }
       
//injection via MEF
        [
Import(AllowDefault=true)]
       
public IDesignerController DesignerController { get; set; }

       
CompositionContainer _Container;
       
//injection via CAB
        [
ServiceDependency]
       
public CompositionContainer CompositionContainer
        {
           
get
            {
               
return _Container;
            }
           
set
            {
                _Container =
value;
               
if (value != null)
                {
                   
//injection du contenu WPF (designer WF)
                   
value.ComposeParts(this.elementHost1.Child);
                   
//injection de this
                   
value.ComposeParts(this);
                    RegisterDesigners();
                }
            }
        }

       
//injection via MEF
        [
ImportMany(typeof(IRegisterMetadata))]
       
public IEnumerable<IRegisterMetadata> RegisteredMetadata { get; set; }

       
/// <summary>
       
/// enregistrement des designers pour les activités du designer de workflow
       
/// </summary>
       
private void RegisterDesigners()
        {
           
//designers fournis par le framework
           
new System.Activities.Core.Presentation.DesignerMetadata().Register();
            //designers fournis par composition via MEF
            foreach (var item in RegisteredMetadata)
            {
               item.Register();
            }
        }
    }

on remarque bien ici que les injections CAB et MEF se font par des attributs.
- Import, ImportMany, Export,… pour MEF
- ServiceDepencency, SmartPart,… pour le CAB

En revanche si nous regardons l’implémentation du designer de workflow, il n’utilise que MEF et WPF 

    public partial class DesignerHost : UserControl, IDesignerController
    {
       
private WorkflowDesigner _workflowDesigner;
       
private string _fileName;

       
public DesignerHost()
        {
            InitializeComponent();

           
this.Loaded += new RoutedEventHandler(DesignerHost_Loaded);
        }

       
/// <summary>
       
/// interface de conrtôle du designer (chargement, enregistrement,...) 
       
/// </summary>
        [
Export]
       
public IDesignerController Controller
        {
           
get
            {
               
return this;
            }
        }

       
/// <summary>
       
/// liste des activités qui seront affichées dans la toolbox
       
/// </summary>
        [
ImportMany("Toolbox.Activities", AllowRecomposition=true)]
       
public IEnumerable<Lazy<IActivityToolboxProvider, IWorkflowCategory>> ToolboxItems { get; set; }

       
private void LoadToolbox(string categoryName) ...

   }

 

En conclusion, CAB et MEF cohabite très bien, ce qui peut permettre de faire des migrations/évolutions d’applications en douceur, tout en bénéficiant des dernières avancées technologiques.
Effectivement l’exercice ici est d’autant plus facile, que mon application est au départ modulaire. 

nota : une fois que l’application utilise le framework 4.0, il n’est plus possible de la debogger avec VS 2008, il vous faut utiliser VS 2010.

Premières lignes de code sous VS2010

 

Premières lignes et premières stupeurs…

en effet les types Action<T> et Func<T> ont pris du poids… puisque Action<T> passe de 4 paramètres à 16, idem pour Fun<>

image

Je pense que pour de la génération de code cela doit être utile, mais à écrire c’est un peu long ;-)

Installation de VS2010 sur bootcamp

j’ai fait l’acquisition d’une machine en dual boot SnowLeopard/Windows 7 x64.

j’ai donc décidé d’installer Visual studio 2010 béta 2 sur la partition Windows 7, non sans mal….

c’est parti !

image image

 

image

image

Le framework 4, ne s’ installe pas. voyons le log …

image

pas très parlant mise à part, qu’il y a un problème d’accès (à je ne sais pas quoi). Vérification faite, je suis bien Administrateur de la machine.

voyons le “log file” qui est plus détaillé :

image

c’est donc bien ça, l’installation n’arrive pas à acceder au fichier d’installation du framework

mais pourquoi ?

Antivirus ???…qu’a cela ne tienne, je desactive l’antivirus (ce serait un comble si c’était lui, puisque c’est celui de Microsoft)

nouvelle tentative,… même résultat…

l’iso télécharger depuis msdn, serait-il corrompu ?

j’ai donc télécharger le “web installer” du framework 4 uniquement, pour effectuer une nouvelle tentative

image

oui… encore moins parlant comme erreur.

à ce stade, l’absence d’idée total sur les causes eventuelles…il faut donc se résoudre à appeler mes amis Bing et Google :-)

ce que je craignais arriva, je n’ai rien trouvé sur la toile (peut-être que je n’ai pas chercher au bon endroit..)

LA solution

dans un éclair de génie, oui parfois ça arrive ;-)

le message ci-dessus m’indique que c’est clairement un problème au système de fichier. Voyons la liste des sytèmes de fichiers présent :

image

C : Windows
E: Snow Leopard
F: Visual studio 2010 béta 2

les seuls en lecture sont E: (système HFS) et F:

la solution à ce problème est bien de désactiver la lettre E

image 

image

nouvelle tentative… cette fois ci c’est la bonne !

image 

pour quelles raisons l’installation tente d’écrire sur un autre disque, de plus en lecture seul….mistère

en esperant que ce post pourra en aider d’autres !

F# =:= Erlang ?

L’ excellente série d’articles sur la programmation par messages en F#, de Luca Bolognese, s’est enrichie d’un article.

Pour ceux qui n’ont pas suivi, ça commence ici. Luca a commencé un framework, pour “faciliter” la programmation par messages avec F#. Celui-ci est basé sur les “MailboxProcessors”. Ce qui intéressant c’est son approche, qui est calquée sur le principe des processus Erlang.

En effet son framework est basé sur deux primitives : “spawnWorker” et “spawnParallelWorker”,…tiens tiens tiens, en Erlang c’est “spawn”. La notion de thread est encore un peu présente (voir dans le premier article, en Erlang cette notion n’existe pas), mais du point de vue du consommateur celle-ci peut être “oubliée”.  Dans son dernier article il explique qu’il a “ré-architecturé” son framework, afin que les agents (i.e “récepteurs de messages”) ne traitent que des messages fortement typés (ce qui pour moi est une très bonne chose, il y a plus de vérifications lors de la compilation).

Bref une série d’article à lire…, et pour le tester c’est par .

Guide de migration vers Workflow Foundation 4

Microsoft propose un guide de migration pour migrer vos workflows WF3 (framework .net 3.0, 3.5) vers WF4(framework .net 4.0)

http://www.microsoft.com/downloads/details.aspx?FamilyID=bd94c260-b5e0-4d12-93ec-53567505e685&displaylang=en

 

source : http://blogs.msdn.com/swiss_dpe_team/archive/2009/06/06/migration-guidance-for-wf-developers.aspx

Tetris on the cloud !

Il y a quelque temps (un peu plus de 2 ans 1/2), je testais WPF, WCF, WF et à cette occasion j’avais réalisé un jeu, une forme de “Tetris” mais multi-joueurs

image

Celui-ci était réalisé avec le framework 3.0.

Un framework et un servicepack plus tard j’ai donc décidé de le faire évoluer, et d’utiliser Windows Azure.

Architecture d’origine

Chaque joueur pouvant être “serveur”, toutes connexions entre les joueurs passe par le serveur.

image

Le serveur doit être connu de tout les participants. Le serveur est un service WCF  basé sur le protocole “net.p2p”. J’ai pour cela dérivé la classe “System.ServiceModel.PeerResolver”.

Inconvénients

  1. Le joueur serveur reçoit toute les connexions, si il “tombe” le jeu est terminé pour l’ensemble des joueurs
  2. autre inconvénient majeur de cette solution est l’ouverture d’un port sur toute les machines.
  3. Le joueur serveur est aussi avantagé, sa connexion avec le “serveur” est locale.
  4. Cette architecture était plutôt orientée LAN

Le but au départ était de montrer un exemple utilisant les nouvelles briques du framework 3.0.

Ce qu’apporte Windows Azure et le ServiceBus

Pour ce jeu, j’ai tout simplement remplacer toute la partie qui gère le p2p entre les joueurs, c’est le rôle de la plateforme Azure.  Si vous ne connaissez pas cette plateforme vous trouverez pas mal d’informations ici.

Le service utilisé dans ce jeu est le ServiceBus, et plus particulièrement la publication/souscription en multicast.

image

Tous les participants sont connectés sur un même point central (défini par une uri), et ainsi peuvent envoyer/recevoir sans avoir besoin de se connaitre mutuellement.

ainsi la nouvelle architecture est :

image

ceci est l’état du système lors d’une phase de jeu. Mais que ce passe-t-il avant….au commencement du jeu…

image

  1. Le joueur qui désire être serveur, envoi un message “SendRequest” avec l’uri pour répondre (ici : sb://…/Guid/Acceptor)
  2. les joueurs souhaitant participer se connectent au service d’acceptation pour obtenir une autre Uri, cette fois celle du service multicast pour la nouvelle partie. celle-ci est générée dynamiquement à chaque nouvelle partie.
  3. les joueurs ayant accepter l’invitation du serveur se retrouvent connectés ensemble sur un point qu’il sont seuls à connaitre.

 image

ainsi plusieurs parties peuvent avoir lieu au sein de la même “solution“ Windows Azure

Les différentes interfaces des différents services

La gestion de la connexion (service représenté en orange ci-dessus), ce service permet au joueurs de se voir mutuellement

[ServiceContract(Namespace = Constants.ContractNamespace)]
public interface IPeerConnexionService
{
    #region connection managment
   
/// <summary>
    /// used to join, others player should respond with hello 
    /// </summary>
    [OperationContract(IsOneWay = true)]
   
void Join(PeerPlayer player);

   
/// <summary>
    /// used to leave the room
    /// </summary>
    [OperationContract(IsOneWay = true)]
   
void Leave(PeerPlayer player);

   
/// <summary>
    /// the new player receive one "Hello" from all other players
    /// </summary>
    [OperationContract(IsOneWay = true)]
   
void Hello(PeerPlayer player);

   
/// <summary>
    /// used to send a ping to a specific player
    /// </summary>
    [OperationContract(IsOneWay = true)]
   
void Ping(PeerPlayer from, PeerPlayer to);

   
/// <summary>
    /// used to respond from ping
    /// </summary>
    /// <param name="from"></param>
    /// <param name="to"></param>
    [OperationContract(IsOneWay = true)]
   
void Pong(PeerPlayer from, PeerPlayer to);

   
/// <summary>
    /// 
    /// </summary>
    /// <param name="player"></param>
    /// <param name="acceptor">uri of the acceptor service</param>
    [OperationContract(IsOneWay = true)]
   
void SendGameRequest(PeerPlayer player, Uri acceptor);
    #endregion
}

 

Le service que chaque joueur publie pour accepter les autres joueur dans son espace de jeu. ce service à la particularité d’être un service “wcf” standard, contrairement aux autres qui sont “multicast”

[ServiceContract(Namespace = Constants.ContractNamespace)]
public interface IAcceptorService
{
    [
OperationContract]
   
Uri IWouldLikeToplay(PeerPlayer player);
}

 

service utiliser pendant la phase de jeu (en vert sur le schéma ci-dessus)

    [ServiceContract(Namespace = Constants.ContractNamespace)]
   
public interface ITetrisGameService
    {
        [
OperationContract(IsOneWay = true)]
       
void SendBoard(Guid idplayer, byte[] board, int lengthDimension0, int lengthDimension1);

        [
OperationContract(IsOneWay = true)]
       
void SetTimerInterval(Guid idplayer, double newValue);

        [
OperationContract(IsOneWay = true)]
       
void GameOver(Guid idplayer);

        [
OperationContract(IsOneWay = true)]
       
void SendOption(Guid from, Guid to, byte option);

        [
OperationContract(IsOneWay = true)]
       
void SendScore(Guid idplayer, int score);

        [
OperationContract(IsOneWay = true)]
       
void HideBoard(Guid idplayer, bool value);

        [
OperationContract(IsOneWay = true)]
       
void GameStarting(Guid idCoordinator, int nbPlayer);

        [
OperationContract(IsOneWay = true)]
       
void PlayerReady(Guid idplayer);

        [
OperationContract(IsOneWay = true)]
       
void ImIn(Guid idplayer);
    }

Premières impressions

  • extrêmement simple de publier un service mondialement ! ;-)
  • c’est du WCF, donc la configuration est identique à ce que l’on connais déjà
  • la publication des services sur le cloud reste assez lente (plusieurs secondes par service)
    • il ne faut pas oublier que le framework Windows Azure est en CTP
    • par contre ensuite (dans le cadre du tetris) une fois la connexion établie,  les échanges sont fluides.
    • vous le remarquerez en cliquant sur “connect to mesh” dans le menu “game”

 

Utiliser ce jeu

Téléchargez l’installation depuis codeplex : http://geniustetris.codeplex.com/

une fois installer il faut modifier le fichier de configuration de l’application “geniustetris.exe.config”, plus précisément  les “credentials” pour se connecter à windows azure

    <behaviors>
      <
endpointBehaviors>
        <
behavior name="password">
          <
transportClientEndpointBehavior credentialType="UserNamePassword">
            <
clientCredentials>
              <
userNamePassword userName="GeniusTetris" password="****" />
            </
clientCredentials>
          </
transportClientEndpointBehavior>
        </
behavior>
      </
endpointBehaviors>
    </
behaviors>

Remplacer “GeniusTetris” par le nom votre solution Windows Azure, et le mot de passe par le votre. n’oubliez pas de modifier dans le jeu les options “réseaux” et de fournir le nom de la solution à utiliser.

il est possible d’utiliser d’autres moyens d’authentification  comme “CardSpace”, cela fonctionne aussi.

vous voulez jouer ? alors rendez vous sur http://geniustetris.codeplex.com/

 

bon amusement !

“Axum” un langage pour le faciliter l’écriture d’applications parallèles

un nouveau projet à vu le jour sur dev labs, il s’agit d’un langage Axum

Curieux.., j’ai installer le msi, qui me donne dans visual studio 2008, un type de projet supplémentaire :

image

 

curieux de connaitre ce qui avait derrière… j’ai suivi le webcast présent sur devlabs, et réalisé ma librairie mathématiques….

using System;
using System.Collections.Generic;
using System.Text;

namespace AxumMath
{
       
public channel IntOperator
    {
       
input int X;
       
input int Y;
       
output int Z;
    }
    
       
public agent AdderAgent : channel IntOperator
    {
       
public AdderAgent()
        {
           
while(true)
            {                
                Z
<-- (receive(X) + receive(Y));
            }
        }
    }
}

qui fait une addition….

mes premiers sentiments au sujet de ce langage sont :

  • effectivement on commence par décrire le message que l’on souhaite traiter, ensuite l’agent qui traite le message. mais je trouve cette description encore un peu trop verbeuse...

je pense qu’il est possible d’être un peu plus succinct.

public message IntOperator
{
   
input int X;
   
input int Y;
   
output int Z;
}

public agent AdderAgent
{
       
receive<IntOperator
        {
                Z
<-- X + Y;
        }
}

évidemment on peut imaginer une multitude d’écriture…

  • ce sucre syntaxique génère beaucoup de code(voir plus bas), mais en revanche cela simplifie l’écriture des applications
  • ce langage s’approche du domaine fonctionnel mais sans l’être.
  • le type du message est très “parlant”, on sait immédiatement ce qui est en entrée(input) et en sortie(ouput).

Revenons à notre agent et channel d’origine, et voyons ce que devient le code une fois compilé :

image

en réalité le mot clé channel, génère une classe avec les données qui dérive d’un classe “Channel”, mais pas seulement...

image

les données X,Y, Z, ne sont pas membres de la classe sous forme d’entier, mais sous forme d’objet complexe. Et oui fournir un langage pour concevoir des applications parallèles n’est pas simple…, surtout si le langage doit être accessible aux plus grands nombre,tout en rendant abstrait la distribution/parallélisme de “calculs utilisateur”.

en creusant un peu plus, cette implémentation de Axum utilise WCF pour faire transiter les données “input” :

image

il est clair que pour faire une addition, c’est peu être un peu trop…

La programmation parallèle est de plus en plus présente, tout les acteurs proposent des frameworks, langages, outils pour développer plus facilement des applications parallèles.

  • Outils
    • intel parallel studio
    • visual sutdio 2010
  • Framework
    • Parallel Fx (.Net)
    • PLINQ (.Net)
    • JPPF (java)
  • Langages
    • Arche (successeur de Polygoth)
    • Erlang
    • Axum

cette liste n’est pas exhaustive, mais la tendance est là !

“Code canvas” / Deep Zoom for code

Microsoft Research nous présente leur travaux sur l’interface homme machine dans le domaine de la programmation. Ce projet à pour but de visualiser votre code sous un autre angle...

Aujourd’hui dans Visual studio nous avons plusieurs manière de “voir” notre code:

  • l’éditeur de code (et oui parfois c’est pratique pour tapez du code…)
  • l’explorateur de classes
  • l’explorateur de solution
  • l’explorateur d’objet
  • les differents designers (windows forms, WPF, WF,…)
  • ...

et bien il y a un petit nouveau qui pointe son nez !

image

en fonction du zoom on voit les dépendances

  • entre les assemblies
  • entre les fichiers sources
  • entre les classes
  • entre les propriétés des classes

une superbe application du “deep zoom”, à voir absolument !

 

un autre exemple issue du webcast sur le CCI (Common Compiler Infrastructure)

image 

un conseil : regarder ce webcast !

les liens :

 

un projet à suivre asbolument !

[ccimetadata] un framework pour écrire des lecteurs/écrivains pour MSIL

ccimetadata est un projet disponible sur codeplex  qui permet d’écrire des lecteurs /ecrivains pour MSIL et les fichiers de symboles.

 

mais à quoi cela peut-il bien servir ?

FxCop, ILMerge sont  des applications cible de ce framework. Mais si je vous dit “programmation orienté aspect”… ça vous parle ?

Effectivement ce type de framewrk peut être utilisé pour faire du tissage d’aspect.

et devinez qui participe à ce projet ??

-> jonathan de halleux, acteur sur les projets Pex, QuickGraphcci, codecontracts, Chess et  le créateur de MBUnit

 

encore un projet MsResearch à suivre !

DevLabs: CodeContracts

un petit nouveau est apparu sur DevLabs. il s'agit de CodeContracts, un framework de vérification. Il vous suffit de spécifier sur vos API, des pré-conditions, post-conditions, et invariants sous forme de contrats. Ces contrats peuvent ensuite utilisés pour une vérification statique (à la compilation), pour une vérification au runtime (à l'éxécution), mais ces contrats peuvent être utilisés aussi  pour les tests, et bien sur pour la documentation. En effet je pense que ce dernier point permet de garder toujours une documentation en adéquation avec le code (puisqu'elle en est issue..).

un projet à suivre tout comme Pex....

Installation de Windows 7 dans un fichier vhd

il existe un bon tutoriel pour installer Windows 7 dans un fichier .vhd, c'est ici : http://blogs.msdn.com/editeurs_de_logiciels/pages/installer-windows-7-beta-sans-casser-votre-machine.aspx

cependant si comme pour moi cette procédure ne fonctionne pas correctement (i.e le chargement du driver disk.sys, provoque un reboot au démarrage du sytème, et donc la machine reboot indéfiniment).

voici une solution qui fonctionne dans mon cas.

Modifier l'étape 7 :

7. Nous allons ensuite créer un disque virtuel (*.vhd), pour ensuite installer Windows 7, en utilisant l’utilitaire diskpart.exe, suivi des commandes suivantes pour créer un disque virtuel.

   create vdisk file=c:\win7beta.vhd maximum=32000

   select vdisk file=c:\win7beta.vhd

   attach vdisk

   exit

La commande create vdisk file=”xxx” maximum=yyy permet de fixer la taille de votre disque virtuel. Prévoyez suffisamment d’espace pour vos applications. Dans l’exemple, j’ai choisi de créer un disque virtuel représenté par c:\win7beta.vhd de taille 32 Go.

le but est de placer le fichier .vhd dans un sous répertoire et non à la racine (ne me demandez pas pourquoi...mystère).

donc avant d'executer dispkart, il faut d'abord créer un répertoire

md c:\vhd

ensuite le reste identique au répertoire près

7. Nous allons ensuite créer un disque virtuel (*.vhd), pour ensuite installer Windows 7, en utilisant l’utilitaire diskpart.exe, suivi des commandes suivantes pour créer un disque virtuel.

   create vdisk file=c:\vhd\win7beta.vhd maximum=32000

   select vdisk file=c:\vhd\win7beta.vhd

   attach vdisk

   exit

La commande create vdisk file=”xxx” maximum=yyy permet de fixer la taille de votre disque virtuel. Prévoyez suffisamment d’espace pour vos applications. Dans l’exemple, j’ai choisi de créer un disque virtuel représenté par c:\vhd\win7beta.vhd de taille 32 Go.

 

Cette méthode possède l' avantage de ne pas toucher au système hôte.

Un Silverlight tour, sous forme de formation

Les sociétés RunAtServer Consulting et Octo Technology organisent une halte à Paris du Silverlight Tour le 19, 20, 21 Janvier 2009.

c' est Laurent Duveau (MVP canadien) qui donne cette formation à Paris. Si vous êtes intéressé c' est ici.

Small basic - un projet intéressant

Connaissez vous ce projet : small basic ?

c' est un projet hébergé sur msdn devLabs, dont le but est d' apprendre la programmation aux débutants (faq).

image 

l' interface est bluffante (en WPF évidement), Mais le coté intéressant de ce projet est l' approche utilisateur :

  • un langage avec 14 mots clés (donc simple)
  • Approche très contextuel
  • Une aide au fil de l' eau
  • Le clic droit dans l' éditeur est absent, mais dans ce cadre inutile
  • Intellisense limité à 7 élements visible, mais la liste est circulaire
  • Ici l' utilisateur ne fait que consommer des objets, il n' a pas la possibilité d' en définir.

Conclusion :

il possible de faire un IDE avec une dizaine de "commandes".

Dans bien des cas on désire offrir à une catégorie de personnes, un éditeur de script orienté "métier". Je pense que ce projet est une bonne source d' inspiration.

 

Une autre question me chatouille quelques neurones...

Il existe un éditeur de code en WPF ?

- oui

Ce projet est basé sur une partie d' un framework qui à fait son apparition à la PDC "Olso SDK". Tiens, tiens... serait-ce un avant goût du prochain Intellipad ?

Training KIT .NEt 4.0 déjà dispo !

au hazard des mes lectures..., j'ai découvert via ce blog, et qu'il était possible de télécharger le training kit pour Visual Studio 2010.

et oui on en oublierai presque que le Framework 3.5 sp1 viens de sortir il y a 3 mois...

Pacman Silverlight 2 RTW (enfin !)

je n'avais pas encore eu le temps de migrer ce petit jeu pour la version RTW de Silverlight 2.0. C'est dorénavant chose faite :

Amusez vous bien !

pour ceux qui ont encore le client Silverlight Béta 2, l'ancien fonctionne toujours mais à cette adresse : ici

Comment faire un récepteur de messages à la Erlang en C#

Un autre langage utilise lui aussi le pattern matching pour la reception des "messages" dans la communication inter-process, c'est Erlang. En effet en Erlang pour recevoir des messages on utilise ce type de syntaxe :

receive
    Pattern1 ->
      Expressions1;
    Pattern2 ->
      Expressions2;
end

un exemple :

receive
    {rectangle, Width, Ht} ->
        io:format("Aera of rectangle is ~p~n", [Width * Ht]);
    {circle, R} ->
        io:format("Aera of circle is ~p~n", [3.14159 * R * R]);
end

On remarque aisément que cela ressemble à un switch. tiens, tiens, ... ni aurait-il pas une ressemblance avec ce post(comment faire un pattern matching en C# comme celui de F#) ?

Mais comme on parle de messages, on peut imaginer un système de "publish-subscribe" basé sur le Type du message.

on pourrait ainsi écrire en C# :

    class Program
    {
       
class MyRectangle
        {
           
public int Width { get; set; }
           
public int Ht { get; set; }
        }

       
class MyCircle
        {
           
public int R { get; set; }
        }


       
static void Main(string[] args)
        {
           
PubSub.Subscribe<MyRectangle>(r =>
            {
               
Console.WriteLine("Area of Rectangle is {0}", r.Width * r.Ht);
            });
           
PubSub.Subscribe<MyCircle>(c =>
            {
               
Console.WriteLine("Area of Circle is {0}", c.R * c.R * 3.14159);
            });

           
//publication 
            new MyRectangle() { Width = 6, Ht = 10 }.Publish();
           
new MyCircle() { R = 23 }.Publish();

           
Console.ReadLine();
           
return;
        }
    }

à l' exécution

image

Le principe  ?

Associer un Type (i.e MyRectangle) avec une déléguée (i.e r => ...).

public static Guid Subscribe<T>(Action<T> caseAction)
{
   
return Subscribe(string.Empty, caseAction);
}

public static Guid Subscribe<T>(string topic, Action<T> onMessageReceived)
{
   
Guid result = Guid.NewGuid();
   
lock ((_subscriptions.Keys as ICollection).SyncRoot)
    {
       
Action<object> current;
       
if (_subscriptions.TryGetValue(topic, out current))
        {
           
//add the new delegate to current subscribers list
            var currentCase = current.Target as CaseActionHolder<object>;
           
var newCase = current.Case(result, onMessageReceived);
            currentCase.PreviousID = result;
            ((
CaseActionHolder<object>)newCase.Target).NextAction = current;
            _subscriptions[topic] = newCase;
        }
       
else
        {
           
//creates case
            current = current.Case(result, onMessageReceived);
            _subscriptions.Add(topic, current);
        }
        _subscriptionsById.Add(result, topic);
    }
   
return result;            
}

Dans mon implémentation, j'ai ajouté une notion (topic), le sujet qui permet d'avoir à l'utilisation un découpage logique des abonnements. De plus il est possible de se désabonner grâçe au guid renvoyé lors de l'abonnement.

Le "switch-case" pour dispatcher le message ressemble beaucoup à celui de mon post sur le pattern matching F#:

static Action<object> Case<TArg>(this Action<object> fn, Guid id, Action<TArg> caseAction)
{
   
var thisCase = new CaseActionHolder<object> { ID = id };
    thisCase.Action = (arg) =>
    {
       
if (typeof(TArg).IsAssignableFrom(arg.GetType()))
        {
           
var convertedArg = (TArg)arg;
            caseAction(convertedArg);
        }
        thisCase.NextAction(arg);
    };
   
//no exception by default 
    thisCase.NextAction = (arg) => { };
   
return new Action<object>(thisCase.DoAction);
}

une souscription tel que "Subscribe<MyRectangle>(r => ...), reçoit les messages de Type MyRectangle, mais aussi pour tous les types qui dérivent de MyRectangle.

ainsi si on dérive de MySquare : MyRectangle

class MySquare : MyRectangle
{
}

...
new MySquare() { Width = 4, Ht = 4 }.Publish();
...

   donne comme résultat :
image

avec cette technique il possible de faire des récepteur à messages fortement "typées", certainement moins puissante qu'avec Erlang, mais l'idée est là.

vous pouvez télécharger le code source ici :

 

Plus de Messages Page suivante »


Les 10 derniers blogs postés

- Les pièges de l’installation de Visual Studio 2017 par Blog de Jérémy Jeanson le 03-24-2017, 13:05

- UWP or not UWP sur Visual Studio 2015 ? par Blog de Jérémy Jeanson le 03-08-2017, 19:12

- Désinstallation de .net Core RC1 Update 1 ou SDK de Core 1 Preview 2 par Blog de Jérémy Jeanson le 03-07-2017, 19:29

- Office 365: Ajouter un utilisateur ou groupe dans la liste des Site collection Administrator d’un site SharePoint Online via PowerShell et CSOM par Blog Technique de Romelard Fabrice le 02-24-2017, 18:52

- Office 365: Comment créer une document library qui utilise les ContentTypeHub avec PowerShell et CSOM par Blog Technique de Romelard Fabrice le 02-22-2017, 17:06

- [TFS] Supprimer en masse les dépendances à SQL Enterprise ou Developer avant de procéder à une migration par Blog de Jérémy Jeanson le 02-20-2017, 20:30

- Office 365: Attention au volume utilisé par les fichiers de Thèmes de SharePoint Online par Blog Technique de Romelard Fabrice le 02-07-2017, 18:19

- [SCVMM] Supprimer une machine bloquée par Blog de Jérémy Jeanson le 01-31-2017, 21:22

- Microsoft .Net Challenge 2017 par Le Blog (Vert) d'Arnaud JUND le 01-30-2017, 15:25

- Office 365: Utiliser le bouton Export to Excel depuis un teamsite SharePoint Online et avec le client Office 2007 par Blog Technique de Romelard Fabrice le 01-27-2017, 18:58