Blog de JP Gouigoux

15/08/2008

UI Automation : on touche au but !

Classé dans : .NET, UIAutomation — jpgouigoux @ 9:51
Tags: , , ,

Miboboio a gagné le droit de me traiter d’andouille, et a eu la noblesse de ne pas le faire dans son commentaire de mon précédent post. Il a pourtant trouvé la solution à mon problème récurrent sur UIAutomation et je l’en remercie vivement !

Son approche est la suivante : puisque le TextPattern ne propose pas de SetValue, mais juste un GetValue, on va passer par le ValuePattern. J’avais essayé ce pattern ainsi que le InvokePattern, mais sans succès. Et c’est là que Miboboio a trouvé l’astuce : dans le cas où la zone de texte ne constitue pas un ValuePattern, il place le focus dessus (pas besoin de passer par un pattern pour ça, c’est appelable directement sur l’instance de AutomationElement), et ensuite fait un System.Windows.Forms.SendKeys.SendWait. Je précise bien le namespace sur le nom de classe, car il ne fait pas partie des espaces de nommages liés à l’UIAutomation.

Je me suis permis de raccourcir un peu le code de Miboboio, et de l’intégrer dans un code complet incluant le lancement du processus à contrôler, de façon que les personnes intéressées puissent simplement copier-coller dans VS.NET et lancer. Je vous laisse aller sur son commentaire pour voir l’original avec tous les commentaires. Et sinon, vous pouvez tester directement ceci :

Process notepad = Process.Start("notepad.exe");
Thread.Sleep(2000);
AutomationElement notepadForm = AutomationElement.FromHandle(notepad.MainWindowHandle);
AutomationElement zoneTexte = notepadForm.FindFirst(TreeScope.Children, new PropertyCondition(AutomationElement.NameProperty, ""));
TextPattern txtPattern = zoneTexte.GetCurrentPattern(TextPattern.Pattern) as TextPattern;
object valuePattern = null;
if (!zoneTexte.TryGetCurrentPattern(ValuePattern.Pattern, out valuePattern))
{
 zoneTexte.SetFocus();
 Thread.Sleep(500);
 SendKeys.SendWait("coucou");
}
else
{
 zoneTexte.SetFocus();
 ((ValuePattern)valuePattern).SetValue("coucou");
}

Vous aurez juste besoin de rajouter les using ci-dessous :

using System;
using System.Diagnostics;
using System.Threading;
using System.Windows.Automation; // inclure l'assembly UIAutomation
using System.Windows.Forms; // inclure l'assembly System.Windows.Forms

Moralité de l’histoire : quand la doc Microsoft dit que ce n’est pas possible de le faire pour des raisons de sécurité… trouvez une autre faille… pardon, une autre façon de faire.

Ah, juste un petit détail : n’essayez pas de faire fonctionner ce code en debug, ou en tout cas, ne passez pas par VS.NET entre le SetFocus et le SendKeys : en effet, dans ce cas-là, le focus repasse à VS.NET, au lieu du contrôle à piloter, et le SendKeys sur VS.NET pendant qu’il est en train de débugger ne se passe pas bien du tout (blocage du processus).

C’est d’ailleurs ça, la clé de l’astuce de Miboboio : quand vous faites un SetFocus sur un AutomationElement, le focus est vraiment passé à l’application piloté. L’UIAutomation ne fonctionne pas comme ManagedSpy++ avec des hooks Windows activés depuis le processus pilote : il envoie vraiment les messages Windows correspondants. Je vous encourage à voir l’article de Frédéric Queudret qui comprend un schéma très détaillé de comment ça fonctionne. J’avais d’ailleurs oublié de donner le lien dans mon post précédent. Désolé. Le voici.

Allez, un dernier lien pour la route : le forum de Microsoft dédié à l’accessibilité. Il y a pas mal de questions sur des cas précis : comment activer une combo, etc. Je pense que je vais trouver les réponses au reste de mes questions là-dedans, et j’espère dans quelques mois avoir mis en place un petit framework pour utiliser tout ça. Idéalement, une grammaire XML pour écrire des tests automatisés sur une application, avec un système de test unitaire embarqué. Bien évidemment, je vous tiendrai au courant.

En attendant, merci encore à Miboboio !

