La novedad esencial que incorporará la siguiente versión de C#, que formará parte de la propuesta conjunta que presentarán próximamente .NET Framework 4.5 y Visual Studio 11, es sin duda alguna el soporte a nivel de lenguaje para la programación asíncrona, tema que ya hemos tratado anteriormente en dNM. Este artículo describe una pequeña característica que completa la oferta de novedades de la versión 5.0 de C#: la información de llamada.

En el ocaso de la Ley de Moore, las transiciones a procesadores de múltiples núcleos, la computación aprovechando la GPU y la computación en la nube basada en Hardware as a Service (HaaS) no son tendencias separadas, sino aspectos de una misma tendencia: los ordenadores de uso común, desde equipos de escritorio hasta smartphones, se están transformando de manera permanente en clusters heterogéneos de superordenadores. De aquí en adelante, una aplicación independiente que realice cálculos intensivos necesitará poner a trabajar a diferentes tipos de núcleos, en cantidades inmensas, para hacer su trabajo. La comida gratis se terminó. Bienvenido ahora a la jungla del hardware.

En el ocaso de la Ley de Moore, las transiciones a procesadores de múltiples núcleos, la computación aprovechando la GPU y la computación en la nube basada en Hardware as a Service (HaaS) no son tendencias separadas, sino aspectos de una misma tendencia: los ordenadores de uso común, desde equipos de escritorio hasta smartphones, se están transformando de manera permanente en clusters heterogéneos de superordenadores. De aquí en adelante, una aplicación independiente que realice cálculos intensivos necesitará poner a trabajar a diferentes tipos de núcleos, en cantidades inmensas, para hacer su trabajo. La comida gratis se terminó. Bienvenido ahora a la jungla del hardware.

CQRS ha pasado a formar parte de nuestro techy-vocabulario durante estos últimos meses, y son muchas las preguntas que nos hacemos acerca de este, no tan nuevo, patrón de arquitectura. Llevo involucrado en mayor o menor medida con este patrón (que llegó a mi conocimiento gracias a mi buen amigo y compañero Hadi Hariri) desde hace algo más de un año. Este recurso, más la realización del curso "Arquitecturas SOA Distribuidas", que impartí en Londres de la mano de Udi Dahan, más la posterior puesta en práctica, me ha otorgado un punto de vista particularmente interesante, que me gustaría compartir en este artículo.

Este artículo presenta, de una manera práctica, las principales posibilidades que pondrá a disposición de los desarrolladores ASP.NET Web API, una API de tipo REST que próximamente hará su aparición oficial.

Hace ya un par de años que vimos a Anders Hejlsberg hacer una demo en la que ejecutaba interactivamente código C# al vuelo y hablar por primera vez de lo que serían los Servicios de compilación, avizorando, sin algarabía, lo que se venía preparando. Desde entonces aumentaron las expectativas de los que siempre hemos querido "interactuar" con los compiladores y mejorar la experiencia de programación. Pues en noviembre pasado Microsoft acaba de lanzar una muy inicial CTP de este proyecto, con nombre en clave Roslyn, para que la comunidad pueda empezar a experimentar con estos servicios. Aunque aún con muchas interrogantes, funcionalidades pendientes de implementar y casi ninguna documentación, dNM no ha querido demorar en mostrarles ya algo de Roslyn a sus lectores. Va en esta entrega una muestra de lo que se puede hacer en relación con el scripting.

¿Preocupado por cómo lidiar con la latencia de una operación remota? ¿Se enmaraña su código cuando no quiere esperar por la terminación de la invocación a un método del que se puede incluso no retornar? En este artículo echaremos un primer vistazo al nuevo recurso lingüístico async/await, que ya podemos probar en C# y VB mediante Microsoft Visual Studio Async CTP, así como al patrón propuesto para utilizar dicho recurso, que nos simplifica la forma de hacer programación asíncrona.

La programación es cada día más asíncrona: máquinas con múltiples núcleos, interfaces gráficas que no se bloquean, sistemas en la nube, etc. En vista de ello, Microsoft ha decidido echarle otro cable a los desarrolladores para lidiar con esta complejidad: Reactive Extensions. En este artículo aprenderemos los fundamentos de esta tecnología revolucionaria.

En esta entrega se analizan algunas de las insatisfacciones que aún tenemos los que nos hemos involucrado con el recurso dynamic introducido en C# 4.0. Reflexionaremos sobre qué faltaría para poder verlas satisfechas y qué podemos ir haciendo por ahora para paliar la situación.

Este artículo describe de una manera práctica cómo implementar el enrutamiento utilizando Routing Service, una de las novedades más importantes de WCF 4.

Este artículo resume las novedades que incorpora la quinta edición de ECMAScript, el lenguaje de scripts estandarizado por ECMA International.

Qué bonito se vería el código de nuestras aplicaciones si pudiéramos eliminar todo lo que no fuera lógica de negocio pura. Desacoplar toda esa “ceremonia” relacionada con el logging, la gestión de excepciones y seguridad, el cacheo de información, etc. Verlo todo encapsulado en componentes que podamos “enchufar” a nuestras clases. Pues bien, en este artículo vamos a ver cómo podemos lograrlo apoyándonos en Unity y en una de sus extensiones: Interception.

En nuestro anterior artículo sobre el DomainDataSource, nos dedicamos a realizar un repaso general de este control de datos, presentando sus principales características. En esta ocasión, por el contrario, nos detendremos en particular en una de sus funcionalidades, el filtrado, profundizando un poco más en el mismo, con la intención de mejorar la experiencia de usuario.

Muchas aplicaciones cuentan, en el momento de su despliegue, con la opción de seleccionar un tipo de base de datos (SQL Server, MySQL, PostgreSQL, entre otras) en la que almacenar la información. En este artículo se muestra cómo desarrollar una aplicación .NET con soporte transparente (pluggable) para el almacenamiento de los datos sin depender directamente de un "mapeador" relacional (ORM) como Entity Framework o NHibernate al permitir modelar/realizar consultas LINQ de forma abstracta, es decir, sin depender de las características particulares del proveedor de datos que se utilice.

Al mismo ritmo al que crece la popularidad del acrónimo SOLID como uno de los axiomas (si es que existe alguno) del desarrollo de software moderno, crece el interés por las tecnologías que nos permiten llevarlo a cabo. En este artículo veremos cómo utilizar Unity, un framework de gestión de dependencias, en los escenarios más habituales.

Este artículo echa un primer vistazo a las nuevas posibilidades que ofrece Office 365 desde el punto de vista del desarrollador.

Como colofón de la serie de cinco artículos dedicados a los principios SOLID, en esta ocasión toca hablar del Principio de Inyección de Dependencias (Dependency Inyection, DI), abordando la problemática de los modelos altamente acoplados y mostrando por qué este principio está tomando cada vez más relevancia en nuestros desarrollos.

No sólo el mundo del software cambia: el del hardware también. Puede parecer mentira, pero los días de soldar y programar PIC puede que tengan sus días contados. Dentro de poco podremos crear circuitos con C# y Visual Studio.

En este artículo se exponen tres buenas prácticas para aplicar en tiempo de diseño de las interfaces gráficas de usuario (GUI), ya sea con formularios Web o Windows Forms. Éstas consisten en acceder directamente a propiedades de un componente mediante smart tags, seleccionar todas las instancias de un tipo de componente, y asignar incremental y automáticamente valor a la propiedad TabIndex de una sucesión de componentes. Además, se identifican algunas limitaciones de .NET Framework y Visual Studio que impiden que las nuevas funcionalidades puedan explotarse con toda eficacia.

Como ya se ha comenzado a tratar en DNM (ver [1]), ahora con .NET Framework 4.0, que implementa sobre el CLR el nuevo motor de ejecución dinámico (DLR1), se incorporan a la plataforma .NET lenguajes dinámicos puros como Python y Ruby, y C# se fortalece como lenguaje multi-paradigma con la inclusión de algunos recursos dinámicos, que permiten además la interoperabilidad con dichos lenguajes dinámicos. Tomando como hilo conductor el concepto de memoization (un patrón para lograr que un método pueda “memorizar” cálculos ya realizados para no repetirlos), el presente artículo nos ilustra esta evolución de paradigmas en .NET con ejemplos de código en C#, F# y Python.

