Lost in the matrix

FAXCOMLib & Acrobat Reader 10

2011-06-04T23:46:00.000-07:00

La FAXCOMLib est un bon moyen pour envoyer des fax à partir d'une application en C#/.Net. Toutefois, il faut savoir qu'elle utilise le lecteur PDF par défaut de l'utilisateur de son contexte. Ainsi, le comportement de la FAXCOMLib peut varier en fonction de ce lecteur. En effet, depuis la version 10 de Acrobat Reader, les fax envoyés à partir de la FAXCOMLib ne partent plus.

Lors de l'envoie d'un fax, une exception "System.Runtime.InteropServices.COMException (0x80070102):Operation failed" est lancée au bout d'un certain temps. Grâce à mon précédent article "Interpréter une exceptionCOM sous Windows", nous savons qu'il s'agit d'un "timeout". Ce "timeout" est dû au fait qu'Acrobat Reader a changé son fonctionnement et essaie de lancer son IHM (GUI). La FAXCOMLib n'étant pas capable de gérer ce changement de protocole, elle "timeout" au bout de cinq minutes, le comportement à adopter dans cette situation.

solutions:

Installer une autre version d'Acrobat Reader (9 par exemple)
Installer un lecteur alternatif (exemple : Foxit Reader)

Interpréter une exception COM sous Windows

2011-06-04T11:41:00.000-07:00

Parfois, il nous arrive d'utiliser des composants "Bas Niveau" dans nos applications (utilisation du fax par exemple). Cependant, du fait que le code est souvent non-managé, il est difficile d'interpréter les erreurs remontées par ces composants. Par conséquent, voici une petite astuce à connaître :

Pour notre exemple, nous allons considérer que nous avons une application en .Net et que nous utilisons le composant FAXCOMLib pour envoyer un fax. Enfin, nous allons considérer que l'exception suivante est survenue lors de l'exécution du programme :

System.Runtime.InteropServices.COMException (0x80070102): Operation failed

1) De cette exception nous allons extraire le code de l'erreur : 0x80070102

2) Puis extraire les 4 chiffres suivant le chiffre 7 : 0x80070102

3) Convertir le nombre de la base 16 (hexadecimal) à la base 10 : 258

Astuce : utiliser un site pour éffectuer la conversion, tel que :
http://www.statman.info/conversions/hexadecimal.html

4) Ouvrir un invité de commandes (cmd.exe) et taper : "net helpmsg 258"

Cette commande affiche "The wait operation timed out."

Astuce : la liste des codes d'erreur de Windows est disponible à cette adresse :
http://msdn.microsoft.com/en-us/library/ms681382(v=vs.85).aspx

Les erreurs COM sont maintenant lisibles :)

Téléchargement anormalement lent sur Steam

2011-02-27T03:38:00.000-08:00

Voici, un petit hors-serie sur Steam qui, je l'espère devrait résourdre les problèmes de lenteur chez certain.

1) Fermer Steam (vérifier le cas échéant dans le gestionnaire de tâches).

2) Supprimer le fichier "ClientRegistry.blob" qui se trouve à la racine du répertoire d'installation de Steam. Exemple:
C:\Program Files (x86)\Steam\ClientRegistry.blob
Ce fichier contient entre-autres diverses informations sur votre connexion (ex: Client Bandwidth Stats)

3) Redémarrer Steam (Steam devrait vous re-demander vos identifiants, sinon recommencer à l'étape 1).

4) Relancer vos téléchargements.

Ajouter une image dynamiquement dans un rapport avec Crystal Reports XI

2011-01-04T01:55:00.000-08:00

1) Lancer Crystal Reports XI

2) Créer un nouveau rapport vide

3) Cliquer sur l'icône "Insérer une image"

4) Sélectionner une image arbitraire

5) Placer l'image

6) Ajouter un nouveau paramètre correspondant au chemin du fichier image

7) Ajouter un paramètre de type de "Chaîne", ici nommé "Image"

8) Clique droit sur l'image, puis cliquer sur "Mettre en forme le graphique"

9) Cliquer sur le bouton "formule" (X+2)

10) Mettre la formule "{?Image}" ou "Image" est le nom du paramètre

---

Il ne reste plus qu'a tester le modèle.

Savoir si une machine est "pingable" en C sous Windows

2010-08-29T13:00:00.000-07:00

Ceci est une version très basique de la fonction Ping.
Elle ne gère pas tous les cas, mais je vais poster une version améliorée bientôt.

#include <winsock2.h>
#include <Ipexport.h>
#include <icmpapi.h>

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")

int IsPingable(const char *host, int timeout)
{
 IP_OPTION_INFORMATION ioi;
 ICMP_ECHO_REPLY       ier;
 LPHOSTENT             Host;
 WSADATA               wsaData;
 IN_ADDR               iaAddr;
 HANDLE                hIcmp;

 if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
 {
  WSACleanup();
  return (0);
 }
 iaAddr.s_addr = inet_addr(host);
 if (iaAddr.s_addr == INADDR_NONE)
  Host = gethostbyname(host);
 else
  Host = gethostbyaddr((char *)&iaAddr, sizeof(IN_ADDR), AF_INET);
 if (Host == NULL)
 {
  WSACleanup();
  return (0);
 }
 hIcmp = IcmpCreateFile();
 ioi.Ttl = 255;
 ioi.Tos = 0;
 ioi.Flags = 0;
 ioi.OptionsSize = 0;
 ioi.OptionsData = NULL;
 IcmpSendEcho(hIcmp, *(DWORD *)(*Host->h_addr_list), NULL, 0, &ioi, &ier, sizeof(ICMP_ECHO_REPLY), timeout);
 IcmpCloseHandle(hIcmp);
 WSACleanup();
 return (ier.Status == 0);
}

Exemple:

int main(int argc, char **argv)
{
 printf("IsPingable : %d\n", IsPingable("clustrmaps.com", 5000));
 getchar();
 return (EXIT_SUCCESS);
}

