Nativement, dans Visual Studio nous avons à notre disposition prop et propdp, bien utiles dans la vie de tous les jours du développeur Silverlight pour créer propriétés et DependencyProperties sans trop avoir à taper du code purement répétitif. Par contre rien pour les propriétés déclenchant l’évènement PropertyChanged - sans doute car l’implémentation concrète d’INotifyPropertyChanged est laissée au développeur… bien que l’on fasse quasiement tous pareil.

Pour palier à ce manque je vous propose nprop, un snippet venant s’ajouter à votre IDE et qui vous permettra du temps dans vos développements

Elle s’utilise comme n’importe quel autre snippet, tapez juste nprop puis TAB et le code apparaitra en vous invitant à remplir les trous.

• Fichier d’installation automatique .vsi
• Fichier snippet nu à placer dans votre dossier %Documents%\Visual Studio 20xx\Code Snippets\Visual C#\My Code Snippets au cas où le fichier précédent poserait problème

Cette primitive permet de savoir si le code courant tourne dans le thread d’UI ou pas, et donc si un BeginInvoke() est nécessaire ou pas.

Exemple, pour récupérer un setting de l’IsolatedStorage depuis n’importe quel thread :

public void GetSetting(string key, out object value)
        {
            if (Deployment.Current.Dispatcher.CheckAccess())
            {
                value = IsolatedStorageSettings.ApplicationSettings[key];
            }
            else
            {
                using (ManualResetEvent sync = new ManualResetEvent(false))
                {
                    object _value = null;

                    Deployment.Current.Dispatcher.BeginInvoke(() =>
                        {
                            _value = IsolatedStorageSettings.ApplicationSettings[key];
                            sync.Set();
                        });

                    sync.WaitOne();
                    value = _value;
                }
            }
        }

Et bien CheckAccess() est toujours bien là dans la classe Dispatcher, même si l’Intellisense de Visual Studio ne vous la propose pas.

Rappel : Pour les débutants en multi-threading sous Silverlight, le seul Dispatcher auquel vous avez accès depuis un autre thread que l’UI est Deployment.Current.Dispatcher. Si vous essayez de taper directement dans le Dispatcher d’un FrameworkElement vous irez tout droit à la CrossThreadException .

Source : Forums MSDN

Attention, pour le coup vous perdrez l’avantage des requêtes asynchrones et votre thread appelant sera bloqué pendant le déroulement de la requête, comme au bon vieux temps !
Tout retour de bug ou message de remerciement est le bienvenu, ce code est disponible sous licence LGPL.

If you’re looking forward to port .NET applications to Silverlight/Windows Phone 7, the following might interest you.
In Silverlight, the WebRequests are asynchronous (and that’s a good thing), but this change in the API can cause numerous changes in your code. That’s what lead me to write this C# class : HttpWebRequestSync featuring an interface as close as possible as what was there before.

Note that you’ll lose the advantage of asynchronous requests and that you’re thread will be locked waiting for the request to complete, ol’school style.
If you find any bug or just want to leave a ‘thank you’ not you’re welcome. This code is available under the LGPL license.

/**********************************************************
 * HttpWebRequestSync.cs
 * Provides an implementation close to the .NET CF (3.5)
 * synchronous HttpWebRequest with Windows Phone 7's
 * asynchronous implementation.
 * TL;DR : Abstract the dev from all the async callback.
 *
 * Written by : Pierre BELIN <pierre.belin@inbox.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the Lesser GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the Lesser GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 **********************************************************/
using System;
using System.Net;
using System.Threading;
using System.IO;

namespace Ree7.Utils.Net
{
 public class HttpWebRequestSync
 {
 private ManualResetEvent getRequestDone = new ManualResetEvent(false);
 private ManualResetEvent getResponseDone = new ManualResetEvent(false);
 private HttpWebRequest request;

 private HttpWebResponse response;
 private Stream requestStream;

