B Blog

Utiliser des template T4 avec des paramètres c'est possible

franky — Sun, 05 Apr 2009 06:08:00 -0400

Dernièrement j'ai voulu à développer une petite application pour générer du code. L’idée est bien simple je voulais avoir une interface me permettant de saisir quelques informations et ensuite… le code devait se généré.

Après quelques recherches, mon choix s’est porté sur Text Template Transformation Toolkit (T4) de Microsoft. Le générateur de code utilisant les T4 est inclus dans Visual Studio 2008. Donc même si rien n’est nécessaire, je conseille fortement le T4 Editor de Clarius Consulting qui affichera le code avec quelques couleurs. La version de la communauté est gratuite, la version complète est payante… on s’en doutait ;)

Créer un template simple

Il y a plusieurs excellents tutoriels expliquent comment utiliser les templates T4, notamment sur les blogs de Oleg Sych et Scott Hanselman. Mais pour faire vite, voici un tout petit exemple.

Dans un projet Visual Studio, cliquer sur [Project] –> [Add new Item].
- Vous pouvez sélectionner
  - La catégorie [Code Generation] et le template [File].
  - La catégorie [General] et le template [Text File]. Dans ce cas assurez-vous spécifier l’extension “.tt”.
Entrez le nom de votre fichier, cliquez le bouton [Add]
Le fichier à été ajouté a votre projet. Double cliquez dessus.
À la fin du fichier ajoutez le code suivant: Nous sommes le: <#= DataTime.Now.TimeOfDay #>
Votre fichier devrait ressembler à:

<#@ template language="C#" hostspecific="True" debug="True" #>

<#@ output extension="txt" #>



<#

// <copyright file="File1.tt" company="">

//  Copyright © . All Rights Reserved.

// </copyright>

  

  

#>

  

Nous sommes le: <#= DateTime.Now.TimeOfDay #>

Pour voir le texte généré, il faut développer (expand) le noeud du fichier et double cliquer sur le sous-fichier.
Voilà!

Utiliser des paramètres

Il est possible de créer des templates statique ou dynamique. Pour mon projet je voulais pouvoir passer des paramètres à la dernière seconde, donc mon template ce devait d’être dynamique. Dans un des post de Oleg Sych ce dernier spécifie qu’un Custom Host doit être fait pour pouvoir passer des paramètres. Cependant je n’ai pu trouver plus de détails… Afin de faire profiter d’autre personne de mon experience j’ai décider d’écrire ce billet.

Voici donc comment j’y suis parvenu.

Objectifs

En partant du “Hello world” classique je vais le personaliser pour dire bonjour à une personne en particulier. Le nom de cette personne sera le paramètre.

Avant de commencer

Tout d’abord afin de pouvoir faire le Custom Host il faut avoir accès au namespace Microsoft.VisualStudio.TextTemplating qui se trouve dans le VS2880 SDK. Donc il faut installer le Visual Studio 2008 SDK (s’il n’est pas présent sur votre poste).

Custom Host

Pour faire le Custom Host j’ai simplement pris le code de Microsoft, il servira de classe de base.

//CustomT4EngineHost.cs

  

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.VisualStudio.TextTemplating;

using System.CodeDom.Compiler;

using System.IO;

  

namespace CustomT4

{

    //The text template transformation engine is responsible for running 

    //the transformation process.

    //The host is responsible for all input and output, locating files, 

    //and anything else related to the external environment.

    //-------------------------------------------------------------------------

    [Serializable]

    public class CustomT4EngineHost : MarshalByRefObject, ITextTemplatingEngineHost

    {

  

  

        //the path and file name of the text template that is being processed

        //---------------------------------------------------------------------

        public string TemplateFile

        {

            get { return ""; }

        }

  

  

        //This will be the extension of the generated text output file.

        //The host can provide a default by setting the value of the field here.

        //The engine can change this value based on the optional output directive

        //if the user specifies it in the text template.

        //---------------------------------------------------------------------

        private string fileExtensionValue = ".txt";

        public string FileExtension

        {

            get { return fileExtensionValue; }

        }

  

  

        //This will be the encoding of the generated text output file.

        //The host can provide a default by setting the value of the field here.

        //The engine can change this value based on the optional output directive

        //if the user specifies it in the text template.

        //---------------------------------------------------------------------