Como parte de la serie dedicada a presentar los cinco principios SOLID de programación, este mes nos centramos en el Principio de Segregación de Interfaces (Interface Segregation Principle, ISP). Este principio trata sobre las desventajas de las interfaces “pesadas”, y guarda una estrecha relación con el nivel de cohesión de las aplicaciones. En este artículo veremos qué perjuicios ocasionan las interfaces “pesadas”, qué impacto tienen en la cohesión del sistema y cómo en muchas ocasiones vulneran el Principio de Responsabilidad Única, y cómo ISP ofrece una solución a estos problemas.

Mono es un proyecto bajo los términos de licencia LGPL que ofrece una implementación de la tecnología .NET y puede ejecutarse en diversas plataformas y sistemas operativos. Si bien Mono tiene casi la misma edad que Microsoft .NET (ya que su líder Miguel de Icaza2 supo calibrar tempranamente la valía de la tecnología .NET como para llevarla también al mundo no Windows), no había sido tratado hasta el momento por dotNetManía. Sin embargo, la aparición de una gran variedad de aparatejos móviles, en los que Windows no es el sistema dominante, ha provocado la inquietud de algunos de nuestros lectores-desarrolladores, que por una parte no quieren abandonar .NET, pero por otra quisieran aprovechar los nuevos espacios que les abre el mercado. Mono es entonces una alternativa a considerar. Este artículo nos pone al día sobre el estado actual de Mono y su comparación con Microsoft .NET, a la vez que nos muestra algunos recursos muy útiles de Mono que aún no están disponibles en Microsoft .NET, como es el caso de los “servicios de compilación”.

Tercer principio de programación SOLID. En esta ocasión presentamos los fundamentos del Principio de Sustitución de Liskov y cómo la aplicación de este principio tiene una repercusión directa sobre las jerarquías de herencia entre clases.

Este artículo introduce un tipo de datos para representar matrices numéricas programado en F# que utiliza funciones en lugar de arrays numéricos. Se describe cómo esta nueva abstracción puede contribuir a reducir el consumo de memoria para representar matrices, al tiempo que confiere a la evaluación de operadores un carácter diferido y admite un estilo de codificación similar a la notación matemática. Más adelante se discute cómo estas características y la utilización del patrón iterador permiten expresar computaciones que sirvan de entrada a Parallel LINQ. Por último, se presenta una personalización de la herramienta F# Interactive que ofrece soporte para el tipo de datos desarrollado a lo largo del texto.

Este es el segundo de una serie de cinco artículos que describen los principios SOLID y su aplicación en la Programación Orientada a Objetos. Después de examinar en nuestra entrega anterior el Principio de Responsabilidad Única, este mes nos adentramos en otro de los principios, que además guarda una estrecha relación con el primero: el Principio Open/Closed.

Este artículo, dedicado al llamado "Principio de responsabilidad única", es el primero de una serie de cinco artículos que descubren cinco principios fundamentales del paradigma de la Programación Orientada a Objetos (POO).

Hace varios años de la aparición de este lenguaje de Microsoft, desarrollado por los laboratorios de MS-Research en Cambridge (Reino Unido). Y ha ido ganando adeptos poco a poco, especialmente entre aquellos interesados en el manejo de fórmulas y cálculos aplicables en Economía, Ingeniería, Física, Matemáticas y otras disciplinas que hacen uso de aparatos matemáticos que van más allá de las 4 reglas básicas. Ahora, F# aparece en Visual Studio 2010 como “ciudadano de 1ª clase”, y ofrece posibilidades interesantísimas aplicado a estos contextos, e incluso a otros, como Silverlight.

Con la llegada de la versión 4 de .NET Framework, todo el ecosistema de tecnologías que lo componen incorpora múltiples novedades. WCF (Windows Communication Foundation) no es una excepción y en este artículo analizaremos dos de ellas: la simplificación en la configuración de servicios y el nuevo servicio de enrutado (routing). Comprobaremos también hasta qué punto los desarrolladores vamos a ganar con el cambio.

Desde hace tiempo, Microsoft viene trabajando en ofrecer recursos de programación para desarrollar software paralelo y distribuido [1]. Uno de estos trabajos fue el denominado Parallel Extensions, que se nos presentó como una librería de código administrado que se podía descargar para referenciar en nuestros proyectos de VS2008. dotNetManía alertó previsoramente a los lectores sobre este tema a través de un trabajo del colega Octavio Hernández [2]. Pero si hace tres años algunos tal vez ni teníamos ordenadores con procesadores multi-núcleo, hoy ya éstos abundan en el mercado. Ahora con Visual Studio 2010 y .NET Framework 4 esta librería viene más evolucionada e integrada de oficio; es por ello que estamos llamados a ir introduciendo el paralelismo en nuestra mentalidad de “desarrolladores secuenciales”. Este artículo es una primera aproximación a ese tema, y presenta los componentes más relevantes de esta librería y ejemplifica cómo utilizarlos.

La familia de tipos genéricos Tuple<> constituye una de las múltiples novedades que nos ofrece la Librería de clases base (BCL) de .NET Framework en su versión 4. Este artículo describe de una manera práctica qué son y para qué sirven los tuplos.

La llegada de Visual Studio 2010 marca también un nuevo paso en la evolución de Visual Basic. Uno de los grandes clásicos entre los lenguajes de programación desembarca con energías renovadas y un notable conjunto de nuevas características, que a buen seguro serán bienvenidas por toda la comunidad de desarrolladores. En este artículo hacemos una revisión de las más importantes novedades que se presentan en esta nueva versión.

En números anteriores, dotNetManía ha venido presentando algunas de las novedades de programación que estarán presentes en .NET Framework 4 y C# 4.0, como los parámetros nombrados y por omisión [1], la varianza y contravarianza [2], o la programación por contratos [3]. En esta entrega vamos a tratar la que tal vez sea la más controvertida y revolucionaria de las novedades: el tipado dinámico (dynamic typing) [4].

En este artículo veremos algunas de las sorpresas que Microsoft nos tiene preparadas para la próxima versión de Workflow Foundation, que vendrá de la mano de la versión 4.0 de .NET Framework y de Visual Studio 2010, cuyas versiones definitivas estarán disponibles seguramente en abril de 2010.

Un espacio de tuplas es una implementación del paradigma de memoria asociativa, utilizado en la programación distribuida y paralela. Un tal espacio puede verse como un repositorio de datos expresado en forma de tuplas, el cual puede ser accedido concurrentemente por distintas aplicaciones. Utilizado como elemento de coordinación, un espacio de tuplas permite modelar problemas bajo la concepción productor-consumidor: los "productores" colocan sus datos como tuplas en el espacio y los consumidores toman del espacio aquellas tuplas que cumplan con el patrón que éstos requieren.

Como continuidad de nuestra promesa de hablar sobre lo que vendrá con .NET 4.0 y Visual Studio 2010, el presente artículo está dedicado a una de estas novedades, cuyas ideas tal vez aún no sean muy conocidas por algunos desarrolladores: Code Contracts.

La posibilidad de crear prototipos funcionales de los proyectos que se vayan a desarrollar y la capacidad de poder añadir feedback a un prototipo de forma fácil e intuitiva son algunas de las características principales que ofrece SketchFlow, la nueva herramienta de creación de prototipos incluida en Microsoft Expression 3.

Desde hace mucho tiempo venimos oyendo acerca de la programación paralela, los hilos, tareas y conceptos relacionados, pero en la mayoría de los casos esto no ha ocasionado un impacto directo en la manera que tenemos de desarrollar. Sin embargo, esta situación está a punto de cambiar. En este artículo explicamos por qué.

Visual Studio 2008 es, si no la mejor, una de las mejores y más completas plataformas de desarrollo actualmente existentes. Aun así, trata de abarcar tanto que en ocasiones quedan pequeños flecos que se pueden mejorar. En nuestro artículo anterior mostramos cómo mejorar la infraestructura para crear aplicaciones localizables; esta vez nos centraremos en la creación de los típicos combos de controles con un solo clic.

A menudo, cuando nos hablan de InfoPath, no acabamos de comprender qué es y para qué sirve. Nos hacemos multitud de preguntas como las siguientes: ¿Cuál es su utilidad? ¿Es parte de Office? ¿Permite hacer formularios? ¿Los formularios son documentos? ¿Dónde se guardan? ¿Se pueden usar en SharePoint? A lo largo del presente artículo intentaremos disipar un poco todas esas dudas e ilustrar al lector lo sencillo que es diseñar plantillas de formularios InfoPath y utilizarlas en formularios Web o aplicaciones SharePoint.