Editer les sous-objets dans une PropertyGrid (C# / .Net)

2010-08-24T12:50:00.000-07:00

Aujourd'hui, je suis tombé sur un problème avec le contrôle PropertyGrid, car je voulais éditer les propriétés d'un objet ainsi que ses sous-objets. Toutefois, j'ai eu quelques soucis, car la PropertyGrid ne permet pas (de base) d'éditer les sous-objets et ceux-ci apparaissent grisés.

Voici mon code:

using System.Drawing;
using System.Windows.Forms;

namespace WindowsFormsApplication
{
    public partial class PropertyGridTest : Form
    {
        public PropertyGridTest()
        {
            InitializeComponent();
            this.propertyGrid1.SelectedObject = new Car();
        }
    }

    public class Driver
    {
        public string Name { get; set; }
        public bool HasDriverLicence { get; set; }
    }

    public class Car
    {
        public Car()
        {
            this.Driver = new Driver()
            {
                Name = "Johannes Fetz",
                HasDriverLicence = false
            };
            this.Color = Color.Red;
            this.Kind = "Sedan";
        }

        public string Kind { get; set; }
        public Color Color { get; set; }
        public Driver Driver { get; set; }
    }
}

qui donne le résultat suivant:

Après quelques recherches, j'ai trouvé comment résoudre ce problème. En effet, il suffit d'indiquer à la PropertyGrid que "Driver" est un objet "Expandable". Pour cela, il faut ajouter un using :

using System.ComponentModel;

et un attribut au dessus de la classe "Driver" :

[TypeConverterAttribute(typeof(ExpandableObjectConverter))]
public class Driver
{

Ce qui donne le résultat suivant:

Pseudo delegate en langage C

2010-05-23T14:29:00.000-07:00

Voici une petite démonstration d'une implémentation des delegates que j'ai fait en langage C :)
Dans ce code, une fonction est déclarée en locale avec un nom unique, composé du mot
"__delegate__" et du numéro de la ligne courrante (__LINE__). Puis, l'adresse est stockée
dans la variable de l'utilisateur sous forme d'un pointeur sur fonction de type "Delegate".

#include <stdio.h>

#define CONCAT2(s1, s2) s1##s2
#define CONCAT(s1, s2) CONCAT2(s1, s2)
#define NewDelegate(Ptr, Expr) void \
        CONCAT(__delegate__, __LINE__)() Expr \
        Ptr = (Delegate)&CONCAT(__delegate__, __LINE__)

typedef void (*Delegate)(void);

void    PseudoDelegateTest()
{       
        int  i;
        Delegate my_delegate;

        NewDelegate(my_delegate,
        {
           printf("i = %d\n", i);
        });

        for (i = 0; i < 5; ++i)
            my_delegate();
}

int main(int argc, char **argv)
{
  PseudoDelegateTest();
  getchar();
  return (0);
}

Débuter avec Vim

2010-05-19T03:12:00.000-07:00

Cela fait pas mal de temps que je m'intéresse à cet éditeur dont les possibilités sont infinies. En effet, j'ai eu l'occasion grâce à un ami, de le voir à l'oeuvre. Toutefois, il n'est pas toujours évident d'utiliser un autre éditeur quand on est habitué à un autre (personnellement j'utilise Emacs). Cet éditeur offre réellement une plus-value pour celui qui le maîtrise. Notamment grâce à son système de macros très bien pensé. Ainsi, j'ai appris les commandes de base et j'ai rédigé un document avec la liste des commandes élémentaires pour commencer avec Vim.

Voici le lien vers le document complet (pdf ou txt) : Commandes élémentaires de Vim

Lien vers le site officiel de Vim : www.vim.org

Corriger le problème de lenteur du "ApplyLogOnInfo" dans Crystal Reports

2010-04-20T06:18:00.000-07:00

A la place de :

ConnectionInfo crConnectionInfo = new ConnectionInfo();
crConnectionInfo.Type = ConnectionInfoType.SQL;
crConnectionInfo.ServerName = "ODBCsource";
crConnectionInfo.DatabaseName = "DataBase";
crConnectionInfo.UserID = "Login";
crConnectionInfo.Password = "Password";
foreach (CrystalDecisions.CrystalReports.Engine.Table tmpTable in doc.Database.Tables)
{
     tmpTable.LogOnInfo.ConnectionInfo = crConnectionInfo;
     tmpTable.ApplyLogOnInfo(tmpTable.LogOnInfo);
     tmpTable.Location = tmpTable.Name;
}

Il suffit de faire :

doc.DataSourceConnections[0].SetConnection("ODBCsource", "DataBase", "Login", "Password");
doc.Refresh();

Où la variable "doc" est du type "ReportDocument".
Attention j'ai pris l'index 0 dans "DataSourceConnections" à titre d'exemple.
La valeur peut changer en fonction du modèle.

Indexe à valeurs multiples en C#

2010-04-20T06:01:00.000-07:00

Voici une petite astuce dont je ne vois pas l'utilité immédiate, mais qui peut intéresser certain.

public int this[string val1, string val2]
{
    set
    {
       Console.WriteLine("{0} - {1}", val1, val2);
    }
}

Win32Exception : "The operation completed successfully" et Crystal Reports

2010-03-29T11:38:00.000-07:00

Aujourd'hui, j'ai eu un problème lors de l'impression d'un rapport avec le composant Crystal Reports.
Lors de l'appel de la méthode "ReportDocument.PrintToPrinter" une étrange erreur
"Win32Exception : The operation completed successfully" est apparue. Après une longue recherche,
je me suis aperçu, que le problème était en réalité lié au pilote (Driver) de mon imprimante sous
Windows 7 64 bits. En effet, le programme fonctionne très bien sous Windows Vista 64 bits
avec la même imprimante. De plus, un de mes collègue à strictement le même problème
avec la même configuration. Cependant, le problème est particulièrement vicieux, car j'arrive à imprimer
certains documents à partir de mon poste, avec le Bloc Note de Windows par exemple.
Quelle péripétie!

Problème de lenteur avec le contrôle CrystalReportViewer

2010-03-22T08:39:00.000-07:00

Je viens de trouver dans mon code pourquoi ma fenêtre de pré-visualisation Crystal Report
était très lente. J'ai supprimé la ligne ci-dessous dans la méthode "InitializeComponent" de
mon formulaire (.Designer.cs) :

this.crystalReportViewer1.SelectionFormula = "";

Cela m'a permis de gagner neuf secondes à l'affichage.

Récupérer les plateformes supportées par l'Assembly en C#

2010-03-15T06:15:00.000-07:00

using System.Reflection;

public sealed class AssemblyInfo
{
    #region Ctors

    static AssemblyInfo()
    {
    }

    private AssemblyInfo()
    {
        PortableExecutableKinds peKind;
        ImageFileMachine machine;

        Assembly.GetCallingAssembly().ManifestModule.GetPEKind(out peKind, out machine);
        this.Kind = peKind;
        this.Machine = machine;
    }

    #endregion

    #region Public Methods

    public bool Is(PortableExecutableKinds kind)
    {
        return ((this.Kind & kind) != 0);
    }

    public bool Is(ImageFileMachine machine)
    {
        return ((this.Machine & machine) != 0);
    }

    #endregion

    #region Properties

    public static AssemblyInfo Instance
    {
        get
        {
            return (AssemblyInfo._instance);
        }
    }

    public PortableExecutableKinds Kind { get; private set; }

    public ImageFileMachine Machine { get; private set; }

    #endregion

    #region Fields

    private static readonly AssemblyInfo _instance = new AssemblyInfo();

    #endregion
}

Exemple d'utilisation:

if (AssemblyInfo.Instance.Is(PortableExecutableKinds.Required32Bit))
{
}

Différence entre deux dates en C#

2010-03-10T06:34:00.000-08:00


/// <summary>
/// Différence entre deux dates en minute.
/// </summary>
/// <param name="start">Date de début</param>
/// <param name="end">Date de fin</param>
/// <returns>La différence en minute</returns>
public static int GetMinuteDiff(DateTime start, DateTime end)
{
   if (start > end)
      return (-((int)start.Subtract(end).TotalMinutes));
   return ((int)end.Subtract(start).TotalMinutes);
}

Intel Threading Building Blocks

2010-02-11T15:11:00.001-08:00

Introduction

Depuis l’avènement en 2005 des processeurs multi-cœurs dans nos appareils domestiques, nous, développeur, avons dû changer notre façon de concevoir les applications afin d’exploiter cette technologie. Tout le monde est concerné, directement ou indirectement. Les domaines d’utilisation sont vastes. Ils ne se limitent plus aux super calculateurs comme c’est le cas depuis plus de 20 ans, mais notamment aux jeux vidéos, et aux multimédias en générale. Ainsi nous avons vu apparaître un grand nombre de solution qui permette la parallélisation des traitements au sein d’un programme.

Mais en premier lieu, Il a fallu reconcevoir (ou concevoir) les kernels(noyaux) et les drivers(pilotes) des systèmes d’exploitation modernes pour supporter les nouvelles architectures multi-cœurs. Puis ce fut le tour des applications. Ce qui a par conséquent poussé Intel à développer TBB.

TBB en résumé

TBB est une bibliothèque de programmation portable écrite en C++ qui permet la parallélisation des données au sein d’un code C++ (ou compatible C++). TBB est arrivé en 2006 et fournit un haut niveau d’abstraction des threads grâce à sa conception qui combine le « Task Programming » et le « Data Parallelism ». De plus, TBB est compatible avec les autres bibliothèques de programmation telle qu’OpenMP, les POSIX Threads, les fibres, les (co)routines et les Protothreads.

Au niveau des compilateurs, il n’y a pas de restrictions particulières. N’importe quel compilateur compatible ISO C++ peut être utilisé (Intel Compiler, VC++, G++, DM, …) contrairement à Open MP qui est directement intégré au compilateur.

Au niveau des processeurs, seuls les processeurs IA 32/64, AMD 32/64 et Sparc sont supportés pour l’instant.

Au niveau de la licence, elle est « open source » sous licence GPL version 2.

Remarque : TBB n’est pas compatible avec Mono.

Quelle est la raison d’être de TBB ?

Intel s’est fixé plusieurs objectifs tels que :

Ø Donner aux développeurs la possibilité d’utiliser le Multithreading sans en être un expert.

Ø Obtenir des gains de performance sur les architectures multi-cœur.

Ø Privilégier le « Data Parallelism » plutôt que le « Functional Parallelism ».

Quelle est la différence entre le « Data Parallelism » et le « Functional Parallelism » ?

Supposons le code ci-dessous :


          Func1() ;
Func2() ;

Le « Functional Parallelism » consiste à séparer chaque fonction dans un contexte différent.

Thread 1	Thread 2
Func1() ;	Func2() ;

Par opposition, si nous prenons le code ci-dessous :


          For (i = 0 ; i < 42 ; ++i)
          Func(i);

Le « Data Parallelism » consiste à scinder un block de donnée en N block et de les traités dans un contexte différent.


          Thread   1
         Thread   2
     
        for (i = 0 ;   i < 21 ; ++i)
         Func(i);
         for (i = 21 ; i < 42 ; ++i)
         Func(i);

Le grand avantage du « Data Parallelism » c’est qu’il est beaucoup plus évolutif dans ma mesure que l’on peut changer la taille des blocks à traité, sans devoir réécrire le code. De plus on peut facilement imaginer un scheduler (ordonnanceur de tâches) qui va définir la taille des blocks et leurs contextes en fonction de l’architecture matérielle et logicielle (ce que fait TBB).

Architecture de TBB

L’architecture de TBB est composée de plusieurs couches dont la première est « les allocateurs de mémoire ». Chaque couche repose sur l’implémentation de la précédente à l’exception de la première. Voici le schéma de l’architecture de TBB (à lire de bas en haut) :

TBB par la pratique

La meilleure façon d’apprendre une technologie c’est par la pratique. Par conséquent, nous allons commencer par un cas simple. Pour notre exemple nous allons partir du code suivant :


          void            Func1(float *tab, int size)
{
      for (int i = 0; i < size; ++i)
           tab[i] = Func2(i);
}

Dans ce code, nous devons traités un tableau de nombre flottant et effectuer un traitement sur chacun des membres de ce tableau. Comme nous avons vu précédemment, TBB fonctionne autour du « Data Parallelism » et du « Task Programming ». Ainsi, nous allons considérer trois choses :

Ø Notre tableau de nombre flottant constitue un block de donnée.

Ø Notre bloque de donnée peut être découpé en sous block.

Ø Le traitement sur un block constitue une tâche.

La première étape est de créer la « class » qui va représenter le traitement sur un block de donnée. Cette « class » prendra dans un constructeur public un pointeur sur notre tableau de nombre flottant (notre block) et le stockera.


          class             CalcFloat
{
      public:
                  CalcFloat(float *tab)   : _tab(tab) {  }

      private:
           float  *_tab ;
} ;

Remarque : Le pointeur passé en paramètre dans le constructeur de « CalcFloat » sera l’adresse du tableau (du block) au complet.

Maintenant, il faut rajouter une méthode qui effectuera le traitement sur le block qu’elle contient. En réalité TBB n’utilise pas une méthode mais la surcharge de l’opérateur (). De plus, cet opérateur n’effectuera pas le traitement sur l’intégralité du block mais sur une portion (range). Sous TBB, une portion est définie par un « blocked_range ». Ainsi à chaque appel de l’opérateur on reçoit en paramètre la portion sur laquelle il faut effectuer un traitement.

Les « blocked_range »

Il existe 3 types de blocked_range :

Ø Unidimensionnel: blocked_range

Ø Bidimensionnel: blocked_range

Ø Tridimensionnel: blocked_range

La particularité des blocked_range c’est qu’ils implémentent un « Split Constructor » que nous détaillerons un peu plus loin.

Dans notre cas, nous avons un conteneur unidimensionnel représenté par notre tableau de nombre flottant. Par conséquent nous allons utiliser un blocked_range


  #include <tbb/blocked_range.h>

class               CalcFloat
{
      public:
                    CalcFloat(float   *tab) : _tab(tab) {  }
               void   operator () (const   tbb::blocked_range &range) const
             {
             }
      private:
             float  *_tab;
} ;

Il ne nous reste plus qu’à ajouter notre traitement :


          #include <tbb/blocked_range.h>

class               CalcFloat
{
      public:
                    CalcFloat(float   *tab) : _tab(tab) {  }
             void   operator () (const   tbb::blocked_range &range) const
             {
                      for (int i = range.begin(); i != range.end(); ++i)
                        this->_tab[i]   = Func2(i);
             }
      private:
             float  *_tab;
} ;

Enfin, la dernière étape consiste à utiliser l’algorithme « parallel_for » à la place du « for » dans « Func1 ».


          void      Func1(float *tab, int size)
{
      tbb::parallel_for(tbb::blocked_range(0,   size),
                 CalcFloat(tab))
}

On remarque que le constructeur du blocked_range prend la taille du block à traiter (0 -> size).

Grâce à ce code, TBB va découper le blocked_range en plusieurs morceaux puis appeler la surcharge de l’opérateur () pour chacun de ces morceaux (qui sont aussi des blocked_range).
Bien entendu ce découpage n’est pas aléatoire, il sera détaillé dans la section « granularité ».

Voici le code final :


          #include <tbb/blocked_range.h>
#include <tbb/parallel_for.h>

class               CalcFloat
{
      public:
                    CalcFloat(float   *tab) : _tab(tab) {  }
             void   operator () (const   tbb::blocked_range &range) const
             {
                    for (int i =   range.begin(); i != range.end(); ++i)
                          this->_tab[i] = Func2(i);
             }
      private:
             float  *_tab;
} ;

void      Func1(float *tab, int size)
{
        tbb::parallel_for(tbb::blocked_range(0, size),
                 CalcFloat(tab))
}

Split Constructor

Comme nous avons vu à la section précédente, chaque block de donnée est découpé et traité séparément. Ce découpage est réalisé par l’intermédiaire d’un « Split Constructor » que le blocked_range implémente. Ainsi les blocks sont récursivement découpés dans les algorithmes de parallélisation de TBB tels que le « parallel_for ».


          Range::~Range()  // Destructeur.
Range::Range(Range &r, split)  //   Coupe r en deux.
bool Range::empty() const  // vrai si   il est vide.
bool Range::is_divisible() const  //   vrai si il peut être découpé.

Remarque : de préférence, on essai toujours que lorsque l’on coupe un « range » en deux, les deux parties soient égales pour ne pas tromper le scheduleur (ordonnanceur de tâches).

Le découpage des blocks est réalisé par l’intermédiaire du « Partitioner » qui s’appui entre-autre sur la valeur de la granularité du block.

Granularité

Pour que le « Partitioner » découpe de façon optimisé les blocks, il à besoin de connaître la granularité de chaque block. La granularité constitue l’unité d’itération. Elle peut être explicite ou implicite. En effet, nous n’avons pas précisé de granularité dans notre exemple avec le parallel_for. Sous TBB la granularité est représenté par un entier non-signé.

On peut expliciter la granularité grâce au troisième paramètre du blocked_range :


          void      Func1(float *tab, int size)
{
        tbb::parallel_for(tbb::blocked_range(0, size, 42),
                 CalcFloat(tab))
}

La valeur de la granularité a une très grande influence sur les performances du programme. Mais si elle est mal calculée, elle peut avoir des conséquences désastreuses.

Voici un graphique fournit pas Intel qui illustre l’importance de la granularité :

Calcul de A[i] = B[i] * C sur 1 million de float avec une machine à 4 sockets et 8 hard-threads.

On remarque que le graphique est en forme de baignoire. En effet, le temps d’exécution du programme diminue jusqu'à que la granularité atteint 100000 puis remonte assez brusquement. On peu considérer que les performances sont correctes quand la granularité est comprise entre 100 et 100000.

Mais quelle est la valeur optimale pour la granularité dans notre cas ?

En réalité c’est très simple, il suffit de prendre la plus grande valeur de l’intervalle ou les performances sont correctes.

Pourquoi ?

Plus la valeur de la granularité est petite, plus les blocks sont petits. Par conséquent il est inutile de surchargé le scheduler (ordonnanceur de tâches) avec des petits fragments. D’autant plus que cela n’apporte aucun grain de performance par rapport à une granularité fixé à 100000.

Pourquoi ne pas laisser TBB décider de la valeur de la granularité ?

Même si la valeur que l’on définit est identique à celle qu’il calcul, il est préférable d’expliciter la granularité car cela évite qu’il la calcule (donc gain de temps). De plus la granularité dépend aussi du traitement que l’on va effectuer sur le block. Par conséquent, TBB ne peut pas toujours calculer de façon fiable la granularité à tous les coups.

Partitioner

Le « Partitioner » est le dispositif de TBB qui est chargé de découper les « Range » en « SubRange ». Il intervient pour deux algorithmes :

Ø parallel_for

Ø parallel_reduce

Il existe 3 types de « partitioner » :

Ø simple_partitioner : taille des blocks = valeur de la granularité.

Ø auto_partitioner : taille des blocks automatiques (calculé en interne).

Ø affinity_partitioner : auto_partitioner + gestion du « cache affinity ».

Il est tentant d’utiliser le « affinity_partitioner » dans tous les cas, car celui-ci est le plus complet. Pourtant il faut bien faire attention à son emploi.

Voici un graphique fournit par Intel qui illustre la différence entre le «auto_partitioner » et le « affinity_partitioner » :

On remarque que le « affinity_partitioner » est utile lorsque l’on a un nombre important d’élément. Attention, l’abus du « affinity_partitioner » peut avoir des effets très négatifs sur la performance du code. Seule l’expérience peut déterminer si son emploi est justifié.

Les conteneurs

Le gros défaut des conteneurs de la STL (Standard Template Library) c’est qu’ils ne sont pas « Thread-Safe » et que par conséquent, (dans la plupart des cas) on encapsule chaque accès du conteneur dans une section critique par l’intermédiaire de mutex, sémaphores, barrières, etc. Quant à lui, TBB fournit 4 conteneurs qui répondent à la plupart des besoins :

Ø concurrent_hash_map : Quasi similaire à la std::map de la STL.

Ø concurrent_vector : Similaire au std::vector de la STL.

Ø concurrent_queue : Une FIFO non bloquante.

Ø concurrent_bounded_queue : Une FIFO bloquante avec possibilité de définir une capacité.

Remarque : Les conteneurs de type « queue » supporte les itérateurs de la STL.

Mutex

Malgré que cela ne soit pas conseillé, TBB fournit néanmoins plusieurs implémentations des mutex dans le cas ou une opération nécessite un accès exclusif.

Voici un tableau des différents mutex que l’on retrouve dans TBB :

Mutex	Scalable	Fair	Recursive	Long Wait	Size
mutex	OS dep	OS dep	Non	Bloque	≥ 3 words
recursive_mutex	OS dep	OS dep	Oui	Bloque	≥ 3 words
spin_mutex	Non	Non	Non	« yields »	1 byte
queuing_mutex	Oui	Oui	Non	« yields »	1 word
spin_rw_mutex	Non	Non	Non	« yields »	1 word
queuing_rw_mutex	Oui	Oui	Non	« yields »	1 word
null_mutex	Non	Oui	Oui	Jamais	Zero
null_rw_mutex	Non	Oui	Oui	Jamais	Zero

Opérations atomiques

Parallèlement aux mutex, TBB fournit une implémentation des types atomiques qui a l’avantage d’être beaucoup plus rapide que les mutex. De plus il n’y a pas de risque de « Deadlock ». D’une manière générale les opérations atomiques sont préférables aux mutex.

Syntaxe : atomic<T>

Remarque : T doit être un type de base : int, float, long, enum depuis la version 2.2.

Exemples :

= x // lit la valeur de x.

x = // écrit la valeur de x et la retourne.

x.fetch_and_store(y) // y = x et renvoi l’ancienne valeur de x.

x.fetch_and_add(y) // x += y et renvoi l’ancienne valeur de x.

x.compare_and_swap(y,z) // si x == z, alors x = y. sinon il renvoi l’ancienne valeur de x.

Liens utiles :

Ø http://www.threadingbuildingblocks.org

Ø http://koalab.epitech.net/

Øhttp://software.intel.com/en-us/blogs/2008/12/16/compare-windows-threads-openmp-intel-threading-building-blocks-for-parallel-programming

Résoudre les problèmes de lenteur du Crystal Report Viewer

2010-02-11T14:18:00.000-08:00

La première fois que l'on utilise le "CrystalReportViewer",

la fenêtre peut mettre plus d'une minute à se lancer.

Par conséquent j'ai cherché un patch pour résoudre ce problème.

Le patch ci-dessous est particulièrement moche, mais il a le mérite de fonctionner.

____________________________________________________________________

ReportDocument doc = new ReportDocument();

doc.Load("report.rpt");

#region Crystal Report Viewer Patch

doc.ExportToStream(CrystalDecisions.Shared.ExportFormatType.Text).Close();

#endregion

CrystalReportViewer1.ReportSource = doc;

SELECT non sensible aux accents avec Microsoft SQL Server (Transact-SQL)

2009-10-27T11:52:00.000-07:00

Bonsoir,

Vous avez probablement déjà voulu faire une requête qui recherche
des éléments dans une table avec une clause de type LIKE.
Cependant, comment peut-on faire pour rendre le LIKE non sensible
aux accents. Voici donc la méthode pour effectuer cette recherche
avec Microsoft SQL Server.

En un mot la solution est : COLLATE.

La clause COLLATE permet (entre-autre) la conversion du classement
d'une expression. Cette clause doit être combinée avec une chaîne
spécifiant le nom d'un classement SQL Server.

Dans notre cas j'ai choisi : SQL_Latin1_General_Cp437_CI_AI.

C'est à dire:

Latin1_General: identifiant l'alphabet ou la langue dont les
règles de tri sont appliquées.
Cp437: page de code 437.
CI: ne distingue pas la casse.
AI: ne distingue pas les accents.

-----

Cela donne cette requête:

SELECT * FROM MY_TABLE WHERE MY_TABLE.STR LIKE '%Libellé%'

COLLATE SQL_Latin1_General_Cp437_CI_AI;

-----

Par consequent, cette commande renverra les entrées dans
la table si le champ STR est égale aux valeurs ci-dessous:

libelle
LiBeLlE
libéllE
Libellé

Créer un plugin pour Microsoft Visual Studio

2009-09-26T06:21:00.000-07:00

Pour notre démonstration, nous allons créer un plugin qui permet
d'ouvrir un onglet contenant un UserControl de votre choix.
Cette démonstration sera réalisée en C# sous visual studio 2008.

Grace à cet exemple vous pourrez étendre de façon exponentielle
les possibilités de Visual Studio.

1) Ouvrez Visual Studio et créez un nouveau projet.

2) Sélectionnez “Complément Visual Studio

