Les articles de c2i.fr

A propos de prévisionnistes...

Fri, 29 Mar 2013 06:41:47 GMT

Réunion du conseil d'administration d'IDC

Ce matin, je tombe sur un article sur Tablette-Tactile.net reprennant le dernier rapport d'IDC. La principale info, c'est que le nombre de tablette vendue en 2013 devrait être de 191 millions.

Bon, OK, mais quelques mois auparavent, ils annonçaient 172 millions. Ils se seraient donc trompés de 11%. D'abord, ce n'est pas mince comme erreur mais surtout, c'était il y a seulement 3 mois ! (communiqué de presse du 5 Déc 2012).

Là ou cela devient encore plus drôle, c'est qu'ils font des prédictions à 2017. Leurs prédictions changent radicalement à 3 mois alors imaginez à 5 ans ! Donc qu'annoncent-ils à 5 ans ?

1/ Android aura 46% de part de marché.

2/ iOS 43.5% (précis à la virgule près).

3/ Windows 7.4%

4/ Windows RT 2.7%

Moi je prédis que :

1/ Android aura moins de 5% de part de marché car il aura été abandonné par Google 2 ans auparavent (pas assez rentable, car Google Reader),

2/ iOS aux alentours de 8.562%,

3/ Microsoft viendra de lancer Windows 12 mais toujours aucun fabricant n'implémentra l'os dans leur machine,

4/ Auratura Inc. qui viendra de lancer son nouveau cartable numérique restera leader du marché avec 82.5%,

5/ Blackberry frisera les 6% de part de marché.

OK, ca fait plus de 100% mais de toutes façons, personnes ne fait la vérification des données.

Amusons nous quelques secondes et faisons juste le chemin inverse, soit début 2007 : l'iPhone n'existait pas (9/01/2007), l'iPad encore moins, le marché des tablettes n"existaient même pas dans les rêves sous héroïne du CEO d'IDC.
Le marché des tablettes commence à peine et la meilleure preuve est que Windows 8 est encore tout frais, n'a pas encore eu le temps de sècher (premier séchage prévu cet été avec Windows Blue).

Tout ca pour dire que c'est du grand n'importe quoi, et que ce genre de prédiction n'a aucune, mais aucune valeur ! Dire qu'il y a des "journalistes" qui reprennent ces données pour argumenter leurs dires...

Message pour Google : "Don't be evil"!

Mon, 07 Jan 2013 08:25:40 GMT

Bon je sais, elle est facile celle-là : retourner le slogan de Google contre lui ;-)

Mais c'est bel et bien ce qui est en train de se passer. On a souvent vu des editos, des articles, des réflexions de nombreuses personnes contre la position dominante de Microsoft. C'est bien car cela permet d'éviter justement que ladite société n'en fasse "trop" à sa tête. Mais il ne faudrait surtout pas oublier Google. Si l'on est objectif, Google est actuellement bien plus présent dans notre vie quotidienne qu'un Microsoft ou même un Apple.

En quelques années, Google a réussi à faire oublier les Altavista & co. Dans le monde du mobile, bien que les journalistes (et les gens en général) ne parlent que de l'iPhone, Android est en large position dominante. On dit que Microsoft n'est pas inovateur et achète les sociétés avec leurs brevets grâce à son cash : qu'à fait Google avec Youtube ?

Bref, Google est devenu un gros monstre omniprésent.

Personnellement, cela ne me dérange pas (trop) si ils jouent le jeu, c'est à dire qu'ils continuent à fournir un service de qualité (le service de messagerie de c2i.fr est chez Google). Mais le récent "scandale" concernant le non accès à Google Maps par les Windows Phone est un signe majeur. Google peut, en quelques instants, décider de couper son service pour tel ou tel artefact. Dans ce cas présent, la cible est Windows Phone qui commence à faire un tout petit peu d'ombre à Android.

Et Google n'aime pas ca.
Google n'aime pas les téléphones Windows Phone.
Google ne veut pas voir sur cette Terre des téléphones Windows Phone.
Google met en oeuvre tout ses moyens pour exterminer les Windows Phone.

Nous sommes dans un monde capitaliste et cette guerre concerne des entités commerciales (ouf, j'ai eu peur que ce soit du raciste ou quelque chose dans le genre...).

Cela peut faire sourire, ne pas inquiéter, mais il faut être vigilant, car demain, Apple pourra de nouveau faire une pub faisant voler en éclat un écran diffusant une image d'un Android, elle ne sera jamais diffusée sur un Internet contrôlé par Google.

Edit : le site Gizm...(je ne veux pas lui faire de la pub) a montré encore une fois la pertinence des ses infos ;-)

Sauvegarder et lire ses données dans un fichier zip

Mon, 19 Nov 2012 14:38:11 GMT

Il est fréquent que l’on sauvegarde ses données dans un fichier. Pour effectuer cette opération, le plus simple (si l’on est un peu fainéant) est d’utiliser l’un des sérialisateurs fourni par le Framework (le plus optimisé est de créer son propre format mais c’est une autre histoire).

Ici, nous allons utiliser le sérialisateur DataContractSerializer, utilisé pour les contrats WCF.

L’inconvénient de ce sérialiseur, c’est qu’il ne cherche absolument pas à optimiser la taille du fichier généré, et comme le format est un format Xml, il est verbeux et donc volumineux.

Vous allez me dire, avec les disques durs que l’on a actuellement, ce n’est pas vraiment un soucis. Oui, sauf que si le fichier, on veut le sauvegarder dans le RoamingFolder pour pouvoir le sauvegarder “in ze cloud”, il va falloir faire attention à ce qu’il ne dépasse pas les 100Ko, sinon il ne sera pas uploadé “in ze cloud” (propriété RoamingStorageQuota).

Donc la bonne idée, enfin celle que j’ai trouvée bonne, consiste donc à zipper le contenu du fichier xml généré par le sérialisateur.

Dans mon exemple, je sérialise une énumération d’objet User :

private async Task WriteToZipFile()
{
    var sw = Stopwatch.StartNew();
    var file = await ApplicationData.Current.RoamingFolder
                                    .CreateFileAsync(
                                        UsersFileName,
                                        CreationCollisionOption.ReplaceExisting);

    // archivage dans le zip
    using (var fileStream = await file.OpenStreamForWriteAsync())
    {
        using (var archive = new ZipArchive(fileStream, ZipArchiveMode.Create, false))
        {
            var entry = archive.CreateEntry(UsersEntry, CompressionLevel.Fastest);
            var serializer = new DataContractSerializer(typeof (IEnumerable<User>));
            serializer.WriteObject(entry.Open(), Users);
        }
    }

    Debug.WriteLine("Sauvegarde ZIP : {0}ms", sw.ElapsedMilliseconds);
}

Et je fais la même chose en sens inverse pour lire le contenu de ce fichier :

private async Task<IEnumerable<User>> ReadFromZipFile()
{
    var sw = Stopwatch.StartNew();

    var file = await ApplicationData.Current.RoamingFolder
                                    .GetFileAsync(UsersFileName);

    // archivage dans le zip
    using (var archive = new ZipArchive(await file.OpenStreamForWriteAsync(), ZipArchiveMode.Read, false))
    {
        var entry = archive.GetEntry(UsersEntry);
        var serializer = new DataContractSerializer(typeof(IEnumerable<User>));
        var result = (IEnumerable<User>) serializer.ReadObject(entry.Open());
        Debug.WriteLine("Lecture : {0}ms", sw.ElapsedMilliseconds);

        return result;
    }
}

Ce n’est pas très compliqué et on gagne énormément de place

ATTENTION : l’enregistrement, c’est-à-dire la création du fichier zip est long, très long, donc à utiliser avec parcimonie et pas à toutes les sauces (comme je l’avais fais dans mon code ).

Une belle épingle pour son site sous Windows 8

Wed, 14 Nov 2012 14:50:53 GMT