        private Encoding fileEncodingValue = Encoding.UTF8;

        public Encoding FileEncoding

        {

            get { return fileEncodingValue; }

        }

  

        //These are the errors that occur when the engine processes a template.

        //The engine passes the errors to the host when it is done processing,

        //and the host can decide how to display them. For example, the host 

        //can display the errors in the UI or write them to a file.

        //---------------------------------------------------------------------

        private CompilerErrorCollection errorsValue;

        public CompilerErrorCollection Errors

        {

            get { return errorsValue; }

        }

  

  

        //The host can provide standard assembly references.

        //The engine will use these references when compiling and

        //executing the generated transformation class.

        //--------------------------------------------------------------

        public IList<string> StandardAssemblyReferences

        {

            get

            {

                return new string[]

                {

                    //If this host searches standard paths and the GAC,

                    //we can specify the assembly name like this.

                    //---------------------------------------------------------

                    //"System"

  

                    //Because this host only resolves assemblies from the 

                    //fully qualified path and name of the assembly,

                    //this is a quick way to get the code to give us the

                    //fully qualified path and name of the System assembly.

                    //---------------------------------------------------------

                    typeof(System.Uri).Assembly.Location

                };

            }

        }

  

  

        //The host can provide standard imports or using statements.

        //The engine will add these statements to the generated 

        //transformation class.

        //--------------------------------------------------------------

        public IList<string> StandardImports

        {

            get

            {

                return new string[]

                {

                    "System"

                };

            }

        }

  

  

        //The engine calls this method based on the optional include directive

        //if the user has specified it in the text template.

        //This method can be called 0, 1, or more times.

        //---------------------------------------------------------------------

        //The included text is returned in the context parameter.

        //If the host searches the registry for the location of include files,

        //or if the host searches multiple locations by default, the host can

        //return the final path of the include file in the location parameter.

        //---------------------------------------------------------------------

        public bool LoadIncludeText(string requestFileName, out string content, out string location)

        {

            content = System.String.Empty;

            location = System.String.Empty;

  

            //If the argument is the fully qualified path of an existing file,

            //then we are done.

            //----------------------------------------------------------------

            if (File.Exists(requestFileName))

            {

                content = File.ReadAllText(requestFileName);

                return true;

            }

  

            //This can be customized to search specific paths for the file.

            //This can be customized to accept paths to search as command line

            //arguments.

            //----------------------------------------------------------------

            else

            {

                return false;

            }

        }

  

  

        //Passes in the name of a service. If you have that service, you need to 

        //pass back a pointer to it. Otherwise, you need to pass back NULL to 

        //indicate that you have no knowledge of that service.

        //--------------------------------------------------------------------

        public object GetHostOption(string optionName)

        {

            object returnObject;

            switch (optionName)

            {

                case "CacheAssemblies":

                    returnObject = true;

                    break;

                default:

                    returnObject = null;

                    break;

            }

            return returnObject;

        }

  

  

        //The engine calls this method to resolve assembly references used in

        //the generated transformation class project and for the optional 

        //assembly directive if the user has specified it in the text template.

        //This method can be called 0, 1, or more times.

        //---------------------------------------------------------------------

        public string ResolveAssemblyReference(string assemblyReference)

        {

            //If the argument is the fully qualified path of an existing file,

            //then we are done. (This does not do any work.)

            //----------------------------------------------------------------

            var _assemblyRef = assemblyReference;

            if (_assemblyRef.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase))

                _assemblyRef = _assemblyRef.Remove(_assemblyRef.Length - 4);

            if (_assemblyRef.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase))

                _assemblyRef = _assemblyRef.Remove(_assemblyRef.Length - 4);

  

            foreach (var _assembly in AppDomain.CurrentDomain.GetAssemblies())

            {

                var _assemblyName = _assembly.GetName();

                if (String.Compare(_assemblyName.Name, _assemblyRef, true) == 0 ||

                    String.Compare(_assemblyName.FullName, _assemblyRef, true) == 0)

                    return _assembly.Location;

            }

            if (File.Exists(assemblyReference))

            {

                return assemblyReference;

            }

  

            //Maybe the assembly is in the same folder as the text template that 

            //called the directive.

            //----------------------------------------------------------------

            string candidate = Path.Combine(Path.GetDirectoryName(this.TemplateFile), assemblyReference);