3) Cliquez sur “Suivant”

4) Sélectionnez “C#” et cliquez sur “Suivant”

5) Sélectionnez “Microsoft Visual Studio 200X” et
cliquez sur “Suivant”

6) Entrez les informations sur votre plugin et
cliquez sur “Suivant”.

7) Selectionnez les élements comme ci-dessous et
cliquez sur “Suivant”

8) Cliquez sur “Suivant”

9) Cliquez sur “Suivant”

10) Ouvrez le fichier “Connect.cs”

Ce fichier contient une classe “Connect” qui est le point
d’entrer de notre plugin. Attention, c’est du C#.Net 1.0.
Par conséquent le code généré est plutôt moche.

Cette classe contient 7 méthodes:

Methode	Action
OnConnection	Appelée lors du chargement du plugin.
OnDisconnection	Appelée lors du déchargement du plugin.
OnAddInsUpdate	Appelée lorsque des plugins on été chargés ou déchargés
OnStartupComplete	Appelée lorsque le Visual est en cours de lancement
OnBeginShutdown	Appelée lorsque le Visual est en cours de fermeture
QueryStatus	Appelée lorsque le paramétrage d’une commande a changé
Exec	Appelée lors de l’exécution d’une commande dans le plugin

Pour l’instant, nous n’allons pas modifier ce fichier.