Windows 8 change la façon de gérer ses favoris et met en avant "l'épinglage" des sites. Quand vous êtes sur un site quelconque et que vous le trouvez sympatique, avec IE 10, la meilleure (et unique sous WinRT) façon de faire est d'épigner le site.

Malheureusement, à l'heure actuelle, on se retrouve avec des icônes, pardon, des tuiles, qui se ressemblent toutes, avec généralement un gros "e" sur forme de couleur uni. Beuark !

Sous Android ou Windows Phone 7, on peut avoir des captures d'écran du site, sous Windows 8 RT, on n'a qu'un "e" : c'est au développeur du site de faire le boulot.

Et c'est en réalité très simple puisqu'il n'y a que 3 balises META à ajouter à votre header :

<meta name="application-name" content="c2i.fr - Le 1er site .NET"/>
<meta name="msapplication-TileColor" content="#0072BC"/>
<meta name="msapplication-TileImage" content="http://www.c2i.fr/Media/Default/mesImages/c2iLogoIE10.png"/>

Le application-name est le nom qui sera affiché sur la vignette, msapplication-TileColor la couleur de fond et TileImage l’image utilisée. Cette dernière doit faire 144px * 144px et, comme vient de me signaler Fabrice Romelard, être forcement au format png.

Et vous ne deviendrez pas ainsi un énième raccourci sur l’écran d’accueil de Windows 8

Pour les grosses fainéasses, il y a même un site qui vous génère le code : http://www.buildmypinnedsite.com/windows8

Mettre à jour massivement une table SQL Server (1ère partie)

Tue, 13 Nov 2012 16:54:09 GMT

Aujourd’hui, je ne vais pas parler de Windows 8 pour une fois mais d’une problématique que l’on peut rencontrer si l’on travaille avec des masses de données importantes.

Imaginons donc une simple table SQL Server et une application qui récupère des données et souhaite les injecter dans cette table.

Jusqu’ici, rien de bien particulier. Il existe plusieurs solutions :

Parcourir les données une à une et faire un INSERT (pas terrible au niveau perf),
Faire un BulkInsert (cool au niveau perf).

Seulement le BulkInsert de SQL Server ne fait pas les mises à jour. Si par hasard on a une ligne que l’on souhaite injecter qui a le même ID qu’une ligne existante dans la table (ID étant la clé de la table), alors le BulkInsert vous jettera comme un malpropre.

NB : ce n’est pas le cas pour MySQL qui autorise, lui, l’Insert/Update dans un BulkInsert. cf l’article suivant.

Il existe toutefois une solution qui permet d’effectuer un maximum d’opération du côté de SQL Server, donc avec des performances importantes.

La solution consiste a utiliser l’instruction MERGE de Transact-SQL (je crois que cette instruction n’est possible que depuis SQL Server 2008). MERGE permet de synchroniser les données de 2 tables. Il se charge de faire les INSERT, UPDATE et même les DELETE qu’il faut.

Tout d’abord, nous allons voir comment faire le BulkInsert

BulkInsert

Pour simplifier les développements de nos classes Repository, nous allons créer une classe de base qui définie le ConnectionString :

public abstract class RepositoryBase
{
    public const string ConnectionStringKey = "MyDb";
    
    #region ctor

    protected RepositoryBase()
        : this(ConfigurationManager.ConnectionStrings[ConnectionStringKey].ConnectionString)
    {
    }

    protected RepositoryBase(string connectionString)
    {
        ConnectionString = connectionString;
    }

    #endregion
    
    /// <summary>
    /// Chaine de connection
    /// </summary>
    public string ConnectionString { get; set; }
}

Le ConnectionString est donc recherché dans le fichier de configuration avec la clé par défaut valant “MyDb” (why not!).

Ensuite, nous allons définir une classe abstraite de base pour effectuer le BulkInsert. C’est une classe générique basée sur l’entité que l’on manipule. Elle ne possède qu’une seule méthode qui attends comme arguments les données à insérer et un mappeur de propriétés. Ce dernier implémente l’interface IRepositoryBulkInsertMapper :

public interface IRepositoryBulkInsertMapper
{
    string DestinationTableName { get; }
    IEnumerable<BulkInsertColumnDescription> GetColumnDescriptions();
}

DestinationTableName est le nom de la table ou l’on souhaite insérer les données. GetColumnDescription retourne une collection de BulkInsertColumnDescription :

/// <summary>
/// Décrit une colonne utilisée pour le mapping pour le BulkInsert
/// </summary>
public class BulkInsertColumnDescription
{
    public BulkInsertColumnDescription()
    {}

    public BulkInsertColumnDescription(string columnName, Type columnType)
    {
        ColumnName = columnName;
        ColumnType = columnType;
    }

    /// <summary>
    /// Nom de la colonne dans la base de données
    /// </summary>
    public string ColumnName { get; set; }

    /// <summary>
    /// Type de la colonne
    /// </summary>
    public Type ColumnType { get; set; }
}

Exemple d’implémentation de cette interface :

public class PersonBulkInsertMapper : IRepositoryBulkInsertMapper
{
    public PersonBulkInsertMapper(string destinationTableName   )
    {
        DestinationTableName = destinationTableName;
    }

    #region Implementation of IRepositoryBulkInsertMapper

    public string DestinationTableName { get; set; }

    public IEnumerable<BulkInsertColumnDescription> GetColumnDescriptions()
    {
        return new[]
            {
                new BulkInsertColumnDescription("Id", typeof (int)),
                new BulkInsertColumnDescription("Name", typeof (string)),
                new BulkInsertColumnDescription("Age", typeof (int)),
                new BulkInsertColumnDescription("CompanyId", typeof (int))
            };
    }

    #endregion
}

On voit que ce mappeur indique que les colonnes à insérer dans la table de destination sont Id, Name, Age et CompanyId.

Revenons donc maintenant à notre classe générique :

/// <summary>
/// Classe de base qui permet le BulkInsert
/// </summary>
/// <typeparam name="T">Entité de base</typeparam>
public abstract class RepositoryBulkInsertBase<T> : RepositoryBase
{
    /// <summary>
    /// Effectue un BulkInsert d'une collection d'entité
    /// </summary>
    /// <param name="datas">Les entités à insérer</param>
    /// <param name="mapper">Le mapper entre les colonnes et les valeurs</param>
    public void BulkInsert(IEnumerable<T> datas, IRepositoryBulkInsertMapper mapper)
    {
        using (
            var bulkCopy = new SqlBulkCopy(
                ConnectionString,
                SqlBulkCopyOptions.TableLock |
                SqlBulkCopyOptions.CheckConstraints |
                SqlBulkCopyOptions.FireTriggers))
        {
            // création de la DataTable et du mapping
            var table = new DataTable();
            foreach (var description in mapper.GetColumnDescriptions())
            {
                // ajout de la colonne
                table.Columns.Add(new DataColumn(description.ColumnName, description.ColumnType));
                // ajout du mapping dans le bulkCopy
                bulkCopy.ColumnMappings.Add(description.ColumnName, description.ColumnName);
            }

            // table ou l'on souhaite insérer les données
            bulkCopy.DestinationTableName = mapper.DestinationTableName;

            // remplissage de la DataTable avec les données
            foreach (var data in datas)
            {
                var columnValues = new List<object>();

                foreach (DataColumn column in table.Columns)
                {
                    columnValues.Add(typeof (T).GetProperty(column.ColumnName).GetValue(data, null));
                }
                table.Rows.Add(columnValues.ToArray());
            }

            // envoi du BulkCopy à SQL Server
            bulkCopy.WriteToServer(table);
        }
    }
}

Cette méthode ne fait que créer dans un premier temps la structure de la DataTable grâce aux ColumnDescriptions et rempli cette DataTable avec nos données.

Implémentons maintenant cette classe abstraite (oui, il n’y a aucune ligne de code ) :

public class PersonBulkInsertRepository : RepositoryBulkInsertBase<Person>
{}