En artículos anteriores ([1], [2], [3]) se han introducido los conceptos básicos de la programación de gráficos por ordenador. En este artículo se abordará la programación de shaders. La intención de los shaders es definir mediante código un comportamiento personalizado del procesamiento gráfico para que sea ejecutado en el núcleo de las tarjetas gráficas. Mediante la programación de shaders, las aplicaciones visuales actuales pueden lograr en tiempo real efectos de gran realismo.

Este artículo describe las novedades que incluye el recién aparecido Windows 7 para los desarrolladores. Al ser un artículo introductorio, no ahondaremos en código ni en técnicas concretas, pero sí facilitaremos al final del mismo una lista de recursos actualmente disponibles en la red.

Uno de los primeros cambios que se notan al comenzar a manejar Windows 7 es la nueva barra de tareas. Algunas de las características de esta barra se pueden controlar desde programa. Aunque las API para conseguirlo son esencialmente no manejadas, Microsoft ha publicado unas librerías denominadas Windows API Code Pack que permiten llamar a estas API desde .NET. En este artículo presentamos un breve resumen de las nuevas características de la barra de tareas, y cómo controlarlas desde código manejado.

La feliz inclusión de la genericidad en .NET Framework 2.0 y el lenguaje C# 2.0 significó un gran avance en flexibilidad y expresividad para desarrollar software a la vez que se mantenía la robustez del control estático de tipos. Estas capacidades en el sistema de tipos se vieron enriquecidas en .NET Framework 3.5 y C# 3.0 con la inferencia de tipos, la creación de tipos anónimos y las expresiones lambda, aportes que dieron soporte a LINQ y que hoy forman parte del instrumental de los desarrolladores .NET. Los recursos para expresar covarianza y contravarianza que se incorporarán en los próximos .NET Framework 4.0 y C# 4.0 complementan la genericidad y suponen un paso más en la expresividad y flexibilidad de programación conciliadas en el contexto seguro que nos aporta el control estático de tipos. Este artículo, que se enmarca en la serie anunciada por dotNetManía para adelantar lo que viene con .NET Framework 4.0 y Visual Studio 2010, nos presenta una primera aproximación a estas "varianzas" en el sistema de tipos.

Microsoft nos ha abierto las puertas a un nuevo mundo de posibilidades creativas con el lanzamiento, el pasado 10 de julio, de Silverlight 3 y la nueva suite Expression Studio 3 (de la que forma parte Expression Blend 3), buscando así potenciar el desarrollo de aplicaciones RIA para la nueva generación Web que nos avecina, y combinando toda la potencialidad y experiencia de usuario de las aplicaciones de escritorio y las tecnologías en la nube.

Con Expression Web 3, uno de los componentes integrados en la suite Expression Studio 3, Microsoft ha abierto las puertas a un mundo lleno de nuevas posibilidades creativas y técnicas a la hora de afrontar el desarrollo de aplicaciones Web. Este artículo presenta las principales novedades que incorpora esta nueva versión.

Visual Studio 2008 es, si no la mejor, una de las mejores y más completas plataformas de desarrollo actualmente existentes. Aun así, trata de abarcar tanto, que en ocasiones quedan pequeños flecos que se pueden mejorar. La infraestructura para crear aplicaciones localizables es uno de estos ejemplos. En este artículo veremos cómo mejorarla mediante un add-in que facilita el cambio rápido de idioma en un formulario o control.

Aunque parezca mentira, han pasado ya más de tres años desde que comenzamos a escribir en dotNetManía sobre las novedades del entonces flamante C# 3.0 [1]. Hoy todas aquellas características (incluyendo LINQ) son parte integral de nuestra vida diaria, y nos preparamos para enfrentarnos a las nuevas posibilidades que C# 4.0 pondrá a nuestra disposición. Este artículo hace una presentación general de esas características, y a continuación describe las más básicas.

En este artículo profundizamos en el lenguaje M y desarrollamos un ejemplo completo que nos permite captar la descripción en lenguaje de alto nivel de una interfaz de usuario y transformarla, empleando las diferentes tecnologías que el lenguaje M nos proporciona, en código XAML capaz de ser interpretado por el motor de Windows Presentation Foundation (WPF).

Oslo constituye un conjunto de tecnologías orientadas a incrementar la productividad de nuestros desarrollos mediante la adopción de un paradigma de desarrollo basado en modelos. Oslo está compuesto por un lenguaje de modelado (M), una herramienta de modelado visual (Quadrant) y un repositorio relacional de modelos. En este artículo, repasaremos los principales conceptos de Oslo, centrándonos en presentar los fundamentos del lenguaje M desde un enfoque práctico.

La interoperación entre código manejado y no manejado es una de las tareas que se presentan frecuentemente a cualquier programador .NET. Aquí se describen detalladamente dos enfoques diferentes: el primero, haciendo uso de los recursos que ofrecen para ello C# y .NET; el segundo, utilizando C++/CLI, una extensión de C++ diseñada con la interoperabilidad como uno de sus objetivos centrales.

En este artículo se hace una introducción a PRISM, el marco de trabajo para el desarrollo de aplicaciones visuales WPF propuesto por Microsoft Patterns & Practices para hacer posible la creación de aplicaciones más mantenibles y extensibles. También se presentan diversos patrones relacionados con PRISM, como Presentación separada e Inversión de control.

En este artículo se presenta C++ Interop (también conocido como IJW - It Just Works), uno de los principales recursos para interactuar con código nativo que ofrece el lenguaje C++/CLI. Como ejemplo, se desarrolla un componente que encapsula llamadas a la librería para reproducción de sonido del sistema operativo, para posteriormente incluirlo en una aplicación escrita en C#.

Este artículo presenta los métodos de extensión de C# 3.0 (también disponibles en Visual Basic 9.0) y describe las múltiples ventajas que este reciente recurso lingüístico aporta. Más adelante, presenta propuestas de posibles adiciones al lenguaje C# que contribuirían a promover aún más una de las principales ventajas que aportan los métodos de extensión: la extensibilidad de la programación.

El despliegue de los servicios y clientes WCF en diferentes entornos (desarrollo, preproducción, producción) es una tarea propensa a errores en la que normalmente se hace necesario “tocar” manualmente los archivos de configuración. En este artículo se presenta una propuesta para simplificar el despliegue de nuestros servidores y clientes WCF mediante proyectos de instalación que solicitan la dirección de los servicios y actualizan automáticamente estos archivos.