Remarque : un plugin est en réalité qu’une bibliothèque
de classes compilée (MyFirstAddIn.dll dans notre cas)

11) Allez dans les propriétés du projet.

Notre plugin est destiné à être utilisé avec Visual Studio. C’est-à-dire
que pour déboguer notre plugin, nous allons lancer une instance de
Visual Studio qui sera l’hôte de notre application.
Ainsi, nous allons indiquer à Visual Studio qu’il doit lancer une instance
de Visual “devenv.exe” en mode Debug.

12) Dans l'onglet “Déboguer” Sélectionnez “Démarrer le programme externe”
dans “Action de démarrage”.

Assurez-vous que le chemin vers le programme “devenv.exe” est
correct. Normalement les paramètres par défaut sont corrects.

13) Lancez l’application en mode “Debug”.

Comme nous pouvons le voir Visual va lancer une instance Visual.
Nous pouvons aussi remarquer qu’un nouveau bouton “"MyFirstAddIn”
est apparu dans “Outils”. Si nous cliquons dessus, il se passe
bien entendu rien du tout, car nous n’avons rien implémenté dans
le fichier “Connect.cs”.

14) Ajoutez un nouveau UserControl.

Nous avons vu que le plugin est parfaitement chargé par Visual Studio.
Il faut maintenant créer le Contrôle utilisateur(UserControl)
pour notre démonstration.