Et pour l’utiliser :

var rep = new PersonBulkInsertRepository();
rep.BulkInsert(persons, new PersonBulkInsertMapper("Persons"));

Si l'on sait que cette classe utilisera même toujours la même interface de mapping, on peut lui ajouter une méthode simplifiant son utilisation :

public class PersonBulkInsertRepository : RepositoryBulkInsertBase<Person>
{
    public void BulkInsert(IEnumerable<Person> datas)
    {
        BulkInsert(datas, new PersonBulkInsertMapper("Persons"));
    }
}

Moralité, l’insertion massive de données dans la table devient encore plus simple :

var rep = new PersonBulkInsertRepository();
rep.BulkInsert(persons);

Conclusion

Maintenant que nous savons faire du simple BulkInsert, nous verrons dans le prochain article comment l’utiliser pour faire du Merge.

Mettre à jour massivement une table SQL Server (2ème partie)

Tue, 13 Nov 2012 16:52:55 GMT

Dans le premier article, je vous indiquais comment faire du BulkInsert avec SQL Server. Dans cette deuxième partie, nous allons voir comment utiliser l’instruction MERGE pour faire de la mise à jour massive. On avait le schéma de classes suivant :

Notre but va donc être de pouvoir faire de la mise à jour massive. Nous avons besoin pour cela d’uen table temporaire possédant la même structure que la table cible. Puis, nous allons procéder ainsi :

Vider la table temporaire (par sécurité),
Faire un BulkInsert des données dans la table temporaire,
Faire un Merge entre la table temporaire et la table cible,
Vider la table temporaire (la madame elle aime bien faire le ménage…)

Donc dans un premier temps, définissons une classe abstraite implémentant l’opération de Merge :

/// <summary>
/// Classe de base qui permet de faire le Merge
/// </summary>
/// <typeparam name="T">Entité</typeparam>
public abstract class RepositoryMergeBase<T> : RepositoryBulkInsertBase<T>
{
    /// <summary>
    /// Requête SQL pour le Merge à définir dans les classes dérivantes
    /// </summary>
    protected abstract string SqlMerge { get; }

    /// <summary>
    /// Nom de la table temporaire utilisée pour le Merge dans les classes dérivantes
    /// </summary>
    protected abstract string TempTableName { get; }

    protected virtual void CleanTempTable()
    {
        using (var connection = new SqlConnection(ConnectionString))
        {
            using (var command = new SqlCommand(string.Format("DELETE FROM {0}", TempTableName), connection))
            {
                connection.Open();

                command.ExecuteNonQuery();
            }
        }
    }

    public SynchronizationResult Merge(IEnumerable<T> datas, IRepositoryBulkInsertMapper mapper)
    {
        if (string.IsNullOrEmpty(SqlMerge))
            throw new InvalidOperationException("SqlMerge n'a pas été défini");

        if (string.IsNullOrEmpty(TempTableName))
            throw new InvalidOperationException("TempTableName n'a pas été défini");

        // on vide la table temporaire avant l'import (au cas ou)
        CleanTempTable();

        // importation massive des données dans la table temporaire
        BulkInsert(datas.ToList(), mapper);

        // exécution du Merge entre la table temporaire et la table cible
        var result = Merge();

        // on vide la table temporaire
        CleanTempTable();

        return result;
    }

    #region private methods
    /// <summary>
    /// Effectue le merge
    /// </summary>
    /// <returns></returns>
    private SynchronizationResult Merge()
    {
        var result = new SynchronizationResult();
        using (var connection = new SqlConnection(ConnectionString))
        {
            // SqlMerge est l'instruction Transact-SQL avec MERGE
            using (var command = new SqlCommand(SqlMerge, connection))
            {
                connection.Open();

                // l'instruction Merge retourne le nombre d'insert/update/delete effectué
                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        switch ((string)reader["$action"])
                        {
                            case "INSERT":
                                result.Inserted++;
                                break;
                            case "UPDATE":
                                result.Updated++;
                                break;
                            case "DELETE":
                                result.Deleted++;
                                break;
                            default:
                                throw new NotImplementedException(
                                    "Erreur dans le merge : " +
                                    (string) reader["$action"]);
                        }
                    }

                    return result;
                }
            }
        }
    }
    #endregion

}

Cette classe abstraite demande aux classes qui en dérivent de définir la propriété SqlMerge et TempTableName. SqlMerge est l’instruction Transact-SQL (voir plus loin) et TempTableName est le nom de la table temporaire.

Dans la méthode Merge, on effectue les tâches décrites plus haut : vidage, bulkInsert dans la table temporaire, merge et vidage (again). En procédant ainsi, les données ne sont envoyées qu’une seule fois massivement à SQL Server, et c’est lui qui fait tout le travail. Les autres aller-retour avec le serveur ne sont que des petites instructions SQL, donc on a une rapidité optimisée.

Le plus compliqué (si l’on peut dire) consiste à implémenter cette classe, c’est-à-dire surtout à définir l’instruction Merge. Voyons pour notre exemple son implémentation :

public class PersonRepository : RepositoryMergeBase<Person>
{
    public SynchronizationResult Merge(IEnumerable<Person> rows)
    {
        return Merge(rows, new PersonBulkInsertMapper(TempTableName));
    }

    #region Overrides of RepositoryMergeBase<Person>
    /// <summary>
    /// Nom de la table temporaire utilisée pour le Merge
    /// </summary>
    protected override string TempTableName
    {
        get { return "Persons_Temp"; }
    }

    /// <summary>
    /// Requête SQL pour le Merge à définir dans les classes dérivantes
    /// </summary>
    protected override string SqlMerge
    {
        get
        {
            return @"
MERGE Persons AS target
USING Persons_Temp AS source
ON (target.Id = source.Id)
WHEN MATCHED THEN
 UPDATE
      SET
           target.Name = source.Name,
           target.Age = source.Age,
           target.CompanyId = source.CompanyId
WHEN NOT MATCHED BY TARGET THEN
 INSERT (Name, Age, CompanyId)
 VALUES (source.Name, source.Age, source.CompanyId)
OUTPUT
 $action;
";
        }
    }
    #endregion
}

Vous voyez que l’instruction Merge est décomposée en trois parties :

L’instruction On définit quand 2 enregistrements sont considérés comme égaux
L’instruction Update à utiliser quand On est vérifié
L’instruction Insert à utiliser quand On n’est pas vérifié.

Merge nous renvoi également un tableau de résultat avec une colonne contenant l’action qu’il a effectué. On sait ainsi s’il a effectué un insert, update ou delete (NB : dans cet exemple, nous n’effectuons pas de Delete, juste du Insert/Update). On retourne cette information sous la forme d’un objet de type SynchronizationResult.

Pour utiliser cette classe, cela devient un jeu d’enfant :

var repository = new PersonRepository();

var result = repository.Merge(persons);

Console.WriteLine(
    "Inserted = {0}, Updated = {1}, Deleted = {2}", 
    result.Inserted, 
    result.Updated, 
    result.Deleted);

Résumons

Pour faire notre Merge, nous n’avons besoin que de définir SqlMerge et TempTableName dans la classe dérivée.

Simple non ?

Téléchargez le source de cet exemple.

'Un jour, une plante' pour Windows 8

Fri, 02 Nov 2012 09:35:24 GMT

"Un jour, une plante" est une application pour Windows 8 qui vous propose de lire quotidiennement une fiche sur une plante de votre jardin, de votre potager, écrite par un spécialiste français reconnu dans le domaine, Pierrick Eberhard.

Téléchargez l'application sur le Windows Store

Homéo Zen pour Windows 8

Fri, 02 Nov 2012 09:31:34 GMT

"Homéo Zen", une application Windows 8 de c2i.fr, vous propose quotidiennement une dose de positif, d’attitude zen pour profiter au mieux de votre journée.

Pour en savoir plus sur cette application : http://www.c2i.fr/HomeoZen

Téléchargement sur le Windows Store