En la próxima versión de .NET Framework (la 4.0) se incluirá lo que se conoce como DLR (Dynamic Language Runtime), que viene a ser el motor de ejecución de los lenguajes dinámicos de .NET. De esa forma, se permitirá al CLR (y por extensión a los lenguajes como VB y C#) el acceso de forma dinámica a los miembros de los objetos que haya en memoria, algo parecido a lo que siempre se ha conocido como late binding... o casi...

Este artículo describe el desarrollo de una herramienta que permita generar de forma automática un mapeo a nivel de objetos de una base de datos relacional (DBML), en este caso MS Access, sobre el que se podrá posteriormente aplicar consultas LINQ.

Una parte importante del proceso de creación de software pasa por asegurar los requerimientos de calidad del producto. Team System Test Edition nos ayuda a incorporar el cumplimiento de esos criterios en todo el ciclo de vida del desarrollo. En este artículo exploraremos las herramientas disponibles y las buenas prácticas que nos ayudarán a conseguir nuestro objetivo.

Visual Basic permite varias formas distintas de acceder al contenido de los ficheros, unas se basan en las clases de .NET Framework, otras son específicas de Visual Basic. Entre estas últimas encontramos funcionalidad compatible (o casi) con Visual Basic 6.0. En este artículo veremos las diferentes formas de acceder al contenido de los ficheros para que el lector pueda elegir la que mejor se adapte a sus necesidades.

Otro mes, y otro componente. Veamos cómo nuestros otros componentes pueden relacionarse con el sistema operativo, la seguridad, los usuarios… el Directorio activo.

La versión de Visual Basic que se incluye con .NET Framework 3.5 o Visual Studio 2008 permite que creemos métodos que extiendan la funcionalidad de clases existentes sin necesidad de tener acceso al código fuente de éstas. En este artículo veremos cómo crear este tipo de métodos y qué consideraciones debemos tener en cuenta para usarlos de la forma más adecuada.

Si me rinde el código y no lo entiendo, ¿realmente me rinde? Este debería haber sido el título de este artículo, pero era demasiado largo, aunque en el contenido sí que veremos algunas cuestiones que debemos tener en cuenta a la hora de decidir qué es mejor, si entender lo que escribimos o que rinda mejor. Por supuesto, lo bueno es que seremos nosotros los que decidamos qué hacer, sobre todo si sabemos cómo hacerlo.

Siguiendo con la serie de componentes de múltiples usos, veamos cómo crear nuestros propios contadores y definir trazas, lo cual nos permitirá identificar aquellas situaciones que puedan provocar dolores de cabeza cuando toda la aplicación esté en uso.

No, no es que a Microsoft le haya dado por crear una nueva versión de Visual Basic que se solidarice con la humanidad. Pero el que escribe quiere que los lectores de esta “Isla VB” sí se solidaricen, y esa solidaridad solo la pueden demostrar actuando. ¡Espero que actúen!

Continuando con la serie de componentes listos para ser reutilizados, veremos cómo terminar la definición de una clase genérica de acceso a datos, incluyendo la preparación del terreno para utilizar contadores y trazas. También veremos cómo definir una clase funcional basada en ésta, y un pequeño aplicativo cliente para probar todo.

Los programadores tendemos a estar reinventando la rueda continuamente, lo cual reduce mucho nuestra productividad. Cualquier tarea que sea habitual y generalizable deberíamos evitar repetirla desde cero. Los frameworks se diseñan con esta idea en mente. En este artículo vamos a ocuparnos de uno de ellos que resuelve una situación bastante común y compleja: la sincronización de datos.

El lenguaje Visual Basic tiene sus peculiaridades, y algunas de ellas debemos conocerlas a fondo para poder sacarle un buen rendimiento a VB, particularmente cuando algunas de esas exclusividades son las que se utilizan en algunas de las características incorporadas en la nueva versión de este compilador, como es el caso de los métodos extensores.

Comenzamos aquí el desarrollo del primer componente de funcionalidad compleja. Dada la importancia que tiene a la hora de desarrollar aplicaciones, comenzaremos con el acceso a datos, explicando según se desarrolla los fundamentos y consideraciones en los que basa, para que se pueda usar, modificar o repensar completamente y que os pueda ser realmente útil.

Con el quinto año de dotNetManía estrenamos una nueva columna en la revista dedicada exclusivamente a los que gustan desarrollar con Visual Basic. No es que antes no hubiera nada para Visual Basic, pero ya iba siendo hora de que tuviésemos nuestro propio rincón. En esta isla tendremos ocasión de ver muchas cosas relacionadas con Visual Basic, particularmente con la versión 9.0, que es la que se incluye en Visual Studio 2008, aunque muchos conceptos serán válidos también para las versiones anteriores.

En esta ocasión, seguimos tratando el tema de depuración con Visual Studio, pero nos centraremos más en la característica de “editar y continuar”, de forma que veamos las posibilidades que tenemos a la hora de hacer esas modificaciones tan necesarias cuando el código de nuestra aplicación no se comporta como esperamos que lo haga.

En esta oportunidad, nos ocuparemos de crear una clase que nos permita algo más de libertad a la hora de manejar colecciones y listas de nuestros propios objetos, o inclusive de cualquier otro conjunto de valores que necesitemos.

El desarrollo de software está en constante evolución hacia modelos de desarrollo cada vez “más elevados”. Ser más eficientes y productivos es la máxima que todo el mundo busca, y el sector de los videojuegos no iba a librarse eternamente de esta tendencia. XNA nace para acercar al sector esos dos objetivos y para fomentar la comunidad de desarrolladores “indie”, actualmente desplazada por proyectos multimillonarios. ¿Será una apuesta acertada?

La depuración es una de esas cosas que todos hacemos, o deberíamos hacer, y que a nadie le gusta tener que hacer; no porque no sea necesaria, sino porque al final terminabas fatal de los nervios cuando la depuración la realizabas con versiones anteriores de Visual Studio para .NET; por suerte, esto ya no es así con Visual Studio 2005. En esta serie de dos artículos mostraremos las principales posibilidades que este último entorno pone a nuestro alcance para facilitarnos la depuración de nuestros programas.

Siguiendo con la idea de las generalizaciones en componentes expuesta en el número anterior, en este artículo veremos algunos otros ejemplos que pueden resultarle interesantes.

En este artículo describimos cómo pueden implementarse funcionalidades genéricas que sean útiles a cualquier tipo de aplicación que debamos programar, considerando elementos de diseño como su pertenencia a un componente específico o como simples rutinas. Dentro de estas definiciones, aclararemos cómo es posible definir configuraciones específicas para cada componente que diseñemos, así como una estructura genérica que permita llevar una bitácora histórica de los errores dentro de las aplicaciones.

En este trabajo se presentan las características generales de una biblioteca “open source” en .NET que ofrece funcionalidades para el reconocimiento óptico de caracteres. Estas funcionalidades se sustentan en más de un centenar de tipos que han sido implementados basados en muchos de los algoritmos disponibles en la red y en otros desarrollados por los propios autores.

Si queremos comprimir (o descomprimir) ficheros con .NET Framework 2.0 sin usar librerías externas, podemos usar las dos clases que se definen en el espacio de nombres System.IO.Compression: DeflateStream y GZipStream. Por otra parte, en la versión 3.0 de .NET existen clases que nos permiten crear ficheros del tipo ZIP. En este artículo veremos cómo usar las clases que las dos versiones de .NET nos ofrecen para realizar las tareas de compresión.

Cuando hablamos de procesos de negocio, indudablemente en algún momento tendremos que hablar de los mecanismos y reglas que puedan variar el comportamiento de los mismos y/o el flujo de nuestros procesos.

Un sistema de ayuda es algo que siempre deberíamos implementar en nuestras aplicaciones. En este artículo veremos cómo usar la clase Help y el componente HelpProvider, el cual nos permite añadir ayuda a nuestras aplicaciones Windows de una forma muy sencilla.

Windows Presentation Foundation ha supuesto una revolución en el mundo del desarrollo de interfaces de usuario para nuestras aplicaciones. En anteriores entregas de esta revista, hemos podido conocer un poco más sobre lo que el nuevo subsistema de presentación de Windows nos proporciona; a lo largo de este artículo, vamos a dar a conocer lo necesario para poder aprovechar las bondades de WPF en la creación de aplicaciones para Windows Media Center.

Seguramente en alguna ocasión se le ha presentado una situación en la que tiene que crear un objeto que ocupa bastante memoria y que tarda en crearse. En tales casos, lo primero sería revisar el diseño de ese objeto para ver cómo optimizarlo, pero si no podemos hacerlo es común que nos asalte la duda de qué hacer: ¿hacemos Dispose() del objeto al acabar de utilizarlo para liberar memoria? ¿o lo mantenemos para evitar los costes de construcción en un futuro?

En el artículo anterior vimos cómo “persistir” los objetos usando las clases que utilizan IFormatter. En aquella ocasión tuvimos la oportunidad de ver cómo definir los tipos que queríamos serializar por medio del atributo Serializable y la interfaz ISerializable. En este artículo veremos otra forma de serializar nuestros objetos, que utiliza XML puro como formato.

Este artículo es un divertimento que nos muestra cómo se pueden combinar atractivos recursos de .NET y C# 3.0 como los atributos, la reflexión, la genericidad, los métodos extensores y la capacidad de consulta de LINQ para implementar un método que pueda hacer la clonación completa de objetos .NET.

ILMerge es una herramienta de línea de comandos que permite combinar varios ensamblados en uno solo.

Hace tiempo me planteé desarrollar una aplicación Bluetooth para mi Smartphone. Las pocas alternativas libres de pago que existían y la búsqueda de cómo funciona realmente Bluetooth me llevaron a plantearme la creación de una librería .NET para Windows Mobile, que posteriormente pasé también a Windows XP.

En nuestra entrega anterior presentamos los tipos de aspectos que podemos colocar en nuestro código C# basándonos en atributos .NET. En esta segunda parte, vamos a ver cómo hacer que Visual Studio entreteja el código para aplicar la funcionalidad de los aspectos.

En el número 9 de esta revista se incluyó un artículo acerca de cómo llevar a cabo la sobrecarga de operadores en C#. Por aquellos tiempos, la sobrecarga de operadores estaba vetada para los programadores de Visual Basic .NET, debido a que el equipo de desarrollo del lenguaje no pudo incluirla por razones de tiempo. Afortunadamente, con la llegada de Visual Studio 2005 ya podemos contar con esta funcionalidad.

Con la Programación Orientada a Aspectos (Aspect Oriented Programming – AOP) se pretende que la funcionalidad del código principal de una aplicación y la funcionalidad adicional indicada en forma de “aspectos” puedan ser reusadas, modificadas y extendidas sin afectarse entre sí.

C++/CLI es el lenguaje de bajo nivel dentro del mundo .NET, puesto que permite realizar tareas que son prácticamente imposibles con otros lenguajes; aparte de ello, permite ir incorporando paulatinamente facetas de .NET a proyectos ya existentes, tanto Win32 como MFC. Otros aspectos importantes son el rendimiento (tanto dentro del propio .NET Framework como en los cambios de contexto entre manejado/nativo) y la facilidad para mezclar ambos tipos de código.

En este cuarto artículo dedicado a los delegados y eventos nos centraremos en cómo comunicarnos entre la clase que define los eventos y la que los intercepta. Veremos esa comunicación de dos formas diferentes, usando parámetros por referencia y de la forma recomendada, que es definiendo nuestra propia clase para usar como parámetro de los eventos. También abordaremos una característica exclusiva de C#, que es la posibilidad de usar clases base como parámetros de los métodos que reciben los eventos.

En esta ocasión vamos a centrarnos en los delegados y eventos desde el punto de vista del programador de Visual Basic, y particularmente en la nueva instrucción Custom Event, desde la que tendremos control total sobre cómo se crean, destruyen y utilizan los eventos desde Visual Basic 2005. También veremos cómo definir e interceptar los eventos de las distintas formas que nos permite ese lenguaje.

Han estado ahí desde el comienzo. Los hemos utilizado en seriación, servicios Web, etc. Nos ayudan a personalizar el comportamiento del .NET Framework… Pero, ¿podemos aprovecharlos? La respuesta es sí. Algo tan sencillo como un metadato que amplía la definición del lenguaje nos ofrece la oportunidad de montar arquitecturas que dialogan con el desarrollador; y esto abre un impresionante abanico de posibilidades.

Aplicar políticas de compatibilidad transaccional a nuestros componentes se convierte, en ocasiones, en un arma de doble filo en la que acabamos sacrificando la escalabilidad de la aplicación por la confianza ciega en una tecnología cuya base teórica es abstracta. Cómo, quién, dónde y por qué son preguntas a las que debemos tener respuestas de antemano y de cuyo acierto, sencillamente, dependerá que una arquitectura funcione o quede en evidencia.

Windows Workflow Foundation no es, desde luego, una tecnología sencilla de describir en un solo artículo, debido a la flexibilidad y potencia que nos ofrece. El presente artículo ayudará a los lectores a hacerse una idea de las posibilidades que WWF brinda, dejando claro cuáles son los campos más propicios para la utilización de esta nueva herramienta.

En el número anterior vimos con detalle casi todo lo concerniente a los delegados, y aunque solo lo viésemos de pasada, comprobamos la relación entre los delegados y los eventos. En este número nos centraremos en los eventos, pero antes comprobaremos que hay ciertas características de los delegados que los hacen imprescindibles para usarlos con los eventos.

Siguendo los pasos de este tutorial podrás personalizar el ribbon de Office 2007 de una forma realmente sencilla y fácil. Explicamos cómo crear un add-in de Office 2007 basado en la interfaz IDTExtensibility2 y la forma en la que puedes añadir pestañas y botones propios en el ribbon.

En este número vamos a tratar de los delegados, y también de los eventos (aunque de estos últimos nos encargaremos con más detalle en el próximo artículo), ya que en .NET están estrechamente relacionados; tanto es así que no podemos definir un evento sin la intervención de un delegado.

Excel es una estupenda hoja de cálculo, que expone una funcionalidad extendida y muy interesante a la par que peligrosa… ¿Cuántas veces hemos tenido que pelearnos con marañas de código VBA para modificar una hoja de este tipo? ¿Cuántas veces nos han echado en cara los usuarios que la interfaz de nuestras aplicaciones es muy pobre y que ellos se manejan mejor con sus hojas Excel?… Con VSTO por fin vamos a poder poner fin a estos problemas y desarrollar aplicaciones .NET con interfaz Office.

¿Más sobre singleton? podrán pensar algunos lectores. Bastante se ha escrito sobre el patrón de diseño Singleton desde que fue caracterizado en el clásico libro del clan de los cuatro [1]. En este artículo pretendemos ordenar algunas ideas sobre el singleton (¿será de una vez y por todas?) e ilustrar cómo se puede lograr en C# implementar mejor este patrón gracias a la genericidad y la reflexión.

En el pasado PDC celebrado en Los Angeles, Microsoft desveló por primera vez varias de las características previstas para la siguiente versión de Visual Studio, Orcas. La “joya de la corona” en lo que a los lenguajes de programación respecta es LINQ (Language INtegrated Query).

En este artículo veremos cómo crear componentes en .NET que se puedan usar desde aplicaciones que utilicen componentes COM. Pero no lo haremos de la forma fácil, sino que veremos cómo hacer que esos componentes funcionen de la misma forma que lo harían con cualquier entorno de desarrollo capaz de generar componentes COM (o ActiveX), de forma que tengan compatibilidad binaria, para no tener que volver a generar la aplicación cliente si decidimos modificar el componente.

Si bien el correo electrónico es un servicio de comunicación ampliamente utilizado, es un mecanismo pasivo y relativamente lento cuando se quiere establecer un diálogo y una comunicación más cercana al tiempo real. Es por ello que millones de personas en todo el mundo utilizan sistemas de comunicación instantánea, incluso haciendo uso de transmisión de voz y video sobre la red.

En dos artículos anteriores de dotNetManía [1,2] mostramos las capacidades de la biblioteca Reflection.Editor para editar ensamblados. Estas capacidades se basaban en nuevos tipos como EditionType y EditionMethod que disponían de funcionalidades para lograr el efecto de renombrar, eliminar, copiar e insertar tipos, y miembros dentro de un tipo, en un ensamblado, así como también la posibilidad de poder colocar atributos a las diferentes entidades de un ensamblado.

En este artículo nos centraremos en la interoperabilidad con código no administrado (unmanaged code), que es la que nos permitirá usar funciones declaradas en librerías escritas con lenguajes que no pertenecen a la plataforma .NET, (por ejemplo funciones del API de Windows), desde un lenguaje que usa el código administrado de .NET Framework.

Si bien la apariencia del entorno es muy similar a la que ofrecía Delphi 2005, tras unas pocas sesiones de interacción con el producto cualquiera podrá convencerse de que se trata de una herramienta mucho más ligera, rápida y productiva que su antecesor.

En la primera parte de este artículo se analizó la problemática de los sistemas de ficheros tradicionales en cuanto a la administración de contenidos digitales y se introdujo al lector en la tecnología de WSF. En esta segunda y última parte se profundizará en los fundamentos técnicos de WSF y en qué aporta WSF al desarrollador de aplicaciones. Mi abuela siempre decía: “Segundas partes nunca fueron buenas”. Yo confío en que desde “Star Wars: El Imperio Contrataca” la cosa haya cambiado. Eso sí, recomiendo leer la primera parte del artículo para entender toda trama y quien avisa no es traidor...

Cuando implementamos un control, además de su funcionalidad en tiempo de ejecución, es importante que disponga de un buen soporte en tiempo de diseño, consiguiendo así un aspecto y comportamiento mucho más profesional.

La interoperabilidad bien entendida hace referencia a cómo utilizar clases de código no administrado desde aplicaciones de .NET y viceversa. Cuando hablamos de código no administrado, nos estamos refiriendo a código que no está generado con los compiladores de la plataforma .NET. El concepto de interoperabilidad lo ampliaremos un poco para aplicarlo también a los ensamblados creados con .NET, de forma que podamos usar las librerías creadas con un lenguaje de .NET desde otro lenguaje también de la familia .NET, típicamente con C# y Visual Basic.

En el PDC 2005, Microsoft sorprendió a propios y extraños anunciando el lanzamiento de la versión Beta 1 de su nuevo sistema de ficheros relacional, bautizado con el nombre Windows Storage Foundation y más conocido desde el PDC 2003 por su nombre en clave WinFS (Windows Future Storage). La sorpresa fue desvelar el doble secreto que se guardaba. Como decía mi abuela: “¿No querías sopa? Toma dos platos”. Trataré de explicar porqué sorprendió tanto y cuál era ese doble secreto, pero para eso tendré que contar toda la historia...

En el número de octubre de dotNetManía (nº 19) en la sección dnm.inicio.fundamentos estuvimos hablando sobre cómo crear aplicaciones localizables en .NET, en esa ocasión tratamos las clases que .NET Framework pone a nuestra disposición para manejar todo el tema de la localización o globalización de nuestras aplicaciones, en este artículo veremos de forma práctica cómo diseñar un formulario que se adapte a cada referencia cultural que creamos conveniente.

Windows Communication Foundation (WCF) es el nuevo modelo de programación unificado para el desarrollo de comunicaciones punto-a-punto y Arquitecturas Orientadas a Servicios (SOA) en .NET. Recoge lo mejor de Remoting, servicios Web, System.Messaging y los .NET Enterprises Services en un único Framework que formará parte de WinFX.

Este artículo presenta de manera concisa las novedades fundamentales que ofrece al desarrollador la nueva versión del lenguaje C#, características que ya estaban implementadas casi completamente en las diferentes versiones beta de Visual Studio 2005 que hemos ido probando hasta la fecha, y que ahora reciben el espaldarazo natural que representa su estandarización.

Por primera vez, y con la reciente salida de la versión 2005 de Visual Studio, Microsoft tiene una bonita historia que contar en torno a los 64 bits. Los compiladores para el .NET Framework 2.0 son los primeros capaces de generar código MSIL optimizado para plataformas de 64 bits, tanto para procesadores Itanium como los basados en tecnología extendida x64.

La genericidad es un recurso importante de factorización y reusabilidad en la programación y un soporte para estar más protegidos de cometer errores por inconsistencia en el uso de los tipos. La inclusión de la genericidad es una de las más atractivas y clamadas novedades del venidero .NET Framework 2.0.

En trabajos previos de dotNetManía [1] hemos ilustrado las bondades de esa maravilla introducida por .NET que son los atributos para colocar metainformación dentro de los ensamblados. Veremos en este artículo cómo el propio Visual Studio hace un uso intensivo de los atributos para que podamos personalizar nuestros propios controles visuales.

Es un hecho que en estos tiempos que corren, las aplicaciones que hagamos pueden ser utilizadas por un número o tipo de gente que puede ser de lo más variopinto, todo ello debido a que si dichas aplicaciones las distribuimos en Internet no debemos dejar las puertas cerradas a otras culturas o idiomas. Por ese motivo vamos a ver qué posibilidades nos ofrece .NET para internacionalizar nuestras aplicaciones.

Conseguir que nuestra aplicación apareciese en el área de notificación de Windows (como hace Messenger o una herramienta antivirus) no era tarea fácil con las herramientas de desarrollo antiguas. ¿Qué tal se porta .NET a la hora de implementar esta funcionalidad?

En el artículo sobre las interfaces de dnm.inicio.fundamentos publicado en el nº 16 de dotNetManía, explicamos lo que son las interfaces y vimos algunos ejemplos de cómo usarlas. En esta ocasión veremos más ejemplos, con idea de que nos quede claro cómo utilizar las interfaces en nuestros proyectos, aunque en esta ocasión vamos a usar las interfaces de una forma diferente a lo “habitual”, con la intención de que nos hagamos una idea de lo útiles que pueden llegar a ser estos tipos de datos.

Siguiendo con el tema del último artículo, volvemos a tratar algunos patrones de diseño básicos. En este caso veremos el singleton. Si bien puede tener dos lugares distintos de donde se llaman, siempre es la misma instancia que atiende a la petición cliente.

En este artículo se demuestra por medio de patrones cuando la herencia es una buena opción y algunos síntomas que nos pueden indicar cuando usarla se puede convertir en un problema y cómo resolverlo.

En este primer artículo de esta nueva seccción explicamos las Interfaces. Las interfaces son de esos elementos de .NET Framework que juegan un papel bastante importante, pero que, a pesar de estar por todas partes, aparentemente pasan desapercibidas...

Microsoft WSE es un nuevo módulo de componentes .NET que permite extender el marco de trabajo de .NET Framework 1.1 para poder desarrollar servicios Web XML con características avanzadas. WSE es algo que, sin embargo, al no tenerlo disponible directamente con Visual Studio 2003 no es muy conocido por el momento, pero si se quiere desarrollar un servicio Web XML complejo, hoy en día, la única opción es basarse en WSE 2.0. La intención de este artículo es simplemente dar una visión de alto nivel de qué es WSE y cómo se integra mediante SOAP con .NET 1.1 y Visual Studio 2003.

En este trabajo se presenta la biblioteca Reflection.Editor que nos permite lograr efectos tan atractivos como cambiar nombres de tipos, métodos, quitar miembros de un ensamblado, añadir nuevos miembros, pasar miembros de un ensamblado a otro, poner atributos, y otros mas, y todo ello claro sin tener que disponer del código fuente. Se presenta además la herramienta IL_Lego desarrollada sobre esta biblioteca nos da la posibilidad de hacer interactivamente modificaciones de esta naturaleza.

Las Expresiones Reguladas, son una de las características y posibilidades que ofrece un lenguaje de programación y que por alguna oscura razón, hace que el programador sienta miedo al enfrentarse a ellas. En realidad no voy a descubrir nada diciendo que su dominio requiere tiempo y dedicación; el resumen de esto es que no es lo que definiríamos como sencillo, pero no nos asustemos, no deja de ser en cierta manera un mito y prueba de ello es lo que vamos a ver a partir de ahora: Qué son las Expresiones Reguladas, para qué sirven y cómo usarlas en .NET.

En esta última parte describiremos cómo llamar a funciones externas con un ejemplo a una API de Windows. También describiremos la utilización de TypeLibConverter, en el proceso de exportación e importación de la biblioteca de tipos, clave para llevar acabo la interoperabilidad COM.

Para la mayoría de la gente, el formato PDF es un tipo de documento universal que se puede ver desde cualquier máquina sin perder detalle. ¿Cómo se crea un PDF? Herramientas especiales, conversores…, en definitiva: “cajas negras”. En este artículo vamos a convertir dicha caja opaca, en transparente, estudiando su formato y viendo las diversas formas de generarlo; para ello usaremos C#.

Último artículo sobre Sistemas distribuidos en .NET con Remoting. Una vez visto cómo configurar las opciones de los objetos, los canales que usaremos y la ubicación de éstos mediante RemotingConfiguration, veremos cómo configurar .NET Remoting mediante archivos. Finalmente veremos cómo utilizar un servicio o IIS como host en lugar de una aplicación de consola como hemos venido haciendo hasta ahora.

En este artículo se explican los conceptos básicos de las clases de la infraestructura para gestión de red, así como también la forma de programar un cliente FTP utilizando .NET framework versión 1.0 ó 1.1.

Con tanto bullicio generado alrededor de los servicios Web parece que los programadores de toda la vida (sí, los que usan COM y/o lenguajes de Script, por ejemplo) se han quedado fuera de la nueva onda. Sin embargo .NET ofrece soluciones para todo el mundo, incluso para aquellos que no saben nada de .NET. En este artículo veremos cómo dar el salto al mundo de los servicios Web desde lenguajes tradicionales como Visual Basic 6.0, usando de manera indirecta .NET pero sin tener que aprender nada nuevo.

La interoperabilidad de .NET desde COM es quizás mas inusual aunque sus ventajas nos ofrecen una nueva técnica en un entorno de migración e interoperabilidad. En esta entrega conoceremos cómo utilizar dicha técnica además de las consideraciones previas para interoperar de una manera más eficiente.

Millones de personas conectadas a la red de redes utilizan programas para compartir información. Aplicaciones como Kazaa, eMule y BearShare permiten a sus clientes formar gigantescas comunidades virtuales. En este artículo se enumeran algunas debilidades de estas tecnologías de intercambio Punto a Punto (P2P), entre ellas la de no operar entre sí. El artículo presenta a PON (Peer to peer Over .NET): una plataforma implementada sobre la tecnología .NET, la cual permite el desarrollo de comunidades de nodos .NET. Con esta plataforma se da la posibilidad de conectar aplicaciones diferentes formando redes de intercambio aún más universales. Además de que, cómo en cualquier aplicación, PON aprovecha las bondades de .NET para acortar el proceso de desarrollo, PON se sustenta en el uso de importantes capacidades existentes en .NET como su carácter multiplataforma, y sus capacidades de Reflexión (facilita inspeccionar lo recibido), Serialización (facilita convertir la información al enviarla y al recibirla) y Nombrado Fuerte (nos permite dar y tener seguridad en lo que se envía y en lo que se recibe). La plataforma no requiere de la existencia de servidores para su funcionamiento ya que se apoya en la cooperación de nodos que decidan colaborar en el intercambio.

Después de los conceptos sobre la arquitectura de .NET Remoting que vimos en la anterior entrega, podemos zambullirnos por completo en la creación de objetos remotos. En este capítulo veremos un tema vital, los diferentes comportamientos que pueden presentar los objetos remotos en .NET Remoting. A menudo la primera decisión que tenemos que tomar a la hora de diseñar un objeto remoto o una familia de objetos es elegir el modelo de comportamiento de los mismos.

La subclasificación de ventanas es una técnica específica de la plataforma Windows que permite ampliar las capacidades de la mayoría de los controles y formularios de Windows Forms. Con su uso se consiguen características poco frecuentes pero muy útiles. Veamos cómo sacarle partido.

Conocer las ventajas y posibilidades tanto de COM Interop como de la interoperabilidad con código no adminsitrado en general, nos permite no sólo extender el alcance de nuestras apliciones sino replantearnos los escenarios de migración, ayudados con estas técnicas que ofrece .NET, permitiendo una mayor productividad, menores costes de mantenimiento y como resultado una estrategia de migración mas eficiente.

En la primera parte de esta serie, vimos cómo iniciar una sesión con Messenger (autentificándonos con éxito) y chequear nuestra lista de contactos. En esta segunda parte vamos a ver como “chatear” con ellos.

Sin duda la gran mayoría de las aplicaciones que se desarrollan actualmente son aplicaciones distribuidas. El framework de .Net nos proporciona un poderoso marco para el desarrollo de este tipo de aplicaciones. Veremos como .NET remoting permite desarrollar, desplegar y configurar con facilidad aplicaciones distribuidas sin los quebraderos de cabeza y las limitaciones que presentaban anteriores soluciones.

Con los recursos de reflexión del .NET Framework 1.1 podemos inspeccionar un ensamblado y crear dinámicamente uno nuevo que “mimetice” los tipos y métodos del original. Sin embargo, no podemos copiar código IL de un ensamblado existente hacia otro que estemos creando. Cualquier intento de usar en el nuevo ensamblado funcionalidades de otro ensamblado, implica emitir un código que use recursos del original y por tanto exigir que una aplicación que se desarrolle con el nuevo ensamblado tenga que disponer también del original. Este es un patrón muy común cuando se crean tipos proxy que van a hacer de intermediarios entre el código cliente y el código de un tipo servidor. El código de la nueva aplicación va a facilitarse el trabajo usando el ensamblado del proxy, pero tiene que cargar también con el otro ensamblado porque el proxy hace referencia a éste. ¿Podemos aspirar a formar un nuevo ensamblado “copiando” y “pegando” código extraído de un ensamblado para luego prescindir de éste? En este artículo veremos cuáles recursos aportará el .NET Frame­work 2.0 que pueden ayudarnos a extraer el código IL de un método y copiarlo hacia otro método. Se muestra un ejemplo que ilustra bajo cuáles condiciones se podría “clonar” un ensamblado creando uno igual con la misma funcionalidad (los mismos tipos y métodos) pero en el que se pueden haber cambiado los nombres originales. ¿Se puede lograr un tal efecto de copia y pega más general y ambicioso? Veremos en este trabajo cuáles son las limitaciones para esto; en un próximo artículo se propondrá una biblioteca para facilitar esta “edición de ensamblados” y se mostrará una herramienta (IL-LEGO) desarrollada para realizar visualmente esta edición.

MSN messenger, ICQ, Yahoo Messenger, AOL,… todos hemos usado al menos una de estas redes de mensajería. Hoy en día estas redes gestionan a millones de usuarios a nivel mundial. Seguro que más de una vez se habrá hecho preguntas del estilo de ¿cómo pueden gestionar tantos usuarios a la vez?, ¿son aplicaciones P2P o nos están “escuchando”? Hay clientes de Messenger corriendo bajo Linux, ¿es fácil implementar un cliente que use una de estas redes con .NET?

En este artículo veremos cómo implementar las diferentes versiones del método ToString para que, cuando sea preciso, el usuario de nuestras clases pueda utilizar los formatos personalizados que creamos conveniente aplicar a nuestros tipos de datos.

Con los recursos que brinda .NET, es posible desarrollar mecanismos para interceptar la llamada a un método. Una vez interceptada una llamada se puede entonces tomar el control y ejecutar funcionalidades relacionadas con la ejecución del método, pero que no están incluidas en el código de éste. Este artículo desarrolla y explica tres vías para llevar a cabo esta “intercepción”. Se propone además un patrón de cómo aprovechar la intercepción para, mediante el uso de los atributos de .NET, poder “intercalar” funcionalidad para asociar a la ejecución del método interceptado. Se muestra cómo esta funcionalidad puede expresarse en términos de atributos. Esto sirve de base a lo que se suele llamar “entretejido” de código (weaving) y con ello dar soporte a la aplicación de las ideas de la Programación Orientada a Aspectos (AOP1) en el desarrollo de software sobre .NET.

En no pocas ocasiones debemos utilizar ficheros de inicialización para almacenar determinados valores que serán utilizados por nuestra aplicación. Sin embargo, y según el tipo de proyecto, en algunas ocasiones resulta especialmente útil trabajar con el registro de Windows.

Lo primero que salta a la vista de Delphi 2005 es su voluntad integradora, pues incluye bajo un único entorno de desarrollo la posibilidad de crear software tanto para Win32 como para .NET Framework, utilizando como lenguajes de programación Delphi o C#.

Microsoft .NET Framework y el Common Language Runtime (CLR) marcan un cambio significativo en cómo los desarrolladores construyen aplicaciones para la plataforma Windows. El programador se libera de la tediosa tarea del manejo de la memoria usando características de .NET que lo gestionan automáticamente: para ello, .NET Framework ubica memoria a petición y la reclama al sistema una vez que está libre.

Una de las características que tiene el lenguaje C# desde su aparición es la posibilidad de crear sobrecargas de operadores, tanto aritméticos como lógicos, en nuestros propios tipos. En este artículo veremos algunos consejos que nos serán útiles a la hora de implementar esta característica.

Es mucho lo que se ha escrito (y seguramente se seguirá escribiendo) sobre esta nueva característica de la próxima versión de .NET Framework. Pero en casi todas las ocasiones es referente a que es una nueva característica de C#. Para los que aún no lo sepan, espero que se enteren de que Visual Basic también existe y que forma parte de la familia de lenguajes de .NET y por tanto Visual Basic .NET también podrá usar y crear tipos genéricos, por la sencilla razón de que los tipos genéricos forman parte del .NET Framework 2.0.

Recientemente nuestro maestro Daniel A.Seara, me rechazó dos trucos cortos porque según me cuenta, y con toda razón, no describían ninguna tecnología, así como tampoco detallaba apenas código. ¡Apenas código!, ¡pero si la codificación está desapareciendo! ¡qué rabia! Casi seguro tampoco podré publicar My.primer.articulo porque My.como.tecnología es difícil de describirla dentro del concepto de programación convencional.

En otros artículos hemos podido leer interesantes enfoques de ejecución dinámica de código. Pero a veces, esa aproximación puede suponer auténticos quebraderos de cabeza. La solución muchas veces pasa por mecanismos más sencillos, pero que parten del mismo principio: la abstracción.

En este trabajo se ilustra la utilidad de los enumeradores y del ciclo foreach en C#. Se analizan cuáles son las limitaciones de estos enumeradores que justifican la importancia de la nueva inclusión de iteradores en el venidero C# 2.0. Se ejemplifican las ventajas de estos iteradores en C# 2.0 para escribir código más elegante, legible y menos propenso a errores. Finalmente se proporciona una implementación de iteradores por medio de hebras que, además de ilustrar la utilización de las hebras, ofrece una forma concreta de usar iteradores en el actual C#.

Hay clases de .NET Framework, particularmente algunos tipos de colecciones, que nos permiten clasificar los elementos contenidos en ellas mediante el método Sort, pero debido a que el contenido de dichas colecciones pueden (y suelen) ser de tipos de datos dispares, entre ellos los creados por nosotros, tenemos que darle algún tipo de información para que pueda realizar una clasificación que esté acorde con el tipo de datos contenido en la colección; en este artículo veremos cómo podemos hacerlo.

En todos los libros de ASP .net suele haber un ejemplo, de 4 líneas de código, sobre cómo enviar un correo electrónico con texto plano suponiendo que el servidor de correo se encuentra en la misma máquina o red local… ¿y si queremos hacer algo más? ¿Tenemos que comprar un componente más potente?

La serialización de XML consiste en pasar de un esquema XML a una clase y a la inversa, pudiendo así gestionar los datos XML como si fueran un objeto, simplificando así el tratamiento de XML complejos.

Con el objetivo de poder generar código ajustado a la especificación común de lenguaje (CLS) de la plataforma .NET, Borland ha tenido que introducir ciertos cambios en el compilador de Object Pascal que incorpora la versión 8 de Delphi.

Existe en .Net cuatro maneras de distribuir aplicaciones, a saber: Los servicios web, .Net Remoting, Mensajería (MSMQ) y Componentes empresariales (COM+). Los tres primeros métodos de distribución son controlados por el la plataforma .Net, por lo que sólo explicaré estas tres primeras en los próximos párrafos.

El conjunto de clases incluido en el espacio de nombres System.Drawing, provee al programador de todas aquellas características necesarias para dotar a los gráficos de efectos adicionales, que permitan aportarles una mayor vistosidad. A lo largo de este artículo, realizaremos un repaso de los principales elementos existentes en GDI+, de forma que sirvan de base al lector para la elaboración de sus propios efectos.

Entre otras razones .NET supera a tecnologías de componentes precedentes por la transparencia con la que integra código y metadatos favoreciendo con ello la metaprogramación. Este trabajo muestra cómo usando reflexión (reflection) se define un conversor de tipos que permite a partir de un objeto, el cual comparte una misma funcionalidad con un interface, obtener un objeto proxy equivalente en funcionalidad al original pero que garantiza ser subtipo de dicha interface. De este modo el objeto proxy puede ser utilizado como si estáticamente hubiese declarado que implementa el tipo interface. Con ello se facilita la adaptabilidad del software y la factorización de código ya existente para poder aprovechar una funcionalidad común. La solución propuesta permite ilustrar además la existencia de un peligroso agujero de seguridad en el sistema de tipos de .NET, el cual lamentablemente no es controlado por el CLR. Esta falla permitiría la escritura de código malicioso aún ejecutando bajo el supuesto modo seguro del código administrado.

Tercera y última entrega de esta serie de artículos en la que hemos pretendido explicarle cómo hacer las mismas cosas (o casi) tanto en C# como en Visual Basic .NET

La llegada de la tecnología .NET ha venido acompañada de GDI+ (Graphics Device Interface), que como su nombre deja entrever, se trata de la nueva generación del API gráfico de Windows, adaptado a la plataforma .NET Framework.

En este artículo veremos la forma de compilar bajo demanda código creado al vuelo o residente en archivos externos a nuestra propia aplicación. Como ejemplo práctico construiremos un evaluador de expresiones.

Segunda entrega de esta serie de artículos que pretende explicarle cómo hacer las mismas cosas (o casi) tanto en C# como en Visual Basic .NET.

Una cosa que es indiscutible, en lo que a la programación de aplicaciones para .NET Framework se refiere, es que todos los lenguajes se apoyan en las clases que ese marco de trabajo incluye. Ya pasó la época en la que para hacer ciertas tareas comunes, como abrir un fichero, acceder a una base de datos o interactuar con el sistema operativo subyacente cada lenguaje de programación tenía su propia forma de hacerlo. Por suerte para los programadores ahora sólo necesitamos conocer una forma de trabajar: La forma que las clases de .NET Framework tienen para hacerlo. .NET Framework incluye casi toda la funcionalidad que necesitamos para crear nuestras aplicaciones, y si algo que necesitamos hacer no se incluye entre los numerosos espacios de nombres plagados de clases de .NET Framework, podemos recurrir a componentes creados por terceros e incluso crearlos nosotros mismos. Ahora, lo importante es que, independientemente del lenguaje que estemos usando, siempre tendremos la oportunidad de hacer las cosas al estilo de .NET Framework: Usar una clase para lo que necesitemos. Para poder usar una clase, sólo necesitamos saber cómo declararla e instanciarla en la memoria para que esté lista para usar. No necesitamos saber nada más, salvo conocer la sintaxis apropiada del lenguaje que hayamos elegido para desarrollar nuestras aplicaciones para poder hacer esa tarea. Lo mismo ocurrirá si pretendemos crear nuestras propias clases; tendremos que saber cómo quiere .NET Framework que hagamos las cosas, qué requisitos nos exige y una vez que sepamos esas exigencias, podremos crear nuestro propio juego de clases. En ambos casos debemos conocer la sintaxis que utiliza nuestro lenguaje predilecto para hacernos entender con .NET Framework. Se supone que si estamos programando en Visual Basic .NET, o en C#, sabremos aplicar las reglas sintácticas del lenguaje para poder realizar todas las tareas... o casi todas, que algunas veces no sólo es suficiente conocer la sintaxis del lenguaje, ya que si no conocemos cómo realizar ciertas cosas, por muy bien que sepamos hacer un bucle FOR, no nos servirá de mucho. Voy a dar por supuesto que ya sabes programar para .NET, es decir, ya sabes cómo hacer las cosas para trabajar con las clases de .NET Framework, (aunque no conozcas todas las clases incluidas en .NET), ya sabes cómo crear tus propias clases, ya sabes cómo derivar una clase a partir de otra, ya sabes cómo implementar una interfaz, ya sabes cómo crear un bucle o definir una propiedad e incluso un constructor o un destructor (o finalizador); sí, se supone que ya sabes hacer todas esas cosas en el lenguaje que has elegido para programar, (en esta serie de artículos supondré que ha sido el lenguaje C# o Visual Basic .NET), pero lo que seguramente te gustaría es saber cómo hacerlo en el otro lenguaje. Y eso es lo que esta serie de artículos pretende, explicarte cómo hacer las mismas cosas tanto en C# como en Visual Basic .NET. Seguramente serán los programadores de Visual Basic los que tengan más interés en conocer cómo trabajar con sintaxis de C#, por aquello de que en algunos sitios valorarán más a quién sepa programar en C# frente al que sólo sepa programar en el, siempre mal visto, lenguaje de la familia BASIC. Aquí no voy a enseñarte a programar en ninguno de los dos lenguajes más utilizados por los desarrolladores de .NET Framework, aunque seguramente algunas de las cosas aquí explicadas te ayudarán a clarificar tus ideas. Si quieres aprender a programar, deberías plantearte acudir a algún centro de formación, a algún sitio de Internet o comprarte algún libro. Sin más historias empecemos viendo las distintas tareas que podemos realizar en .NET Framework comparadas entre los lenguajes C# y Visual Basic .NET, veremos desde cómo declarar una variable hasta cómo llamar desde el constructor de una clase derivada al de la clase base.

Cuando comenzó Internet, nadie conocía el alcance real que hoy día tiene. Lo más valioso de la red de redes es la información, pero ¿tenemos control sobre la información que se publica en Internet y tenemos acceso a ella fácilmente?. Desgra­ciadamente, la información fluye a una velocidad imparable e incontrolable, pero permanece inaccesible en muchos de los casos, y en otros, requiere que realicemos diferentes saltos entre un lugar y otro en Internet para conocer las noticias e informaciones que publica un sitio y otro o sobre un tema de interés. Es decir, la información se encuentra dispersa y sin criterio alguno que nos permita compartir y acceder a ella sin trastornos para los usuarios. Para tratar de evitar en parte esta desinformación, apareció el concepto de RSS. Ahora bien, ¿qué y cómo es?, ¿cómo acceder a este tipo de recursos? y sobre todo, ¿cómo tratarlos en nuestras aplicaciones ASP .NET?. Esto es justamente lo que veremos en este artículo.

Es costumbre cada 2 años que Microsoft aporte una nueva versión de sus sistemas operativos. No obstante, esta vez el período de tiempo será mayor, y según parece los cambios internos en el sistema, también. Es la herencia de algo que comenzó con la revolución .NET, de la cual esta edición de Windows es su exponente más completo. Vamos a analizar algunas de las características de sus 3 APIs principales.