cross_lang_inherit_managed_c_plusplus

Herencia cruzada de idiomas en .NET

Una introducción a la herencia entre idiomas en .NET.

Introducción

La introducción de .NET hace que el desarrollo de lenguajes sea más sencillo que nunca. Ya no necesitamos preocuparnos por usar contenedores ATL en C++ para acceder a componentes de VB, ni por llamar a convenciones cuando intentamos interactuar con código FORTRAN. Todos los lenguajes habilitados para .NET son ahora entidades de primera clase e interoperan sin problemas, lo que permite que sistemas dispares trabajen juntos más fácilmente que nunca y también permite a los desarrolladores con diferentes habilidades trabajar juntos en armonía en proyectos.

Creando un componente .NET

Crear un componente en un idioma que pueda ser utilizado en otro idioma es muy sencillo. Utilice el Asistente de Visual Studio.NET para crear una biblioteca de clases en su lenguaje .NET favorito, compílelo y listo.

Por ejemplo, crearemos una clase simple en C# que exponga dos métodos:

 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;
		}
	}
}

El primer método, MyMethod , toma un objeto de cadena y devuelve su longitud. El segundo método es virtual y devuelve el cuadrado del número pasado. Supongamos que hemos compilado este componente en MyCSClass.dll .

Usando un componente .NET en C++ administrado

Para consumir este componente usando C++ administrado, primero debemos importar el ensamblado a nuestro programa:

# using " MyCSClass.dll "

Eso es todo. Sin bibliotecas de tipos, sin archivos .def, sin encabezados ATL. Simplemente usamos la declaración #using (y nos aseguramos de que el dll esté en la ruta de búsqueda del compilador) y dejamos que el compilador haga el resto.

Una vez que hayamos importado la clase, podemos usar la declaración using para ahorrarnos escribir:

 using namespace MyCSClass ;

Tenga en cuenta la diferencia aquí: #using es para importar un ensamblaje a su proyecto. using especifica el espacio de nombres con el que trabajaremos y simplemente ahorra escribir.

En realidad, consumir la clase es lo mismo que usar cualquier otro tipo de referencia administrada en .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 

Herencia cruzada de idiomas

La interoperabilidad entre idiomas va más allá de simplemente facilitar el uso de componentes escritos en diferentes idiomas. También podemos heredar nuevas clases de componentes escritos en otros lenguajes, sin necesidad del código fuente original del componente .

Imagine que ha comprado o adquirido algún componente genial que le encanta usar, pero que le gustaría tener una o dos funciones más, o que hiciera algo ligeramente diferente. En .NET puede heredar una nueva clase de ese componente para crear un nuevo componente que funcione exactamente como le gustaría. No está creando un contenedor para el componente: está creando un nuevo componente que deriva sus propiedades, métodos y campos y que puede anular los métodos virtuales del componente anterior y agregar nuevos métodos.

Volvamos a nuestro ejemplo. El método CSClass::MyVirtualMethod es virtual, así que declaremos una nueva clase de C++ que se derive de esta clase de C# y anulemos ese método virtual.

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

Hemos anulado CSClass::MyVirtualMethod con nuestro nuevo método que devuelve el cubo, no el cuadrado, del número dado. Una vez que compilamos el código, tenemos un nuevo componente C++ que anula el método virtual en la clase C# y también tiene la función MyMethod() no virtual.

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

La descarga adjunta a este artículo contiene un componente C# y VB.NET que es consumido y heredado por un componente C++.

Conclusión

La interoperabilidad entre idiomas le permite ampliar componentes de terceros con su propia funcionalidad de forma orientada a objetos. Puede trabajar fácilmente con componentes en cualquier lenguaje compatible con CLS y, durante la depuración, puede recorrer las llamadas a funciones entre componentes y entre idiomas en la misma aplicación. El manejo de excepciones también es consistente en todos los idiomas. Si un componente en un idioma genera una excepción, puede detectarse y manejarse mediante código escrito en otro idioma. Lo más importante es que le permite a usted y a su equipo la libertad de elegir el idioma en el que desean trabajar.

Historia

16 de octubre de 2001 - actualizado para beta 2