Blog de Nico-pyright(c) » C++/CLI

Renouvellement MVP

nico-pyright(c) — Mon, 05 Jan 2009 19:00:00 +0000

Me voici à nouveau renouvelé pour cette année 2009, toujours à votre service.

J’en profite pour vous adresser mes meilleurs voeux pour cette année, puisse-t-elle être encore pleine de .NET, de tutoriels et de questions marquées résolues

[C++/CLI] Mise à jour de la FAQ C++/CLI.

nico-pyright(c) — Wed, 08 Oct 2008 23:00:00 +0000

Voilà une petite mise à jour de la FAQ C++/CLI.

Au programme, 250 réponses à vos questions, dont 29 nouvelles.

Aller consulter la FAQ C++/CLI

[C++/CLI] Comment créer un Wrapper C++/CLI, exemple de compression en .Cab

nico-pyright(c) — Sat, 27 Sep 2008 08:58:09 +0000

on me demande souvent comment créer un wrapper C++/CLI …

Je vais, dans ce post, vous guider dans la création d’un tel wrapper.
Pour l’exemple, je vais utiliser la très bonne bibliothèque de compression en .Cab, créée par Elmue sur CodeProject.

Cette bibliothèque possède une version C++ et une version .Net, cette dernière ayant été créé avec le Managed C++ de Visual Studio 2002, je vais vous montrer comment on peut encapsuler la version C++ pure dans un wrapper C++/CLI afin de l’utiliser avec vos projets .Net.

Pour cet exemple, je vais encapsuler uniquement la compression, donc je vais soulager le projet C++ de quelques fichiers et je vais les modifier pour retirer les références à ces fichiers inutiles.

J’ai donc cette liste de fichier qui vont me servir :
– Blowfish.h
– Compress.h
– Error.h
– File.h
– Map.h
– String.h

(notez que j’ai renommé les fichiers .hpp en .h parce que j’aime mieux …)

Je créé ensuite un nouveau projet CLR : Class Library que j’appelle CabUtil (il est donc compilé avec l’option /clr).
J’y ajoute les fichiers précédemment cités, je compile … et c’est presque terminé !
La fonctionnalité nommée C++ Interop a fait tout le boulot pour nous. Elle a compilé du code natif dans notre assembly .Net.

Passons désormais à la création du wrapper C++/CLI, qui fera office de wrapper et de façade en même temps.

Je créé une nouvelle classe, que j’appelle CabUtil.

Ici, je n’ai pas grand chose à wrapper, mais nous allons le faire quand même. On remarque qu’on a besoin d’un char * qui représente la clé de cryptage du .Cab.

Créons donc un membre privé de type char *

char * s8_EncryptionKey;

Je vais lui affecter une valeur par défaut dans mon constructeur :

CabCompress()
{
s8_EncryptionKey = new char[73];
strcpy(s8_EncryptionKey, "");
}

Maintenant, on va créer une propriété qui va exposer une String ^ .Net et qui se chargera de convertir en char * :

property String ^EncryptionKey
{
void set(String ^value)
{
if (value->Length > 72)
value = value->Substring(0, 72);
char* temp = static_cast(Marshal::StringToHGlobalAnsi(value).ToPointer());
strcpy(s8_EncryptionKey, temp);
Marshal::FreeHGlobal(safe_cast(temp));
}
}

Note : la clé ne peut pas dépasser 72 caractères.

Bien sur, il ne faudra pas oublier de désallouer le char * dans les destructeurs et finalizers :

~CabCompress()
{
delete s8_EncryptionKey;
s8_EncryptionKey = NULL;
}

protected:
!CabCompress()
{
delete s8_EncryptionKey;
s8_EncryptionKey = NULL;
}

Je vais maintenant passer à l’écriture d’une méthode qui va compresser une liste de fichier, cette méthode étant une façade pour un algorithme un peu plus complexe.
Il s’agit de la méthode :

void CompressFileList(IDictionary^ fileList, String ^compressFile)

Elle prend en paramètre un dictionnaire qui va contenir le nom du fichier à compresser et sa destination dans l’arborescence du .Cab. Le deuxième paramètre est le fichier archive de destination.

Il y a dans cette méthode quelques conversions de String ^ en char *, mais nous n’allons pas nous attarder, vu qu’on a déjà vu le principe plus haut.
L’autre élément intéressant est le mapping d’une callback native en delegate .Net. Nous allons créer un événement pour être informé de la mise à jour du status de la compression.