12/08/2008

UI Automation : cent fois sur le métier remettez votre ouvrage…

Classé dans : .NET, UIAutomation — jpgouigoux @ 8:27
Tags: , , , ,

L’automatisation de test me titille à nouveau…

Dans un post précédent (Microsoft UI Automation : déçu, encore une fois…), j’avais expliqué ce qui, selon moi, faisait que le framework UI Automation ne permettait pas de faire de l’automatisation de test : le manque de possibilité d’écrire dans une zone de texte. En effet, je veux bien croire que certaines applications fonctionnent uniquement avec des boutons, mais moi je bosse sur des applications de gestion, qui sont utilisées par des secrétaires et des personnes qui instruisent des dossiers, et quand ils s’en tapent une centaine pas jour, ils ont usé le clavier…

Bref, je pensais avoir tiré une croix sur le sujet, et voilatipa qu’un nouvel article sort là-dessus, dans les flux RSS qui s’affiche au démarrage de Visual Studio. L’auteur n’est autre que Frédéric Queudret, qui était également l’auteur si je me rappelle bien d’un article dans Programmez! sur le même sujet. Je me dis qu’il y a peut-être du nouveau, et surtout une réponse à mon interrogation : dans mon post précédent, je finissais en disant que je serais heureux de me faire traiter d’andouille par quelqu’un qui peut me montrer que je suis passé à côté de la plaque, et je le pense vraiment.

Me voilà donc sur l’article cité, et l’exemple n’est pas avec le notepad comme dans les tutoriels que j’avais trouvé sur le sujet : chouette, ça veut dire que c’est du nouveau. Donc peut-être avec une réponse à ce fameux problème : comment entrer du texte ?

L’application traitée est la calculatrice. On va donc vérifier un calcul. Et donc avoir à entrer des données. Youpi, on chauffe !

Et bien non : c’est là tout l’avantage de cette application : il y a des boutons sur lesquels on tape pour rentrer du texte. Vous l’avez compris : le test automatisé pour vérifier que la calculatrice donne bien trois quand on tape 1 + 3 consiste à simuler le clic sur le bouton 1, puis sur le bouton +, etc.

Voyons les choses du bon côté : ça tend à prouver tout simplement ce que j’avais conclu l’autre fois, et je vois s’éloigner les chances de me faire traiter à juste titre d’andouille. Le mauvais côté des choses est que je suis toujours bredouille.

Il paraît que la CTP de Rosario prend en charge les tests automatisés. J’espère deux choses :

  1. que Microsoft aura étendu son UI Framework, ou au pire créé des hooks sur les contrôles pour pouvoir entrer du texte
  2. que les commerciaux de Microsoft seront un jour au courant de ce qui se passe dans leur application avant de l’apprendre par des blogs de personnes extérieures à leur société : j’ai demandé plusieurs fois au commercial France sur Visual Studio si il y allait avoir quelque chose là-dessus, et il n’était au courant de rien. Même chose aux TechDays.

En attendant, je vais envoyer de ce pas un petit mail à Frédéric Queudret en lui proposant de me traiter d’andouille, à condition qu’il me donne la solution à ce problème de 10 ans ! Si des gens lisent ce post, je m’engage à vous tenir au courant de sa réponse, et de ma quête sans fin sur ce sujet…

01/08/2008

DataSets typés et multi-bases de données

Classé dans : .NET — jpgouigoux @ 8:45
Tags: , , ,

ADO.NET supporte plusieurs bases de données, et pas seulement SQLServer. Vous pouvez faire de l’Oracle, principalement, et vous disposez aussi d’un driver OLEDB. Mais ne comptez que sur vous-mêmes si vous souhaitez développer une application supportant plusieurs bases de données. Vous pouvez utiliser les interfaces de programmation pour la connexion, quelques classes de résultats, mais dès que vous faites une commande paramétrée, vous devrez prendre en compte les différents cas possibles.

Le problème devient plus complexe lorsque vous désirez utiliser des DataSets typés. Si vous créez les mêmes structures dans deux bases de données différentes, les types C# correspondants ne sont pas les mêmes dans tous les cas, et surtout, le code généré contient le pointeur vers la base ainsi qu’une grosse partie de code spécifique à la base de données pointée.