Créer un lien vers le Windows Store dans votre application

Sat, 29 Sep 2012 01:00:57 GMT

Une petite astuce ce vendredi matin.

Il se peut que dans votre application vous ayez besoin d'intéragir avec le Windows Store. Voici quelques exemples :

Inciter votre utilisateur à poster un commentaire sur votre application,
Ouvrir le Windows Store sur une autre de vos applications,
Ouvrir le Windows Store vers une recherche particulière.

Concernant le premier exemple, je ne suis pas sur que si le "bouton" ou le truc qui permet d'effectuer cette action est trop voyant, votre application passe la certification. Veillez donc à quelle soit discrète ou plutôt logique.

En revanche, pour les deux autres, si vous avez d'autres applications, c'est fortement recommandé pour créer une synergie entre vos applis. (si un utilisateur est content de votre application, il y a de fortes chances qu'ils désirent ne serait ce essayer vos autres applications). Ci-dessous un exemple d'écran "A propos de..." :

Le bouton Découvrez 'Un jour, Une plante' ouvre le Windows Store directement sur cette "fantastique" application, le second effectue une recherche sur le store sur toutes les applications de c2i.fr.

Pour procéder, rien de plus simple, il suffit de créer une Uri conforme au protocole de lien du Windows Store. Toute Uri vers le Store est préfixée par : ms-windows-store:

Ensuite, elle est suivi par l'action que vous souhaitez effectuer :

PDP : ouvrir la page d'une application spécifique,
Updates : ouvre le page des mises à jour de toutes vos applications,
Search : ouvre la page de recherche du Store,
Review : ouvre la page de commentaire d'une application spécifique (écrivez un commentaire ou modifiez un commentaire si vous l'avez déjà saisi). Attention : action non documentée ;-)

Enfin, certaines actions attendent un paramètre :

PDP et Review attendent le Package Family Name,
Search la requête à effectuer.

Mise en oeuvre d'un lien vers une application spécifique

Ainsi, pour créer un lien vers mon application "Homéo Zen", j'ouvre son package manifeste et je note son Package Family Name :

Dans mon autre application, pour ouvrir le store vers cette fantastique application (bon, si LA, vous avez toujours pas compris qu'il faut la télécharger et l'installer, je ne sais plus quoi faire ! Si, le lien : pour Un jour, Une plante, et pour Homéo Zen), il suffit de créer l'Uri :

ms-windows-store:PDP?PFN=c2i.fr.Unjouruneplante_xxxxxxxxx

Et pour la lancer dans votre application, un simple : await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-windows-store:PDP?PFN=c2i.fr.Unjouruneplante_xxxxxxxxx"));

Lien vers une recherche

Pour la recherche, c'est aussi simple avec cette fois le paramètre query. Exemple pour les applications de c2i.fr, l'uri est (si vous êtes sous IE10, testez le lien pour voir) :

ms-windows-store:SEARCH?query=c2i.fr

Oui, en cliquant dessus dans IE10, le browser de Microsoft ouvre bien lui même le Windows Store (une bonne façon pour tester le résultat de votre recherche).

Lien vers le commentaire

Tout comme pour l'ouverture de la page de l'application, l'action REVIEW attend le Package Family Name :

ms-windows-store:REVIEW?PFN=c2i.fr.Unjouruneplante_xxxxxxxxx

Encore une fois, cette action est non documentée et son utilisation est à prendre avec des pincettes.

Conclusion

Si vous développez plusieurs applications pour Windows Store, il est important de créer cette synergie entre vos applications, donc n'hésitez pas à intéragir avec le Windows Store, vous augmenterez vos téléchargements.

CodeS-SourceS rejoint CommentCaMarche.net : retour en arrière...

Fri, 28 Sep 2012 07:41:06 GMT

Hier, petit retour en arrière...

En consultant Google+ hier avant de prendre l'avion, je tombe sur une publication de Pierre Tran (le geek vampire ;-)) qui pointe vers la page suivante :

L'histoire fabuleuse de CodeS-SourceS.com qui rejoint le groupe CommentCaMarche.net

Oula boudiou, ca nous rajeunit pas tout ca ! Après une soirée avec Redo lundi, Nix qui revient dans l'avant scène de l'actualité ce jeudi !

Et pourquoi pas pro.wanadoo.fr/c2i, ASP-Magazine.com, Asp-php.net, TechHeadBrothers.com (Laurent va me tuer, il est pas mort son site ;-)), Dotnetguru.org, Dotnet-project.com et j'en passe...

Tous ont été des acteurs majeurs des développeurs du web francophone fin des années 90, début des années 2000.