On avait en C++, la définition suivante pour gérer la callback :

Cabinet::CCompress::kCallbacks k_ComprCallbacks;
k_ComprCallbacks.f_UpdateStatus = &CMain::OnUpdateStatus;

avec la méthode statique associée :

static int CMain::OnUpdateStatus(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param)
{
...
}

pour wrapper ceci, nous allons créer un delegate, dans les membres privés :

[UnmanagedFunctionPointer(CallingConvention::StdCall)]
delegate int WrapperUpdateStatusHandler(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param);
WrapperUpdateStatusHandler ^UpdateStatusDelegate;

Notez que le delegate a bien sur la même signature que la méthode OnUpdateStatus.

Dans notre méthode, on pourra instancier notre delegate ainsi :

UpdateStatusDelegate = gcnew WrapperUpdateStatusHandler(this, &CabCompress::UpdateStatus);

qui est raccroché à la méthode

static int UpdateStatus(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param)

(les observateurs auront noté que j’ai changé le nom de la méthode C++, qui au passage, n’est plus statique)

Ensuite on utilise GetFunctionPointerForDelegate pour raccrocher ce delegate à la callback en C++

IntPtr p = Marshal::GetFunctionPointerForDelegate(UpdateStatusDelegate);
k_ComprCallbacks.f_UpdateStatus = (Cabinet::CCompress::kCallbacks::t_UpdateStatus)p.ToPointer();
i_Compress.SetCallbacks(&k_ComprCallbacks);

Maintenant, la méthode UpdateStatus pourra lever l’événement suivant (qu’on aura défini comme membre public de la classe) :

delegate void UpdateStatusHandler(int PercentComplete);
event UpdateStatusHandler ^OnUpdateStatus;

int UpdateStatus(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param)
{
if (pk_CurStatus->FolderPercent > 0)
OnUpdateStatus(pk_CurStatus->FolderPercent);
return 0;
}

Et voilà, il ne nous reste plus qu’à compiler et notre assembly est prête.

Reste à l’utiliser dans un programme C#. Pour ce faire, on référence cette assembly dans notre projet, et on peut appeler la méthode de compression ainsi :

static void Main()
{
CabCompress c = new CabCompress();
c.OnUpdateStatus += c_OnUpdateStatus;
Dictionary dictionary = new Dictionary
{
{"C:\\test.txt", "C\\test.txt"},
{"C:\\temp\\fichier.mp3", "C\\temp\\fichier.mp3"}
};
c.CompressFileList(dictionary, "C:\\OutPut_%d.cab");
}

static void c_OnUpdateStatus(int PercentComplete)
{
Console.WriteLine("Compression : {0} %", PercentComplete);
}

Vous pouvez télécharger les sources de cet exemple : version zip ou version rar

[Winforms] [C++/CLI][C#] Databinding Bidirectionnel avec les Winforms

nico-pyright(c) — Sun, 21 Sep 2008 08:30:58 +0000

Le binding bidirectionnel consiste à « associer » une propriété de classe à un controle de Formulaire.

Par exemple, j’ai un textbox sur ma form qui est associé à une chaine (String) dans ma classe. Toute modification de ce textbox entraine automatiquement une modification de ma chaine. Inversement, toute modification de cette chaine en code, implique une répercution visuelle sur la valeur du textbox.

Voici comment implémenter un tel binding :

Le principe est d’utiliser l’interface INotifyPropertyChanged. L’appel de l’événement PropertyChanged permet d’informer que la valeur a changé et automatiquement répercuter ce changement.

Voici comment faire en C++/CLI (plus loin, la version C#) :

Tout d’abord, la form doit implémenter INotifyPropertyChanged

public ref class Form1 : public System::Windows::Forms::Form, INotifyPropertyChanged

Ceci implique de définir l’événement suivant :

virtual event PropertyChangedEventHandler ^PropertyChanged;

Il nous faut ensuite une propriété de type String. C’est cette propriété qui sera bindée à notre TextBox :

private:
String ^_chaine;
public:
property String ^Chaine
{
String ^ get() { return _chaine; }
void set(String ^value)
{
if (value != _chaine)
{
_chaine = value;
NotifyPropertyChanged("Chaine");
}
}
}

On note l’appel à la méthode NotifyPropertyChanged pour indiquer une changement de valeur.

private:
void NotifyPropertyChanged(String ^info)
{
PropertyChanged(this, gcnew PropertyChangedEventArgs(info));
}

La méthode NotifyPropertyChanged appelle l’événement PropertyChanged pour signaler le changement afin qu’il soit répercuté à tous les endroits où le binding est effectué.

Ne pas oublier de définir le binding, au plus tot, dans le form_load par exemple :
textBox1->DataBindings->Add("Text", this, "Chaine");

Et le tour est joué.

Voici la syntaxe pour du C# :

public partial class Form1 : Form, INotifyPropertyChanged

private string _chaine;
public string Chaine
{
get { return _chaine; }
set
{
if (value != _chaine)
{
_chaine = value;
NotifyPropertyChanged("Chaine");
}
}
}

private void Form1_Load(object sender, EventArgs e)
{
textBox1.DataBindings.Add("Text", this, "Chaine");
}

public event PropertyChangedEventHandler PropertyChanged;

private void NotifyPropertyChanged(String info)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(info));
}
}