 /// <summary>
 /// Private ctor, to get an HttpWebRequestSync you shall use Create()
 /// </summary>
 private HttpWebRequestSync()
 {

 }

 /// <summary>
 /// Initializes a new HttpWebRequestSync for the specified URI scheme
 /// </summary>
 public static HttpWebRequestSync Create(string url)
 {
 return Create(new Uri(url));
 }

 /// <summary>
 /// Initializes a new HttpWebRequestSync for the specified URI scheme
 /// </summary>
 public static HttpWebRequestSync Create(Uri uri)
 {
 HttpWebRequestSync wrs = new HttpWebRequestSync();
 wrs.request = (HttpWebRequest)WebRequest.Create(uri);

 return wrs;
 }

 #region HttpWebRequest Interface
 /// <summary>
 /// Summary:
 ///     Gets or sets the value of the Accept HTTP header.
 ///
 /// Returns:
 ///     The value of the Accept HTTP header. The default value is null.
 /// </summary>
 public string Accept
 {
 get
 {
 return request.Accept;
 }
 set
 {
 request.Accept = value;
 }
 }
 /// <summary>
 /// Not Implemented Yet
 /// </summary>
 public int ContentLength
 {
 get
 {
 return 0;
 }
 set
 {
 return;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets or sets the value of the Content-type HTTP header.
 ///
 /// Returns:
 ///     The value of the Content-type HTTP header. The default value is null.
 /// </summary>
 public string ContentType
 {
 get
 {
 return request.ContentType;
 }
 set
 {
 request.ContentType = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Specifies the collection of System.Net.CookieCollection objects associated
 ///     with the HTTP request.
 ///
 /// Returns:
 ///     A System.Net.CookieContainer that contains a collection of System.Net.CookieCollection
 ///     objects associated with the HTTP request.
 ///
 /// Exceptions:
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 /// </summary>
 public CookieContainer CookieContainer
 {
 get
 {
 return request.CookieContainer;
 }
 set
 {
 request.CookieContainer = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets a value that indicates whether a response has been received from an
 ///     Internet resource.
 ///
 /// Returns:
 ///     true if a response has been received; otherwise, false.
 ///
 /// Exceptions:
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 /// </summary>
 public bool HaveResponse
 {
 get
 {
 return request.HaveResponse;
 }
 }
 /// <summary>
 /// Returns the underlying HttpWebRequest (handle it with care)
 /// </summary>
 public HttpWebRequest HttpWebRequest
 {
 get
 {
 return request;
 }
 }
 /// <summary>
 /// Summary:
 ///     Specifies a collection of the name/value pairs that make up the HTTP headers.
 ///
 /// Returns:
 ///     A System.Net.WebHeaderCollection that contains the name/value pairs that
 ///     make up the headers for the HTTP request.
 ///
 /// Exceptions:
 ///   System.InvalidOperationException:
 ///     The request has been started by calling the System.Net.HttpWebRequest.BeginGetRequestStream

(System.AsyncCallback,System.Object)
 ///     or System.Net.HttpWebRequest.BeginGetResponse(System.AsyncCallback,System.Object)
 ///     method.
 /// </summary>
 public WebHeaderCollection Headers
 {
 get
 {
 return request.Headers;
 }
 set
 {
 request.Headers = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets or sets the method for the request.
 ///
 /// Returns:
 ///     The request method to use to contact the Internet resource. The default value
 ///     is GET.
 ///
 /// Exceptions:
 ///   System.ArgumentException:
 ///     No method is supplied.-or- The method string contains invalid characters.
 ///
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 ///
 ///   System.NotSupportedException:
 ///     The System.Net.HttpWebRequest.Method property is not GET or POST.
 /// </summary>
 public string Method
 {
 get
 {
 return request.Method;
 }
 set
 {
 request.Method = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets the original Uniform Resource Identifier (URI) of the request.
 ///
 /// Returns:
 ///     A System.Uri that contains the URI of the Internet resource passed to the
 ///     System.Net.WebRequest.Create(System.Uri) method.
 ///
 /// Exceptions:
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 /// </summary>
 public Uri RequestUri
 {
 get
 {
 return request.RequestUri;
 }
 }
 #endregion

 public Stream GetRequestStream()
 {
 // start the asynchronous operation
 request.AllowReadStreamBuffering = false;
 request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), request);

 // Keep the main thread from continuing while the asynchronous
 // operation completes. A real world application
 // could do something useful such as updating its user interface.
 getRequestDone.WaitOne();

 Stream result = requestStream;

 // Avoid keeping an unnecessary ref on the stream in this object
 requestStream = null;

 return result;
 }

 private void GetRequestStreamCallback(IAsyncResult asynchronousResult)
 {
 request = (HttpWebRequest)asynchronousResult.AsyncState;
 requestStream = request.EndGetRequestStream(asynchronousResult);

 getRequestDone.Set();
 }

 public HttpWebResponse GetResponse()
 {
 // Start the asynchronous operation to get the response
 request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);

 getResponseDone.WaitOne();

 HttpWebResponse result = response;

 // Avoid keeping an unnecessary ref on the response in this object
 response = null;

 return result;
 }

 private void GetResponseCallback(IAsyncResult asynchronousResult)
 {
 request = (HttpWebRequest)asynchronousResult.AsyncState;

 // End the operation
 response = (HttpWebResponse)request.EndGetResponse(asynchronousResult);

 getResponseDone.Set();
 }

 }
}

Cette exception m’a donné un peu de fil à retordre, je vais donc partager ma solution avec vous.
Dans le cadre d’un projet C#, il arrive qu’on ait besoin d’utiliser des libraires (.DLL) non managées. Pour l’impétrant ce n’est pas forcément une balade de santé…  même en demandant à Google.
La documentation MSDN est un peu fouillis et on clique de lien en lien sans vraiment trouver de quoi se dépêtrer.

Je ne prétends pas que la solution que je vais vous proposer est la meilleure (si des experts veulent réagir, vous êtes les bienvenus), mais elle à le mérite de fonctionner.

Ma problématique était la suivante : « J’ai trouvé un source C++ génial sur le net qui fait exactement ce que je veux, et j’aimerais l’utiliser dans mon application C#. »

Ceci dit cet article peut vous aider si vous cherchez simplement à utiliser une DLL quelconque en C# (sautez à l’étape deux).

• Etape 1 (facile) : Je fais quoi de mon source C++ ?

  Vous m’aurez vu venir de loin… pour utiliser notre fameux code C++ nous allons créer une DLL.
  Pour cela, il faut créer un nouveau projet C++ au sein de la solution :

  • Visual C++, Win32 Console Application, puis cocher DLL et Empty project dans l’assistant de création

  Ensuite, on importe les sources dans VC++ (je pars du principe que vous savez utiliser C++ et VC++, le cas échéant, vous devriez trouver moult aide sur le net).

  Enfin on ajoute au projet C++ un .h et .cpp pour l’interface de notre DLL. Dans ce fichier on déclare (.h) et écrit (.cpp) les fonctions que l’on souhaite exposer dans la DLL (aka, utiliser depuis C#).

  Cela peut être simplement des appels vers les fonctions qui vous interessent dans le code C++ ou, et là est l’intérêt, des fonctions qui machent un peu le travail avant de passer la main à C#.
  Pourquoi donc ? Car l’on ne peut exporter une classe de C++ vers .Net, car pour l’instant, le framework ne supporte pas __thiscall. Il va donc falloir se contenter de fonctions échangeant :

  • Des types simples (bool, int, double…)
  • Des pointeurs
  • Des structs

  Pour déclarer une fonction exportée dans la DLL, il suffit de faire précéder sa déclaration (dans le .h donc) de :  __declspec(dllexport)

  Voici en exemple, un bout de mon code, brut de décoffrage. Je cherche à utiliser une classe : voronoicell, je vais donc l’instancier dans ma DLL en tant variable globale statique (car je ne peux pas la manipuler en C#, du moins pas de façon simple), puis les fonctions que j’expose dans la DLL me permettent de jouer avec la-dite instance de classe.

  Fichier dllinterface.h

  #ifndef _VORO_DLL_INTERFACE_
  #define _VORO_DLL_INTERFACE_

  /*
  * Voro++ DLL Interface * ==================== * Port of the library Voro++ (only basic functions) as a DLL file, exposing some basics features.
  * Made in order to be integrated in a C# project.
  *
  * Author : Pierre BELIN, 2009.
  */

  namespace VoroDLL
  {
  extern « C »
  {
  __declspec(dllexport) void SCAInit(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
  __declspec(dllexport) void SCAPlane(double x, double y, double z, double rsq);
  __declspec(dllexport) void SCACleanup(void);
  }
  }

  #endif

  Fichier dllinterface.cpp

  #include « dllinterface.h »
  #include « voro++.cc.h »

  // Note : Compile with /EHsc /LD

  namespace VoroDLL
  {

  static voronoicell * SCA;

  void SCAInit(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)
  {
  if(SCA != NULL)
  delete SCA;

  SCA = new voronoicell();
  SCA->init((fpoint)xmin, (fpoint)xmax, (fpoint)ymin, (fpoint)ymax, (fpoint)zmin, (fpoint)zmax);
  }

  void SCAPlane(double x, double y, double z, double rsq)
  {
  SCA->plane((fpoint)x, (fpoint)y, (fpoint)z, (fpoint)rsq);
  }

  void SCACleanup(void)
  {
  delete SCA;
  }
  }

  Il ne reste plus qu’a compiler et linker tout ça pour obtenir une jolie petite DLL.

• Etape 2 : Et pour l’utiliser en C# ?
  

  C’est à cette étape que j’ai eu quelques soucis à faire quelque chose qui fonctionne à l’aide de la documentation.

  Premièrement, pour ne pas se prendre la tête avec les chemins, car Visual Studio, ce gros malin, ne place pas les résultats d’un build C# et d’un build C++ d’une même solution dans les mêmes répertoires par défaut, il est de bon ton de régler le chemin de sortie de votre projet C# à la racine de votre solution.

  • En Debug : VC# sors le projet dans -Solution-/-ProjetC#-/bin/x86/Debug, et VC++ dans -Solution-/Debug.
  • En Release : VC# sors le projet dans -Solution-/-ProjetC#-/bin/x86/Release, et VC++ dans -Solution-/Release.

  Changer les propriétés du projet C# pour une sortie dans ../Debug et ../Release fera l’affaire, et votre .exe C# se trouvera donc dans le même répertoire que votre .dll C++, ce qui épagnera des erreurs « Je trouve pas ta DLL mon coco » à l’exécution.

  Ensuite pour utiliser une DLL non managée au sein de C#, il faut faire appel à DLLImport et au package System.Runtime.InteropServices;
  Personellement, j’ai écrit une classe qui ‘wrappe’ ma DLL, voici ce que ça donne :

  Fichier Voro++.cs :

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

  namespace xxx.Analysis
  {

  /// <summary>
  /// Voro++ DLL Interface
  /// ====================
  /// Port of the library Voro++ (only basic functions) as a DLL file, exposing some basics features.
  /// This library allows to compute Voronoi cells in a 3D space.
  ///
  /// Author : Pierre BELIN, 2009.
  /// </summary>

  class VoroPP
  {[DllImport("Voro++.dll", EntryPoint = "#2")]
  private static extern void _Init(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
  [DllImport("Voro++.dll", EntryPoint = "#3")]
  private static extern void _Plane(double x, double y, double z, double rsq);
  [DllImport("Voro++.dll", EntryPoint = "#1")]
  private static extern void _Cleanup();

  public static void Cleanup()
  {

  try
  {
  _Cleanup();

  }
  catch (Exception e)
  {
  MessageBox.Show(« Error interacting with Voro++.dll : «  + e.Message, « DLL Error », MessageBoxButtons.OK, MessageBoxIcon.Error);
  Application.Exit();
  }

  }

  public static void Init(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)
  {

  try
  {
  _Init(xmin, xmax, ymin, ymax, zmin, zmax);

  }
  catch (Exception e)
  {
  MessageBox.Show(« Error interacting with Voro++.dll : «  + e.Message, « DLL Error », MessageBoxButtons.OK, MessageBoxIcon.Error);
  Application.Exit();
  }

  }

  public static void Plane(double x, double y, double z, double rsq)
  {

  try
  {
  _Plane(x, y, z, rsq);
  }
  catch (Exception e)
  {
  MessageBox.Show(« Error interacting with Voro++.dll : «  + e.Message, « DLL Error », MessageBoxButtons.OK, MessageBoxIcon.Error);
  Application.Exit();
  }

  }

  }

  }

  Vous l’aurez donc compris, pour faire appel à votre fonction exportée, il faut reprendre son prototype en la déclarant static extern et en ajoutant le préfixe DLLImport : [DllImport("Ma DLL", EntryPoint = "Un numéro obscur ou le nom de la fonction")]

  L’EntryPoint est sensé marcher avec les noms de fonctions automatiquement…
  Cependant, selon la façon dont à été codée la DLL que vous voulez utiliser, vous pouvez vous manger l’exception en tête d’article…
  La parade dans ce cas est d »appeler les fonctions via leur numéro ordinal, c’est plus moche mais ça fonctionne.

  Pour trouver le numéro ordinal correspondant à votre fonction, il faut ouvrir la DLL avec laquelle vous voulez jouer avec un petit utilitaire, par exemple DLL Export Viewer :

  
  Sinon, comme vous pouvez le voir, je n’utilise pas directement les fonctions de DLL, histoire de pouvoir prendre en compte les exceptions pouvant arriver lors de l’exécution, typiquement DLLNotFound et EntryPointNotFound.
  J’espère vous avoir épargné quelques moments de tâtonnements et frustration

Plus d’infos :

• La plupart de ce qu’il faut savoir (en anglais), par Paul DiLascia : http://msdn.microsoft.com/en-us/magazine/cc301501.aspx

Je ne suis pas un grand expert C/C++ mais j’ai eu affaire à une chose étrange aujourd’hui, qui m’aura couté (et à d’autres) de longues heures.

Erreur de l’éditeur de lien : error LNK2019: unresolved external symbol « short __cdecl ga_population_seed(struct population_t *) »

Le contexte, une solution C/C++ principalement écrite en C, dont deux des projets sont une librairies (sortie en .lib) C (GAUL : Genetic Algorithm Utility Library pour ne pas la citer).

La compilation se passe sans heurts (ceci dit, nous avons du modifier un petit peu la version soit disant Windows de GAUL pour qu’elle fonctionne sous VS2008 – soucis de #define, etc… assez triviaux dans l’ensemble). Mais le linking est une catastrophe, impossible pour VS de trouver les fonctions définies dans le header de notre librairie. Diantre !

Et bien le souci vient de la configuration du projet par défaut sous Visual Studio. En effet celui ci nous propose de choisir entre un compilateur C, et un compilateur C++, mais son choix par défaut semble être un étrange et indigeste mix des deux !

Tentative d’explication :

- Le compilateur par défaut (qui accepte de compiler sans broncher) doit déclarer nos fonctions (dans les .obj) d’une maniere differente de celle attendue par le linker ( __cdecl blah-blah-blah)

La solution :

- Forcer le compilateur a utiliser le compilateur C++ (ou C suivant votre convenance)

- Corriger les erreurs levées par le compilateur (et ca peut etre long, dans notre cas GAUL utilise moult attributions de pointeurs sans cast, déclare des fonctions s’appelant new ou delete, … – environ 300 erreurs au total chez nous).

Et voila, ça devrait linker correctement maintenant !

On remercie Ben pour avoir trouvé la solution !