(tiens, y'a toujours une pub pour Project Hoshimi ;-))

Comme le dit (ou sous-entend Nico), pratiquement la majorité de ces acteurs ont été Microsoft MVP, que ce soit les fondateurs de ces sites que les membres les plus actifs de ces communautés (d'ailleurs, j'aimerais bien qu'on me dise quelles sont les communautés de développeurs .NET aujourd'hui ? A part Developpez.com, j'ai peur que les plus actifs ne soient les évangélistes de MS - ce qui en dirait long - mais je me trompe peut-être).

Ceci dit, Nico a lancé son site perso à peu près à la même période que moi (je dirais plutôt après mais je ne voudrais pas le vexer, il est succeptible ;-)) et que de chemin parcouru.

VBFrance puis CodeS-Sources puis l'industrialisation de CodeS-Sources (dans le bon sens), son départ "hollywoodien" du programme MVP, et la fondation de Magma Mobile.

BRAVO NICO !

Bon et maintenant j'ai envi de dire : quoi de neuf docteur ? what's next ?

NB : si j'ai oublié des sites, désolé ce n'est pas voulu, c'est juste Alzeihmer qui me guête. N'hésitez pas à le signaler.

Tester l'existence d'un fichier avec les API Win32 pour WinRT

Tue, 31 Jul 2012 09:50:24 GMT

C’est un sujet qui revient périodiquement quand vous développez une application pour Metro : comment savoir si un fichier existe déjà ?

Malheureusement, les API de WinRT ne proposent pas par défaut de méthode comme FileExists du Framework 1.0 de .NET ! Pour l’instant, je n’ai trouvé que deux possibilités.

Par itération

On effectue une itération sur l’ensemble des fichiers du StorageFolder et dès qu’on a trouvé le fichier recherché, on retourne true, sinon on retourne false. Cette méthode a été exposée par David Catuhe sur son blog et se résume ainsi :

public static class StorageFolderExtensions
{
    public static async Task<bool> FileExistsAsync(this StorageFolder folder, string name)
    {
        var files = await folder.GetFilesAsync();

        return files.Any(f => f.Name == name);
    }
}

L’inconvénient de cette méthode est que si votre dossier contient de nombreux fichiers, elle est “lente”.

La méthode brutale

Cette dernière essaye d’obtenir une référence vers le fichier et si il n’existe pas, une exception est déclenchée. Il suffit donc de mettre tout cela dans un try/catch :

public static class StorageFolderExtensions
{
    public static async Task<bool> FileExistsAsync(this StorageFolder folder, string name)
    {
        try
        {
            await folder.GetFileAsync(name);
            return true;
        }
        catch
        {
            return false;
        }
    }
}

L’intérêt est que cette méthode est plus rapide mais qu’elle est basée sur le déclenchement d’une exception, ce qui n’est pas du meilleur effet !

Il y a tout de même une autre solution : l’utilisation des API Win32

La méthode Win32

Depuis que je fais du .NET, j’avoue que je n’ai jamais plus utilisé les API Win32 comme on le faisait couramment avec Visual Basic 4-6. C’est donc avec une larme à l’oeil (souvenir, souvenir) que je me suis replongé dedans. Avec Metro, vous avez accès à une liste d’API Win32 triés sur le volet par Microsoft. Parmi celles-çi, il y en a une qui nous intéresse plus particulièrement ici : GetFieAttributesEx.

Nous allons donc créer une classe NativeOperations ou nous allons déclarer l’API et les structures qui sont nécessaires :

internal class NativeOperations
 {
     // ReSharper disable InconsistentNaming
     /// <summary>
     /// La déclaration de l'API GetFileAttributesEx
     /// </summary>
     /// <param name="lpFileName">Le nom du fichier recherché</param>
     /// <param name="fInfoLevelId">Quelles types d'info on recherche</param>
     /// <param name="lpFileInformation">Structure contenant les informations une fois l'API appelée</param>
     /// <returns></returns>
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     [return: MarshalAs(UnmanagedType.Bool)]
     public static extern bool GetFileAttributesEx(
         string lpFileName,
         GET_FILEEX_INFO_LEVELS fInfoLevelId,
         out WIN32_FILE_ATTRIBUTE_DATA lpFileInformation);

     /// <summary>
     /// Type d'infos recherchées
     /// </summary>
     public enum GET_FILEEX_INFO_LEVELS
     {
         /// <summary>
         /// C'est la seule valeur autorisée avec WinRT
         /// </summary>
         GetFileExInfoStandard,
         /// <summary>
         /// Ne fonctionne pas sous WinRT => marqué Obsolete
         /// </summary>
         [Obsolete]
         GetFileExMaxInfoLevel
     }

     /// <summary>
     /// Structure contenant les informations sur le fichier
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     public struct WIN32_FILE_ATTRIBUTE_DATA
     {
         public FileAttributes dwFileAttributes;
         public FILETIME ftCreationTime;
         public FILETIME ftLastAccessTime;
         public FILETIME ftLastWriteTime;
         public uint nFileSizeHigh;
         public uint nFileSizeLow;
     }

     // quelques valeurs d'erreurs succeptibles d'arriver
     private const int ERROR_FILE_NOT_FOUND = 2;
     private const int ERROR_PATH_NOT_FOUND = 3;
     private const int ERROR_ACCESS_DENIED = 5;

Maintenant, il ne nous reste plus qu’à utiliser cette API :

public static bool FileExist(string fileName)
{
WIN32_FILE_ATTRIBUTE_DATA fileData;
if (GetFileAttributesEx(fileName, GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, out fileData))
    return true;

// récupération de la dernière erreur (in the same thread of course ;-))
var lastError = Marshal.GetLastWin32Error();
if (lastError == ERROR_FILE_NOT_FOUND || lastError == ERROR_PATH_NOT_FOUND) return false;
// si c'est pas un fichier non trouvé, on lance une exception
if (lastError == ERROR_ACCESS_DENIED)
    throw new SecurityAccessDeniedException("Accès interdit");

throw new InvalidOperationException(string.Format("Erreur pendant l'accès au fichier {0}, code {1}", fileName, lastError));
}

Et ca marche, sans exception, sans itération, et c’est très rapide.

Limitations de cette démarche

Il y a une grosse limitation à cette démarche : elle ne fonctionne qu’avec le local storage ! Même si vous déclarez que vous avez le droit d’accéder au dossier des Images & co, il refusera d’y accéder (AccessDeniedException). Donc cela va très bien si vous recherchez des fichiers dans votre local Storage, mais vous pouvez la mettre à la poubelle si vous voulez rechercher dans un autre dossier (sniff, sniff).

En revanche, côté performances, il n’y a pas photo. J’ai effectué un test (IMPORTANT : en mode Release) sur un répertoire contenant plus de 600 fichiers. J’effectue une recherche d’existence de chacun des fichiers puis sur des noms de fichiers dont je sais pertinemment qu’ils n’existent pas. Résultat : je vais entre 5 et 10 fois plus vite avec les API Win32.

Il n’y a donc pas photo : si vous devez chercher régulièrement dans votre local Storage, utilisez cette méthode. En revanche, elle ne vous sera d’aucunes utilités ailleurs. Dommage !

En espérant que la version finale des API WinRT comportera une méthode optimisée…

Les API Win32 supportés par Metro

Tue, 31 Jul 2012 09:49:11 GMT

Suite à mon précédent article, certaines personnes se demandaient qu'elles étaient ces fameuses API Win32 supportées par Metro.

La liste complète est disponible ici : http://msdn.microsoft.com/en-us/library/windows/apps/br205757.aspx

Elles sont classées en 10 catégories :

Data : File System, Jet (et oui ;-)) et XML,
Devices : Device access, Game controllers, Windows portable devices,
Diagnostics : Debugging & error handling, Last Error, Windows Error Reporting, Windows Event,
Graphics : Direct2D, Direct3D, DirectWrite, DirectMath, Windows Imaging Component,
Multimedia : Camera, Core Audio, Media Foundation, XAudio2
Networking : Dynamic Host Configuration Protocol, Mobile Broadband, Windows Web Services, XML Http Request,
Printing & documents : Printing, XPS documents,
System : COM, Compression, DLLs, Info, Integers, Large Integer, Loader, Memory, RDP, Processes, Threads and synchronization, Time,
User interface : Accessibility, Globalization, Property system, Spell check, Strings, Text services framework, Windows animation,
Alternatives to Windows APIs

Comme vous pouvez le voir, il y a quand même pas mal d'APIs qui sont disponilbes nativement dans le framework. Donc à n'utiliser que si vous n'y arrivez pas avec du simple code C#/VB .NET (non, je ne parlerais pas de javascript ici ;-))).

De l'évolution du test de l'existence d'un fichier en .NET

Mon, 30 Jul 2012 06:52:14 GMT

.NET Framework 1.0, 2002 :

WINRT

Première solution (blog de David Catuhe)

2ème solution (brutale, "à la Mitsu" ;-))

10 ans de progrès...

De l'utilisation de Skydrive dans ses applications

Wed, 25 Jul 2012 16:13:21 GMT

Si je m'attaque à ce sujet, c'est que je viens de lire sur Smartphone Fr le billet suivant : Skydrive sur Windows Phone : Une politique surprenante !

Suite à un post sur le forum MSDN de Mark Chamberlain de Microsoft, il semblerait que l'utilisation de Skydrive pour sauvegarder des données dans son application Windows Phone n'est pas autorisée et qu'en conséquence, votre application risquait d'être rejetée.

Ce post concerne Windows Phone mais touche également Windows 8 (ou alors, je comprends plus rien !).

Donc le scénario suivant est impossible : vous avez une application WinRT et même si vous prévenez votre utilisateur que vous voulez sauvegarder des données dans son Skydrive (de toutes façons, vous êtes obligé de l'avertir, ce qui est normal), vous n'en avez pas le droit.

La seule solution que vous avez pour remonter des informations "in ze cloud" n'est donc que le roaming storage limité à 100Ko.

Beaucoup trouve cela bizarre, commencent à crier au scandale, etc. Même si cela m'embête (pour les applications que je développe) d'un autre côté, cela se comprend. Bien que vous prévenez votre utilisateur de l'utilisateur de son Skydrive, il n'a pas la maitrise des données qui y seront stockées. Ce n'est pas vraiment lui le "moteur", l'intiateur, le controleur de ces données et il se peut qu'à terme, son Skydrive soit plein si une application fait n'importe quoi (et en la désinstallant, il ne purgera pas son Skydrive).

En revanche, je pense que si votre application permet d'enregistrer des documents (tout comme Office), cela devrait être permis.

Et vous, vous en pensez quoi ?

Office 2013 : point de vue d'un développeur

Tue, 17 Jul 2012 09:12:53 GMT

Hier, Microsoft a révélé la nouvelle version d'un de ses produits phare (avec Windows), Office 2013. Il s'agit encore d'une beta, ou plus exactement d'une preview (faudra qu'on m'explique un jour la différence ;-)).

Donc depuis hier, vous pouvez télécharger Office 2013 avec Work, Excel, Powerpoint, etc. sur le site suivant : http://www.microsoft.com/office/preview/en

(inutile de passer du temps sur la video d'accueil, ce n'est que du marketing qui ne montre rien).