[C#][Winforms] Ne lancer qu’une seule instance de son application

nico-pyright(c) — Thu, 18 Sep 2008 20:00:00 +0000

Pour ce faire, on va utiliser un mutex

Il suffit d’encadrer l’instanciation par défaut de la form dans le fichier Program.cs

bool owned;
Mutex mutex = new Mutex(true, "Mon_Mutex_Pour_Mon_Application", out owned);
if (owned)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
mutex.ReleaseMutex();
}
else
MessageBox.Show("L'application est déjà lancée");

Et voilà

[C++/CLI] Enregistrer un fichier avec SaveFileDialog

nico-pyright(c) — Fri, 11 Jul 2008 20:00:00 +0000

J’étais passé rapidement sur ce point dans mon tutoriel d’introduction aux winforms, je reviens dessus vu que ca ne semble pas assez clair

Pour enregistrer le contenu d’un textbox avec une SaveFileDialog, il suffit d’utiliser le stream fournir par OpenFile :

saveFileDialog1->Title = "Sélectionnez un fichier";
saveFileDialog1->FileName = nullptr;
saveFileDialog1->DefaultExt = "txt";
saveFileDialog1->Filter = "Fichiers Texte (*.txt)|*.txt|Tous (*.*)|*.*";
if (saveFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK)
{
Stream ^s = saveFileDialog1->OpenFile();
StreamWriter ^sw = gcnew StreamWriter(s);
sw->Write(textBox1->Text);
sw->Close();
}

C’est tout

[C++/CLI] Un addin reflector pour le C++/CLI

nico-pyright(c) — Thu, 20 Mar 2008 20:00:00 +0000

Je viens de tomber sur un addin de reflector qui permet d’avoir le code en C++/CLI.

C’est encore en version Alpha, mais ca a l’air de plutot pas trop mal marcher.

C’est ici que ca se passe : http://www.sandpapersoftware.com/Main/Reflector.html

En tous cas, moi ca m’éclate

