Blog de Jérémie Bertrand » C#

Lancement d’AppConfig Code Generator

laedit — Tue, 22 Mar 2011 14:30:08 +0000

Petite news (depuis fort longtemps malheureusement…) pour annoncer le lancement du projet AppConfig Code Generator !

Hébergé sur codeplex (http://appconfigcodegen.codeplex.com/), ce projet est un Custom Tool pour Visual Studio 2008 et 2010 permettant la génération automatique en C# ou VB.NET d’une classe d’accès aux appSettings et connectionStrings contenu dans le fichier App.config du projet.

Codé en une journée, ce projet est encore jeune et ne demande qu’à être amélioré grâce à vos idées, donc n’hésitez pas à aller sur le site pour dire ce que vous en pensez !

Dessiner un PNG avec le Compact Framework

laedit — Wed, 01 Sep 2010 13:09:25 +0000

Qui n’a jamais dû dessiner une image transparente avec le Compact Framework sur Windows Mobile ou pire Windows CE ?
Le plus simple est d’utiliser une image PNG. Le problème étant que le Compact Framework ne prend pas en charge la transparence.

Il faut donc utiliser les dlls de l’OS afin de remédier à ce petit problème.

Après un petit tour sur le web,on trouve assez rapidement qu’il faut utiliser l’API Imaging. On peut également utiliser l’API Alpha blend afin de rendre transparente une image qui ne l’est pas, mais les possibilités ne sont pas aussi étendues qu’avec une image PNG.

Une fois cette info en poche, un petit tour sur PInvoke.net nous apprend qu’il faut utiliser un object COM nous permettant par la suite d’avoir une interface IImage, représentant une image transparente, et une interface IImagingFactory, permettant de créer des objets de type IImage.
L’imprémentation en est très bien expliqué dans le post Alphablending with NETCF de Chris Lorton.

Une fois les diverses structures et interfaces en place, on lance le projet et tout marche, on a de la transparence !

Enfin, pas pour tous. Vous n’êtes peut-être pas tombé dessus, mais en changeant les coordonnées du rectangle de destination d’une IImage l’exception ArgumentException avec le message très explicite « 0x80070057″ peut être levée.
Une fois connue, la raison en est simple : le rectangle de destination ne fonctionne pas exactement de la même manière que dans les autres fonctions de dessin.
Le rectangle est normalement composé de 4 entiers : X et Y représentent les coordonnées du point situé en haut à gauche de la zone à dessiner et Width et Height représentent la largeur et la hauteur de la zone à dessiner.

Mais dans le cas présent, si X et Y gardent la même fonction, c’est Width et Height qui sont différents. En effet, ils ne correspondent pas à la largeur et la hauteur du rectangle dont le point en haut à gauche est situé à X,Y mais à 0,0.

Il faut donc ajouter X à la largeur voulue et Y à la hauteur voulue :

Rectangle(X, Y, X + Width, Y + Height)

Par exemple, j’ai une image avec ce rectangle de destination: 0, 0, 50 ,50.

Si je souhaite la déplacer, j’aurais donc ce rectangle de destination: 20, 30, 20 + 50, 30 + 50, afin de conserver les proportions de l’image.

Update :
Un petit plus afin de gagner du temps lors du dessin, pensez à utiliser la méthode SetImageFlags avec en paramètre ImageFlagsCaching de l’objet IImage.
Plus d’informations ici (attention, code non-managé).

Bonne chance avec vos projets Compact Framework !

Amazon Product Advertising API en C#

laedit — Sat, 07 Aug 2010 18:37:34 +0000

Avez-vous déjà voulu requêter les web services d’amazon afin de récupérer le titre d’un film ou d’un livre ?

Si oui, vous vous êtes sûrement déjà confrontés au brouillard de tous les web services amazon afin de trouver le bon, et après il faut encore trouver son nom ( car ils ont tendance à changer ) et à trouver quelques bons exemples de codes encore valable, voire la bonne adresse du WSDL.

Après une petite après-midi de recherche, j’ai pu trouver ce que je voulais et arriver au résultat voulu : récupérer toutes les informations d’un produit à partir de son code EAN (code-barre).

Après avoir passé quelques heures sur le site d’amazon et m’être aperçu que tous les exemples ne sont plus valable, je me suis tourné vers google. Et après quelques recherches infructueuses, j’ai trouvé la perle : le code-source et le guide pour réaliser le même code.

Merci Oren Trutner : https://flyingpies.wordpress.com/2009/08/01/17/

Au passage, il faut se créer un compte pour utiliser les web services d’Amazon. Vous pouvez vous en créer un gratuitement à cette adresse : http://aws.amazon.com/ en cliquant sur le lient « Create an AWS Account » en haut à droite. Une fois la création effectuée, allez dans Account->Security Credentials et gardez sous la main l’Access Key ID et la Secret Access Key dans la partie Access Credentials, vous en aurez besoin par la suite.

Au niveau du code, au début rien de bien compliqué : le WSDL est dispo à l’adresse http://webservices.amazon.com/AWSECommerceService/AWSECommerceService.wsdl.
Il suffit de créer une nouveau projet dans Visual Studio et d’ajouter une référence de service avec cette uri, en asynchrone ou non selon vos goûts.
On obtient donc de jolies classes de proxy, que l’on peut donc utiliser afin de requêter Amazon.

class Program
{
// your Amazon ID's
private const string accessKeyId = "AccessKeyId";
private const string secretKey = "SecretAccessKey";

// the program starts here
static void Main(string[] args)
{

// create a WCF Amazon ECS client
AWSECommerceServicePortTypeClient client = new AWSECommerceServicePortTypeClient(
new BasicHttpBinding(),
new EndpointAddress("http://webservices.amazon.com/onca/soap?Service=AWSECommerceService"));

// prepare an ItemSearch request
ItemSearchRequest request = new ItemSearchRequest();
request.SearchIndex = "All";
request.Keywords = "3700259800655";
request.ResponseGroup = new String[] { "Large" };

ItemSearch itemSearch = new ItemSearch();
itemSearch.Request = new ItemSearchRequest[] { request };
itemSearch.AWSAccessKeyId = accessKeyId;

// issue the ItemSearch request
ItemSearchResponse response = client.ItemSearch(itemSearch);

// write out the results
foreach (var item in response.Items[0].Item)
{
Console.WriteLine(item.ItemAttributes.Title);
}

Console.ReadLine();

Pour information, la liste de tous les SearchIndex est ici : http://docs.amazonwebservices.com/AWSEcommerceService/4-0/ApiReference/SearchIndexValues.html. Il faut tout de même lui ajouter All, qui correspond à une recherche sur toutes les catégories.

Mais le code précédent ne fonctionne pas. Pas avant d’avoir bidouillé un peu. Car ce qu’Amazon ne dit pas sur son site (ou alors il fallait chercher pendant encore quelques heures), c’est toute la partie authentification des messages SOAP qu’il faut mettre en place.
Trois classes vont rendre cela possible :

AmazonSigningMessageInspector : implémente IClientMessageInspector et permet de modifier la requête avant son envoi. Elle va donc rajouter les headers.
AmazonSigningEndpointBehavior : implémente IEndpointBehavior et permet d’ajouter le bon MessageInspector au bon moment.
AmazonHeader : hérite de MessageHeader et est utilisée par le MessageInspector pour ajouter les headers.

Voilà la partie du code de AmazonSigningMessageInspector ajoutant les headers :

public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
// prepare the data to sign
string operation = Regex.Match(request.Headers.Action, "[^/]+$").ToString();
DateTime now = DateTime.UtcNow;
string timestamp = now.ToString("yyyy-MM-ddTHH:mm:ssZ");
string signMe = operation + timestamp;
byte[] bytesToSign = Encoding.UTF8.GetBytes(signMe);

// sign the data
byte[] secretKeyBytes = Encoding.UTF8.GetBytes(secretKey);
HMAC hmacSha256 = new HMACSHA256(secretKeyBytes);
byte[] hashBytes = hmacSha256.ComputeHash(bytesToSign);
string signature = Convert.ToBase64String(hashBytes);

// add the signature information to the request headers
request.Headers.Add(new AmazonHeader("AWSAccessKeyId", accessKeyId));
request.Headers.Add(new AmazonHeader("Timestamp", timestamp));
request.Headers.Add(new AmazonHeader("Signature", signature));

return null;
}

Cela permettra de mettre en place un header de ce type :

xmlns:aws="http://security.amazonaws.com/doc/2007-01-01/">
YOURACCESSKEYIDHEREX
2009-08-15T23:59:59Z
SZf1CHmQnrZbsrC13hCZS061ywsEXAMPLE

Il suffit ensuite de modifier la façon d’appeler le web service pour que tout roule :

// create a WCF Amazon ECS client
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
binding.MaxReceivedMessageSize = int.MaxValue;
AWSECommerceServicePortTypeClient client = new AWSECommerceServicePortTypeClient(
binding,
new EndpointAddress("http://webservices.amazon.com/onca/soap?Service=AWSECommerceService"));

// add authentication to the ECS client
client.ChannelFactory.Endpoint.Behaviors.Add(new AmazonSigningEndpointBehavior(accessKeyId, secretKey));

Et afin de pouvoir « localiser » les web services, j’ai créée une petite classe AmazonEndpointAdress recensant toutes les adresses des endpoint des web services Amazon, accessibles ici : http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/index.html?AnatomyOfaRESTRequest.html.
Bien entendu, votre fichier App.config doit comporter tous les endpoint correspondant.
Et au final, le code d’appel ressemble à celle-ci :

AWSECommerceServicePortTypeClient client = new AWSECommerceServicePortTypeClient(
binding,
new EndpointAddress(AmazonEndpointAdresses.FR));

Et voilà !

Vous pouvez maintenant rechercher n’importe quel produit sur n’importe quel site d’Amazon !

Les sources sont disponibles ici : http://laedit.ftp-developpez.com/CSharp/Amazon/AmazonProductAdvtApiWcfSample.zip.

Guide de programmation MEF

laedit — Mon, 31 May 2010 08:00:00 +0000

Après plus d’un mois de traduction, relecture et corrections diverses, je viens enfin de terminer un joli petit dossier sur l’utilisation de MEF (Managed Extensibility Framework), le framework permettant de créer facilement une application pouvant être étendue par le biais de plugins.

Sans plus attendre, voici le lien vers l’article : http://laedit.developpez.com/CSharp/MEF/Programming_Guide/

Et le sommaire :

I. Introduction
I-A. Qu’est-ce que MEF
I-B. Quels sont les problèmes que MEF peut résoudre
I-C. Comment fonctionne MEF
I-D. Vue d’ensemble de l’architecture

II. Guide de programmation MEF
II-A. Héberger MEF dans une application
II-A-1. Ajout d’une Part directement dans le container
II-A-2. Ajout en utilisant un AssemblyCatalog
II-B. Définition des Composable Parts et des contrats
II-B-1. Composable Part
II-B-2. Contrats
II-B-2-1. Contrats d’interface / abstraits
II-B-3. Assemblage de contrats
II-C. Déclaration des exports
II-C-1. Export de Composable Part
II-C-2. Export de propriétés
II-C-3. Export de méthodes
II-C-4. Héritage d’export
II-C-5. Découverte de Composable Parts privées
II-D. Déclaration des imports
II-D-1. Import de propriétés
II-D-2. Paramètre de constructeur
II-D-2-1. Import de paramètres
II-D-3. Import de champs
II-D-4. Imports optionnels
II-D-5. Import de collections
II-D-6. IPartImportsSatisfiedNotification
II-E. Imports différés
II-F. Exports et métadonnées
II-F-1. Ajouter des métadonnées à un export
II-F-1-1. Utiliser l’attribut ExportMetadata
II-F-1-2. Utiliser un attribut d’export personnalisé
II-F-2. Importer des métadonnées
II-F-2-1. Utiliser des métadonnées fortement typées
II-F-2-2. Utiliser des métadonnées faiblement typées
II-F-2-3. Le filtrage des métadonnées et l’attribut DefaultValueAttribute
II-G. Utilisation des catalogues
II-G-1. AssemblyCatalog
II-G-2. DirectoryCatalog
II-G-3. AggregateCatalog
II-G-4. TypeCatalog
II-G-5. DeploymentCatalog – uniquement dans Silverlight
II-G-6. Utilisation d’un catalogue dans un Container
II-H. Catalogues filtrés
II-I. Cycle de vie des Parts
II-I-1. Shared, Non Shared et propriété
II-I-2. Disposer le container
II-I-3. Container et références des Parts
II-I-4. Scoped operations et récupération rapide des ressources
II-I-5. Hiérarchie des containers
II-I-6. Ordre de disposition
II-I-7. AddPart / RemovePart
II-J. Recomposition
II-J-1. Mises en garde
II-J-2. La recomposition et Silverlight
II-K. Requêter le CompositionContainer
II-K-1. GetExportedValue
II-K-2. GetExport
II-K-3. GetExportedValueOrDefault
II-L. Composition Batch
II-M. Débogage et diagnostics
II-M-1. Diagnostiquer les problèmes de composition
II-M-1-1. Problèmes liés au rejet
II-M-1-2. Dump Composition State
II-M-1-3. Trouver les root causes probables
II-M-1-4. Débogage des proxies
II-M-2. Mefx : outil d’analyse en ligne de commande
II-M-3. Tracer les informations de composition
II-N. FAQ
II-N-1. Comment avoir des exports utilisant un objet Type
II-N-2. Comment utiliser des containers imbriqués

III. Fonctionnalités spécifiques à Silverlight
III-A. Héberger MEF dans Silverlight en utilisant le CompositionInitializer
III-A-1. Utilisation de CompositionInitializer depuis des éléments XAML
III-A-2. Mises en garde dans l’utilisation de CompositionInitializer.SatisfyImports
III-B. Redéfinir la configuration de l’hôte
III-B-1. Redéfinition grâce aux catalogues
III-B-1-1. Configurer la découverte des Parts dans le XAP courant
III-B-2. Redéfinition grâce à un container
III-C. Instanciation dynamique et ExportFactory
III-C-1. ExportFactory
III-C-2. ExportLifetimeContext
III-D. Partitionnement d’application avec le DeploymentCatalog
III-D-1. DeploymentCatalog
III-D-2. Télécharger des Parts après le démarrage de l’application
III-D-3. Composer dynamiquement les Parts téléchargées et utiliser la recomposition
III-D-4. Téléchargement des Parts à la demande après démarrage de l’application et basé sur les actions de l’utilisateur
III-D-5. Gestion des erreurs durant le téléchargement
III-D-6. Mise à jour de la progression
III-D-7. Annulation du téléchargement
III-D-8. Utilisation du DeploymentCatalog quand l’application est hors-ligne ou Out of Browser
III-D-9. Mises en garde contre l’utilisation du DeploymentCatalog

IV. Codes sources et exemples
V. Liens
VI. Remerciements
VII. Contact

Utiliser Business Objects dans une application C#

laedit — Thu, 15 Apr 2010 07:48:01 +0000

Vu que je me retrouve embarquer là dedans pour des raisons professionnelles, et que j’ai galéré à trouver des infos, voilà comment faire pour utiliser Business Objects XI R2 dans une application C#.

Première étape, et non des moindres, installer BO.

Je ne vais pas détailler le processus ici, je préfère me concentrer sur du technique. Et puis c’est pas bien compliqué :p

Une fois l’installation finie, des dlls ont été installés dans le dossier System32, d’autres se retrouvent dans le GAC (C:\WINDOWS\assembly), tandis que d’autres encore sont présentes dans un des dossiers du dossier d’installation de BO, qui est par défaut « C:\Program Files\Business Objects\BusinessObjects Enterprise 11.5\win32_x86\ ».
[Update] D’autres dlls (pour les types de fichiers par exemple), sont présentes dans le dossier « C:\Program Files\Business Objects\common\3.5\managed ».

Parmi les dlls présentes dans le GAC, trois vont nous intéresser :

CrystalDecisions.Enterprise.dll
CrystalDecisions.Enterprise.Framework.dll
CrystalDecisions.Enterprise.InfoStore.dll

Ce sont celles qui vont nous permettre de faire des requêtes dans l’InfoStore de BO et ainsi récupérer, modifier ou supprimer divers objets BO.

Pour tester tout ça, il suffit maintenant de créer une application C#. Une application console fera l’affaire.

Ne pas oublier de référencer les trois dlls citées précédemment.

Et maintenant place au code :

// Création d'un sessionManager, c'est lui qui va nous permettre de nous identifier
SessionMgr boSessionMgr = new SessionMgr();

try
{
// Connexion à un serveur BO et récupération de la session [login] [mot de passe] [CMS name] [type d'authentification]
EnterpriseSession boEnterpriseSession = boSessionMgr.Logon("administrator", string.Empty, "VMSqlServer05", "Enterprise");

// Récupération d'un InfoStore afin de faire des requêtes
InfoStore boInfoStore = new InfoStore(boEnterpriseSession.GetService(SERVICE_INFOSTORE));
// Récupération d'une liste d'objets BO grâce à une requête dans l'InfoStore
InfoObjects boObjects = boInfoStore.Query("Select * From CI_INFOOBJECTS WHERE SI_KIND != 'Inbox' AND SI_KIND != 'PersonalCategory' ORDER BY SI_ID");

// Affichage des CUID et ID des objets
foreach (InfoObject infoObject in boObjects)
{
Console.WriteLine(infoObject.CUID + " : " + infoObject.ID);
}

Console.WriteLine();
Console.WriteLine("Modification d'un objet");

// Modification du titre du premier objet récupéré
// Attention, dans BO les listes d'objets (InfoObjects) commencent à 1 et non à 0
boObjects[1].Title = newTitle;
// Enregistrement des modifications dans l'InfoStore de BO
boInfoStore.Commit(boObjects);

Console.WriteLine();
Console.WriteLine("Objet modifié");

}
catch (COMException COMEx)
{
Console.WriteLine("ErrorCode: " + COMEx.ErrorCode);
Console.WriteLine("Message: " + COMEx.Message);
Console.WriteLine("StackTrace: " + COMEx.StackTrace);
}

Console.ReadLine();

Ce code détaillé permet donc de se connecter à BO, de récupérer une liste d’objet et de modifier l’un d’entre eux. Histoire de connaître les bases des relations entre BO et C#

Si une erreur survient lors de l’instanciation du SessionMgr, c’est que la dll EnterpriseFramework.dll, qui est présente dans le dossier « win32_x86″ du dossier d’installation de BO, n’a pas été installée. Il faut donc le faire via la ligne de commande « regsvr32 EnterpriseFramework.dll ».

Et pour finir, voici quelques bons liens :

Pro Crystal Enterprise/Business Objects XI programming Par Carl Ganz : aperçu d’un très bon livre sur la programmation avec BO
Querying the Busines Objects XI CMS InfoStore Database Tables : un très bon tips sur les requêtages des tables de l’InfoStore
La doc officielle de Business Objects XI R2
La doc officielle chez SAP avec deux sections intéressantes :
.NET SDK Developer Guides and API References
Object Model Diagrams

J’espère qu’avec ceci vous ne perdrez pas autant de temps que moi à trouver des informations sur comment utiliser BO via une application C# !

Code Header Designer

laedit — Mon, 07 Sep 2009 18:15:13 +0000

J’ai découvert ce week end une application assez sympathique. Elle n’a qu’un seul but mais le fait bien, elle permet de définir un header et un footer à rajouter/remplacer à des fichiers de codes.

Certes, ce n’est pas une chose que l’on fait souvent, mais quand on prend l’habitude de partager son code, c’est toujours bien de laisser une trace. Et même pour soi, garder certaines informations en entête peut être utile.

Présentation

En premier lieu, l’utilisateur va définir un header via un template, comme celui-ci par exemple :

/* ----------------------------------------------------------------------------
* [COMPANY NAME]
* ----------------------------------------------------------------------------
* [PRODUCT NAME]
* ----------------------------------------------------------------------------
* File: [AUTO:FILE]
* Author: [AUTO:AUTHOR]
* ----------------------------------------------------------------------------
*/

Entre crochet, ce sont des champs remplaçables. On définira donc par la suite leur valeur.
Les champs commençant par ‘AUTO:’ sont des champs automatiques : ils seront automatiquement remplacés par le programme, sans que l’utilisateur ai besoin de définir une valeur de remplacement.

De base, on dispose de deux champs auto :
– File qui va être remplacé par le nom du fichier
– Author qui va être remplacé par le nom d’utilisateur windows

Ensuite, on va donc définir les champs à remplacer via un DataGridView :

Il faut maintenant sélectionner les fichiers auxquels on veut appliquer le header. Pour cela, en haut de la fenêtre on va aller cliquer sur le bouton ‘Source Directory’ pour choisir un dossier. Généralement, ce sera un dossier d’une solution ou d’un projet. Une fois cela fait, on va sélectionner les fichiers via le bouton ‘Select files’. Là, on va pouvoir choisir un pattern de recherche des fichiers, qui par défaut recherche les fichier .cs. La liste des sous-dossiers va apparaître dans un TreeView à gauche tandis que les fichiers contenus dans le dossier sélectionné seront listés à droite. Il suffit de cocher un fichier pour l’inclure dans les fichiers auxquels le header sera appliqué. A noter, une option très pratique dans le menu : ‘Select all’, ‘Unselect all’.

Et voilà, on peut maintenant appliquer le header aux fichiers en cliquant sur le bouton ‘Go’ en bas à gauche de l’application. Une fenêtre de log est même présente afin de savoir si le header à pu être appliqué ou non et dans le dernier cas, de savoir pourquoi.

L’application propose aussi une gestion de sauvegarde et d’ouverture de fichier .headerx, comprenant le template et la liste de correspondances des champs avec leur valeur de remplacement.

Téléchargement : http://code.msdn.microsoft.com/HeaderDesigner

Ajouts

Etant un peu trop limité pour mon utilisation personnelle, j’y ai donc rajouté quelques petites choses.

Champs automatiques :
– Modification_Date : date de dernière modification du fichier.
– Creation_Date : date de création du fichier.
– Solution : nom de la solution si il y en a une.
– Project : nom du projet.
– Namespace : nom du namespace.
– Inherit : nom de la classe mère si il y en a une.
– Implements : nom des interfaces implémenté si il y en a.

Une petite aide à la saisie à aussi été intégrée dans l’éditeur de template, pour ne pas devoir avoir la documentation sous les yeux pour ajouter un champ automatique.

Le dossier source et les fichiers sélectionnés sont enregistrés dans le fichier .headerx, et sont donc reconnus lors de l’ouverture du fichier.

L’extension .headerx est associé à l’application, il suffit donc d’un double-clic sur un fichier .headerx pour l’ouvrir avec le Code Header Designer.

Téléchargement :
– installeur
– sources

Lien

Blog du créateur du Code Header Designer : http://colbyafrica.blogspot.com/

WebService PHP consommé par une application C#

laedit — Wed, 18 Mar 2009 20:57:48 +0000

Pour créer un WebService facilement en PHP, il faut travailler en PHP5 avec l’extension SOAP d’activée. Pour cela, le mieux est de travailler en local avec Wamp Server (Wamp 5), qui permet d’activer cette extension.

Une fois le matériel prêt, on va commencer par ouvrir notre éditeur de PHP préféré et d’écrire la classe qui être utilisé par le WebService.
Dans notre exemple, on va juste définir une petite classe chargée de faire une opération et une soustraction :

class Math
{

public function Add($a, $b)
{
return $a + $b;
}

public function Substract($a, $b)
{
return $a - $b;
}

}

Voilà donc les méthodes qui seront exposées part le WebService.
Il ne reste plus qu’à créer le serveur et la partie PHP sera terminée.
Pour cela, nous allons utiliser la classe SoapServer :

require 'Math.class.php';

// première étape : désactiver le cache wsdl lors de la phase de test
ini_set("soap.wsdl_cache_enabled", "0");

$wsdl = 'WebService.wsdl';
//Création du serveur SOAP avec le fichier WSDL
$server = new SoapServer($wsdl);
//Ajout de la classe Math dans les éléments proposés par le WebService
$server->setClass('Math');

//l'utilisation du WebService se fera toujours par la méthode POST
if ($_SERVER["REQUEST_METHOD"] == "POST")
{
$server->handle();
}
else //dans le cas contraire, la page affichera les méthodes proposées par le WebService
{
echo '

Ce serveur SOAP peut gérer les fonctions suivantes :

'.$func.'

';
}

Vous avez sûrement remarqué qu’on fait appel au fichier WebService.wsdl alors qu’on ne l’a pas encore créé. On va donc s’en charger maintenant. Le mieux pour cela est d’utiliser un logiciel qui va générer le fichier wsdl finale grâce à des informations qu’on lui aura apporté. Pour ma part j’utilise Altova XML Spy qui est disponible gratuitement en version d’essai.
Voilà donc ce que ça donne en version graphique :

La partie serveur est à présent terminée, attaquons nous au client .net en C#.

L’utilisation de Visual Studio 2008 est conseillé, il permet la génération automatique d’un proxy grâce a WCF à partir du fichier WSDL.
On va commencer par créer une application console. Ensuite, il suffit d’ajouter une un Service Reference en passant en adresse celle du fichier WSDL (http://localhost/WebServices/WebService.wsdl dans notre cas) et Math comme namespace pour la référence.

WCF a alors généré la classe MathServiceClient ainsi qu’un fichier de configuration qui vont nous servir à intéragir avec le WebService.
On va instancier cette classe :

MathServiceClient math = new MathServiceClient();

Puis on va simplement appeler nos deux méthodes :

Console.WriteLine(math.Add(5, 5));
Console.WriteLine(math.Substract(10, 5));

Et bien sûr, il ne faut pas oublier de fermer le client :

math.Close();

Et voilà, notre client .net consomme notre WebService PHP !

Les sources de cet article sont disponibles ici.

Interopérabilité PHP / C# via WebService

laedit — Wed, 18 Mar 2009 20:51:52 +0000

Interopérabilité est peut être un bien grand mot pour décrire ce qui va suivre. En effet, dès que l’on parle de WebService, il suffit d’avoir un fichier WSDL pour qu’on puisse consommer le WebService par une application d’un autre langage. Nous verrons donc dans un premier temps ce qu’est un fichier WSDL, puis la création d’un WebService en PHP consommé par une application .NET en C# et inversement.

Qu’est-ce qu’un fichier WSDL ?

Juste une rapide présentation, pour plus d’information, vous pouvez aller voir ici (http://www.w3.org/TR/wsdl).
Le fichier WSDL décrit une Interface publique d’accès à un Service Web, notamment dans le cadre d’architectures de type SOA (Service Oriented Architecture).
C’est une description fondée sur le XML qui indique « comment communiquer pour utiliser le service »;

Il décrit notamment le Protocole de communication (SOAP RPC ou SOAP orienté message), le format de messages requis pour communiquer avec le service, les méthodes que le client peut invoquer ainsi que la localisation du service.
Le fichier WSDL est un fichier XML qui commence par la balise et qui contient les balises suivantes :
- : définit le protocole à utiliser pour invoquer le service web
- : spécifie l’emplacement actuel du service
- : décrit un ensemble de points finaux du réseau

Les opérations possibles et messages sont décrits de façon abstraite mais cette description renvoie à des protocoles réseaux et formats de messages concrets.
Il y a différents moyens de réaliser ce fichier, certaines seront décrites dans cet article, mais étant donné que c’est du XML, un simple bloc note suffit !

Dans ce post, on verras un WebService PHP consommé par une application C#.

Et dans celui-là, un WebService C# en WCF consommé par une application PHP.

Créer un addin pour Internet Explorer

laedit — Mon, 26 Apr 2010 14:40:00 +0000

A travers plusieurs recherches sur le net, j’ai pu m’apercevoir qu’à première vue, la création d’un addin pour IE doit se faire en C++. Loin de moi de dénigrer se langage, mais quand c’est possible je préfère développer en C#. Et heureusement pour nous, Pavel Zolnikov à convertit les librairies C++ nécessaires à la création d’un addin pour IE en C#.

Il en a d’ailleurs fait un excellent article sur CodeProject.

La partie qui nous intéresse est la classe BandObject. C’est grâce à celle-ci que l’on va pouvoir créer un addin pour IE.
En effet, il suffira de créer une classe héritant de BandObject, de préciser un Guid ainsi que quelques paramètres via un attribut, et vous aurez votre toolbar. Vide au début, mais il ne tient qu’à vous de la remplir avec un ToolStrip et quelques boutons

Christophe Geers en a fait un article très intéressant sur son blog, détaillant le processus du début à la fin tout en résolvant les innombrables problèmes qui ne manquent pas de survenir.

Et pour finir pour les tutoriels, un article sur CodeProjet de Sharon Salmon, qui reprend les articles vu plus haut tout en rendant les choses plus simples, notamment en centralisant dans une classe statique les données telles que le GUID de l’addin, son nom, etc. Il Implémente aussi une classe Installer spéciale pour les addins de IE, nous évitant ainsi la tâche ardue et complexe d’enregistrer notre addin dans la base de registre afin qu’Internet Explorer le prenne en compte.

Maintenant quelques trucs et astuces.
En effet, étant donné que nous construisons un addin pour IE, certaines choses sont interdites/limitées. Je n’ai par exemple pas réussi à utiliser un fichier de configuration (app.config), mais peut être n’ai-je pas assez cherché.

Par contre, la classe BackgroundWorker fonctionne, évitant ainsi de freezer IE à chaque lancement si notre addin va chercher des informations sur un fichier distant par exemple. Car IE instancie chacun de ses addins lors de son lancement, et ne finit lui même de charger que lorsque tout ses addins ont finis, rendant son utilisation impossible si les addins sont trop nombreux ou prennent trop de temps à s’instancier.

Pour ceux qui voudraient que leur addin ait leur toolbar bien à eux, vous pouvez jouer avec la propriété dwModeFlags de la classe BandObject, en particulier dans sa méthode GetBandInfo.
D’après mes recherches, DBIMF.ADDTOFRONT permettrait de pouvoir déplacer l’addin parmi les barres d’outils (quand celles-ci ne sont pas vérrouillées, Affichage -> Barre d’outils -> Verrouiler les barre d’outils) tandis que DBIMF.BREAK permettrait à l’addin d’avoir sa toolbar. Mais ces valeurs étant prévues pour IE6, elles ne réagissent pas très bien avec IE7 et 8, mêmes si j’ai réussi à déplacer mon addin je n’ai jamais pu lui faire prendre la forme d’une toolbar complète.

Voilà, j’espère avoir réussi à vous aider dans la création d’un addin pour Internet Explorer

WebService C# en WCF consommé par une application PHP

laedit — Tue, 27 Oct 2009 16:23:08 +0000

Faisant suite après quelques mois à l’article sur le webservice PHP consommé par une application C#, nous verrons ici l’inverse.

Je ne vais pas détailler WCF ici, nous allons juste voir la mise en place d’un service via une application console. Si vous souhaitez en savoir plus sur WCF, voilà l’excellent article de Julien Corioland. (http://blogs.dotnet-france.com/julienc/post/Introduction-a-Windows-Communication-Foundation.aspx)

Nous garderons les mêmes méthodes que dans le post précédent, c’est-à-dire une addition et une soustraction d’entiers.

Commençons donc par définir l’interface du service :

[ServiceContract]
public interface IService
{
[OperationContract]
public int Add(int a, int b);
[OperationContract]
public int Substract(int a, int b);
}

L’attribut ServiceContract définit le contrat du service qui sera exposé. Il possède une propriété Namespace qui permet de changer le namespace du service (tempuri.org par défaut).
L’attribut OperationContract définit les méthodes visibles du service.

Passons à l’implémentation du service :

public class Math : IService
{
#region IService Members

public int Add(int a, int b)
{
return a + b;
}

public int Substract(int a, int b)
{
return a - b;
}

#endregion
}

Jusque là, rien de bien compliqué, il suffit d’implémenter l’interface définie plus haut. Passons maintenant au serveur, qui exposera le service WCF.

L’application sera une application console des plus classique. La première chose à faire est de créer un fichier de configuration (App.config) qui va paramétrer le type, l’adresse et le protocole du service.

binding="basicHttpBinding"
contract="ServiceContract.IMathService" />

On créer ensuite un host en lui indiquant le type que l’on veut exposer en service :

ServiceHost host = new ServiceHost(typeof(ServiceImplementation.Math));

Il suffit ensuite de mettre le service en écoute :

host.Open();

Console.WriteLine("Le service Math est à l'écoute");

Console.WriteLine("Appuyez sur une touche pour quitter");

Console.ReadLine();
host.Close();

Le service est maintenant prêt.

Mais le fichier WSDL n’a pas été créé, ce qui manque cruellement pour pouvoir consommer le service avec une application PHP. Heureusement, WCF permet de le générer automatiquement. Pour cela, il suffit de modifier le fichier de configuration.

On va tout d’abord rajouter un comportement au service. Dans la balise System.ServiceModel, on rajoute ceci :

Il faut ensuite modifier la balise service comme suit :

Et voilà, notre service peut maintenant être consommé par n’importe quelle application via son fichier WSDL.

Il ne reste plus qu’à faire le client PHP. Pour cela, le mieux est de générer le client SOAP à partir du fichier WSDL. Je me suis personnellement servi de wsdl2php, disponible ici : http://www.urdalen.no/wsdl2php/, mais d’autre scripts font ça très bien aussi, comme WSDLInterpreter : http://code.google.com/p/wsdl2php-interpreter/.

Une fois le WSDL passé à la moulinette, on obtient donc une jolie classe Math qui hérite de SoapClient et qui possèdent deux fonctions : Add et Substract. Sont également générées les classes qui vont servir à passer les paramètres et à récupérer les résultats : Add qui contient deux entiers, AddResponse qui possède une propriété AddResult qui est le résultat de l’addition, Substract qui contient également deux entiers et SubsctractResponse qui possède une propriété SubstractResult qui est le résultat de la soustraction.

Maintenant qu’on a de quoi consommer le service WCF, il ne reste plus qu’à faire le client PHP. On va tout d’abord créer le fichier client.php. Première chose à ajouter, un include sur le fichier généré par wsdl2php : Math.php.

Ensuite, on va instancier le client du service Math :

$client = new Math();

Il faut maintenant créer les paramètres pour la fonction Add :

$addParameters = new Add();
$addParameters->a = 2;
$addParameters->b = 2;

Vous remarquerez que a et b correspondent aux noms des paramètres de la fonction Add définis par le contrat du service.
On appelle la fonction Add :

$result = $client->Add($addParameters);

On peut ensuite utiliser la propriété AddResult de $result pour récupérer le résultat de l’addition et l’afficher par exemple :

echo $result->AddResult;

Et c’est fini, nous avons maintenant un client PHP qui consomme notre service WCF !

Les sources de cet article sont disponibles ici.