Parmi les grandes nouveautés, on notera l'intégration de Skydrive dans Office : vous ne sauvegardez plus sur votre disque dur mais dans Skydrive ce qui vous permet d'avoir accès à vos documents de n'importe ou (enfin les designer avec des powerpoint de plusieurs mega, je leur souhaite bien du courage).

Je ne parlerai pas des nouveautés d'Office, car franchement, je n'y connais rien en bureautique et ce n'est pas ma passion. Je noterais juste au passage l'intégration d'un menu "à la maya" (logiciel d'image de synthèse des années 90 racheté par Autodesk depuis) dans OneNote (pour WinRT) :

(Ca à pas l'air évident comme ca, mais je vous assure à l'usage que c'est la même inspiration ;-)).

Mais le plus important pour nous développeur, ce n'est pas tout cela mais le nouveau modèle de développement proposé (imposé ?) par Microsoft.

Macros & modèle COM toujours présents

Que les afficionados de VBA se rassurent : les macros Visual Basic sont toujours présentes avec l'éditeur de macro qui n'a pas bougé d'un iota. On retrouve la même interface, les mêmes boutons (pas de ribbon), les même menu (en camel case, pas en upper case), etc.

Bref, ils n'y ont pas touchés. Certains diront : on ne change pas une équipe qui gagne. OK, why not.

Comme on a donc toujours ces objets COM exposés, je suppose que l'on a aussi les wrappers pour .NET qui vont bien et que l'on a des projets modèles dans Visual Studio qui permettent de créer des complètements d'Office en .NET avec C#ou Visual Basic .NET, avec un vrai langage moderne quoi.

NB : j'ai installé Office 2013 sur une tablette Samsung Slate avec Windows 8 Preview qui n'avait pas Visual Studio 2012 Preview d'installé, je n'ai donc pu vérifier ce point.

Et, comme de sous-entendu, j'en viens au nouveau modèle de programmation proposé (imposé) par Microsoft.

Office Apps, Apps for Office, as you want.

L'idée de Microsoft est de permettre à des éditeurs de développer des applications pour Office distribuables via le Windows Store (avec une "spécialisation", l'Office Store) et installables sur des Windows 8 WinRT (aka pour ARM). Il fallait donc pour cela que l'application puisse suivre le modèle de sécurité, de sandbox de WinRT.

La solution, et l'unique solution qui a été trouvée, est de permettre le développement d'applications en HTML5/javascript. Donc pour résumer, sur un langage inventé en 1995 et une techno encore en draft. L'avantage, c'est que vous allez pouvoir intégrer des projets/framework Open Source comme jQuery dans vos applis Office. L'inconvénient c'est que, comme html5 est toujours en draft, Microsoft ajoute ses propres spécificités qui font que ce n'est pas aussi universel que cela en à l'air. De plus, quand on voit la guerre les différences d'interprétations entre IE, Chrome, Firefox & co sur du Html5, ce n'est pas prêt de se stabiliser tout cela. Enfin bon, c'est un couple, Html5/javascrip qui à l'avantage d'être connu de tous.

Vous pouvez développer 3 types d'applications :