[C# et C++/CLI] Sérialisation et désérialisation binaire

nico-pyright(c) — Thu, 06 Mar 2008 20:00:00 +0000

Pour sérialiser et désérialiser en binaire, on va utiliser l’objet BinaryFormatter qui fait partie du namespace System.Runtime.Serialization.Formatters.Binary.

Combiné à un MemoryStream pour que ca se fasse en mémoire, voilà en résultat deux méthodes génériques (une version C++/CLI et une version C#):

Exemple en C++/CLI

using namespace System;
using namespace System::IO;
using namespace System::Runtime::Serialization::Formatters::Binary;

generic
String^ Serialize(T obj)
{
BinaryFormatter^ bf = gcnew BinaryFormatter();
MemoryStream^ ms = gcnew MemoryStream();
bf->Serialize(ms, obj);
array^ buff = ms->ToArray();
ms->Close();
return Convert::ToBase64String(buff);
}

generic
T DeSerialize(String ^val)
{
array^ buff = Convert::FromBase64String(val);
BinaryFormatter ^bf = gcnew BinaryFormatter();
MemoryStream ^ms = gcnew MemoryStream(buff);
T result = (T) bf->Deserialize(ms);
ms->Close();
return result;
}

int main(array ^args)
{
array ^ tabASerialiser = gcnew array {"abc", "def", "ghi"};
array ^ tab2ASerialiser = gcnew array { 123, 456, 789 };

// serialisation
String ^val = Serialize(tabASerialiser);
String ^val2 = Serialize(tab2ASerialiser);

// deserialisation
array ^ result = DeSerialize ^>(val);
array ^ result2 = DeSerialize ^>(val2);

for (int i = 0 ; i < result->Length ; i++)
Console::WriteLine(result[i]);
Console::WriteLine();
for (int i = 0; i < result->Length; i++)
Console::WriteLine(result2[i]);
return 0;
}

Exemple en C#

public static string Serialize(T obj)
{
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
bf.Serialize(ms, obj);
byte[] buff = ms.ToArray();
ms.Close();
return Convert.ToBase64String(buff);
}

public static T DeSerialize(string val)
{
byte[] buff = Convert.FromBase64String(val);
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream(buff);
T result = (T) bf.Deserialize(ms);
ms.Close();
return result;
}

static void Main()
{
string[] tabASerialiser = new string[] {"abc", "def", "ghi"};
int[] tab2ASerialiser = new int[] { 123, 456, 789 };

// serialisation
string val = Serialize(tabASerialiser);
string val2 = Serialize(tab2ASerialiser);

// deserialisation
string[] result = DeSerialize(val);
int[] result2 = DeSerialize(val2);

for (int i = 0 ; i < result.Length ; i++)
Console.WriteLine(result[i]);
Console.WriteLine();
for (int i = 0; i < result.Length; i++)
Console.WriteLine(result2[i]);
}

NB : J’utilise une conversion en base 64 car dans mon cas, j’ai eu besoin de stocker l’information sérialisée sous forme de chaine.

[C#] Une PictureBox qu’on peut déplacer et redimensionner à la souris

nico-pyright(c) — Fri, 15 Feb 2008 20:00:00 +0000

J’ai écrit vite fait cette petite classe qui surcharge la classe PictureBox pour les besoins d’un copain. Et puis, je me dis qu’il pourrait être bon d’en faire profiter tout le monde.

Au menu, une surcharge de l’événement Paint et un dessin de rectangle (très moche, je sais ) et les surcharges des événements de click souris (down et up) et de son mouvement.

class MaPictureBox : PictureBox
{
private bool isResizing;
private bool isCandidateToResize;
private Point positionClick;

protected override void OnPaint(PaintEventArgs pe)
{
base.OnPaint(pe);
if (isResizing)
{
pe.Graphics.DrawRectangle(new Pen(Color.Red), new Rectangle(0, 0, Width - 1, Height - 1));
}
}

protected override void OnMouseMove(MouseEventArgs e)
{
if (isResizing)
{
Width = e.X;
Height = e.Y;
SizeMode = PictureBoxSizeMode.StretchImage;
}
else
{
if (e.X >= Width - 4 && e.Y >= Height - 4)
{
Cursor = Cursors.SizeNWSE;
isCandidateToResize = true;
}
else
{
isCandidateToResize = false;
if (!isResizing)
{
if (e.Button == MouseButtons.Left)
{
Location = new Point(Location.X + e.X - positionClick.X, Location.Y + e.Y - positionClick.Y);
}
Cursor = Cursors.Arrow;
}
}
}
Refresh();
base.OnMouseMove(e);
}

protected override void OnMouseDown(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (isCandidateToResize)
{
isResizing = true;
Refresh();
}
else
{
isResizing = false;
positionClick = e.Location;
}
}
base.OnMouseDown(e);
}

protected override void OnMouseUp(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
isResizing = false;
isCandidateToResize = false;
Refresh();
}
base.OnMouseUp(e);
}
}

C’est pas du tout optimisé, mais bon, c’est une première base.

Ca s’utilise comme une picturebox bien sur :

MaPictureBox pic = new MaPictureBox();
pic.Image = Image.FromFile(@"C:\test.png");
pic.Width = pic.Image.Width;
pic.Height = pic.Image.Height;
Controls.Add(pic);

Télécharger le programme de test

[C++/CLI] Participez à l’augmentation de la bibliothèque marshal_as

nico-pyright(c) — Thu, 14 Feb 2008 20:00:00 +0000

Une nouveauté dans visual studio 2008 est l’utilisation du template marshal_as pour faire du marshaling.

Incomplète encore à l’heure actuelle, retrouvez le blog dédié à son enrichissement à cette adresse : http://www.marshal-as.net/
Vous pouvez également envoyer vos contributions à Kate Gregory