Bref, si vous souhaitez écrire du code générique utilisant un DataSet typé dans deux bases de données, vous êtes bons pour écrire une couche intermédiaire. Et c’est là que ça devient drôle : comme les fonctions du DataSet typé renvoyent elles-mêmes des objets typés selon la base, vous êtes bons pour réécrire une redirection pour toutes les fonctionnalités que vous utilisez. En tout cas, je n’ai personnellement pas trouvé d’autre solution.

Le mieux que j’ai trouvé pour l’instant et de créer une classe chapeautant les deux DataSet typés et contenant des instances pour chacune des bases, sachant qu’une seule sera effectivement instanciée à la fois. On fait la même chose en interne, à savoir que les objets dont on a besoin sont eux-mêmes rendus génériques en créant une classe contenant une instance de chaque sous-objet typé. Ensuite, l’idée est de mettre en place des constructeurs différenciés pour chaque instance typée, et dans chaque classe correspondant à une table, de pointer sur le DataSet parent, ce qui nous permettra de retrouver le DataSet typé à utiliser à chaque moment.

Enfin, si vous avez du code qui bouclait sur la collection Rows, vous implémentez l’interface IEnumerable sur ces tables, l’implémentation de la fonction GetEnumerator contenant le code ci-dessous :


foreach (DataSet.MaTableRow Ligne in InstanceDataSetParent.InstanceDataSetTypee.MaTable.Rows)
 yield return new MaTableRow(Ligne);

Personnellement, c’est la première fois que je trouve une utilité hors des exemples standards pour le mot clé yield. Dans ce cas précis, je ne sais pas comment j’aurais fait pour transformer la collection sans trop perdre en performance.

Si vous êtes intéressé par le code un peu plus complet que cette rapide description, n’hésitez pas à me contacter.

Retour d’expérience sur ClickOnce

Classé dans : .NET — jpgouigoux @ 8:17
Tags: , ,

Si jamais quelqu’un de Microsoft me lit, je serais curieux de savoir si ClickOnce est considéré comme déjà enterré par Silverlight et consorts, ou si c’est toujours présenté comme une technologie à utiliser. Outre le fait que ClickOnce ne soit pas supporté officiellement (en tout cas, dixit le support téléphonique), plusieurs bugs vraiment gênants existent sur cette technologie, et ne sont visiblement pas en voie de résolution.