15) Entrez un nom puis cliquez sur “Ajouter”.

Pour notre exemple, j’ai appelé le UserControl “MyUserControl”

16) Ajoutez les éléments que vous desirez dans ce UserControl.

Dans notre exemple j’ai ajouté une PictureBox.

17) Implémentez le fichier “Connect.cs”

Nous sommes maintenant en mesure d’implémenter notre plugin.
Pour des raisons pratiques, je vais seulement indiquer les lignes à rajouter dans ce fichier afin
de ne pas nuire à la visibilité de ce tutoriel (le code complet est disponible en bas du tutoriel).

A) Ajoutez un “using” dans l’entête du fichier pour indiquer que nous allons utiliser les “Windows Forms”:

using System.Windows.Forms;

B) Ajoutez deux attributs privés dans la classe:

// Instance de notre UserControl
private UserControl _UserControl;
// Instance sur la fenêtre qui contient notre UserControl
private Window _toolWindow;

C) Ajoutez à la fin de la méthode “OnConnection” le code ci-dessous:

else if  (connectMode != ext_ConnectMode.ext_cm_UISetup)
{
   try
   {
        object  obj = null;// Instance du  contrôle renvoyé par CreateToolWindow2
        Windows2 windows2 = this._applicationObject.Windows as Windows2;
        this._toolWindow = windows2.CreateToolWindow2(this._addInInstance,
                        Assembly.GetExecutingAssembly().Location,
                        "MyFirstAddIn.MyUserControl", // Nom du  contrôle
                           "MyFirstAddIn", // Nom du plugin
                      // Identificateur unique pour la nouvelle fenêtre.
                      "{84A3675C-CDA0-4c8b-858F-8F00BEACF199}",
                      ref obj);
        this._UserControl = obj as  UserControl;
        this._toolWindow.Linkable = false;
        this._toolWindow.IsFloating = false;
  }
  catch  (Exception) // A  implémenter
  {
  }
}

D) Ajoutez dans la méthode “Exec” le code ci-dessous
juste avant le “handled = true;”:

this._toolWindow.Visible = true;

E) Compilez, exécutez, puis cliquez dans le bouton “MyFirstAddIn”
dans “Outils”.

Remarque: ne lancez jamais le plugin dans l’instance du Visual que vous
utilisez pour développer le plugin, sinon vous devrez redémarrer Visual.

Notre plugin est maintenant fonctionnel. Il ne reste qu’à implémenter
notre UserControl. Vous pouvez ainsi réaliser une multitude d’outil
pour améliorer la productivité dans votre organisation comme:

- Un client VIM intégré dans visual.
- Un client de messagerie instantané.
- Des outils de diagnostiques.
- Des “Profiler” de code.
- Un gestionnaire de documentation colaboratif.

Afin de gagner du temps, vous pouvez assigner un raccourcis clavier à
votre commande. Pour cela il suffit d’aller dans “Outils” puis “Options”.

Sélectionnez “Environnement –> Clavier”. Faites une recherche afin de retrouver
la commande. Dans notre cas la commande s’appelle “MyFirstAddIn.
Connect.MyFirstAddIn”. Il ne vous reste plus qu’à assigner un raccourcis.

18) Déployment du plugin.

Pour Déployer le plugin, il suffit de fournir la bibliothèque de classe
qui se trouve dans le répertoire de sortie du projet (Dans notre cas
“MyFirstAddIn.dll” ) Ainsi qu’un fichier XML avec l’extension “.AddIn”.

Ce fichier XML est visible dans l’explorateur de la solution.
Dans notre cas il s’appelle “MyFirstAddIn.AddIn”. Il suffit de le copier
dans le répertoire “Addins” de l’utilisateur voir ci-dessous:

Remarque: Un fichier est déjà existant dans votre répertoire.
Il s’agit du fichier utiliser par Visual pour déboguer votre application.

Attention, la seule réstriction c’est que la valeur contenue dans la
balise “Assembly” soit correct. La valeur doit pointer sur le chemin du
plugin que vous deployer. Ainsi le choix de l’emplacement du plugin
est à votre discretion.

Merci d’avoir suivi ce tutoriel.

Dans le prochain article, nous exploiterons un peu plus les possibilités
de Visual Studio (Lancement de compilation, automatisation de tâches,
parsing de code).

Code source du tutoriel : ICI

Transformer un String en Stream

2009-09-03T03:32:00.000-07:00

/// <summary>
/// String2Stream
/// </summary>
/// <param name="str">la chaine</param>
/// <returns>le flux</returns>
public static Stream String2Stream(string str)
{
  MemoryStream memStream = new MemoryStream();
  byte[] data = Encoding.Unicode.GetBytes(str);
  memStream.Write(data, 0, data.Length);
  return (memStream as Stream);
}

Parser un fichier CSV en C#

2009-09-03T03:03:00.000-07:00


/// <summary>
/// CSVsplitter
/// </summary>
/// <param name="str">la chaine</param>
/// <param name="delimiter">le séparateur</param>
/// <param name="hasQuote">utilise les quotes</param>
/// <returns>tableau de chaines</returns>
public static string[] CSVsplitter(string str, char delimiter, bool hasQuote)
{
    if (!hasQuote) // Si il n'y a pas de "quote"
        return (str.Split(delimiter));
    // On remplace le séparateur pour éviter les conflits 
    // avec l'expression régulière
    str = str.Replace(delimiter, '¤');
    string[] tab = (new Regex('¤' + "(?=(?:[^\"]*\"\"[^\"]*\"\")*(?![^\"]+\"\"))",
                    RegexOptions.IgnorePatternWhitespace)).Split(str);
    // On retire les "quotes"
    for (int i = 0; i < tab.Length; ++i)
        tab[i] = (new StringBuilder(tab[i], 1,
                  tab[i].Length - 2, tab[i].Length - 2)).ToString();
    return (tab);
}

