non, le c++ n’est pas mort !!!!! visual studio 2005 et le c++ introduction : pourquoi le c++/cli ?...

C++/CLI Code hybride : Comment re-utiliser du code existant avec le Framework .NET ?

Eric MitteletteEric Vernié

NON, LE C++ N’EST PAS MORT !!!!!

Agenda

Visual Studio 2005 et le C++Introduction : Pourquoi le C++/CLI ?C++/CLI : Eléments SyntaxiquesC++/CLI : Garbage collection et destruction déterministe ?C++/CLI : Code hybride ou comment mixer les codes natifs et managésConclusion : C++/CLI « first class langage for .NET »Le future

Visual Studio 2005 et C++

ISO C++ (98% de la norme)Syntaxe C++ qui cible du code natif

C++/CLISyntaxe C++ qui cible le Framework .NET

Introduction : Pourquoi le C++/CLI ?

Ré utiliser les compétences « fines/pointues » des développeurs C++On ne va pas ré écrire des millions de lignes de code pour une nouvelle plateforme : .NET

« We love your C++ Code »

Syntaxe déposée à l’ECMA et ISOTravail initié en 2002 avec les MC++ (Managed Extension for C++)Intégration de C++/CLI avec ISO-C++« LE » language de l’interopérabilité

Utiliser le Framework .NET de façon naturelle en C++

C++/CLI : Eléments Syntaxiques

Une option de compilation « primordiale »

/CLR : émettre du code MSILSupport de la syntaxe CLI « activée »Option pour le projet ou pour un fichier individuellement

Différentes sous option à /CLR/CLR : Pure/CLR : Safe


Notion d’ “adjective class”

Types C++ et CLR cohérents

Attention : pas d ’héritage multiple de « ref class »Attention : implémentation multiple d’ « interface class »

ref class A abstract { }; // abstractref class B sealed : A { }; // no further derivation ref class C : B { }; // error, B is sealed

ref class A abstract { }; // abstractref class B sealed : A { }; // no further derivation ref class C : B { }; // error, B is sealed

class N { /*…*/ }; // nativeref class R { /*…*/ }; // CLR reference type

value class V { /*…*/ }; // CLR value typeinterface class I { /*…*/ }; // CLR interface type

enum class E { /*…*/ }; // CLR enumeration type

class N { /*…*/ }; // nativeref class R { /*…*/ }; // CLR reference type

value class V { /*…*/ }; // CLR value typeinterface class I { /*…*/ }; // CLR interface type

enum class E { /*…*/ }; // CLR enumeration type


Pointers et Handles

Sur le tas natifComme d’hab pointeurs (*) stables indépendant du GC

Comme d’hab, attention aux fuites mémoire si pas de delete

Sur le tas managéHandles (^) sont des références d’ objets

Pas d’opérations arithmétiques dessus (cf. interior_ptr)

delete devient optionnel

Sur la pile (vraiment ?)Permet des destructions déterministes

TNatif* t1 = new TNatif;TNatif* t1 = new TNatif;

TNet^ t2 = gcnew TNet;TNet^ t2 = gcnew TNet;

T t3;T t3;


* est à ^ ce que & est à %


Propriété

ref class R { int mySize;public: property int Size { int get() { return mySize; } void set(int val) { mySize = val; } }};

R r;r.Size = 42; // use like a field

ref class R { int mySize;public: property int Size { int get() { return mySize; } void set(int val) { mySize = val; } }};

R r;r.Size = 42; // use like a field