            if (File.Exists(candidate))

            {

                return candidate;

            }

  

            //This can be customized to search specific paths for the file

            //or to search the GAC.

            //----------------------------------------------------------------

  

            //This can be customized to accept paths to search as command line

            //arguments.

            //----------------------------------------------------------------

  

            //If we cannot do better, return the original file name.

            return "";

        }

  

  

        //The engine calls this method based on the directives the user has 

        //specified in the text template.

        //This method can be called 0, 1, or more times.

        //---------------------------------------------------------------------

        public Type ResolveDirectiveProcessor(string processorName)

        {

            //This host will not resolve any specific processors.

  

            //Check the processor name, and if it is the name of a processor the 

            //host wants to support, return the type of the processor.

            //---------------------------------------------------------------------

            if (string.Compare(processorName, "XYZ", StringComparison.OrdinalIgnoreCase) == 0)

            {

                //return typeof();

            }

  

            //This can be customized to search specific paths for the file

            //or to search the GAC

  

            //If the directive processor cannot be found, throw an error.

            throw new Exception("Directive Processor not found");

        }

  

  

        //A directive processor can call this method if a file name does not 

        //have a path.

        //The host can attempt to provide path information by searching 

        //specific paths for the file and returning the file and path if found.

        //This method can be called 0, 1, or more times.

        //---------------------------------------------------------------------

        public string ResolvePath(string fileName)

        {

            if (fileName == null)

            {

                throw new ArgumentNullException("the file name cannot be null");

            }

  

            //If the argument is the fully qualified path of an existing file,

            //then we are done

            //----------------------------------------------------------------

            if (File.Exists(fileName))

            {

                return fileName;

            }

  

            //Maybe the file is in the same folder as the text template that 

            //called the directive.

            //----------------------------------------------------------------

            string candidate = Path.Combine(Path.GetDirectoryName(this.TemplateFile), fileName);

            if (File.Exists(candidate))

            {

                return candidate;

            }

  

            //Look more places.

            //----------------------------------------------------------------

            //More code can go here...

  

            //If we cannot do better, return the original file name.

            return fileName;

        }

  

  

        //If a call to a directive in a text template does not provide a value

        //for a required parameter, the directive processor can try to get it

        //from the host by calling this method.

        //This method can be called 0, 1, or more times.

        //---------------------------------------------------------------------

        public string ResolveParameterValue(string directiveId, string processorName, string parameterName)

        {

            if (directiveId == null)

            {

                throw new ArgumentNullException("the directiveId cannot be null");

            }

            if (processorName == null)

            {

                throw new ArgumentNullException("the processorName cannot be null");

            }

            if (parameterName == null)

            {

                throw new ArgumentNullException("the parameterName cannot be null");

            }

  

            //Code to provide "hard-coded" parameter values goes here.

            //This code depends on the directive processors this host will interact with.

  

            //If we cannot do better, return the empty string.

            return String.Empty;

        }

  

  

        //The engine calls this method to change the extension of the 

        //generated text output file based on the optional output directive 

        //if the user specifies it in the text template.

        //---------------------------------------------------------------------

        public void SetFileExtension(string extension)

        {

            //The parameter extension has a '.' in front of it already.

            //--------------------------------------------------------

            fileExtensionValue = extension;

        }

  

  

        //The engine calls this method to change the encoding of the 

        //generated text output file based on the optional output directive 

        //if the user specifies it in the text template.

        //----------------------------------------------------------------------

        public void SetOutputEncoding(System.Text.Encoding encoding, bool fromOutputDirective)

        {

            fileEncodingValue = encoding;

        }

  

  

        //The engine calls this method when it is done processing a text

        //template to pass any errors that occurred to the host.

        //The host can decide how to display them.

        //---------------------------------------------------------------------

        public void LogErrors(CompilerErrorCollection errors)

        {

            errorsValue = errors;

        }

  

  

        //This is the application domain that is used to compile and run

        //the generated transformation class to create the generated text output.

        //----------------------------------------------------------------------

        public AppDomain ProvideTemplatingAppDomain(string content)

        {

            //This host will provide a new application domain each time the 

            //engine processes a text template.

            //-------------------------------------------------------------

            return AppDomain.CreateDomain("Generation App Domain");

  

            //This could be changed to return the current appdomain, but new 

            //assemblies are loaded into this AppDomain on a regular basis.

            //If the AppDomain lasts too long, it will grow indefintely, 

            //which might be regarded as a leak.

  

            //This could be customized to cache the application domain for 

            //a certain number of text template generations (for example, 10).

  

            //This could be customized based on the contents of the text 

            //template, which are provided as a parameter for that purpose.

        }

  

    }

    

}