Deployer Crystal Reports avec un Setup sous Visual Studio 2008

2009-08-19T05:34:00.000-07:00

1 - Ajoutez les dépendances dans votre "setup"

2 - Ajoutez le module Crystal Reports.

3 - Sélectionnez le bon module, ici : "CrystalReports11_5_NET_2005.msm"

4 - Modifiez les propriétés du module Crystal.

5 - Sélectionnez "MergeModuleProperties"

6 - Entrez votre code de licence pour le déploiement.

Instance unique d'un programme sous windows CE en C#

2009-08-17T11:18:00.000-07:00

Il est agréable qu'une application mobile fonctionne de la même
façon sur windows mobile et windows CE. Sous windows mobile,
lorsqu'une application est lancée et que l'on tente de la relancer,
on récupère simplement le "focus" sur l'application existante.
Contrairement à Windows CE qui autorise les instances multiples.
Afin d'homogénéiser le comportement sur ces deux plateformes,
un code très simple permet de résoudre ce problème.

(le code compatible Windows mobile >= 3.0)

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Reflection;
using MobileTools;

namespace MobileTools
{
    static class SingleInstanceApplication
    {
        [DllImport("coredll.dll")]
        private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("coredll.dll")]
        private static extern bool SetForegroundWindow(IntPtr hWnd);

        [DllImport("coredll.dll", SetLastError = true)]
        private static extern IntPtr CreateMutex(IntPtr Attr, bool Own, string Name);

        [DllImport("coredll.dll", SetLastError = true)]
        private static extern bool ReleaseMutex(IntPtr hMutex);

        public static void Run(Form frm)
        {
            SingleInstanceApplication.Run(frm, frm.Text);
        }

        public static void Run(Form frm, string caption)
        {
            // On créer un mutex avec un nom qui nous sert de référence.
            IntPtr MtxHandle = CreateMutex(IntPtr.Zero,
                               true, Assembly.GetExecutingAssembly().GetName().Name);
            // Si le mutex existe déjà on récupère le focus sur
            // l'application existante par son nom (caption)
            if (Marshal.GetLastWin32Error() == SingleInstanceApplication.ALREADY_EXISTS)
                SetForegroundWindow(FindWindow(null, caption));
            else
                Application.Run(frm); // Sinon on lance la forme
            // On libère le mutex
            ReleaseMutex(MtxHandle);
        }

        private const int ALREADY_EXISTS = 183;
    }
}

Détecter la plateforme Mobile de l'application en C#

2009-08-03T01:45:00.000-07:00

//Reference: Microsoft.WindowsCE.Forms

using Microsoft.WindowsCE.Forms;

///

/// Renvoie: WinCEGeneric, Smartphone ou PocketPC
///
public static WinCEPlatform GetPlatformTarget()
{
return (SystemSettings.Platform);
}

Re-coder une version simplifiée de la commande "cut" en script sh

2009-07-31T11:50:00.000-07:00

#
# Usage   : simple_cut <chaine> <separateur> <colonne>
#
simple_cut()
{
   sep=`echo -e "\006"`
   echo -n `echo -n $1 | tr "\n" $sep | tr $2 "\n" | head -n $3 | tail -n 1 | tr $sep "\n"`
}

Obtenir le chemin du Répertoire de l'application sur un PDA en C#

2009-07-31T11:22:00.000-07:00

using System.Reflection;
using System.IO;

namespace Tools
{
   public static class PDATool
   {
        #region Property
     
        public static string ApplicationDirectory
        {
           get
           {
               if (PDATool._Path == null) // On calcul la première fois le chemin.
                   PDATool._Path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().
                                                         GetName().CodeBase);
               return (PDATool._Path);
           }
        }

        #endregion

        #region Attribut

        // On conserve une le chemin pour éviter de le recalculer à chaque fois.
        private static string _Path = null;

        #endregion
   }
}

Obtenir des statistiques sur la mémoire sous windows en C/C++

2009-07-30T15:38:00.000-07:00

#include <windows.h>

void           getMemoryUsage(unsigned long *total,
               unsigned long *avail,
               float *usage,
               unsigned long *virt_total,
               unsigned long *virt_avail)
{
   MEMORYSTATUSEX   statex;

   statex.dwLength = sizeof(statex);
   GlobalMemoryStatusEx(&statex);
   if (total != NULL) // mémoire physique totale
     *total = (unsigned long)(statex.ullTotalPhys / 1024);
   if (avail != NULL) // mémoire physique disponible
      *avail = (unsigned long)(statex.ullAvailPhys / 1024);
   if (usage != NULL) // pourcentage d'utilisation de la mémoire physique
      *usage = (float)(statex.dwMemoryLoad);
   if (virt_total != NULL) // mémoire virtuelle totale
      *virt_total = (unsigned long)(statex.ullTotalVirtual / 1024);
   if (virt_avail != NULL) // mémoire virtuelle disponible
     *virt_avail = (unsigned long)(statex.ullAvailVirtual / 1024);
}

Obtenir le nombre de processeur physique sous windows en C/C++

2009-07-30T15:35:00.000-07:00

#include <windows.h>

unsigned int         getCPUcount(void)
{
   SYSTEM_INFO      sysinfo;

   GetSystemInfo(&sysinfo);
   return ((unsigned int)sysinfo.dwNumberOfProcessors);
}

Think In Parallel - Episode 1

2009-07-26T07:44:00.000-07:00

Bonjour,

Voici le tout premier webcast, de la saga sur le multithreading.


Pour plus d'information sur le CSP, voir ici
Page Wikipédia de Sir Charles Antony Richard Hoare : ici

Compiler et exécuter du code en C#

2009-07-23T13:09:00.000-07:00

using System;
using System.CodeDom.Compiler;
using System.Diagnostics;

public class MicroCompiler
{
   public MicroCompiler()
   {
       this.Language = "CSharp";
       this.WarningLevel = 1;
       this.OutputPath = "./~TMP.exe";
   }

   public bool Compile()
   {
       this.Result = string.Empty;
       this.KillCompiledProgram();
       using (CodeDomProvider codeProvider = CodeDomProvider.CreateProvider(this.Language))
       {
           // Paramètres de la compilation
           CompilerParameters parameters = new CompilerParameters();
           parameters.GenerateExecutable = true;
           parameters.GenerateInMemory = false;
           parameters.WarningLevel = this.WarningLevel;
           parameters.OutputAssembly = this.OutputPath;
           // on compile
           CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters,
                                                        new string[] { this.Source });
           // est ce qu'il y a des erreurs ?
           if (results.Errors.Count > 0)
           {
               foreach (CompilerError CompErr in results.Errors)
                   this.Result += "Line: " + CompErr.Line + " : " + CompErr.ErrorNumber +
                               " => " + CompErr.ErrorText + Environment.NewLine;
               return (false);
           }
       }
       // on créer le processus pour éxecuter le code
       this.CompiledProgram = new Process();
       this.CompiledProgram.StartInfo.FileName = this.OutputPath;
       return (true);
   }

   public bool KillCompiledProgram()
   {
       if (this.CompiledProgram == null || this.CompiledProgram.HasExited)
           return (false);
       this.CompiledProgram.Kill();
       return (true);
   }

   public bool StartCompiledProgram()
   {
       if (this.CompiledProgram == null)
           return (false);
       return (this.CompiledProgram.Start());
   }

    #region Properties

    // Niveau d'avertissement.
    public int WarningLevel { get; set; }

    // Emplacement du programme généré
    public string OutputPath { get; set; }

    // Résultat de la compilation
    public string Result { get; private set; }

    // Le code source
    public string Source { get; set; }

    // Langage de la source (ex: CSharp)
    public string Language { get; set; }

    // Instance du programme en exécution. 
    public Process CompiledProgram { get; private set; }

    #endregion
}