Task pane app : vous développez le contenu d'une fenêtre qui apparait ancrée sur la droite de l'application Office (peut apparaitre dans les différentes applis Office). Par exemple un panneau qui permet de faire une recherche sur Wipikedia et d'afficher l'article dans ce panneau (vous faites un copier-coller dans votre devoir de vacances d'Histoire-géo après ;-))
Content app : accès sépcifique à un type de document Office (Workbook & co). Le plus proche des applis COM, permettent de manipuler l'arborescence objet de Word/Excel avec une nouvelle représentation de celle ci.
Mail app : type spéciale d'appli permettant d'envoyer des emails (spécifique Outlook 2013).

Toute application, pardon App, pour Office est composée d'un manifeste (document xml) et de son "code" en javascript. Oui, c'est du javascript, et pas autre chose (j'insiste car quand vous allez sur la page des exemples, vous avez des exemples dits en C#/VB .NET qui ne contiennent pas une ligne de .NET ;-)).

Comme l'appli ne repose que sur ces technologies, la bonne nouvelle c'est que vous pouvez les développer avec un "vieux" Visual Studio 2012.

Un pari sur l'avenir

Je pense qu'il est clair que Microsoft essaye d'inventer un nouveau marché. Comme Office sera "offert" avec WinRT, la solution qu'ils ont trouvés pour se rémunerer est de permettre la diffusion d'appli dans le Windows Store (et donc de prendre 30% de com au passage). C'est ingénieux.

La bonne nouvelle c'est qu'Office deviendra de moins en moins cher si cet echo-système se développe.

La moins bonne nouvelle, c'est que le développement .NET semble abandonné. Maintenant, je n'y mettrais pas ma main au feu et peut-être qu'une bonne nouvelle sera annoncée prochainement (à moins que je n'ai pas tout compris...).

Le point d'entrée pour le développement d'Office Apps (ou Apps for Office).

Comment charger et afficher beaucoup d'images (WinForms)

Fri, 06 Jul 2012 08:25:37 GMT

L’idée de cet article me vient d’une question posée sur le forum MSDN de C#. La question était la suivante :

J’ai un répertoire avec beaucoup d’images et je souhaite les afficher dans une Windows Form. Le problème est que j’ai un OutOfMemoryException qui se déclenche. Comment faire ?

Bien entendu, si l’on a beaucoup d’images en haute résolution, vous aurez beau avoir un PC de la mort qui tue, la mémoire n’est pas extensible à l’infini. Donc charger "simplement” les images dans des PictureBox ou dans une DataGrid fera que votre PC chauffera.

Le principe

Nous allons donc créer un projet Windows Form (je crois que ca fait 6 ans que je n’en avais pas fait ). Il comportera simplement un bouton pour lancer l’analyse et un contrôle Panel dans lequel nous allons ajouter dynamiquement des contrôles PictureBox.

Quand on clique sur le bouton d’analyse, une première méthode fera le ménage dans notre panel (supprimera les picturebox existants) :

private void ClearImageControls()
{
    // on supprime les picturebox existants
    if (pnImages.Controls.Count > 0)
    {
        for (var index = pnImages.Controls.Count - 1; index >= 0; index--)
        {
            var ctrlImage = pnImages.Controls[index] as PictureBox;
            if (ctrlImage != null)
            {
                pnImages.Controls.RemoveAt(index);
                ctrlImage.Image = null;
                ctrlImage.Dispose();
            }
        }
    }
}

Et donc nous appellerons cette méthode pour vider notre contrôle Panel.

Maintenant, le cœur de notre code va être pour chaque fichier image contenu dans notre répertoire :

Charger l’image,
Créer une vignette de limage,
Décharger l’image,
Ajouter un PictureBox contenant la vignette à notre Panel.

C’est donc, dans un premier temps, une approche synchrone, qui prend du temps et qui gèle l’interface (pas cool) :

private void btnSync_Click(object sender, EventArgs e)
{
    // La madame elle fait le ménache
    ClearImageControls();
    // on mesure le  temps d'exécution
    var sw = Stopwatch.StartNew();
    
    var currentColumn = 0;
    var currentRow = 0;
    // pour toutes les images du répertoire
    foreach (var fileName in Directory.GetFiles(FolderName, "*.jpg"))
    {
        // On charge l'image
        Image img = new Bitmap(fileName);
        // On en fait une vignette
        var newImage = img.GetThumbnailImage(PictureWidth, PictureWidth, null, IntPtr.Zero);
        // on décharge l'image
        img.Dispose();

        // on crée le PictureBox
        var newPic = new PictureBox
                         {
                             Width = PictureWidth,
                             Height = PictureWidth,
                             Location = new Point
                                            {
                                                X = currentColumn*(PictureWidth + PictureMargin),
                                                Y = currentRow*(PictureWidth + PictureMargin)
                                            },
                             Image = newImage,
                         };

        // On ajoute le PictureBox dans le Panel
        pnImages.Controls.Add(newPic);

        // On gère les colonnes, lignes
        currentColumn++;
        if (currentColumn >= ColumnsNumber)
        {
            currentColumn = 0;
            currentRow++;
        }
    }

    // Affichage du temps d'exécution
    lbl.Text = string.Format("{0} ms", sw.ElapsedMilliseconds);
}

Résultat sur un répertoire contenant 350 images très haute résolution (1 Go d’images jpeg) :

Une minute, c’est pas mal, mais j’ai un “beau PC” .

L’approche asynchrone

Bien entendu, le mieux est d’avoir une approche asynchrone, ce que nous permet facilement le Framework 4.0. Nous allons donc lancer une tâche qui va itérer sur l’ensemble des fichiers et retourner la liste des vignettes :

// Démarrage en asynchrone
            Task<IEnumerable<Image>>.Factory.StartNew(
                () =>
{
    // chargement des vignettes dans un ConcurrentBag
    var images = new ConcurrentBag<Image>();
    Parallel.ForEach(Directory.GetFiles(FolderName, "*.jpg"),
                     fileName =>
                         {
                             // On charge l'image
                             Image img = new Bitmap(fileName);
                             // On en fait une vignette
                             var newImage = img.GetThumbnailImage(
                                 PictureWidth,
                                 PictureWidth,
                                 null,
                                 IntPtr.Zero);
                             images.Add(newImage);
                             img.Dispose();
                         });
    return images;
}).ContinueWith(...);

Donc maintenant, dans ContinueWith, on a notre collection d’images que l’on peut ajouter dans le Panel :

.ContinueWith(
task =>
    {
        // on n'a pas de gestion d'erreur ici, mais ce serait une bonne idée quand même
        var currentColumn = 0;
        var currentRow = 0;
        foreach (var image in task.Result)
        {
            var newPic = new PictureBox
            {
                Width = PictureWidth,
                Height = PictureWidth,
                Location = new Point
                {
                    X = currentColumn * (PictureWidth + PictureMargin),
                    Y = currentRow * (PictureWidth + PictureMargin)
                },
                Image = image,
            };
            pnImages.Controls.Add(newPic);

            // On gère les colonnes, lignes
            currentColumn++;
            if (currentColumn >= ColumnsNumber)
            {
                currentColumn = 0;
                currentRow++;
            }
        }
        lbl.Text = string.Format("{0} ms", sw.ElapsedMilliseconds);
    },
TaskScheduler.FromCurrentSynchronizationContext());

Notez l’utiilisation de TaskScheduler.FromCurrentSynchronizationContext() pour s’assurer que le résultat est analyser dans le thread de l’UI.

Moralité :

Le résultat est le même (bonne nouvelle !) et surtout, le temps d’exécution a été sérieusement diminué (14 secondes au lieu d’une minute) et l’interface de l’utilisateur n’a pas été figée. On pourrait rajouter l’affichage d’une image animée pour signifier que l’on travaille, ajouter des informations sur le déroulement de l’analyser, etc. Mais je vais pas vous mâcher tout le travail quand même .

Le code complet en mode asynchrone est donc le suivant :

private void async_btnSync_Click(object sender, EventArgs e)
{
    // La madame elle fait le ménache
    ClearImageControls();
    // on mesure le  temps d'exécution
    var sw = Stopwatch.StartNew();

    // Démarrage en asynchrone
    Task<IEnumerable<Image>>.Factory.StartNew(
        () =>
            {
                // chargement des vignettes dans un ConcurrentBag
                var images = new ConcurrentBag<Image>();
                Parallel.ForEach(Directory.GetFiles(FolderName, "*.jpg"),
                                 fileName =>
                                     {
                                         // On charge l'image
                                         Image img = new Bitmap(fileName);
                                         // On en fait une vignette
                                         var newImage = img.GetThumbnailImage(
                                             PictureWidth,
                                             PictureWidth,
                                             null,
                                             IntPtr.Zero);
                                         images.Add(newImage);
                                         img.Dispose();
                                     });
                return images;
            }).ContinueWith(
                task =>
                    {
                        // on n'a pas de gestion d'erreur ici, mais ce serait une bonne idée quand même
                        var currentColumn = 0;
                        var currentRow = 0;
                        foreach (var image in task.Result)
                        {
                            var newPic = new PictureBox
                            {
                                Width = PictureWidth,
                                Height = PictureWidth,
                                Location = new Point
                                {
                                    X = currentColumn * (PictureWidth + PictureMargin),
                                    Y = currentRow * (PictureWidth + PictureMargin)
                                },
                                Image = image,
                            };
                            pnImages.Controls.Add(newPic);

                            // On gère les colonnes, lignes
                            currentColumn++;
                            if (currentColumn >= ColumnsNumber)
                            {
                                currentColumn = 0;
                                currentRow++;
                            }
                        }
                        lbl.Text = string.Format("{0} ms", sw.ElapsedMilliseconds);
                    },
                TaskScheduler.FromCurrentSynchronizationContext());
}

Comme quoi, l’asynchrone peut servir même pour les applications “old fashion”, aka Windows Form.

Les raccourcis clavier de Windows 8

Tue, 03 Jul 2012 15:53:37 GMT

Plutôt qu'un long discours, voici une superbe capture d'écran de mon clavier avec les raccourcis Windows + Touche de Windows 8 :

A noter également :

1 to 9 - Show/Launch Application from Taskbar
Page Up/Down - Moves tiles to the left/right
Tab - Switch between applications
, (comma) - Aero Peek (desktop)
. (full stop) - Snap Metro style app to right side of the screen
Shift . (full stop) - Snap Metro style app to the left side of the screen
Space - Switch input language and keyboard layout
Enter - Launch Narrator
Arrow keys - Aero Snap (desktop)

L'image en haute résolution.

Ce shéma est basé sur le billet suivant.

Utile ?

Comment redimensionner une image avec WinRT : plusieurs solutions

Fri, 11 May 2012 13:48:33 GMT

J'ai participé hier à une session du Tour de France Windows 8 à Bordeaux. Session très sympathique avec de charmants co-développeurs.

J'en ai profité pour m'avancer sur mon projet d'application WinRT et de me pencher plus avant sur la problématique suivante :

J'ai des nombreuses images dans mon application qui sont de taille "importante" (supérieure à 1024*768). Or il se trouve que ces images peuvent être utilisées pour la vignette de mon application. J'ai donc soit le choix de créer "à la main" une version light de mes images, soit ajouter la fonctionnalité à mon application de redimensionnement d'images (pour info, le poids des images affichées dans les vignettes est limitée, 150Ko je crois de mémoire).

La solution que j'ai trouvée était la suivante :

Une solution "pas simple"

La première étape consiste à récupérer la première frame de l'image à partir du fichier :

// imageFilename 
//      C'est le nom du fichier. 
//      Ici, c'est un fichier image que l'on a placé dans notre projet en tant que Contenu
//      (répertoire Assets dans le projet template de MS) 
//      Il se trouve donc dans le InstalledLocation
//      récupération du fichier, StorageFile
// fileName
//      nom du fichier que l'on veut sauvegarder
// width, height
//      largeur et hauteur de l'image finale désirée

var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(imageFilename);
// récupération du flux du fichier
var baseStream = RandomAccessStreamReference.CreateFromFile(file);
// décodeur de l'image à partir du flux ouvert en lecture
var fileDecoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(await baseStream.OpenReadAsync());
// récupération de la première frame de l'image
var bitmapFrame = await fileDecoder.GetFrameAsync(0);

Ensuite, on récupère les pixels de notre image en spécifiant la taille de l'image finale :

// on veut une image de la taille width*height
var bitmapTransform = new BitmapTransform { ScaledWidth = width, ScaledHeight = height };
// récupération des pixels
var pixelDatas =
    await bitmapFrame.GetPixelDataAsync(
        bitmapFrame.BitmapPixelFormat,
        bitmapFrame.BitmapAlphaMode,
        bitmapTransform,
        ExifOrientationMode.IgnoreExifOrientation,
        ColorManagementMode.DoNotColorManage);

Enfin, on crée le fichier final et on écrit les pixels dedans :

// le fichier ou l'on souhaite enregistrer l'image redimensionnée.
// On la place dans le LocalFolder de l'application
var targetFile =
    await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(
        fileName,
        CreationCollisionOption.ReplaceExisting)
        .AsTask<storagefile>();

// ouverture du flux pour écrire dans le fichier
using (var fileStream = await targetFile.OpenAsync(FileAccessMode.ReadWrite))
{
    // l'encodeur de notre nouveau fichier image
    var newBitmapEncoder = 
        await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync(
            BitmapEncoder.JpegEncoderId, 
            fileStream);
    // on écrit les pixels dans notre nouveau fichier en respectant les infos d'origine (dpi, alpha, etc.)
    newBitmapEncoder.SetPixelData(
        bitmapFrame.BitmapPixelFormat, 
        bitmapFrame.BitmapAlphaMode, 
        bitmapTransform.ScaledWidth, 
        bitmapTransform.ScaledHeight, 
        bitmapFrame.DpiX, 
        bitmapFrame.DpiY, 
        pixelDatas.DetachPixelData());

    // on s'assure que l'on vide bien tout
    await newBitmapEncoder.FlushAsync();
    await fileStream.FlushAsync();
}

Ce n'est pas vraiment simple, mais ca marche.

Une solution plus simple

Montrant ce code à notre cher GO, aka Benoit Laut de Bewise, il me dit : "Mais non, espèce d'abruti, y'a beaucoup plus simple :!".

Bon, OK, il m'a pas dit ca comme ca exactement ;-). Je précise pour ceux qui comprendrait pas le second degré. Il m'a dit très gentillement qu'il pensait qu'il y avait plus simple, notamment avec les méthodes GetThumbnails du framework. Il a donc recherché et quelques temps plus tard, il m'a trouvé le code suivant :

var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(imageFilename);
// on veut une vignette de type image de largeur width et redimensionnée
var thumbnail = await file.GetThumbnailAsync(
    Windows.Storage.FileProperties.ThumbnailMode.PicturesView, 
    width, 
    Windows.Storage.FileProperties.ThumbnailOptions.ResizeThumbnail);

// on crée le fichier cible
var storageFile = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
// ATTENTION : Ajoutez System.IO qui comprend ces méthodes d'extensions
// le flux ou l'on souhaite écrire
var writer = await storageFile.OpenStreamForWriteAsync(); 
var outputStream = writer.AsOutputStream();

// sauvegarde dans le flux de la vignette
await RandomAccessStream.CopyAndCloseAsync(thumbnail, outputStream);

Il y a quand même beaucoup moins de ligne de code, et ca à l'air plus simple.

MAIS

Car souvent avec moi, il y a un MAIS. J'ai donc voulu voir le résultat de ces deux possibilités. Concrètement, on obtient bien une vignette avec la taille désirée (dans le deuxième cas, on ne peut pas spécifier la largeur ET la hauteur, mais ce n'est pas grave dans notre cas). Les deux images sont bien générées :

