Lost in the matrix

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:

-----

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é

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:

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

/// <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);
}

/// <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);
} 

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.

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;
    }
}

//Reference: Microsoft.WindowsCE.Forms

using Microsoft.WindowsCE.Forms;

///