ref class R {public: property int Size; // compiler-generated}; // get, set, and backing store

ref class R {public: property int Size; // compiler-generated}; // get, set, and backing store

Notation simplifiée


Delegate et évènement

delegate void D(int);

ref class R {public: event D^ e; // trivial event; // compiler-generated members

void f() { e(42); } // invoke it};

R^ r = gcnew R();r->e += gcnew D(this, &SomeMethod);r->e += gcnew D(SomeFreeFunction);r->f();

delegate void D(int);

ref class R {public: event D^ e; // trivial event; // compiler-generated members

void f() { e(42); } // invoke it};

R^ r = gcnew R();r->e += gcnew D(this, &SomeMethod);r->e += gcnew D(SomeFreeFunction);r->f();

Vous pouvez écrire, ajouter, enlever et déclencher vous même les évènements.


GenericSyntaxe des Generics ~comme celle des templatesAdmettent des contraintes et l’héritageInstancié à l’exécution

TemplateDisponible pour le C++/CLIGénéré au moment de la compilation

Les generics et les templates peuvent se combiner…

Attention casse tête chinois et rigueur demandée !

generic<typename T>where T : IFooref class GR { /* … */ };

generic<typename T>where T : IFooref class GR { /* … */ };


CLR arraysNotation [] non supportée en C++/CLI

array<int>^ a1 = gcnew array<int>(10);array<int>^ a2 = gcnew array<int> { 1, 2, 3 };array<int>^ a3 = { 1, 2, 3 };array<int>^ a4 = gcnew array<int>(10) { 1, 2 };

F(gcnew array<Component> { button1, button2 });

array<int, 2> a5 = gcnew array<int>(10, 20);array<int, 2> a6 = { { 1, 2, 3 }, { 4, 5, 6 } };

C++/CLI: Garbage collection et destruction déterministe ?

Chaque objet .Net est sous contrôle du « Garbage Collector »

La mécanique du « garbage collector » est un pré requis essentiel à tous développeurs C++/CLIGénération, Collection, Compactage, Pattern IDispose et Finalisation

Heap Managed> 3 private heap + 1 private heap pour les « Large Object »

Elément syntaxique~MaClasse et !MaClasse

C++/CLI: Garbage collection et destruction déterministe ?

Une classe qui implémente un Finalizer doit avoir un destructeur Evitons la duplication de code : appelons le finalizer dans le destructeur

ref class R { /* MORE CODE */

!R() { /* Clean-up value type resources */ }

~R() { /* Do early clean-up, clean-up ref classes */ this->!R(); }};

C++/CLI : Code hybride ou comment mixer les codes natifs et managésC++/CLI : le roi de l’interopérabilité

COM InteropPInvoke

Pour tous les languages .NET

C++ InteropIt Just Works !Tous les scenarii possible…et imaginable

Hosting de la CLRContrôle fin de l’exécution du code .NET

Par exemple dans votre code MFC…

C++/CLI : Code hybride ou comment mixer les codes natifs et managés

Ré utiliser votre existantMigration code VC6

Breaking changes (conformité à la norme ISO98)Un seul environnement de développement (VS2005)

Compilateur 64 bits, Optimisation du code (WPO PGO), support de l’OpenMP …. Et bien plus encore

Utilisation des .lib ou dll depuis VS2005Et inversement !

Gestion du code mixtePasser des données, des pointeurs de fonctions, faire des appels « croisés » entre le monde managé et le monde natif


Scenarii de code hybrideApps VC6 utilisent vos .lib VS2005Apps VS2005 utilise vos .lib VC6

Code Hybride (mixed code)Utiliser une classe native dans du code CLIUtiliser une classe CLI dans du code natifUtiliser de l’assembleur dans du code CLIUtiliser la BCL dans du code natifUtiliser les « Windows Forms » dans les MFC.NETmodule et .Obj + cl.exe !

Hosting de la CLR.

La boite à outils du développeur hybride

vcclr.h : gcroot<>, auto_gcroot<>AfxWindowsForms.h (MAKE_DELEGATE,/CLR System::Runtime::Interopservicespin_ptr<>, interior_ptr<>tblimp, tlbexpdllimport attributesLes APIs de hosting#pragma unmanaged


Conclusion : C++/CLI « first class langage for .NET »

Productivité du développeur accru par la BCLConfort du développeur via l’IDE VS2005Performance au rendez vous-même dans le code managé pur et le code mixteEcrire moins de code en C++/CLI qu’en C#!

Démonstrations

Création d’une ref class simpleDe MFC à .NET

IJW

Des Windows forms dans les MFC

Etude : WPF dans les MFC

Questions

Ressources

Retrouvez nos vidéos sur le site MSDN (FR)

http://www.microsoft.com/france/msdn/visualc/default.mspx

Site MSDN UShttp://msdn2.microsoft.com/en-us/visualc/default.aspx



non, le c++ n’est pas mort !!!!! visual studio 2005 et le c++ introduction : pourquoi le c++/cli ?...

Documents