J'ai bien mes patates redimensionnées et on peut constater que le temps d'exécution est sensiblement le même.

Mais concernant le poids des fichiers, ce n'est pas du tout la même histoire.

Le fichier d'origine fait 250Ko.
Le ficher avec la méthode complexe fait 36Ko
Le fichier avec la méthode simple fait 250Ko !!!

C'est bizarre (et si vous avez une explication, je suis preneur). Mais toujours est-il que je vas donc utiliser la méthode "complexe" dans mon application.

Conclusion

Tout comme dans le framework .NET "normal", pour faire une même opération, on a de multiples possibilités. Mais l'avantage avec le framework normal, c'est que grâce à des décompilateurs, on peut savoir pourquoi. Peux être que sur des images beaucoup plus lourde, la solution complexe est beaucoup plus rapide, peux être qu'avec la version finale, le poid de l'image finale sera optimisée.

Mais comme on n'a pas accès à des décompilateurs pour voir le code qui est réellement exécuté, on est encore dans le flou, et seul des tests permettent de savoir ce qu'il faut utiliser.

Réflechissons un peu ce matin à propos des ORM

Fri, 11 May 2012 06:34:46 GMT

Le blog des bits

Fabrice Marguerie (ca faisait une paille que t'avais rien écris ;-)) vient de publier un petit billet qui fait surtout référence à un autre billet de Martin Fowler (vous connaissez bien entendu Martin Fowler).

Le sujet est à propos des outils ORM, Object-Relational Mapping tools.

En gros, ne vous laissez pas aveugler par ces outils, en supputant qu'ils résolvent tous vos problèmes. Ils peuvent couvrir 80% de votre solution, mais il en restera toujours 20% à traiter avec attention.

Et c'est là ou j'ajouterais que si vous choisissez de partir avec un outil d'ORM, il faut impérativement que ce dernier vous permette d'inclure du code personnalisé, que vous ne soyez pas prisonnier de votre ORM. Car la plupart du temps, les 20% de code qu'il vous faut faire à la main, c'est justement les parties les plus délicates, les plus complexes, au niveau de la compréhension du fonctionnel. Et j'ai vu souvent des arguments de développeur indiquant qu'il faut modifier le fonctionnel pour implémenter une fonctionnalité car le choix de leur outil faisait que ce n'était pas possible.

Alors oui je pense à des outils comme NHibernate ou Entity Framework (quoique) qui font que c'est souvent une usine à gaz qui sort des cartons, qui fait que le développeur passe beaucoup de temps à essayer de comprendre comment détourner son ORM pour terminer son petit WorkItem.

Je pense à un outil comme CodeFluent Entities qui lui au contraire est suffisamment maléable, flexible pour intégrer facilement du code personnalisé (mais qui d'un autre côté vous génère 80% de votre plomberie). Il a même été conçu dans ce sens.

Donc je le répète, faites attention à l'ORM que vous choisissez. Pensez que quand vous choisissez un ORM, cela vous engage pour toute la durée du produit (et pas seulement le temps de son développement), et surtout, soyez certain qu'il y aura des features non couvertes par votre ORM.

Tuile ou vignette ?

Mon, 23 Apr 2012 07:29:45 GMT

Le terme "Tile" est apparu dans le vocabulaire de Microsoft avec Windows Phone 7 et sa nouvelle interface.

La traduction française (si je ne m'abuse) qui a été entérinée depuis est : tuile. (why not).

On s'y était habitué et tout allait bien.

Avec Windows 8 Metro, on a encore une fois la présence de "Tile" dans l'interface du bureau new look. Et ce matin, en consultant la traduction d'un billet du blog des développeurs d'applications Windows 8, je vois le titre :

Creating a great tile experience (part 1)

traduit en :

Création d'une expérience utilisateur optimale en matière de vignettes (première partie)

Donc tile pour Windows 8 a été traduit en vignette. Marrant non ? C'est la subtilité de la langue française, suivant le contexte, un même mot peut changer de signification.

Une cocotte par exemple, est un pliage en papier pour un enfant, c'est un ustensile de cuisine pour une ménagère et une xxx pour l'ado boutonneux.

On a aussi Store qui a été traduit en Stocker (plus étrange encore, vu via l'article précédent).

Bon c'est pas grave. Je pense que l'équipe de traduction de Windows 8 a un travail énorme en ce moment car les délais de traduction sont très courts entre le moment ou le billet est publié et sa traduction. J'ai participé à la traduction de la documentation de .NET 1.0 et de VS 2002, et je peux vous dire que c'est pas de la tarte comme exercice.

Donc encore une fois : merci de nous offrir cette traduction "en temps presque réel".

Vous avez d'autres exemples de traduction "loufoque" ?