cross_lang_inherit_managed_c_plusplus Télécharger - cross_lang_inherit_managed_c

cross_lang_inherit_managed_c_plusplus

VB.NET

1.0.0

Télécharger

Héritage multilingue dans .NET

Une introduction à l’héritage multilingue dans .NET.

Introduction

L’introduction de .NET rend le développement de langages plus simple que jamais. Nous n'avons plus à nous soucier de l'utilisation des wrappers ATL en C++ pour accéder aux composants VB, ni des conventions d'appel lorsque nous essayons d'interagir avec le code FORTRAN. Tous les langages compatibles .NET sont désormais des entités de premier ordre et interagissent de manière transparente, permettant à des systèmes disparates de travailler ensemble plus facilement que jamais, et permettant également aux développeurs possédant des compétences différentes de travailler harmonieusement ensemble sur des projets.

Création d'un composant .NET

Créer un composant dans un langage pouvant être utilisé par un autre langage est très simple. Utilisez l'assistant Visual Studio.NET pour créer une bibliothèque de classes dans votre langage .NET préféré, compilez-la et vous avez terminé.

Par exemple, nous allons créer une classe simple en C# qui expose deux méthodes :

 namespace MyCSClass
{
	using System;

	public class CSClass
	{
		public CSClass () { }
	
		// returns the length of the passed string
		public int MyMethod (string str)
	        {
			return str. Length ;
		}
	
		// returns n squared
		virtual public int MyVirtualMethod ( int n)
		{
			return n*n;
		}
	}
}

La première méthode, MyMethod , prend un objet chaîne et renvoie sa longueur. La deuxième méthode est virtuelle et renvoie le carré du nombre transmis. Supposons que nous avons compilé ce composant dans MyCSClass.dll .

Utilisation d'un composant .NET en C++ managé

Pour utiliser ce composant à l'aide du C++ managé, nous devons d'abord importer l'assembly dans notre programme :

# using " MyCSClass.dll "

C'est ça. Pas de bibliothèques de types, pas de fichiers .def, pas d'en-têtes ATL. Nous utilisons simplement l'instruction #using (et nous assurons que la DLL se trouve dans le chemin de recherche du compilateur) et laissons le compilateur faire le reste.

Une fois la classe importée, nous pouvons utiliser la déclaration using pour enregistrer la saisie :

 using namespace MyCSClass ;

Notez la différence ici : #using sert à importer un assembly dans votre projet. using spécifie l'espace de noms avec lequel nous allons travailler et enregistre simplement la saisie.

En fait, consommer la classe revient à utiliser n’importe quel autre type de référence géré dans .NET :

MyVirtualMethod(2); // will return 2 squared">

CSClass *cs = new CSClass();

int result;
result = cs-> MyMethod ( " Hello World " );  // will return 11
result = cs-> MyVirtualMethod ( 2 );       // will return 2 squared

Héritage multilingue

L'interopérabilité multilingue va plus loin que la simple facilité d'utilisation de composants écrits dans des langues différentes. Nous pouvons également hériter de nouvelles classes de composants écrits dans d'autres langages, sans avoir besoin du code source original du composant .

Imaginez que vous avez acheté ou acquis un composant super cool que vous aimez utiliser, mais que vous souhaiteriez avoir une ou deux fonctionnalités supplémentaires, ou qu'il fasse quelque chose de légèrement différent. Dans .NET, vous pouvez hériter d'une nouvelle classe de ce composant pour créer un nouveau composant qui fonctionne exactement comme vous le souhaitez. Vous ne créez pas de wrapper pour le composant : vous créez un nouveau composant qui dérive ses propriétés, ses méthodes et ses champs et qui peut remplacer les méthodes virtuelles de l'ancien composant et ajouter de nouvelles méthodes.

Revenons à notre exemple. La méthode CSClass::MyVirtualMethod est virtuelle, déclarons donc une nouvelle classe C++ dérivée de cette classe C# et remplaçons cette méthode virtuelle.

__gc class CPPClass : public MyCSClass ::CSClass
{
	public:
		// returns the cube of the given number
		virtual int MyVirtualMethod ( int n)
		{
			return n*n*n;
		}
};

Nous avons remplacé CSClass::MyVirtualMethod par notre nouvelle méthode qui renvoie le cube, et non le carré, du nombre donné. Une fois que nous avons compilé le code, nous avons un nouveau composant C++ qui remplace la méthode virtuelle dans la classe C# et possède également la fonction non virtuelle MyMethod() .

MyVirtualMethod(2); // Will output 2 cubed, not 2 squared">

CPPClass *cpp = new CPPClass();

int result;
result = cpp-> MyMethod ( " Hello World " ); // will return 11
result = cpp-> MyVirtualMethod ( 2 );      // Will output 2 cubed, not 2 squared

Le téléchargement accompagnant cet article contient un composant C# et un composant VB.NET qui sont consommés et hérités par un composant C++.

Conclusion

L'interopérabilité multilingue vous permet d'étendre des composants tiers avec vos propres fonctionnalités de manière orientée objet. Vous pouvez facilement travailler avec des composants dans n'importe quel langage compatible CLS, et lors du débogage, vous pouvez parcourir les appels de fonction entre les composants et entre les langages dans la même application. La gestion des exceptions est également cohérente dans toutes les langues. Si un composant dans un langage lève une exception, elle peut être interceptée et gérée par du code écrit dans un autre langage. Plus important encore, cela vous permet, à vous et à votre équipe, de choisir librement la langue dans laquelle ils souhaitent travailler.