L’idée est d’avoir une classe host dans laquel on pourra passer notre paramètre. Comme on ne peut pas modifier la classe CustomHost on fera une classe qui hérite de Custom Host et qui implemente notre interface dans où le paramètre est défini.

Ensuite nous avons besoin d’une classe qui définisse notre parameter: CustomT4Parameter.

//CustomT4Parameter.cs

  

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

  

namespace CustomT4

{

    [Serializable]

    public class CustomT4Parameter

    {

        public CustomT4Parameter() {}

  

        private string _Name;

  

        public string Name

        {

            get { return _Name; }

            set { _Name = value; }

        }

    }

}

Afin de faire notre classe host qui nous servira dans notre projet, nous avons besoin d’un Interface qui permetera d’avoir accès à notre paramètre.

//ICustomT4Host.cs

  

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

  

namespace CustomT4

{

    public interface ICustomT4Host

    {

        CustomT4Parameter T4Parameter { get; }

    }

}

Rien de bien compliqué…

//T4Host.cs

  

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

  

  

namespace CustomT4

{

    [Serializable]

    public class T4Host : CustomT4EngineHost, ICustomT4Host 

    {

        private CustomT4Parameter _T4Parameter;

  

        public T4Host(CustomT4Parameter param)

        {

            _T4Parameter = param;

        }

  

        #region Members

  

        public CustomT4Parameter T4Parameter

        {

            get { return _T4Parameter; }

        }

  

        #endregion

    }

}

Maintenant, il nous faut un template. Afin d’accèder à notre paramètre il faut inclure une propriété: T4Param. Une fois ce “Getter” fait nous pouvons avois accès aux propriété du paramètre simplement: <#= T4Param.Name #>

//Hello.tt

  

<#@ template language="C#" hostspecific="True"  #>

<#@ assembly name="System.dll" #>

<#@ assembly name="PlayWithT4.exe" #>

<#@ import namespace="CustomT4" #>

// <autogenerated>

// This code was generated by a tool. Any changes made manually will be lost

// the next time this code is regenerated.

// </autogenerated>

  

using System;  

  

public class Hello<#= T4Param.Name #>

{

   public static void SayHello()

   {

      Console.WriteLine("Hello <#= T4Param.Name #>!");

   }

}

  

<#+

    CustomT4Parameter T4Param

    {

        get { 

            ICustomT4Host _host = Host as ICustomT4Host;

            if(_host != null)

               return _host.T4Parameter;

            else

               throw new InvalidOperationException("Expected to find a ClassEntry");

        }

    }

#>

Tout est prêt, il reste seulement à faire l’appel de l’engine et lui passant le custom host et le template. Je me suis fais un petit Helper histoire de garder le code de la forms le plus simple possible, mais ce n’est pas nécessaire…

// TextTemplateHelper.cs

  

using System;

using System.IO;

using Microsoft.VisualStudio.TextTemplating;

using System.Globalization;

  

namespace CustomT4

{

    [Serializable]

    public class TextTemplateHelper

    {

        public static void ProcessTemplate(string templateFileName, string outputFileName)

        {

            ProcessTemplate(templateFileName, outputFileName, new CustomT4EngineHost());

        }

  

        public static void ProcessTemplate(string templateFileName, string outputFileName, CustomT4EngineHost host)

        {

            string templateDirectory = Path.GetDirectoryName(templateFileName);

            string outputFilePath = Path.Combine(templateDirectory, outputFileName);

  

            string template = File.ReadAllText(templateFileName);

            Engine engine = new Engine();

            string output = engine.ProcessTemplate(template, host);

  

            if (host.Errors.HasErrors)

                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Cannot generate template {0}. {1} Error(s). First error is: {2}", templateFileName, host.Errors.Count, host.Errors[0]));

            else

                File.WriteAllText(outputFileName, output, host.FileEncoding);

        }

    }

}

Voilà!

~Franky

References

In love with his phone

franky — Wed, 11 Mar 2009 04:51:00 -0400