Il y en a au moins un qui a été corrigé, mais c’était tellement criant qu’il pouvait difficilement en être autrement : il s’agit du non-support des proxies authentifiés pour le téléchargement. Ca fonctionne grâce à un fix qu’on peut se procurer en le demandant à la hotline Microsoft (http://support.microsoft.com/default.aspx/kb/917952). Je n’ai pas bien compris pourquoi il n’avait pas été mis à disposition publique, mais bon… le problème est réglé.

Par contre, je suis récemment tombé sur un autre souci, à savoir que l’authentification du client .NET se chargeant du téléchargement des modules (donc, l’API ClickOnce de System.Deployment) n’était visiblement pas capable de gérer un saut d’adresse.

Après quelques recherches sur le net, il semblerait que le client de téléchargement se base toujours sur l’adresse effective du fichier .application, et non sur l’adresse à laquelle a été adressée la requête HTTP pour récupérer celui-ci. Ce qui pose problème en cas de pare-feu, DMZ, translation, etc. Un incident a été enregistré, mais il n’y a ni réponse ni activité depuis Juin.

Je commence à me demander si ClickOnce n’est pas en train d’être mis de côté par Microsoft, vu que les problèmes de déploiement d’un client lourd ne se posent plus suite à la mise en place de Silverlight. Pourtant, les applications WPF sont mises en avant, et on trouve de nombreux liens sur le déploiement d’applications basées sur cette techno relativement récente.

En conclusion, si vous devez utiliser ClickOnce de manière industrielle, faites des tests dans la configuration exacte de production (réseau, proxy, authentification, SSL, etc.).

29/06/2008

Microsoft UI Automation : déçu, encore une fois…

Classé dans : .NET, UIAutomation — jpgouigoux @ 2:16
Tags: , , , ,

Que je vous expose mon problème, avant tout : ça fait presque dix ans que je cherche une méthode efficace pour tester des interfaces rapides. J’ai essayé des outils commerciaux (Mercury et consorts), des outils gratuits, des méthodes (instrumentation, scripting VSA, invocation sur hooks, etc.), des bidouilles ignobles (surcharger la librairie ManagedSpy de Ben Wulfe de Microsoft R&D, entre autres). J’ai posé le problème aux DevDays suite à la présentation de Rosario, harcelé des gens de Microsoft pour leur demander quand on aurait enfin un outil pour faire du test d’interface.

Et il y a deux jours, j’ai cru avoir enfin trouvé la voie. Un article de Programmez parlait de UI Automation, qui est un framework d’accessibilité, permettant de parcourir et de lire les contrôles de manière externe au programme cible. Ce framework est intégré à .NET 3.5. Je me renseigne un peu, trouve quelques liens intéressants, et me demande pourquoi mes recherches ne m’avaient pas fait trouvé cette technologie. J’ai pourtant passé un bon bout de temps à chercher ce qui se faisait en .NET, mais visiblement pas avec les bons mots clés.

Bref, je me mets à l’oeuvre en ouvrant Visual Studio 2008, et en rajoutant les références sur UIAutomationClient et UIAutomationTypes, et je reprends l’exemple trouvé sur http://blogs.developpeur.org/tom/archive/2007/07/25/wpf-wpf-ui-automation-rendez-vos-interfaces-graphiques-accessibles.aspx en me disant qu’il ne devrait pas être trop dur de l’étendre pour insérer du texte dans un notepad depuis une application console extérieure.

C’est là que les choses se corsent. J’ai d’abord la surprise de découvrir que UISpy ne fait pas partie du SDK 6.0. Voir à ce sujet http://blogs.msdn.com/windowssdk/archive/2008/02/18/where-is-uispy-exe.aspx. Ce n’est pas grave, je télécharge, j’installe le tout comme un 6.1, et je découvre la structure du notepad grâce à l’outil UISpy. Il y a un élément de type document, qui semble être le contrôle par défaut. Je lui associe un TextPattern, sur lequel un DocumentRange me donne accès à GetText(). Bizarre, il n’y a pas de SetText()…

Mon premier réflexe est de me dire que l’injection doit se faire avec un autre pattern que la lecture de texte. Je trouve un bon candidat, à savoir le InvokePattern, mais ça ne sert apparemment pas à ça, ou bien je n’ai pas compris comment ça fonctionne exactement. Avant de poursuivre plus loin, je me dis que je ferais mieux de me renseigner un peu plus sur le pourquoi de l’absence d’un SetText() dans le TextPattern. Et ce que je trouve sur http://msdn.microsoft.com/en-us/library/ms745158.aspx à la rubrique Security me confirme mes doutes : dixit l’article, “Microsoft UI Automation text providers supply read-only interfaces and do not provide the ability to change the existing text in a control”. Bref, c’est plié encore une fois pour l’automatisation des tests d’interface.

Au passage, la sécurité a bon dos : c’est tout à fait possible d’injecter des valeurs dans un contrôle en passant par les API Win32, ou même en utilisant ManagedSpy.dll (je tiens le code à disposition si quelqu’un est intéressé). Si on voulait simplement empêcher la nouvelle technologie de prendre ce risque, il était également possible de mettre en place un système autorisant la modification distante à condition qu’une autorisation ait été donnée par avance. Ca peut être fait avec un certificat, un token, n’importe quoi. Même si ça ne fonctionne pas avec des applications existantes et que ça force les applications cibles à rajouter une propriété quelconque dans leur code. Ou bien un setting quelque part dans la base de registre, n’importe.

Ma conclusion est la suivante. De deux choses l’une :

  1. Microsoft ne veut pas qu’on fasse de l’automatisation de tests automatisés d’interface avec ses outils. Il est également possible que les problèmes qu’on rencontre avec une approche ManagedSpy (impossibilité de sauter d’un handle de fenêtre principale à un handle de dialogue modal, etc.) existent toujours avec l’approche UI Automation (je ne serais d’ailleurs pas étonné que les deux approches utilisent le même principe, vu la proximité étonnante de UISpy.exe avec ManagedSpy.exe). Peut-être que c’est tout simplement impossible sous Windows…
  2. Je suis passé à côté d’un truc, et il est possible d’envoyer du texte dans un contrôle depuis UI Automation en utilisant un autre pattern. Je dois dire que ce cas-là me ravirait… Oui, je serais content de me faire traiter d’andouille par n’importe qui qui pourra m’apporter un code réalisant enfin ce que je veux faire depuis 10 ans que je bosse dans l’informatique.

30/05/2008

Je suis (enfin) MCSD.NET !

Classé dans : .NET, Perso — jpgouigoux @ 7:28
Tags:

Ca y est : quatre ans après avoir passé la première certification .NET de Microsoft, j’ai enfin réussi à finir le premier cycle de certifications pour être Microsoft Certified Solution Developer. A cette époque là, c’était le top du top… Malheureusement (enfin, pour être honnête, c’est normal), Microsoft a depuis rajouté des niveaux à ses certifications. Il va falloir passer encore deux (ou trois ?) examens passerelles pour me mettre à jour sur le nouveau programme et devenir MCPD.

J’espère vraiment que ça ne changera pas trop vite après, histoire de ne pas passer ma vie à courir après des examens. Encore, tant que c’est des examens comme WinForms ou ASP.NET ou la sécurité, ça va : le sujet est intéressant, et surtout, si on connaît bien le code, on n’est pas pris au piège par les questions. Mais le 70-300, qui est celui sur l’architecture, est vraiment très différent : ce sont des exercices de mise en situation réelle, avec des questions sur les choix d’architecture conceptuelle ou technique. Les réponses sont parfois un peu bizarres, et il y a quelques cas où, vraiment, tout ce qui et proposé paraît ne pas coller à la question. Ca ne vient pas de l’anglais (oui, c’est un des rares examens à ne pas être disponible en français), je suis à peu près bilingue. Les questions sont parfois très vagues, et en architecture informatique, chacun fait son choix. Ce n’est pas comme du code où c’est bon ou mauvais.

La prochaine certification sera le MCTS 70-341 sur SQLServer 2005. Ensuite, les examens passerelles, et peut-être que je pousserai le vice jusqu’à passer les examens WPF et WCF, qui ont été rajoutés récemment. Personnellement, je ne peux que recommander ce cycle de certification. Je ne sais pas ce que valent celles sur les systèmes, SQLServer ou même les certifications non-Microsoft, mais je peux dire que celles que j’ai passées m’ont fait apprendre pas mal de choses en lisant les bouquins de préparation et en faisant les exercices proposés. Il y a bien sûr beaucoup de choses à apprendre, et on se retrouve à bachoter pour certaines classes qu’on n’utilise presque jamais, mais qu’on est obligés d’apprendre pour parer à toute éventualité, mais dans l’ensemble, ce sont des techniques qu’on peut vraiment appliquer au travail.

25/05/2008

Retrouver une valeur d’énumération depuis son libellé par réflexion

Classé dans : .NET — jpgouigoux @ 8:14
Tags:
public enum ModeTraitement : byte { COMPLET = 0, MIXTE = 1, REDUIT = 2 };
<ActionPreventive ModeTraitement="COMPLET">

Imaginez que vous devez mettre en place une désérialisation à la main depuis un fichier XML, parce que la classe ne correspond pas à ce dont vous disposez. Il est plus simple de parcourir ledit fichier et, pour chaque élément, créer par réflexion l’instance de classe correspondante, puis faire de même pour les attributs. Dans le cas de type simple, pas de problème.

Mais souvent, quand les fichiers XML doivent être facilement lisible, vous ne disposez pas pour un attribut correspondant à un type énuméré de sa valeur entière, mais plutôt du libellé associé.

Par exemple :

Bref, pas de chance, car vous ne pouvez pas affecter directement la valeur par réflexion sur la propriété avec le genre de code ci-dessous :

PropertyInfo Propriete = TypeActivite.GetProperty(Attribute.LocalName);
Propriete.SetValue(ActionPreventive, "COMPLET", null);

Vous aurez une erreur car le type doit être byte, et non pas string tel que vous tentez de le faire.

La solution : parcourir par réflexion les valeurs possibles de l’énumération. Le principe paraît simple, mais je fais quand même un petit billet là-dessus, parce que j’ai mis un peu de temps à trouver.

PropertyInfo Propriete = TypeActionPreventive.GetProperty("ModeTraitement");
if (Propriete.PropertyType.IsEnum)
{
 foreach (FieldInfo AtomeEnum in Propriete.PropertyType.GetFields(BindingFlags.Public | BindingFlags.Static))
 if (AtomeEnum.Name.Equals("COMPLET"))
 {
  Propriete.SetValue(ActionPreventive, (byte)AtomeEnum.GetValue(null), null);
  break;
 }
}

En espérant que ça serve à quelqu’un.

05/05/2008

XSL/FO et .NET

Classé dans : .NET, FOP — jpgouigoux @ 9:30
Tags: , , ,

Vous êtes-vous déjà demandé comment faire pour générer un PDF en XSL-FO depuis ASP.NET, ou pour le coup n’importe quelle application .NET ? J’ai eu beau chercher, je n’ai pas trouvé de moteur XSL-FO écrit en code managé et open-source.

La solution glanée sur différents sites web est de faire de l’interop avec ApacheFOP, qui est écrit en Java. Mais là, deux voies sont possibles :

- Ou bien on recompile le code Java en J#, et on obtient des assemblages .NET nécessitant les redistribuables J# pour fonctionner. Avantage : le tout ne pèse que quelques Mo. Inconvénient : ça n’a aucune chance de fonctionner sous Mono.

- Ou bien on exécute en mémoire les JAR en passant par IKVM, qui est une machine virtuelle embarquée dans un processus .NET. Avantage : c’est propre et tout tourne en mémoire, de plus pas de problème théoriquement avec Mono, vu qu’IKVM est carrément livré avec. Inconvénient : ça pèse une trentaine de Mo, car il faut livrer avec la totalité des classes Java. Il doit y avoir moyen de faire autrement en générant une dll IKVM.ClassPath.dll avec seulement ce qui est nécessaire, mais je n’ai pas essayé.

On va expliquer sur ce post la deuxième méthode, qui de mon point de vue est la meilleure. Oui, je sais, ça a déjà été fait sur d’autres pages web, mais je n’ai rien trouvé qui était à jour avec la dernière version de FOP et avec la liste des références nécessaires.

Récupération des librairies

On commence par récupérer FOP sur le site Apache, http://xmlgraphics.apache.org/fop/download.html (la toute dernière version stable est la 0.94). On va également télécharger la dernière version en date de IKVM, à savoir la 0.36.0.11 sur http://sourceforge.net/project/showfiles.php?group_id=69637.

Petite remarque au passage : je suis toujours autant émerveillé de la modestie des équipes capables de réaliser un développement aussi remarquable, et de laisser un numéro de version inférieur à 1. Quand on voit des logiciels soi-disant professionnels toujours aussi buggés en version 10, on se dit que beaucoup d’entre eux devraient prendre exemple sur les développements OpenSource.

On décompresse ensuite tout ça dans deux répertoires /FOP et /IKVM.

Recompilation des librairies FOP par IKVM

IKVM fournit un environnement d’exécution .NET d’une VM Java sous forme d’un exécutable, mais également un compilateur permettant de générer des assemblages .NET à partir des JAR, et qui se nomme IKVMC.

Dans notre cas, on se place dans /IKVM/bin, et on lance successivement les commandes suivantes :

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    /fop-0.94/lib/xml-apis-1.3.02.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    -reference:xml-apis-1.3.02.dll
    /fop-0.94/lib/xercesImpl-2.7.1.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    -reference:xml-apis-1.3.02.dll
    /fop-0.94/lib/avalon-framework-4.2.0.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    -reference:xml-apis-1.3.02.dll
    /fop-0.94/lib/batik-all-1.6.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    /fop-0.94/lib/commons-logging-1.0.4.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    /fop-0.94/lib/commons-io-1.3.1.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    /fop-0.94/lib/xmlgraphics-commons-1.2.jar

ikvmc -target:library
    -reference:IKVM.OpenJDK.ClassLibrary.dll
    -reference:xml-apis-1.3.02.dll
    -reference:batik-all-1.6.dll
    -reference:commons-logging-1.0.4.dll
    -reference:xmlgraphics-commons-1.2.dll
    -reference:commons-io-1.3.1.dll
    -reference:avalon-framework-4.2.0.dll
    /fop-0.94/build/fop.jar

Si vous avez besoin d’assemblages signés, il suffit de spécifier la directive -keyfile:[votre fichier .snk] ou bien -key:[le nom de votre container de clé]. IKVMC contient de nombreuses autres options qui peuvent se réveler très utiles. La prise en compte de la signature par nom fort, dans mon cas, était très importante, et ce fut un vrai soulagement de voir que le paramètre était présent. Je me voyais déjà désassembler l’IL depuis la DLL puis recompiler en ajoutant la signature, et je ne suis même pas sûr que ça soit possible…

Utilisation des assemblages créés

Une fois ceci fait, vous pouvez créer un projet .NET dans lequel vous allez simplement mettre en référence les librairies fop.dll et IKVM.ClassPath.dll générées précédemment. Placer au même endroit toutes les autres références, qui ne seront pas nécessaires pour la compilation, mais indispensables lors de l’exécution. Vous pouvez ensuite taper le genre de code suivant pour vérifier que tout fonctionne. J’ai enlevé tout ce qui est gestion des exceptions et génération des noms de fichiers pour simplifier le code et ne faire voir que ce qui a vraiment du sens pour un tutoriel sur XSL-FO.

Note : je préfère écrire systématiquement les noms de classes complets dans ce genre d’exemple. Je trouve qu’on a toujours du mal à savoir d’où viennent les classes sinon, surtout qu’il est très facile d’oublier de donner les using lorsqu’on copie une simple portion de classe. Dans la pratique, il est bien sûr plus clair d’utiliser des noms de classe simples avec des using.
public void GenererPDF(System.Xml.XmlDocument Source, string FichierXSLFO, string FichierResultatPDF)
{
    // Récupération du fichier XSL
    System.Xml.Xsl.XslCompiledTransform Moteur = new System.Xml.Xslt.XslCompiledTransform();
    Moteur.Load(FichierXSLFO);

    // Application de la transformation
    string FichierResultatFO = System.IO.Path.GetTempFileName();
    System.Xml.XmlTextWriter Scribe = new System.Xml.XmlTextWriter(FichierResultatFO, System.Text.Encoding.Default);

    Moteur.Transform(Source.CreateNavigator(), Scribe);
    Scribe.Close();

    // Création du PDF par interop IKVM avec ApacheFOP
    java.io.File fo = new java.io.File(FichierResultatFO);
    java.io.File pdf = new java.io.File(FichierPDFGenere);
    org.apache.fop.apps.FopFactory fopFactory = org.apache.fop.apps.FopFactory.newInstance();
    org.apache.fop.apps.FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
    java.io.OutputStream sortie = new java.io.BufferedOutputStream(new java.io.FileOutputStream(pdf));
    org.apache.fop.apps.Fop fop = fopFactory.newFop("application/pdf", foUserAgent, sortie);
    javax.xml.transform.TransformerFactory factory = javax.xml.transform.TransformerFactory.newInstance();
    javax.xml.transform.Transformer transformer = factory.newTransformer();
    javax.xml.transform.Source src = new javax.xml.transform.stream.StreamSource(fo);
    javax.xml.transform.Result res = new javax.xml.transform.sax.SAXResult(fop.getDefaultHandler());
    transformer.transform(src, res);
    sortie.close();
}

Résultat

Une fois que les premiers résultats fonctionnels ont été atteint, la curiosité pousse à aller voir combien tout ça prend en mémoire. Il y a en effet finalement 13 librairies à mettre en place pour faire fonctionner le tout, pour un total de 36 Mo. Vu que toutes les classes de Java ont été reproduites en IKVM, c’est un peu logique, mais ce qui est intéressant, c’est que la CLR, comme pour des librairies .NET standards, ne charge que ce dont elle a besoin, à savoir en gros 5 Mo, et prend quelques dizaines de Mo pour un gros PDF, mais cette partie de mémoire est considérée comme ponctuelle, et sera libérée lors du prochain passage du garbage collector.

Bref, ça marche ! Honnêtement, je ne me suis pas penché sur IKVM pour vous indiquer clairement comment, mais je préfère avoir un produit qui fonctionne sans savoir pourquoi que l’inverse.

« Page précédente

Publié sur WordPress.