namespace Test
{
   class Program
   {
       static void Main(string[] args)
       {
           MicroCompiler mc = new MicroCompiler();
           mc.Source = "mettre le code C# ici!";
           if (mc.Compile())
               mc.StartCompiledProgram();
       }
   }
}

vérifier si un fichier existe sous windows en C/C++

2009-07-23T12:16:00.000-07:00

#include <windows.h>

int __stdcall   FileExistsUnicode(wchar_t *fname)
{
   return ((long)GetFileAttributesW(fname) > 0);
}

int __stdcall   FileExistsAscii(char *fname)
{
   return ((long)GetFileAttributesA(fname) > 0);
}

Utiliser le presse-papier de Windows en C/C++

2009-07-22T12:05:00.000-07:00

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int           copy_to_clipboard(char const *str)
{
  HGLOBAL     clipbuffer;
  char        *buffer;

  // On ouvre le presse-papier
  if (!OpenClipboard(NULL))
    return (0);
  // on vide le presse-papier
  EmptyClipboard();
  // on alloue la mémoire nécéssaire
  clipbuffer = GlobalAlloc(GMEM_DDESHARE, strlen(str) + 1);
  // on lock le buffer pour avoir un accès exclusif sur le presse-papier
  if ((buffer = (char *)GlobalLock(clipbuffer)) == NULL)
  {
     GlobalUnlock(clipbuffer);
     CloseClipboard();
     return (0);
  }
  // On copie notre texte dans le presse-papier
  strcpy(buffer, str);
  // On déverouille le presse-papier
  GlobalUnlock(clipbuffer);
  // On met à jour le presse-papier
  SetClipboardData(CF_TEXT, clipbuffer);
  // On ferme le presse-papier
  CloseClipboard();
 return (1);
}

char           *get_clipboard()
{
  char         *buffer;
  HANDLE       hData;

  // On ouvre le presse-papier
  if (!OpenClipboard(NULL))
     return (NULL);
  // On recupère le "handle" du presse-papier en mode texte
  if ((hData = GetClipboardData(CF_TEXT)) == NULL)
     return (NULL);
  // On récupère via le "handle" le presse-papier
  if ((buffer = (char *)GlobalLock(hData)) == NULL)
     return (NULL);
  // On déverouille le presse-papier
  GlobalUnlock(hData);
  // On ferme le presse-papier
  CloseClipboard();
  return (buffer);
}

int      main(int argc, char **argv)
{
  copy_to_clipboard("ma chaine");
  printf("%s\n", get_clipboard());
  getchar();
  return (EXIT_SUCCESS);
}

Embarquer une image dans une page HTML

2009-07-21T04:27:00.000-07:00

Aujourd'hui nous allons voir comment embarquer une image dans une page HTML.
Pour cela nous avons besoin d'une image quelconque au format gif(ou autre chose),
d'un encodeur en base 64 et d'une minute.

1)allez sur le site : http://www.motobit.com/util/base64-decoder-encoder.asp.

2)Sélectionnez une image et encodez-la en base 64.

3)Créez une page HTML comme ci-dessous:

<html>
  <head>
     <title>Image embarquée</title>
  </head>
  <body>
     <div style="text-align: center;">
        <img SRC="data:image/gif;base64,"ALT="Mon image"/>
     </div>
  </body>
</html>

4)Insérez l'image encodée en base 64 après "base64,"

5)C'est fini!

/!\ Attention suivant les navigateurs l'image peut ne pas s'afficher!
Je déconseille par conséquent son utilisation, en production.

Le code ci-dessous affiche une petite étoile:
____________________________________________________________________________

<html>
 <head>
    <title>Image embarquée</title>
 </head>
 <body>
    <div style="text-align: center;">
       <img SRC="data:image/gif;base64,
R0lGODlhEAAQAOZIAP/HYf+kP//IY/HTvfGsTsvDvvKsTerKtP/Xr6RqSvzfmfro2P7fm/3TqfS1
e6dGDt6xlfKmSKNtTv7gnfWUNdZyINVxIP7Xg/y6aNV0I9t4JP3u4PbEheybTP759OuvfbRPDffK
odBsHfGxbfzhov7ajf7hkvebOuzLs9FxIv7UefvhydNzI/uaN/W1ZemPOffl1v7pof+xZKaXjvb2
9v/HYv7dhuvr6/7povPz89HR0e+SNcCGY/7Rb+Li4vn5+bl/XL5tPL2tpP7fpv7yvv+rRv+9WP+0
T////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5
BAEAAEgALAAAAAAQABAAAAengEiCg4SFhkgIMgiHhQ0YQxgNjIIeFApEChQehhsrIQ4uMTgxLg4h
KxuCCy8dIxwkJjYmJBwjHS8LSB8EFwwTJSo9KiUTDBcEH0gwFQYAAAICNdDOBhUwggMiEUbc3UYR
IgOEKCxH5udHLCiFBylF7/BFKQeFEBkBASc7J/gZEIQ5eGhoYQFEEBAWWmgA4uOHoBtCEjyQUABJ
AQkPEszQQWOSx4+DAgEAOw=="ALT="Mon image"/>
    </div>
 </body>
</html>

gérer du code obsolète en C#

2009-07-20T09:16:00.000-07:00

   Il arrive quelquefois que nous devions utiliser des composants
dont certaines parties sont devenues obsolètes avec le temps.
Malheureusement, il est parfois impossible (contrainte de temps
et/ou d'argent) de refaire le code en intégralité. Ainsi, la
plupart du temps nous en-capsulons les anciens composants dans
de nouveaux.

Seulement comment interdire l'accès aux propriétés obsolètes
de la classe de base et les remplacer par de nouvelles ?

En réalité c'est assez simple. Cette problématique a été résolue
Dans la version 2 du framework .Net. Il suffit d'utiliser l'attribut
"Obsolete" et de "override" certaines propriétés.

___________________________________________________________________

using System;

namespace Test
{
 class A
 {
     // Rem: la class A peut toujours utiliser cette propriété.
     public bool OldProperty { get; set; }
 }

 class B : A
 {
     // On indique au compilateur que la propriété est obsolète
     [Obsolete("utilisez NewProperty à la place.", true)]
     public new bool OldProperty { get; set; } // on "override" la propriété

     public bool NewProperty { get; set; }
 }

 class Program
 {
     static void Main(string[] args)
     {
         B test = new B();
         test.NewProperty = true; // OK
         test.OldProperty = true; // Provoque une erreur à la compilation
     }
 }
}

C++, dynamic_cast et bibliothèque partagée sous GCC (>= 3.0)

2009-07-19T10:49:00.000-07:00

   Jusqu'à la version 3.0, GCC utilisait la comparaison des noms
des symboles pour savoir si deux types étaient équivalent. Mais
depuis la nouvelle ABI (application binary interface) il ne compare
plus les noms, mais les adresses. Cela a pour but d'améliorer les performances.

 Ce choix technique ne pose aucun problème avec un "linkage" statique,
car le les adresses sont déterminées et connues du compilateur.
Contrairement aux bibliothèques partagées (.dll, .so) qui
requièrent une résolution des types à l'exécution (runtime).

  En effet si nous prenons en exemple une classe C qui
implémente deux interfaces I1 et I2 définies dans l'exécutable
et dans une bibliothèque partagée. Si nous essayions d'effectuer
un dynamic_cast sur une instance de C renvoyé par la bibliothèque
partagée en I1 ou I2, dynamic_cast renvoie toujours "null".
Le problème est aussi visible via throw et typeid.

  Ce problème est dû au changement dans la résolution des types
énoncés ci-dessus. Pour corriger ce problème, il faut utiliser
l'option "-rdynamic" de GCC qui a pour but de créer une "global 
symbol table" dans la bibliothèque partagée. Sous Linux/BSD le
compilateur réalise cette opération en passant l'option
"-export-dynamic" au "linker".

écrire un nombre en base 16 sans stdio

2009-07-19T05:21:00.000-07:00

#include <unistd.h>

void    my_print_hexa(int fd, unsigned int d)
{
  if (d & ~0xF)                                /* si d > 16      */
     my_print_hexa(fd, d >> 4);                /* rec de d / 16  */ 
  write(fd, (d & 0xF)["0123456789ABCDEF"], 1); /* tab + (d & 16) */ 
}

Débuter avec JNI

2009-07-18T13:05:00.000-07:00

Dans cet article, nous allons étudier le framework JNI.
Ce framework Java permet d'exécuter du code non-managé
C/C++ dans du code Java.

Pour cette démonstration nous allons utiliser GCC 3.4.2(Win32)
et le JDK 6. Le code en C sera disponible dans une DLL.
Dev-CPP ou CodeBlocks conviennent parfaitement pour ce tutoriel.
____________________________________________________________________

1) Pour commencer nous allons créer une classe Java "Hello" avec
une  methode native "Test" dans un fichier "Hello.java".