http://dilbert.com

Suivre un colis sans se fatiguer en 3 étapes

franky — Sun, 01 Mar 2009 06:08:00 -0400

De nos jours rien de plus banal que de faire des achats directement sur le web! Puis après commence la torture, est-ce que mon paquet arrive bientôt? Où est-il rendu? Une des solutions est de ce connecter au site web tu transporteur (USP, Purolator, etc) et de faire une requête pour avoir le status de notre colis. Une autre est de tout simplement le suivre avec TrackThis!

TrackThis est un service gratuit qui permet de suivre (comme son nom l'indique) un colis. Les particularités de ce dernier, est qu'il permet de suivre votre paquet peut importe le transporteur et qu'il vous informe via plusieurs médiums tels que e-mail, SMS, RSS, faceBook.

Étape 1

Pour l'utiliser rien de plus simple, rendez-vous sur le site et créer un profil (account). Au lieu de créer encore un autre nom d'usage et un mot de passe, TrackThis emploiera votre compte d'AOL, de Facebook, de Google, ou de Yahoo. Il vous permet aussi de créer un OpenID pour libre chez myOpenID.com.

Étape 2

Ajouter à votre compte le ou les médiums que vous désiriez utiliser : SMS, E-Mail ou autre.

Étape 3

Enregistrer votre colis à l'aide du numéro de suivi (tracking number)

voilà maintenant reste plus qu'à attendre....

~Franky

Pourquoi delicious est mieux que Google Shared Items

franky — Wed, 04 Feb 2009 14:09:00 -0400

Dernièrement j'ai écrit un article Recherche du parfait lecteur de flux RSS qui expliquait pourquoi j'ai "quitté" Google Reader au profit de NewsGator. Cependant, les shared Items me manquaient ardemment, juqu'à tout récament ou j'ai trouvé beaucoup mieux! Delicious ou plutôt Deli.cio.us.

Avant : Les Shared Items

Pour ceux que ne savent pas ce que sont le Shared Items, voici une courte description. Avec Google Reader il s’agit d’identifier certain article comme étant partageable que vous trouvez intéressant pour les voir automatiquement partagé avec vos "friends". Vos friends étant les contacts GMail ou autres personnes que vous autorisez.

Après: Deli.cio.us

Delcious, est un gestionnaire de favoris (bookmarks) social, qui permet de partager les liens utiles ou intéressants avec d’autres utilisateurs. Vous pouvez identifier les catégories auxquelles se rapporte ce lien et donc organiser votre collection comme bon vous semble.

Lire

Pour lire les favoris de quelq'un rien de plus facile, et aucune obligation. Vous n'avez pas besoin d'un compte, vous n'avez même pas besoin de connaitre la personne.

Voici vos options:

Via le site web: Vous pouvez aller quand bon vous semble aller sur Delicious.com et lire les liens qui selon votre guise sont: les plus populaires, les plus récent ou se rapportant à un suject particulier.
Via le site web personnel: Si vous connaissez un membre, visitez le site de la personne (Delicious.com/NomDeLaPersonne). Ce site est autogénéré donc est toujours à jour. Voici mon lien: http://delicious.com/fboucheros
Via un fil RSS: Vous préférez être averti lors de changement, rien de plus simple ajouté le fil RSS à votre lecteur favori, NewsGator ;) et le tour est joué. Voici mon fil pour mes découvertes delicieuses... http://feeds.delicious.com/v2/rss/fboucheros

Publier

Tout d’abord, vous devez vous créer un compte, en allant sur le site de Delicious.com. Voilà vous êtes prêt! Chaque fois que vous voulez partager ou seulement conservez ( car il est possible de garder des liens privés) plusieurs options s’offrent à vous:

Par le site: Vous pouvez vous connecter à votre compte et ajouter un nouveau lien en suivant le wizard.
Par l’icon: Directement sur la page que vous voulez noter chercher l’icon . Il est de plus en plus répandu. Ceci vous amènera à un formulaire pour créer votre nouveau bookmark.
Par Addons: Il existe plusieurs addons ajoutant des fonctionnalités à votre navigateur…

Plusieurs API (application programming interface) s’offrent à vous pour partager ou présenter vos favoris à même votre blog ou site web. Ainsi, sur le site de Delicious à la page des Settings dans la section Blogging, vous trouverez quatre options de publication:

Network Badges: Montrez vos lecteurs que vous êtes un membre de délicieux et donnez-leur une manière simple de vous ajouter à leur réseau.

Link Rolls: Montrez une liste de vos récents Bookmark Delicious en tant qu'élément de votre site Web.

Tags Roll: Montrez un nuage (tags cloud) ou une liste de vos Bookmark Delicious en tant qu'élément de votre site Web.

Blog Posting: Dispositif expérimental qui peut automatiquement signaler des entrées à votre blog journalier contenant vos derniers liens.

Voilà j’espère vous retrouver à dans mes abonnés, et si vous avez des questions ou suggestions laisser un commentaire!

~Franky

Liens intéressants:

Le nouveau guide d'architecture Mobile de poche

franky — Tue, 20 Jan 2009 17:15:18 -0400

Le 14 janvier dernier, le guide d'architecture Mobile de poche (traduction libre de:The Mobile Architecture Pocket Guide) a été redistribuer dans sa nouvelle version 1.1.

Le guide d'architecture Mobile de poche fournit une vue d'ensemble et des conseils normatifs pour concevoir des applications Mobiles sur la plate-forme de .NET.

Ce guide fait parti des Microsoft Best patterns & practices et est maintenu dans le projet p&p: Application Architecture Guide 2.0 Knowledge Base.

Vous pouvez télécharger ce guide ici

Les changements principaux de cette mise à jour sont:

Mieux adapter le guide pour la réalité du Mobile.
Amélioré la figure de l'application Mobile canonique.
Élaboré sur le "pourquoi" et raisonnement de certaines décisions.
Élaboration sur manipuler les connections.

~ Franky

Références:

Recherche du parfait lecteur de flux RSS

franky — Sun, 18 Jan 2009 20:47:00 -0400

Je ne sais pas pour vous, mais moi j'aime bien avoir ma dose de blogues quotidienne. J'ai essayé plusieurs applications et j'ai enfin trouvé le lecteur de flux (Rss reader) de rêve: FeedDemon.
Ce que je cherchais est un lecteur qui puisse être utilisé en mode déconnecté avec les images. De plus, je voulais qu'il soit une façon de se synchroniser sur plusieurs postes. J’ai essayé plusieurs applications, voici donc le récit de mes essaies.

1- Google Reader

Bien sûr j’ai essayé Google Reader. J’ai beaucoup (et j’utilise encore) les Shared Items pour partager des nouvelles à mes “friends” . Disponible de partout, car il est une application web c’était merveilleux…

Cependant, le mode déconnecté ne permet pas d'avoir les images. De plus, il ne permet pas de spécifier ou on sauvegarde les fichiers.

2- Scoop

Scoop est une application qui utilise la technologie AIR d’Adobe. IL est donc portable sur tous les systèmes et il est très beau. Lors de la mise à jour des fils, l’application semble geler. L’application étant jeune, il faut surveiller la sortie de la prochaine version.

3- Omea Reader

Très complet comme toutes les application de la compagnie JetBrains, Omea Reader est rapide, l’interface est super et configurable. C’est le mode déconnecté encore une fois qui est le problème. Enfin selon ce que je cherchais… ;)

4- FeedDemon - NewsGator

FeedDemon est légé et l’interface est soignée. Il offre une excellente gestion des posts. Vous pouvez “flager” certaines nouvelles pour y revenir plus tard. Vous pouvez également les mettres dans un répertoire pour les conserver (clipings).

Il permet aussi de facilement partager les posts que vous désirez en offrant un lien avec del.cio.us et Digg. Ou si vous avez Windows Live Writer il peut automatiquement créer un post sur votre blog concernant la nouvelle que vous lisez.

Il offre plusieurs options pour le mode déconnecté, pour faire le ménage des anciens post, faire des recherches, avoir de rapports sur vos lecture et vous avez même une option de FeedStation pour le téléchargement des vidéos et autre média.

De plus, il offre la possibilité de synchroniser avec NewsGator l’équivalent de FeedDemon mais online. De ce fait, vous pouvez continuer de lire vos nouvelles sur n’importe quel ordinateur. Plusieurs options pour la synchronisation sont possibles, donc vous pouvez choisir quel fils seront inclus ou exclus.

Comme si ce n’était pas assez NewsGator offre d’autres produits! Tel que:

NetNewsWire pour iPhone
NewsGator Go! pour Mobile
NetNewsWire pour Mac
NewsGator Inbox pour Microsoft Outlook
Free Tools pour amélioré votre l’expérience newsgator ;)

Voilà, si vous connaissez d’autre application laisser un commentaire!

~ Franky

Liens intéressants:

Revu des MSDN Webcast sur Windows Mobile pour l’année 2008

franky — Wed, 31 Dec 2008 09:06:00 -0400

L’année 2008 a été fructueuse pour la technologie mobile. Le nombre d’article et de vidéo disponible sur internet ont grandement augmenté. Entre autres, Constanze Roman (Windows Mobile Community PM), Maarten Struys (MVP) et Jim Wilson ont fait de très belles et instructives vidéos qui sont toujours disponibles sur demande.

Voici donc la liste (en espérant que je n’en oublie pas):

Windows Mobile Webcast Series – Getting Ready for Tech Ed

16 mai: Developing Applications for Windows Mobile Devices (1/5)
21 mai: Developing Your First Real Windows Mobile 6 Application (2/5)
27 mai: Using Device Capabilities and Device Functionality (3/5)
28 mai: Mobile Data Strategies and Synchronization Using SQL Server Compact, XML, and LINQ (4/5)
4 juin: Windows Mobile Development - Live from TechEd Orlando (5/5)

24 Hours of Windows Mobile Application Development

3 septembre: Introduction to Windows Mobile Device Development (Level 200)
10 septembre: Device Emulator and Cellular Emulator (Level 200)
17 septembre: Dealing with Different Form Factors (Level 300)
24 septembre: Creating Adaptive App. for Windows Mobile Devices (Level 300)
1 octobre: Developing Battery-Friendly Applications (Level 300)
8 octobre: Using Pocket Outlook Data Inside a Managed Application (Level 300)
15 sctobre: Interoperability Between Managed and Native Code (Level 300)
22 sctobre: .NET Compact Framework 3.5 Power Toys (Level 200)
29 sctobre: Live Update from the Professional Developers Conference (Level 300)
5 novembre: Unit Testing for Mobile Devices (Level 300)
12 novembre: Windows Mobile Location Awareness Live from Tech-Ed (Level 300)
19 novembre: Windows Mobile Networking (Level 300)
10 décembre:
- .NETCF Asynchronous Programming Techniques (Level 300)
- IPC and True Push Technology on Windows Mobile (Level 300)
17 décembre: Testing Your Windows Mobile Applications (Level 300)

À ne pas manquer en janvier 2009

7 janvier: Windows Mobile Device Security (Level 300)
14 janvier: Top Developer Tips for Windows Mobile (Level 300)
29 janvier: Developing Mobile Applications with Visual Studio 2008 (Level 300)

Bon visionnement et à l’année prochaine!

~ Franky

Références:

A New Start / Un nouveau départ

franky — Sun, 02 Nov 2008 04:36:00 -0400

I start this blog to keep notes of some works or to have a better understanding of some technologies. You "probably" notice my English is not perfect, and this is because it's not my primary language. I was doing this blog in English to improve my skill, but now with my new job, the new schedule and everything, I found that it's to much. I will continue to do my blog but in french.

J'ai commencé ce bog pour garder des notes des petits projets que j'ai fais, sans prétention. J'avais décidé d'écrire en Anglais pour me pratiquer. Après avoir essayer quelques temps je trouve difficile de bien expliquer en Anglais. De plus je trouves qu'il manque de ressource francophone sur le net, donc je continuerai mon blog mais en français.

No more "Post-in" on you're screen

franky — Wed, 29 Oct 2008 00:46:00 -0400

As long as I remember I always want to keep information close to my workspace. I try the little bloc-note, but I was unable to keep one note on top... So I switch to post-it, you can easily imagine what my screen look like. But recently I found "the thing". I will not anymore stick post-it on my screen but in my screen.

Stickies is a little application done by Zhorn Software. This nice application is a virtual post-it manager. A simple double click on the little post-it icon place in you're tray and a new post-it appear on you're screen. The post-it is fully cutomizable. You can create different style that regroup paper color, font, etc.

You can attach a alarm to the note and put it to sleep. So if you want to call you're Mom for her birtday you just need to create a new note and specify the date... Then the note will popup shaking and buzzing just n time.

