Para empezar diremos que se trata de un libro muy técnico y demasiado avanzado en algunos aspectos, tanto, que más del 50% del mismo no te sirve para nada como conocimientos prácticos. Eso sí, el resto es toda una gozada en cuanto a detalles de esos que hacen que te tires un par de días buscando por qué te falla tu programa y qué estás haciendo mal, para descubrir una acumulación de características más o menos oscuras del lenguaje, de la herramienta de desarrollo, del sistema operativo o incluso de todos a la vez que determinan el fallo. Mención especial sobre este tipo de cosas es el capítulo dedicado a los destructores y a toda la parafernalia relativa al Dispose y compañía.
El libro presupone que sabes C++/CLI, y no poco. Apenas entra a nombrar características de C++ si no es cuando está explicando cosas relativas al Interop y que afecten directamente al propio C++/CLI. También está en cierta medida centrado en el .NET, o más bien en aquellos detalles del .NET que no están presentes en otros lenguajes pero sí en C++/CLI; al autor no se le caen los anillos si tiene que mostrarnos código MSIL o pseudocódigo para explicarnos alguna característica preponderante.
Los primeros capítulos son flojitos –es un decir-, y comienzan donde otros libros terminan: modelos de compilación, puntos de entrada manejados en DLL, envoltura de bibliotecas nativas, para luego pasar a contarnos un montón de cosas sobre los tipos del .NET, cómo se almacenan en memoria, diferencias entre tipos valor y tipos referencia y cosas así. La verdad es que esta parte se suele encontrar en la mayoría de libros generales sobre el tema, pero al estar enfocada a C++/CLI no creo que se cubra en muchos otros volúmenes.
Lo siguiente es una somera explicación de los ensamblados, la E/S, el modelo de excepciones, acceso a Web, funciones de ayuda integradas en el código y muy poco sobre ficheros de configuración. Otra vez algo que suele aparecer en otros libros, pero aquí está tratado de pasada, como si el autor lo mencionara para recordarnos lo que pudiéramos haber olvidado cuando estudiamos C#, o más bien nos viene a decir que en C++/CLI también tenemos de eso.
Y ya nos olvidamos de los caramelitos. Ahora viene el hardcore puro y duro. Un capítulo sobre ensamblados, cómo funciona la CAG, metadatos, reflexión y cosas de esas. Finaliza con un toque de serialización de componentes.
Estamos ya en el capítulo 5. Este también es otro capítulo típico, que no puede faltar en ningún libro, y es que nos cuenta sobre los tipos, cómo se inicializan, clases, herencia, componente, etc. Pero el modo de tratarlo no es el habitual, profundizando, sino que a vuelapluma nos explica que C++/CLI tiene de todo eso, y que si no los sabías, aquí no vas a encontrar quien te lo explique.
El siguiente capítulo tiene su miga. Se centra en aspectos técnicos sobre la construcción, cómo funciona el polimorfismo en C++/CLI y otros menesteres similares.
El tema de la integración con Visual Studio comienza, de nuevo, en donde otros libros terminan. Modelos de compilación, excepciones a través de ensamblados, mezcla de ficheros objeto nativos con manejados, ensamblados mixtos, cómo capturar excepciones de C++ y del Sistema Operativo dentro de un programa manejado (y viceversa), macros predefinidas y algo sobre plantillas. Ufff.
El siguiente también es típico, je je. Mezcla de tipos manejados y tipos nativos. Cómo tener un tipo manejado dentro de un tipo nativo, qué ocurre cuando tenemos un puntero a un tipo nativo dentro de uno manejado, objetos proxy, conversión de unos tipos en otros…
Y el que le sigue viene como consecuencia del anterior: transiciones manejadas/no manejadas. Cómo se producen, qué código se ejecuta y cómo. Por qué a veces se produce una doble o triple transición y la forma de evitarlas. Todo ello con medidas de tiempos (el código se publica al final del libro) y destripado de código vario.
Si yo digo: “Envolviendo bibliotecas nativas” todo el mundo sabe de qué hablo, ¿no? Pues no. Volvemos a empezar donde otros acaban, es decir, el autor supone que ya sabes hacerlo. Lo que no supone es que sabes cuales son las pifias y las ineficiencias más comunes.
Luego viene lo que he comentado en el primer párrafo y, aparte de los apéndices, el libro termina con jugoso capítulo explicando el startup de un programa .NET y mixto, es decir, destripa qué hace el cargador de arranque y qué hay antes del main() manejado y nativo. Toda una gozada.
Bueno, hasta aquí llegan las trescientas y pico páginas del libro técnico más denso que recuerdo haber leído (hay otro que se titula Arquitectura de computadores, que todavía no he leído –o más bien no he terminado de hacerlo-).
Es un libro que no recomiendo, por lo menos para avanzar en el estudio de C++/CLI, ya que, como he comentado, tiene poco de práctico, aunque su lectura y aprehensión significa una proeza intelectual bastante considerable.
La sensación que te da al leerlo es que el autor está tratando los temas por encima, de pasada y corriendo (salvo algunos capítulos concretos), lo que es completamente cierto. Como el API de Windows, sería más que una proeza llegar a aprender y conocer por completo y exhaustivamente todo lo que el .NET tiene para ofrecernos, sobre todo si nos centramos en los tiquismiquis del sistema.
Pues bien, hasta aquí llega esta entrada, y os emplazo para un futuro no muy lejano en el que comente dos nuevos libros, C++/CLI in action y mi actual libro de cuarto de baño: Reversing. Secrets of Reverse Engineering.
Se me olvidaba: el libro.