public class Hello
{
 // Methode native qui correspond au prototype de la fonction
 // qui sera appelé dans la DLL
 public native void Test();

 // Nous chargerons une DLL qui s'appelera "Hello.dll"
 static
 {
    System.loadLibrary("Hello");
 }
}

____________________________________________________________________

2) On compile la classe.

$>C:\Sun\SDK\jdk\bin\javac.exe Hello.java

____________________________________________________________________

3) On génère le fichier entête "Hello.h" pour la DLL.

$>C:\Sun\SDK\jdk\bin\javah.exe -jni Hello

#include <jni.h>
#ifndef _Included_Hello
#define _Included_Hello
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     Hello
 * Method:    Test
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_Hello_Test(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif

____________________________________________________________________

4) On implémente dans un fichier "Hello.c" notre fonction suivant
Le prototype définit dans "Hello.h"

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "Hello.h"

JNIEXPORT void JNICALL
Java_Hello_Test(JNIEnv *env, jobject obj)
{
 printf("42\n");
}

____________________________________________________________________

5) On compile notre fichier source.

$>gcc -c -I"C:\Sun\SDK\jdk\include" \
-I"C:\Sun\SDK\jdk\include\win32" -o Hello.o Hello.c
____________________________________________________________________

6) On génère le fichier de définition de la DLL.

$>dlltool Hello.o -z Hello.def

 Cela donne:

EXPORTS
  Java_Hello_Test@8 @ 1

____________________________________________________________________

7) On Compile notre DLL.

$>gcc.exe -shared -o Hello.dll -I"C:\Sun\SDK\jdk\include" \
  -I"C:\Sun\SDK\jdk\include\win32" Hello.c Hello.def


____________________________________________________________________

8) Nous allons maintenant créer un petit programme en Java pour
tester notre "wrapper" C vers Java dans un fichier "Main.java".


public class Main
{
 public static void main(String[] args)
 {
      // Création d'une instance de notre classe "Hello"
    Hello h = new Hello();
      // On appel la fonction dans notre DLL (Hello.dll)
    h.Test();
 }

 public Main()
 {
    super();
 }
}

____________________________________________________________________

9) On Compile notre programme de test.

$>C:\Sun\SDK\jdk\bin\javac.exe Main.java

____________________________________________________________________

10) Il nous reste plus qu'à lancer le programme qui doit afficher
"42" sur la sortie standard suivi d'un retour à la ligne.

$>C:\Sun\SDK\jdk\bin\java.exe Main
$>42
$>

____________________________________________________________________

           --- Le bug du UnsatisfiedLinkError ---

Il est possible qu'au moment où vous avez exécuter le programme
de l'étape 10, une erreur est apparue:


$>C:\Sun\SDK\jdk\bin\java.exe Main
$>Exception in thread "main" java.lang.UnsatisfiedLinkError: Init
$>        at Hello.Test(Native Method)
$>        at Main.main(Main.java:8)

Ce problème vient du fait que Java ne trouve pas le symbole de la
fonction "Test" dans notre DLL. Pour résoudre ce problème,
il nous faut revenir à l'étape 6. Dans le fichier "Hello.def"
où l'on peut lire les lignes ci-dessous:


EXPORTS
  Java_Hello_Test@8 @ 1


Le problème vient des caractères que j'ai souligné en rouge.
Les noms des fonctions générées par les compilateurs ont toujours ces symboles.
La solution consiste à exporter les fonctions de la DLL sous un autre nom.
Pour cela il existe l'option -k de dlltool qui supprime les décorations
autour des fonctions. Par conséquent nous allons remplacer l'étape 6
par l'étape ci-dessous:

$>dlltool -k Hello.o -z Hello.def

    Cela donne:

EXPORTS
  Java_Hello_Test @ 1

Nous pouvons maintenant recompiler le projet qui fonctionne parfaitement.
---
Sous Microsoft Visual C, il faut utiliser le programme "dumpbin" afin
de récupérer les symbole de la DLL:

$>dumpbin Hello.dll /EXPORTS

Puis rajouter des directives pré-processeur #pragma pour chaque symbole
utilisé dans le fichier source ("Hello.c").

Exemple:

#pragma comment(linker, "/EXPORT:Java_Hello_Test=_Java_Hello_Test@8")

Simple implémentation des varargs grâce au pré-processeur C

2009-07-17T14:45:00.000-07:00

Voici une implémentation des varargs que j'ai fait dans
le train ce soir. Elle n'est certes pas portable, mais elle
montre le principe de fonctionnement. Idéal pour un cours de C.
_______________________________________________________________

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

# define Xva_list           long *
# define Xva_start(L, X)    (L) = (((Xva_list)(&(X))) + 1)
# define Xva_arg(L, T)      (*(T *)(L++))

void         test(int s, ...)
{
   /* on déclare un pointeur pour stocker l'adresse dans la pile */
  Xva_list  list;

   /* on récupère l'adresse de "s" que l'on décale de x octet */
   /* x est égale a la taille en octet d'un pointeur. */
  Xva_start(list, s);

   /* on récupère nos arguments sur la pile */
  printf("a = %d\n", Xva_arg(list, int));
  printf("b = %c\n", Xva_arg(list, char));
  printf("c = %s\n", Xva_arg(list, char *));
}

int      main()
{
  int   a = 42;
  char  b = 'a';
  char  *c = strdup("chaine");

  test(10, a, b, c);
  free(c);
  return (EXIT_SUCCESS);
}

Envoyer l'événement "PressKey" à n'importe quel contrôle en C#

2009-07-17T14:29:00.000-07:00

Voici une méthode pour envoyer un évènement "KeyPress" à un
contrôle C#. Elle ne nécessite pas d'avoir le "focus" sur
l'élément visé.
---------------------------------------------------------------
using System;
using System.Windows.Forms;
using System.Reflection;

namespace Test
{
  public sealed class KeyEventSender
  {
     private KeyEventSender()
     {
     }

      // WM_CHAR est définit dans l'API de windows
      // notification d'un événement clavier
     internal static readonly int WM_CHAR = 258;

     public static void Send(Control control, char c)
     {
        Message m = new Message();
        m.HWnd = (IntPtr)control.Handle; // "Handle" du contrôle.
        m.Msg = KeyEventSender.WM_CHAR; // type de l'évènement windows
        m.LParam = IntPtr.Zero; // pas d'option
        m.WParam = (IntPtr)c; // valeur de caractère
         // on récupère la définition de la méthode par réflexion
         // car la méthode n'est pas publique
        MethodInfo dynMethod = control.GetType().GetMethod("ProcessKeyEventArgs",
                                  BindingFlags.NonPublic  BindingFlags.Instance);
         // on invoque la méthode.
        dynMethod.Invoke(control, new object[] { m });
     }

     public static void Send(Control control, KeyPressEventArgs e)
     {
           KeyEventSender.Send(control, e.KeyChar);
     }
  }
}

Thread 1	Thread 2
for (i = 0 ; i < 21 ; ++i) Func(i);	for (i = 21 ; i < 42 ; ++i) Func(i);