Another nice feature is the network share. You cant create as it's call some friends. Those friends can have e-mail address and ip or network name. Then by right-clicking you can share one or all note to one specific person or to all you're friends. You can event configure it to sync with you're mobile device!

That it. Let go and try it you will see it could be a great tools.

~ Franky

Jing the Wonderful from (Be .Net, be Mobile!)

franky — Mon, 13 Oct 2008 16:32:00 -0400

A friend recently talk me about Jing. He said that it was a good tool to take screen shot or do quick screen video. "And what's new?" I said. "Try it", he reply, "you will see".

[read more]

How to configure the cellular emulator

franky — Wed, 10 Sep 2008 10:06:00 -0400

While I was doing the SMS GChat application I need to send and receive SMS to my device emulator. But first let’s start by the beginning, what the cellular emulator.

The cellular emulator is a nice tool that is provide when you install the SDK. May be you didn’t notice but if you go trout you’re Start menu: Programs | Windows Mobile 6 SDK | Tools, you will found a Cellular emulator.

The Emulator is a simple window with some tabs. I will only explain the Call Manager and the SMS tab.

Configure the phone emulator

Before you can use the phone emulator you need to connect it to your device emulator. To do it it’s very simple. First start both emulator the device and the cellular, the order is not important.

Then on the low left corner of the phone emulator you will see a inscription like DE: COM3. It’s mean that this emulator is working with the COM3 (in y case it could be different for you).

On the device emulator go in the menu File | Configure. Then select the tab Peripherals. The first dropdown on the top, Serial port 0, shouldn’t have the COM 3 already so type it in. Then click OK button. Again in the File Menu this time choose to reset softly. You have now the two emulator configured to work together.

Tab: Call Manager

In this tab you will found the tool for the phone (regular voice) call.

On the top you will found a grid with the list of the call the device emulator did.

On the device type any phone number and “do” a call. You will notice that the number you type will be added in the Active Calls grid.

If you want a do instead a call from the phone emulator then you need to type a phone number in the Phone Number textbox and click the Dial button. Notice that the number you type represent the number you call from.

Tab: SMS

Like previously the tab is simple. In the top the Text area is to send a message. The Phone Number will be use as called ID. On the bottom as you can you expect the grid is for the message you receive from the device.

Conclusion

Now you know how to configure and use the phone emulator.

Smart Notification

franky — Mon, 08 Sep 2008 06:58:00 -0400

While I was coding the SMS GChat mobile application I discover that the message box of the Mobile standard (smartphone) is really not like the notification of the Mobile Professional and Classic (Pocket PC).

As you can see the Notification is a nice balloon that allow display of HTML content and is visible only for a for period of time.

In other part the Alert from the Mobile Standard platform is not that powerfull. No Html is support and no timer.

So I want a subtitude those control by a cutom one that will take the advantage of the Notification but will be compatible with all platforms. Then I remember that the LOB Accelerator 2008 got already something like that. So I did my SmartNotification base on those recommendations.

Basically it's a form that contains WebBrowser control and a timer.
To be able to use this control you just need to refer the library and create a instance like this:

C#-Code:

001using fbLib;
002SmartNotification oNotif = new SmartNotification("ALert", "SMS Notification", "Here you HTML message code", "This message will be save in you're SMS history");
003oNotif.TimerNotification.Interval = 20000;
004oNotif.ShowDialog();

I'm planning to add some CSS functionalities later, but that it for now...

Enjoy!

Download the Library | Read the Code

Project: GraphLib for mobile

franky — Thu, 31 Jul 2008 11:07:00 -0400

The GraphLib for mobile is a library to draw some chart on a mobile.

You can see more about this project in the section Project of this blog or by cliking here.

Project: DiagramLib

franky — Thu, 31 Jul 2008 09:30:00 -0400

DiagramLib is a library that give the opportunity to draw some schema like Visio. I did this librairy doing a addon to Microsoft Visual Studio. The goal was simple use the drag&drop to quickly build a schema.

You can read more about it here.

What you must have to enjoy IE7 (Be net, be Mobile)

franky — Thu, 17 Jul 2008 21:51:00 -0400

Recently I got some trouble with the so lovely Firefox, so I got no choice to suffer and use IE. But then I take the time to search how I can improve the application. Here is my top 4 of some add-ons that are really nice....

[read more...]