I Remote

Mudanza

2011-01-08T21:07:00.002+01:00

Me he mudado a WordPress a la dirección http://jmservera.wordpress.com así que no seguiré escribiendo en este. He copiado allí todos mis artículos y en unos meses daré de baja I Remote para siempre.

Seguiré hablando de temas de programación en el mundo del .Net Framework, ahora enfocado más a Surface, WP7 y Azure.

Nos leemos en WordPress.com!

StackOverflow, ¿para cuándo uno en castellano?

2010-10-11T12:10:00.005+02:00

StackOverflow.com es una web colaborativa de preguntas y respuestas sobre programación. Creada por el equipo de Joel Spolsky, empezó como un experimento y hoy en día ya se ha convertido en un punto de referencia para desarrolladores de todo el mundo.

Hace unos meses crearon un sitio (area51) donde proponer nuevas aplicaciones para el motor Stack Exchange, el usado en StackOverflow.

Crear un sitio es gratuito y el único requisito es que haya una comunidad lo suficientemente grande y activa. Hay ya más de 1000 propuestas, de las más variopintas, entre ellas una propuesta de crear un foro de programación en castellano, pero aún está en fase de definición.

¿Alguien se apunta?

Si aún no conocéis StackOverflow.com os animo a visitar el sitio y participar.

Para más referencias podéis ver el vídeo (en inglés) de Scott Hanselman en el que habla sobre StackOverflow y otras cosas interesantes.

Código fuente de la OData Client Library

2010-04-27T17:01:00.003+02:00

Para ayudar a la comunidad a crear sus propias librerías cliente de OData, el equipo de Project Astoria ha publicado sus librerías de cliente .Net y Silverlight en codeplex bajo licencia Apache 2.0.

Enterprise Library 5.0 publicada

2010-04-23T23:57:00.006+02:00

Microsoft patterns & practices ha publicado la nueva Enterprise Library 5.0, una colección de módulos que se pueden usar a modo de bloques prefabricados y configurables para construir grandes aplicaciones.

Como desde su primera versión, incluyen el código fuente como ejemplo de buenas prácticas y también para posibilitar modificaciones que no sean posibles a través de su extenso sistema de configuración.

Al ser un sistema modular no hace falta distribuir toda la librería entera con nuestra aplicación, sino que usaremos sólo los bloques que nos convengan. Para los que aún no sepáis qué es, la colección entera incluye:

Caching Application Block: para almacenar datos temporalmente, tanto en memoria como en un almacen de datos intermedio.
Cryptography Application Block: para incorporar fácilmente hashing y encriptación simétrica a nuestras aplicaciones.
Data Access Application Block: simplifica el acceso a datos, normalmente basado en ADO.Net y DataSets, independizando la capa de acceso a datos del motor.
Exception Handling Application Block: para definir estrategias comunes de manejo de excepciones y errores a todos los niveles de las capas de la aplicación
Logging Application Block: los desarrolladores pueden incluir el registro de mensajes sobre un amplio abanico de fuentes de manera simple y sencilla.
Policy Injection Application Block: usando los mecanismos de inyección de Unity se pueden implementar políticas de captura de mensajes para canalizar la implementación de partes comunes como el manejo de excepciones o el caching.
Security Application Block: para incorporar autorización y funcionalidades de caché de seguridad en las aplicaciones.
Unity Application Block: un contenedor de inyección de dependencias, para que podamos crear aplicaciones fácilmente extensibles
Validation Application Block: permite crear reglas de validación para objetos que puedan ser usadas en otras capas de la aplicación.

Wikipedia Explorer ahora sobre Azure

2009-07-23T09:34:00.007+02:00

DotNet Solutions ha actualizado su Wikipedia Explorer que ahora utiliza la tecnología de Windows Azure para convertir la base de datos de la Wikipedia a formato XML/XAML y así acelerar la aplicación que antes convertía los datos al vuelo.

Wikipedia Explorer es una aplicación WPF que proporciona una nueva forma de navegar por la wikipedia, visualizando las relaciones entre documentos.

Gracias a la plataforma Windows Azure han podido reducir el tiempo de proceso para la conversión de la base de datos de 6 meses a 5 días.

La aplicación está disponible en modo ClickOnce aquí.

Las verdaderas razones detrás de un cambio

2009-04-24T09:35:00.003+02:00

Hoy, leyendo una entrada de Jose Fco Bonnin, me han empezado a sonar las alarmas y he sentido la necesidad de investigar un poco.

El motivo de su post es que en el VS2008 se quitaron algunas reglas del FxCop, entre ellas la "CA1818 - Do not concatenate strings inside loops".

Tal como Jose ha comprobado, no ha habido ningún cambio en el framework para que esa regla se pueda quitar y el motivo que alega el equipo de Code Analysis es que la han quitado debido a "high noise or no longer applicable analysis".

Cualquier desarrollador de .Net que se haya preocupado un mínimo por el rendimiento una de las primeras cosas que suele mirar es si la aplicación está generando demasiados strings; así que debe haber alguna otra razón para quitar esa regla del motor.

Tras buscar un poco he encontrado unas entradas que nos dan alguna una pista: tanto en una conversación en el foro de fxcop beta como en una nota de su blog comentan que el "data flow analysis engine", el encargado de comprobar esa regla, ha sido eliminado porque no funcionaba bien, era muy lento y además indeterminista.

Es una opinión/deducción personal, pero creo que nos han contado una verdad a medias y el impacto de haber quitado esa regla puede ser verdaderamente alto en aplicaciones grandes.

Teóricamente Phoenix iba a arreglar el desaguisado pero no parece que tenga continuidad, así que habrá que ver si en vs2010, que vuelve a tener un data flow engine, las reglas se han vuelto a activar. ¿Alguien lo ha probado ya?

Serialización dinámica con el XmlSerializer

2009-02-23T13:51:00.006+01:00

Para acabar con esta espontanea serie de posts sobre el XmlSerializer os cuento un par de trucos no demasiado bien documentados para controlar la serialización.

En algunas ocasiones podemos necesitar que una clase hija no persista algunas de las propiedades del base, pero, como ya hemos visto antes, si la propiedad no es virtual se complica un poco el asunto. En estos casos podemos añadir un miembro público a la clase base con el mismo nombre de la propiedad + Specified con el valor a true:

public class C1
{
	public string MyProperty { get; set; }
	[XmlIgnore]
	public bool MyPropertySpecified = true;
}

De esta manera al heredar de la clase podremos especificar su valor a false, lo que hará que no se persista dicha propiedad:

public class C2:C1
{
	public string MyOtherProperty { get; set; }
	public C2()
	{
		MyPropertySpecified = false;
	}
}

En otras ocasiones, lo que querremos es decidir cuando se debe persistir el valor y cuando no. Por ejemplo, si una lista no tiene valores o si un string es null puede que no nos interese que aparezca el valor vacío en el xml. Eso se consigue con un método público llamado ShouldSerialize + el nombre de la propiedad y que devuelva un bool indicando si la propiedad debe persistirse:

public class C3 : C2
{
	public string MyThirdProperty { get; set; }
	public bool ShouldSerializeMyThirdProperty()
	{
		return false;
	}
}

Ahora podéis probar las clases, adivinad qué mostrará cada llamada:

XmlSerializer ser = new XmlSerializer(typeof(C1), 
	new Type[] { typeof(C2), typeof(C3) });
ser.Serialize(Console.Out, new C1() { MyProperty = "test"});
Console.WriteLine();
ser.Serialize(Console.Out, new C2() { MyProperty = "test", 
	MyOtherProperty = "test 2" });
Console.WriteLine();
ser.Serialize(Console.Out, new C3() { MyProperty = "test", 
	MyOtherProperty = "test 2", MyThirdProperty="test 3" });
Console.ReadLine();

XmlSerializer y ocultación de propiedades

2009-02-20T16:49:00.006+01:00

Esta mañana tras responder a un post de Eduard Tomàs i Avellana me ha dado por investigar un poco más sobre el tema...

En su caso el problema tenía solución pues podía modificar ambas clases, pero ¿qué pasaría si estamos heredando de una clase que no podemos modificar? Hay múltiples soluciones, desde el uso de un patrón Adapter hasta la implementación del interface IXmlSerializable, pero todas ellas requieren escribir una cantidad considerable de código.

Pero... en algunos casos nos podría servir una sobrecarga del XmlSerializer que admite como argumento una instancia del XmlAttributeOverrides, que, como su propio nombre indica, nos permite sobrecargar los atributos que usa el XmlSerializer sobre una clase para generar el código de serialización. Aunque tiene sus peligros podremos influir en cómo se serializa la clase base sin tener que modificarla.

Por ejemplo, si tuviéramos la siguiente definición de clases:

public class C1
{
 List<C1> _myList = new List<C1>();
 public List<C1> MyList { get { return _myList; } }
}

public class C2:C1
{
 List<C2> _myList = new List<C2>();
 public new List<C2> MyList { get { return _myList; } }
}

Al crear el XmlSerializer nos daría un error de reflexión como pasaba en el caso de Eduard. Pero podemos obligar al serializador que ignore la propiedad de la clase base mediante el siguiente código:


XmlAttributeOverrides xOver = new XmlAttributeOverrides();
XmlAttributes atts = new XmlAttributes(){ XmlIgnore=true};
xOver.Add(typeof(C1), "MyList", atts);
XmlSerializer ser = new XmlSerializer(typeof(C2),xOver);
ser.Serialize(Console.Out, new C2());

Aunque hay que usarlo con extremo cuidado, pues cualquier otra instancia del tipo C1 o derivados no serializará la propiedad MyList con ese serializador.

¿Alguien más se anima a encontrar otra solución?

Optimización de XmlSerializer

2009-02-06T12:00:00.020+01:00

Ayer, haciendo una de revisión en un servicio, nos dimos cuenta que se hacían continuamente llamadas al csc.exe. Esto provocaba que el servicio fuera muy lento y además consumiera mucha memoria, así que nos pusimos manos a la obra.

Como sabíamos que el servicio hacía un uso intensivo de la serialización Xml con el XmlSerializer no hizo falta hacer debug sino que fuimos a mirar el código que probablemente invocaba al csc.

Paso directamente a describir cómo funciona y el porqué del comportamiento que encontramos.

En .Net serializar una clase sencilla (sin referencias circulares, con al menos el constructor por defecto, etc...) a Xml es bastante directo, sólo necesitas crear un XmlSerializer para la clase en cuestión, por ejemplo, si tenemos un conjunto de clases así:public class BaseClass { public int BaseProperty { get; set; } } public class TestClass { public string MyProperty1 { get; set; } public BaseClass MyProperty2{get;set;} }

Para serializar TestClass podríamos usar el siguiente código:
TestClass xmlSerializableClass = new TestClass { MyProperty1 = "test", MyProperty2 = new BaseClass()}; XmlSerializer serializer = new XmlSerializer(typeof(TestClass)); serializer.Serialize(Console.Out, xmlSerializableClass);

Al ejecutarse genera un archivo .cs con el código de serialización de nuestra clase lo compila y lo ejecuta para serializarlo. La siguiente vez la clase XmlSerializer no volverá a compilar pues guarda internamente una lista con (casi) todos los serializadores que va creando.

Si heredamos de BaseClass y queremos que nuestra nueva clase se incluya en el serializador hay que agregar un atributo para que el XmlSerializer la tenga en cuenta automáticamente, en caso contrario nos daría un error en tiempo de ejecución:
public class AnotherClass:BaseClass { public int AnotherProperty { get; set; } } [XmlInclude(typeof(AnotherClass))] public class BaseClass { public int BaseProperty { get; set; } }

De esta manera el siguiente código seguirá funcionando y utilizando el caché:
TestClass xmlSerializableClass = new TestClass { MyProperty1 = "test", MyProperty2 = new AnotherClass()}; XmlSerializer serializer = new XmlSerializer(typeof(TestClass)); serializer.Serialize(Console.Out, xmlSerializableClass);

Hasta aquí bien, pero ¿qué pasa si en tiempo de compilación aún no sabemos exactamente cuantas clases heredarán de BaseClass? Podría ocurrir que tuvieramos una aplicación con plugins y que pudieran añadir más clases ahí. Para eso el XmlSerializer tiene otro constructor donde le podemos pasar una lista de tipos a añadir al serializador aparte de los que haya indicados en el atributo:
XmlSerializer serializer = new XmlSerializer(typeof(TestClass), new Type[]{typeof(NotIncludedClass)});

El único problema de este constructor es que no guarda la clase autogenerada en el caché. Por lo tanto, cada vez que se ejecute el código se ejecutará un csc.exe y se cargará un nuevo assembly dentro de nuestra aplicación. Eso nos produce dos efectos:

Nuestra aplicación se ralentiza
Como los assemblies no se descargan nunca, la memoria no se libera

En estos casos nos conviene guardar una referencia al serializador. Espero haber ayudado a alguien. Podéis descargar el código de ejemplo aquí.

Para saber más, hace ya unos cuantos años escribí un pequeño de introducción al XmlSerializer que podéis encontrar aquí.

The network is the...

2008-12-03T17:38:00.004+01:00

~~Computer~~ Great Deal!
Mientras los unos hablan del Cloud como la evolución natural e ineludible y los otros nos advierten de sus peligros, los más avispados se están dando cuenta de que volvemos a los inicios de la computación, cuando alquilaban los “superordenadores” por horas. El Cloud Computing no va de ubicuidad, ni va de la red, ni va de encontrar la pregunta a la respuesta 42, sino de cambiar la manera en que las grandes compañías hacen el negocio.
Igual que la moda tiene ciclos (y no sólo la de mujer... aunque lo diga Stallman) y cada 50 años vuelven los pantalones de campana, parece ser que en tecnología ocurre lo mismo (y ahí si que le doy la razón).

EC2, GoogleApi, Azure, Project Caroline, Blue Cloud, vCloud son todo tecnologías propietarias, pero yo me pregunto si habrá alguien desarrollando un Free Cloud OS por ahí, algo revolucionario de verdad.

Nota mental: desactivar el informe de problemas y soluciones

2008-12-01T15:28:00.010+01:00

Hace unos días la herramienta de "Informes de errores y soluciones" me dió un buen susto. Mientras ejecutaba unos tests unitarios en Visual Studio el VSTestHost.exe encontró un problema y se cerró... tras el primer susto inicial (que luego os cuento) resultó que una de las clases que estaba testeando daba una StackOverflowException.

Como algunos sabréis las StackOverflowException no son capturables desde la versión 2.0 del framework. Además, para los que no lo hayáis probado sabed que ni siquiera se capturan con RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup, así que el framework de unit testing tampoco las captura, se cierra y punto.

Lo gracioso de todo esto es cómo el Windows Vista ha manejado el error del unit testing. La dichosa herramienta de solución de errores me ha dado la siguiente solución:

Informes de errores y soluciones

Este problema se debe a Visual Studio Team Edition for Software Testers. Visual Studio Team Edition for Software Testers fue creado por Visual Studio Team Edition for Software Testers.

El período de prueba para ejecutar versiones beta o preliminares de Visual Studio Team Edition for Software Testers se ha agotado, y Visual Studio Team Edition for Software Testers ya no ofrece soporte para versiones beta. Deberá realizar la actualización a la versión comercial de Visual Studio Team Edition for Software Testers.

Solución

Para obtener más información acerca de cómo realizar la actualización a la versión comercial de Visual Studio Team Edition for Software Testers, vaya al sitio web que se indica a continuación.

¿Cómo?¿Que tengo que comprar otro VS.Net para ejecutar las pruebas que venía ejecutando hasta ahora? ¿Tan malo soy programando?

Moraleja: en las máquinas de desarrollo con Vista mejor desactivar el informe... os evitaréis problemas innecesarios.

Guía sobre Oslo, Azure & Dublin

2008-11-19T09:34:00.003+01:00

Vía Miguel Llopis he encontrado una guía de los blogs del equipo de Connected Systems en Microsoft donde encontraréis todo lo que se ha hablado sobre estos temas. Podéis encontrar esta guía aquí.

Recordad desbloquear el CHM en las propiedades del fichero para poder verlo.

Revuelo en la nube

2008-11-18T18:20:00.004+01:00

Hace ya algunas semanas que no hace más que hablarse de Azure y los partidarios de cada bando dan sus argumentos de por qué un sistema es mejor que otro: que si amazon lleva más tiempo, que si google sabe más de internet, que si vamos camino del gran hermano de Orwell (otra vez!).

Creo que mejor dejamos esta guerra a los de sistemas y nos centramos en lo que más nos interesa a nosotros: con Azure podremos crear aplicaciones con ASP.Net, desde el Visual Studio y desplegarlas a la nube fácilmente.
¿Qué más queréis? Personalmente me parece fantástico poder crear aplicaciones de una nueva forma sin tener que ampliar de nuevo mis conocimientos, que, como dice David Salgado, ya suficiente tenemos con el nuevo paradigma de MDD y las novedades de C# 4.0.
La pena de todo esto es que por ahora es un CTP cerrado y los mortales que no fuimos al PDC no podemos probarlo aún, habrá que esperar.

Por otra parte, está claro que Microsoft sigue viendo un gran negocio en las aplicaciones de escritorio y Mesh nos permite sincronizar datos entre dispositivos usando la nube. Seguro que cuando lo probéis decidiréis dejar los pendrives en la misma caja donde tenéis los disquettes.

Crack.Net

2008-10-22T10:36:00.003+02:00

No, no es un buscador de lo que pensais sino una nueva herramienta para mirar dentro de la "managed heap" de cualquier aplicación Net de escritorio. La podéis descargar aquí:
http://www.codeplex.com/Project/Download/FileDownload.aspx?ProjectName=cracknetproject&DownloadId=46987

Josh Smith, uno de los creadores de mole ha creado esta potente herramienta que nos ayudará a ver qué hacen nuestras aplicaciones de una manera más intuitiva que el debugger del vs.net.

Multicore & Parallel Programming

2008-10-14T11:03:00.003+02:00

¿Es 2 mejor que 1?

Acabo de leer un post de José Manuel Alarcón sobre el problema de los procesadores multicore y cómo la industria está intentado resolverlo. No es sencillo y, como siempre, quien tiene que apechugar con las "nuevas características" y paradigmas del hardware es el pobre desarrollador. Menos mal que alguna ayudita tendremos gracias a que las Parallel Extensions serán parte de núcleo del Framework 4.0.

Nuevas charlas de Baleares on .Net

2008-10-14T10:37:00.003+02:00

Podéis leer en el blog de Javier Jofre que hay dos nuevas charlas sobre MS SQL Server 2008 preparadas por la gente de Innova. El equivalente al Heroes Community Launch para SQL Server 2008. Serán:
Viernes 24 Octubre:
- Carlos A. García: Tipos de datos nuevos en SQL Server 2008.- Pedro Bauzá: Sql Server 2008 versus SQL Server 2005.
Jueves 20 Noviembre:
- Javier Jofre: Reporting Services con SQL Server 2008.

System.Data.Services

2008-08-12T08:48:00.003+02:00

Hace ya un tiempo que en Baleares on .Net dimos, entre otras, una charla sobre ADO .Net data services. Por entonces estaba en fase beta, pero ya funcionaba bien y prometía mucho.
Como todo tiene un final, ayer, por fin, se publicó el SP1 del Framework 3.5 con todas las nuevas funcionalidades, así que ya podremos usar en producción los servicios REST y unas cuantas cosas más.

La documentación para ADO.Net Data Services está online dentro del namespace System.Data.Services y en el WebLog de Marcelo encontraréis la explicación de los namespaces.

Happy coding.

Ineta Europe gets social

2008-07-29T10:36:00.003+02:00

A través de Mad about .Net he sabido que INETA ha creado una red social para todos sus miembros.

Podéis uniros en http://community.ineta-europe.org/

Herramientas de Sysinternals compartidas en la web

2008-06-13T09:38:00.003+02:00

A través de un blogger de Geeks he encontrado un lugar donde están compartidas todas las herramientas de sysinternals:

http://live.sysinternals.com/
Es una simple lista de utilidades que se pueden ejecutar directamente desde la página en un momento de apuro. Por ejemplo segundos antes de hacer una demo nos damos cuenta que no tenemos instalado el zoomit... pues ahí está.

ADO.NET Data Services Framework Beta 1

2008-05-13T10:02:00.003+02:00

¡Por fin ya tenemos la beta! Viene incluida como parte del paquete .NET 3.5 SP1 Beta 1 al mismo tiempo que Visual Studio 2008 SP1 Beta 1. Hay un montón de cambios que ya empezaron a anunciar en el Mix 08. A nivel de nombres de clases y namespaces ha habido bastantes, algo habitual cuando se pasa de un ctp a una beta, pero además hay unas cuantas novedades importantes:

Batch: ahora se pueden enviar paquetes de cambios que se ejecutarán en un contexto atómico.
Concurrencia optimista: se posibilita mediante un "token" de concurrencia mediante ETags y HTTP If-*.
Nuevo interface IUpdatable: para permitir servicios de escritura sobre fuentes de datos que no estén usando el Entity Framework sino un interface IQueryable.

Podéis leer más en el blog de Pablo Castro.

Hago mis propios programas... y juegos!

2008-05-05T13:17:00.004+02:00

Parece que ese infame anuncio de un curso de programación dejó huella en alguien del equipo de Popfly, y ahí tenéis el resultado:

Un creador de juegos online basado en Silverlight. Podéis ver más en el blog de Jason Zander.

Microsoft se vuelve a subir a la nube con Live Mesh

2008-04-24T13:54:00.004+02:00

Si hace poco ya anunciaron los SQL Server Data Services, que ofrecen a los desarrolladores la plataforma de SQL Server en la nube, ahora dan un paso más alla con todos los servicios del desktop en la nube con Live Mesh. Podéis ver a Ray Ozzie hablando del tema en Channel 9 o ver este video de demostración:

Hands on with Live Mesh

.NET 3.5 Enhancements Training Kit

2008-04-21T20:28:00.002+02:00

El equipo de evangelismo de VS y .Net Framework publicó hace poco un paquete de recursos sobre las siguientes tecnologías:

ADO.NET Data Services
ADO.NET Entity Framework
ASP.NET AJAX History
ASP.NET Dynamic Data
ASP.NET MVC
ASP.NET Silverlight controls

En el post original comentan que irán añadiendo poco a poco más cosas como demos, presentaciones, etc...

Fotos del aniversario de Baleares On .Net

2008-04-02T18:06:00.005+02:00

Jose ha colgado las fotos del aniversario en su facebook.

Primer aniversario de Baleares on Net

2008-03-31T15:58:00.004+02:00

El pasado viernes participé en el Community Launch y aniversario del grupo de usuarios Baleares on Net. Mi charla fué sobre Ado .Net Data Services, espero que os gustara tanto como me ha gustado a mi prepararla. Dentro de poco estarán disponibles las diapositivas y demos para descarga.

Gracias a todos por asistir y a los ponentes por ser tan majos y dispuestos a venir tan lejos.

Heroes Community Launch

2008-03-07T13:43:00.004+01:00

Ya tenemos preparado el Heroes Community Launch en la comunidad Baleares On .Net. Vamos a realizar una jornada para la presentación de los últimos productos de Microsoft lanzados el 27 de Febrero de 2008. José lo ha organizado para que vengan ponentes reconocidos que han estado en otros eventos similares. Será el 28 de Marzo bajo el siguiente programa:
09:00 - 09:30 Registro
09:30 - 10:00 Bienvenida y Presentación.
10:00 - 11:00 Windows Server 2008 - David Cervigón, Microsoft.
11:00 - 12:00 Metodologías Ágiles con TFS 2008 - Rodrigo Corral, PlainConcepts.
12:00 - 12:30 Coffee Break
12:30 - 13:30 SQL Server 2008 - Eladio Rincón, SolidQuality Mentors.
13:30 - 14:30 ADO.NET Framework Entity - Jose Fco Bonnin, Payvision.
14:30 - 15:30 Tiempo libre para almorzar
15:30 - 16:30 ADO.NET Data Services - Juan Manuel Servera, Babtec.
16:30 - 17:30 Diseño Emocional y Experiencias de Usuario Avanzadas con Silverlight y WPF - Miguel Jiménez, Ilitia.
17:30 - 18:30 Advanced Debugging - David Salgado, Microsoft.

Para asistir simplemente es necesario registrarse.

Visual Studio 2008, SQL Server 2008, Windows Server 2008, Astoria, Entity Framework ...

2008-02-19T10:49:00.004+01:00

El 28 de Marzo tenemos un evento especial en Baleares On .Net. El aniversario del grupo coincide con un evento del programa {Community} Launch, del que formamos parte, así que habrá una gran presentación de los nuevos productos de Microsoft para desarrolladores.
Podéis leer más detalles en: http://www.baleareson.net/CommunityLaunch/
Dentro de poco estará disponible el registro.

Silverlight 2.0

2007-12-01T10:19:00.000+01:00

Scott Guthrie acaba de anunciar en su blog (entre otras muchas cosas) el lanzamiento de la primera beta de Silverlight 2.0 a principios del año que viene.
El "truco" reside en que estaban añadiendo tantas características nuevas a 1.1 que han decidido cambiarle el número de versión.
Las mejoras son: uso de un subconjunto de las características del WPF UI compatibles con éste, más de 20 controles ricos que incluyen textbox, checkbox, radiobutton, grid, tabcontrol, progressbar y un largo etcétera, manejo en red de REST, POX, RSS, and WS* y conexiones cross-domain (por fin!), además de las funcionalidades de las librerías base de .Net (colecciones, generics,...) e incluso LINQ to XML.
¡Ya no tendremos excusa para no usarlo!

Visual Studio 2008

2007-11-07T10:26:00.000+01:00

Microsoft anunció en el TechEd de Barcelona la inminente publicación de la versión RTM (release to manufacturing) de Visual Studio 2008 a finales de este mes.

La versión final junto con Windows Server 2008 y SQL Server 2008 la veremos el 27 de Febrero.

AJAX y WebParts

2007-10-22T23:54:00.000+02:00

ASP.NET AJAX Extensions se publicó hace ya algún tiempo y aún no hay una versión oficial de sharepoint con soporte directo para éstas.
En ASP.NET siempre se ha podido leer contenido de manera asíncrona usando la cláusula Async y un par de trucos de javascript; pero todos sabemos que AJAX hace mucho más que eso y de manera mucho más fácil y elegante... hasta que lo intentas usar en sharepoint!
Instalar las extensiones es una tarea complicada pero no imposible si tenemos algo de experiencia con sharepoint, aunque hacer que funcionen como esperamos puede ser un buen rompecabezas.

Afortunadamente hay un montón de gente con ganas de usar AJAX. Ahí tenéis dos ejemplos:

El sr. Zlatan ha dado con una solución para el refresco cíclico de datos en una webpart
Como ya comenté en la presentación, lo verdaderamente complicado de AJAX en Sharepoint son las conexiones entre webparts, aunque siempre podemos usar la nueva SmartPart de Jan Tielens.

Espero que os sirvan.

SharePoint 2007 Learning Guide

2007-10-01T10:55:00.000+02:00

Para los que os haya entrado el gusanillo Sharepoint aquí teneis un sitio con montones de links para aprender sobre él:

http://searchvb.techtarget.com/generic/0,295582,sid8_gci1274283,00.html

Mi primer evento

2007-09-23T23:29:00.001+02:00

El pasado día 21 tuve la ocasión de dar mi primera charla sobre el desarrollo sobre Sharepoint en un evento del grupo Baleares on .Net. Podéis encontrar la presentación powerpoint en la web del grupo. En breve mandaré algunos ejemplos más que me pidieron pero que fue imposible hacer en directo por falta de tiempo.

Nos vemos en el próximo evento!

Copia de listas en Sharepoint

2007-08-28T23:45:00.001+02:00

Hace unos días en el foro Baleares On .Net pedían un ejemplo para fusionar listas en MOSS 2007. Aquí tenéis un ejemplo rápido de cómo se pueden hacer estas cosas gracias al modelo de objetos de WSS. Basta con crear una aplicación de consola con una referencia a la librería Microsoft.Sharepoint.dll (v12) y escribir un código parecido a éste (si lo parametrizais un poco quedará mucho más bonito):

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint;

namespace ListMerge
{
    class Program
    {
        static void Main(string[] args)
        {
            //abre el sitio
            Console.WriteLine("Abriendo sitio...");
            SPSite mySite = new SPSite("http://localhost");
            SPWeb myWeb = mySite.OpenWeb();
            
            //obtiene las listas
            Console.WriteLine("Obteniendo listas...");
            SPList list1 = myWeb.Lists["task list 1"];
            SPList list2 = myWeb.Lists["task list 2"];
            
            //crea una nueva lista para copiar las dos anteriores
            Console.WriteLine("Creando nueva lista...");
            Guid newListId = myWeb.Lists.Add("nueva Lista",
                "nueva lista a partir de otras dos",
                list1.BaseTemplate);
                
            SPList newList = myWeb.Lists[newListId];
            newList.Update();
            
            //copia la primera lista
            Console.WriteLine("copiando lista 1");
            foreach (SPListItem item in list1.Items)
            {
                SPListItem newItem=newList.Items.Add();
                foreach (SPField field in item.Fields)
                {
                    if (!field.ReadOnlyField)
                    {
                        if (newList.Fields.GetField(field.Title) != null)
                        {
                            try
                            {
                                newItem[field.Title] = item[field.Title];
                            }
                            catch (Exception ex)
                            {
                             //algunos campos puede que no se puedan 
                                //copiar (attachments, etc...)
                                Console.WriteLine(ex.Message);
                            }
                        }
                    }
                }
                //necesario para crear el item
                newItem.Update(); 
            }
            
            //copia la segunda lista, código exacto al anterior
            Console.WriteLine("copiando lista 2");
            foreach (SPListItem item in list2.Items)
            {
                SPListItem newItem = newList.Items.Add();
                foreach (SPField field in item.Fields)
                {
                    if (!field.ReadOnlyField)
                    {
                        if (newList.Fields.GetField(field.Title) != null)
                        {
                            try
                            {
                                newItem[field.Title] = item[field.Title];
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(ex.Message);
                            }
                        }
                    }
                }
                newItem.Update();
                
            }
            
            newList.Update();
            Console.WriteLine("Finalizado!!!");
            Console.ReadLine();
        }
    }
}

Webparts conectadas y el ciclo de vida

2007-08-06T15:02:00.000+02:00

La mayoría de las quejas que oigo sobre el modelo de eventos de ASP.Net son por desconocimiento del ciclo de vida de las páginas. La más habitual suele estar relacionada con la gestión de eventos, ya que ocurren después del OnLoad de la página. Es muy importante conocer el orden pues en cada postback se vuelve a repetir todo el ciclo, así que aquí teneis una lista completa de qué pasa cuando se carga una página ASP.Net: http://blogs.thesitedoctor.co.uk/tim/2006/06/30/Complete+Lifecycle+Of+An+ASPNet+Page+And+Controls.aspx

Para el caso de webparts conectadas hay un paso adicional a tener en cuenta: los eventos de consumición de datos. Para no liarnos hay que tener en cuenta siempre este orden:

OnInit
CreateChildControls
OnLoad
Gestión de eventos de postback
Consumición de datos de webparts conectadas
OnPreRender
RenderContents

Hands on lab de MOSS 2007 este viernes

2007-08-06T13:14:00.000+02:00

Este viernes en Innova realizan un Hands on Lab sobre Microsoft Office Sharepoint 2007: http://baleareson.net/forums/p/184/430.aspx#430

Un buen punto de partida para todos los que querais implementar un sitio colaborativo con MOSS2007.

Visual Studio Island en Second Life

2007-06-29T09:37:00.000+02:00

Microsoft se ha apuntado a la moda de promocionarse en Second Life y el mes pasado abrió su Visual Studio Island. Forma parte de la campaña Defy All Callenges donde presentan las bonanzas de sus herramientas de desarrollo a modo de videojuego. Aquí podeis ver el video promocional de la isla:

Video: Visual Studio Island
Hay que resolver diez acertijos lógicos que te conducen a una zona VIP donde el jugador obtiene un premio (presuntamente tierras en Second Life).

El caso de la TypeEntry vacía

2007-06-28T09:16:00.000+02:00

Hace poco encontramos un extraño problema en un smart client conectado a través de remoting a las reglas de negocio. El caso es que utilizamos la clase RemotingHelper de Ingo Rammer para facilitar el modo en que se acceden a las reglas de negocio, pero tenemos un interfaz que no se encuentra registrado en el app.config sino que lo registramos dinámicamente durante el incio del programa llamando a:

RegisterWellKnownClientType(typeof(IMyInterface), url);

A pesar de que el susodicho método no da ningún error, al hacer una llamada al método RemotingConfiguration.GetRegisteredWellKnownClientTypes() el objeto WellKnownClientTypeEntry que se corresponde con el registro anterior tiene un null en su propiedad ObjectType!!!

Tras investigar un poco y gracias al fuslogvw.exe descubrimos que la configuración de remoting no encontraba la librería que contenía el interfaz porque ésta estaba en el GAC y no en la carpeta de la aplicación y el registro de entradas de cliente no la encontraba.

Para conseguir que lo anterior funcione existen dos alternativas:

a) Copiar siempre la librería a la carpeta del ejecutable.
b) Indicar al registro que también hay que buscar la librería en el GAC.

Para la opción b (la buena) el truco está en crear la entrada manualmente usando el FullName de la librería, que contiene la versión y clave pública con la que se puede realizar la búsqueda en el GAC, con el siguiente código:

WellKnownClientTypeEntry entry=new WellKnownClientTypeEntry(
typeof(IMyInterface).FullName,typeof(IMyInterface).Assembly.FullName,commonBusinessUrl);
RemotingConfiguration.RegisterWellKnownClientType(entry);

Así el registro se encargará de buscar la librería en el GAC si hace falta.

Unidades de prueba para aplicaciones multi-hilos

2007-06-27T10:37:00.000+02:00

Muchas veces un pequeño cambio en una función puede romper o bloquear la ejecución de ésta cuando se ejecuta en multiples hilos. Integrar pruebas multi-hilos en nuestras unidades puede resultar complicado y pesado, así que Roy Osherove ha publicado una libreria para ayudarnos a probar:
http://weblogs.asp.net/rosherove/archive/2007/06/22/multi-threaded-unit-tests-with-osherove-threadtester.aspx

ReSharper 3.0

2007-06-22T10:47:00.000+02:00

JetBrains ha anunciado la nueva versión de su Add-in para VS.Net ReSharper 3.0, una herramienta de análisis y productividad casi imprescindible.

Evento: Aplicaciones de la web 2.0 con Microsoft AJAX Extensions

2007-06-21T09:51:00.000+02:00

Ya tenemos fecha y url de registro para el próximo evento de Baleares on .Net: será el día 29 de junio y os podeis registrar en: http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032344604&Culture=es-ES
En esta ocasión contamos con un ponente de lujo: Miguel Jiménez, Software Engineer y responsable de formación en Ilitia Technologies, es MVP de Visual C# y ponente habitual en eventos de Microsoft como el Remix 07.
Los temas que tratará son:

Desarrollo de aplicaciones web dinámicas con VS.Net y AJAX
Cómo usar XML, CSS, XHTML, Javascript, JSON y peticiones asíncronas
Ejemplos prácticos a lo Web 2.0

Nos vemos!

Gestión de proyectos para TFS basado en Scrum

2007-06-14T17:55:00.000+02:00

Microsoft acaba de publicar una herramienta web de gestión de proyectos para la metodología Scrum sobre TFS que se integra con Excel y Project: eScrum 1.0

Introducción a Silverlight

2007-06-12T13:31:00.000+02:00

En el MSDNFlash de hoy he encontrado un artículo muy interesante de introducción a Silverlight. Lo podéis leer en: http://www.microsoft.com/spanish/msdn/articulos/archivo/010507/voices/bb404300.mspx

Acropolis o cómo programar a golpe de click

2007-06-07T10:16:00.000+02:00

Siguiendo los pasos de Composite UI Application Block (CAB) y Smart Client Software Factory llega una nueva plataforma con conjunto de patrones y herramientas para facilitar el desarrollo modular de aplicaciones Smart Client. Con Orcas y Acropolis el desarrollo visual de aplicaciones da un paso adelante, el día de mañana podremos definir toda la aplicación en el diseñador.

Glenn Block explica en su blog cómo funciona e incluso ha escrito un pequeño faq.

La web del proyecto está en http://www.windowsclient.net/Acropolis. Encontraréis un vídeo de introducción para que se os vaya haciendo la boca agua.

Como leí en un viejo libro sobre Delphi, la informática cada vez se parece más a la fontanería.

LiveScribe Smartpen

2007-06-01T17:13:00.001+02:00

Los nuevos ordenadores portátiles se llevan en el bolsillo...

¿Hay vida después del Trace?

2007-06-01T09:46:00.000+02:00

A los programadores nos suele gustar mucho escribir en la consola lo que están haciendo nuestras funciones.
Algunas veces es porque simplemente nos gusta ver que el interior funciona, como cuando abríamos un coche de scalextric o desmontábamos un reloj, pero normalmente es para saber qué está ocurriendo dentro del código sin hacer interminables sesiones de debug.
Cuando la programamos con múltiples hilos, eventos y cientos de controles, poner puntos de debug se vuelve una auténtica locura. Unas pocas líneas llamando a métodos de la clase System.Diagnostics.Trace nos pueden ayudar mucho. Pero, ¿qué pasa cuando no tenemos enganchado el debugger del VS.Net?, ¿adónde van los mensajes de Trace?
El mejor amigo del programador es aquí la clase System.Diagnostics.TraceListener. Heredando de ella podemos crear fácilmente nuestra propia ventana de Trace sin necesidad de tener un debugger para poder verlos. Simplemente hemos de implementar dos métodos que escriban en nuestra ventana:

He aquí una muestra de código, os dejo para vosotros la implementación de la TraceWindow:

/// <summary>
/// Trace Listener que dirige el trace a una ventana.
/// </summary>
public class WindowTraceListener : TraceListener
{

private TraceWindow traceWin;

/// <summary>
/// Crea una instancia de WindowTraceListenerClass
/// </summary>
public WindowTraceListener() : base()
{
ShowTraceWindow();
}

/// <summary>
/// Abre la ventana de Trace.
/// </summary>
public void ShowTraceWindow()
{
ThreadPool.QueueUserWorkItem(
new WaitCallback(ShowTraceWindowInThread));
}

/// <summary>
/// Inicializa una nueva instancia de la clase WindowTraceListener
/// usando el nombre espcificado.
/// </summary>
/// <param name="name">nombre para el listener.</param>
public WindowTraceListener(string name) : base(name)
{
ShowTraceWindow();
}

// ejecuta la ventana en otro thread para evitar atascar nuestra aplicacion
private void ShowTraceWindowInThread(object o)
{
if (traceWin == null)
{
traceWin = new TraceWindow();
traceWin.FormClosed += new FormClosedEventHandler(traceWin_FormClosed);
traceWin.ShowDialog();
}
}

void traceWin_FormClosed(object sender, FormClosedEventArgs e)
{
traceWin.Dispose();
traceWin = null;
}

/// <summary>
/// Escribe un mensaje a la ventana TraceWindow.
/// </summary>
/// <param name="message">el mensaje a escribir.</param>
public override void Write(string message)
{
traceWin.Write(message);
}

/// <summary>
/// Escribe un mensaje a la ventana TraceWindow.
/// </summary>
/// <param name="message">el mensaje a escribir.</param>
public override void WriteLine(string message)
{
traceWin.WriteLine(message);
}

}

Evento: Tecnologías AJAX

2007-05-28T09:29:00.000+02:00

La web 2.0 invade internet, pero ¿qué es?. Únete a nostros el próximo 8 de junio donde veremos qué tecnologías existen para la creación de nuevos interfaces de usuario web en las aplicaciones: uso de AJAX, frameworks Javascript para programación .NET, Lazslo, Flex, JavaFX y MS Silverlight. Ejemplos de uso y resultados visibles desde la nueva web.

Javi Jofre de Innova nos ofrecerá una interesante charla sobre el tema. Os esperamos a todos.

Sandcastle para documentar APIs

2007-05-16T10:07:00.000+02:00

Si queréis generar ficheros chm de documentación tan chulos como los del msdn ya podéis usar la misma herramienta que usa Microsoft para crearlos: Sandcastle. Existe un CTP descargable en: http://www.microsoft.com/downloads/details.aspx?FamilyId=E82EA71D-DA89-42EE-A715-696E3A4873B2&displaylang=en

Evento: Ficheros de la presentación WCF disponibles

2007-05-09T20:45:00.000+02:00

Ya están disponibles en el foro de Baleares On .Net la presentación powerpoint y las demos del evento del pasado día 4 sobre Windows Communication Foundation que hizo Salva.
Las podéis encontrar en: http://www.baleareson.net/files/folders/presentaciones/entry240.aspx
Gracias a todos por asistir.

Rendimiento, contadores y mediciones

2007-05-07T17:18:00.000+02:00

Detectar puntos que degradan la velocidad de una aplicación no siempre es fácil. Si preguntais por ahí normalmente os dirán que useis contadores de rendimiento; eso está muy bien para detectar cuellos de botella en aplicaciones servidor, pero en otros escenarios como Windows Forms o para medir operaciones concretas son muy poco manejables.
Para estos últimos podemos comprarnos un buen profiler o hacerlo a la antigua contando cuanto tiempo de procesador usa cada llamada. En el .Net framework tenemos una clase que nos facilitará algo esas mediciones dentro del namespace System.Diagnostics llamada Stopwatch:

System.Diagnostics.Stopwatch sw = System.Diagnostics.Stopwatch.StartNew();
presuntaLlamadaCostosa();
System.Diagnostics.Trace.WriteLine( string.Format("La llamada tardó {0}ms ({1}ticks)", sw.ElapsedMilliseconds, sw.ElapsedTicks) );

Silverlight para Linux

2007-05-07T13:06:00.000+02:00

En el proyecto Mono no pierden el tiempo. Ya están preparando Moonlight, lo que será la implementación de Silverlight 1.1 para Linux.

.Net Framework 3.5 Beta 1

2007-05-02T12:44:00.000+02:00

Ya se ha publicado la beta 1 del .Net Framework 3.5. Descargable en: http://www.microsoft.com/downloads/details.aspx?FamilyId=E3715E6F-E123-428B-8A0F-028AFB9E0322&displaylang=en

Silverlight y DLR

2007-05-02T12:01:00.000+02:00

Mientras Silverlight 1.0 aún está en beta ya se ha publicado la versión alpha de Silverlight 1.1, que incluye Dynamic Language Runtime (DLR).
Como ya casi todos sabemos, Silverlight es un plug-in multiplataforma (windows y mac os x) para los navegadores más importantes del mercado (iexplorer, firefox, safari y opera).
Hasta ahí nada muy diferente de lo que es el Flash. El problema venía a la hora de programar dentro de la plataforma. Programar sobre un Flash una aplicación Ajax era realmente complicado.
Ahora con el DLR tendremos todas las ventajas de los diferentes lenguajes de script pero combinado con cualquier elemento de .Net 3.0 y 3.5.
Por el momento la implementación inicial incluye ya cuatro lenguajes: IronPython, JavaScript, Ruby y Visual Basic.

Al Adobe Flex le ha salido un duro competidor.

Para leer más:
http://www.eweek.com/article2/0,1895,2123859,00.asp
http://www.microsoft.com/silverlight/default.aspx
Demos:
http://delay.members.winisp.net/SilverlightAirlinesDemo/ (código fuente de la demo)

Evento: Fundamentos de Windows Communication Foundation

2007-04-19T10:46:00.000+02:00

Ya estamos preparando el segundo evento del NUG Baleares on .Net. Será el próximo día 4 de mayo a las 19:00.

Podeis inscribiros en:
http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032337577&Culture=es-ES

Microsoft SilverLight, no más confusión con WPF

2007-04-17T09:31:00.000+02:00

Microsoft ha presentado en el NAB SilverLigth, conocido anteriormente como WPF/E. Se trata de un plugin estilo Flash que incorpora video de alta definición. Formará parte del núcleo de la plataforma .Net y se complementa definitivamente con el Expression Media Encoder, un nuevo producto para la Expression Suite.

El fenómeno wiki en el msdn

2007-04-10T12:59:00.000+02:00

Poco a poco se va extendiendo el fenómeno wiki y este año le ha tocado al MSDN. Por ahora sólo es posible en el sitio en inglés y parcialmente en algunos idiomas. Todavía no han añadido el castellano así que seguiremos esperando.
Quien quiera estar al día puede visitar: http://blogs.msdn.com/msdnwiki/

Baleares on .Net inaugurado!

2007-04-03T15:29:00.000+02:00

El pasado viernes 30 de Marzo inauguramos el grupo con un evento sobre las Novedades en C#3.0. Os podeis descargar la presentación del mismo en http://www.baleareson.net/files/default.aspx.

Jose Fco. Bonnin dió una charla muy interesante, estuvo repleta de ejemplos prácticos del nuevo C# y de LINQ. En la próxima Salvador de la Rosa nos hablará sobre WCF.

Software y Publicidad...

2007-03-22T09:31:00.000+01:00

Mientras algunos insisten, no sin razón, que Google no es ni un buscador ni una companía de software sino todo lo contrario, hoy mismo Microsoft ha movido Windows Live Search del grupo Live al grupo de su plataforma de adCenter. Por algo será.

Menos es más

2007-03-22T01:13:00.000+01:00

Ayer, tras un buen rato discutiendo sobre una opción difícil de comprender (y por lo tanto de explicar) en un menú que además cada uno entendía a su manera, decidimos quitarla para facilitarle la vida al usuario.
Muchas veces tendemos a desarrollar software tremendamente flexible, basando nuestro GUI directamente en la parte estructural y sin tener en cuenta que toda esa flexibilidad va a acabar despistando del todo al usuario.
De esta manera olvidamos que el GUI debe esconder al usuario la lógica de la aplicación. Muchas de las opciones que le queremos dar vienen implícitas en las acciones que el usuario ejecuta.

Como apunta David Carmona en una entrada de su blog: piensa en el usuario.

Resource Refactoring

2007-03-15T13:44:00.000+01:00

Mientras estaba leyendo un artículo sobre la revisión de código he encontrado una herramienta que nos solucionará la vida a más de uno en nuestras revisiones del fxCop: la Herramienta de Refactoring de Recursos. Se integra directamente en el vs.net, ahora mismo voy a probarla:

Nuevas clases de biblioteca en "Orcas"

2007-03-14T10:19:00.000+01:00

Ha salido otro artículo en el msdn sobre algunas clases nuevas que incorprará Orcas: http://msdn.microsoft.com/msdnmag/issues/07/04/CLRInsideOut/Default.aspx?loc=es

De especial interés son las nuevas clases para comunicación entre procesos (IPC).

Pesadillas con el BindingContext

2007-03-06T11:08:00.000+01:00

Para todos aquellos incautos que penséis que podéis heredar de la clase BindingContext... olvidadlo.
No entiendo muy bien porqué se diseñó así esta clase:

El evento CollectionChanged jamás se ejecuta.
El método sobrecargable AddCore no tiene el parámetro datamember y además no es llamado nunca.
Los indexer no son virtual, así que no es posible sobrecargarlos (si se declaran con un new no sirve puesto que las llamadas se hacen a través de la clase base).
No se puede cambiar la lista interna que maneja la colección de bindings.

En fin, que la única manera de manejar lo que haya dentro del BindingContext es iterando dentro de sus items en algún momento después del constructor y después rezar para que nadie añada nada a la lista más tarde.

FxCop en Orcas: Code Metrics!

2007-03-05T17:29:00.000+01:00

En el nuevo FxCop de Orcas han incluido una nueva característica que me parece especialmente interesante: las métricas de código. Quizás no es tan sofisticada como NDepend, pero da una idea clara de cuán complejo es nuestro código y dónde es más probable que necesitemos hacer refactor.

Orcas CTP Marzo 2007

2007-03-05T11:11:00.000+01:00

Ya se ha publicado una nueva versión CTP de Orcas. Podremos encontrar dos versiones:
1. Visual Studio Team Suite
2. Visual Studio Team Suite con el nuevo TFS

Esta nueva versión incluye la implementación de LINQ en C# 3.0 y VB 9.0, editores visuales para WPF, mejoras en el interface WMI, nuevas características en el Team Build y mayor escalabilidad del TFS.
Entre las mejoras del Team Build cabe destacar la incorporación de la integración contínua como parte integrada del sistema.

Botones Redondos y WPF

2007-03-02T10:01:00.000+01:00

Hace unos años expliqué en un artículo cómo crear botones redondos en WinForms. Para ello había que escribir un montón de código y crear un control específico heredando de la clase Button.
Hoy en día con WPF todo es mucho más fácil, sobretodo gracias a Expression. Con escribir un poco de XAML ya lo tenemos todo hecho, incluso con Hit Test adaptado a la forma del control: http://www.baleareson.net/forums/42/ShowThread.aspx#42

Transmitiendo ExtendedProperties con Remoting

2007-02-28T09:39:00.000+01:00

Uno de los valores que habitualmente se devuelven desde una llamada a un método remoto es el DataSet. Si es nuestro caso y además usamos la propiedad ExtendedProperties para almacenar otros datos que acompañan al DataSet nos daremos cuenta que sólo las propiedades introducidas como string se transmiten a través de la capa de remoting.
Una posible solución es cambiar el formato de serialización del dataset a binario cambiando la propiedad RemotingFormat, pero eso no siempre es posible ya que al usar un canal http y SOAP el DataSet volverá ignorará esa propiedad.
Para poder transmitir nuestros valores existe una solución rápida y que no afecta a cómo se programan las reglas de negocio: añadir una capa de serialización al canal de remoting.

Para ello necesitaremos un ServerChannelSink para serializar las propiedades y un ClientChannelSink para deserializarlas.

Creamos la clase:

public class ExtendedPropertiesServerSink :
 BaseChannelObjectWithProperties, IServerChannelSink
{
    IServerChannelSink _next;

    public ExtendedPropertiesServerSink(IServerChannelSink next)
    {
        _next = next;
    }

En la implementación del método ProcessMessage del interface tenemos el truco... Si la respuesta del método contiene un DataSet o DataTable entonces serializamos las extended properties.

public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
    System.Runtime.Remoting.Messaging.IMessage requestMsg,
    ITransportHeaders requestHeaders, System.IO.Stream requestStream,
    out System.Runtime.Remoting.Messaging.IMessage responseMsg,
    out ITransportHeaders responseHeaders,
    out System.IO.Stream responseStream)
{
    if (_next != null)
    {
        ServerProcessing spres = _next.ProcessMessage(sinkStack,
            requestMsg, requestHeaders, requestStream, out responseMsg,
            out responseHeaders, out responseStream);

        ReturnMessage message = responseMsg as ReturnMessage;
        if (message != null)
        {
            DataSet ds = message.ReturnValue as DataSet;
            if (ds != null)
            {
                if (ds.RemotingFormat == SerializationFormat.Xml)
                {
                    // serializa las propiedades extendidas del dataset
                    serializeExtendedProperties(ds.ExtendedProperties);
                    // para cada tabla también hace lo mismo
                    foreach (DataTable t in ds.Tables)
                    {
                        serializeExtendedProperties(t.ExtendedProperties);
                    }
                }
            }
            else
            {
                DataTable t = message.ReturnValue as DataTable;
                if (t != null)
                {
                    if (t.RemotingFormat == SerializationFormat.Xml)
                        serializeExtendedProperties(t.ExtendedProperties);
                }
            }
        }

        return spres;
    }
    else
    {
        responseMsg = null;
        responseHeaders = null;
        responseStream = null;
        return new ServerProcessing();
    }
}

El método para serializar necesita que la clase sea serializable en xml (se puede controlar mediante atributos o implementando el interface IXmlSerializable):

private static void
serializeExtendedProperties(PropertyCollection propertyCollection)
{
    foreach (object key in propertyCollection.Keys)
    {
        MiClase value = propertyCollection[key] as MiClase;
        if (value != null)
        {
            XmlSerializer ser = new XmlSerializer(value.GetType());
            using (StringWriter w = new StringWriter())
            {
                ser.Serialize(w, value);
                propertyCollection[key] =
                    w.ToString();
            }
        }
    }
}

Una vez serializadas las propiedades habrá que crear un deserializador en un ClientChannelSink y enlazarlos ambos con sendos ChannelSinkProvider para poderlos añadir a la configuración de remoting. En la parte servidor hay que colocar la entrada tras la del formatter SOAP:

<channel ref="http" port="5001"
displayName="http with props encoding">
 <serverProviders>
  <!-- support soap encoding -->
  <formatter ref="soap" typeFilterLevel="Full" />
  <!-- serialization layer -->
  <provider type="RemotingTest.ExtendedPropsServerSinkProvider,
   RemotingTest"/>
 </serverProviders>

Acelerando WinForms

2007-02-21T09:50:00.000+01:00

Recientemente tuvimos que revisar una aplicación winforms que se había vuelto muy lenta, cada vez que se instanciaba una nueva ventana o usercontrol tardaba varios segundos en abrirse.
Tras revisar el código vimos que algunos controles se inicializaban en los métodos OnLoad y OnCreateControl. Es un error muy común, ya que hasta que el control no se ha creado no podemos saber si todas sus propiedades tienen el valor correcto y a veces hay propiedades que dependen de otras.
Como sabemos no podemos controlar el orden de creación de los controles en un formulario y no podemos asegurar que un control siempre se creará antes que otro o que una propiedad se asignará antes que otra.
Por nuestra experiencia sabíamos que eso podía ser un problema así que decidimos cambiar algunos controles e implementar en ellos el interface ISupportInitialize.
Este interface es soportado directamente por el entorno de diseño y nos permite ejecutar código en el método EndInit con la garantía de que todos los controles en el formulario ya han sido creados.
El truco está en sustituir el código que había en el OnLoad y moverlo al método EndInit, de esta manera el código se ejecuta dentro del constructor con una ganancia de casi el 50% en velocidad.

Al final de los cambios llegamos a las siguientes conclusiones:

Siempre que sea posible realizar la inicialización en el constructor.
Evitar iteraciones sobre los controles durante los métodos OnLoad y OnCreateControl. Son mucho más rápidas si se realizan dentro del constructor, incluso usando reflection.

Primer evento en Baleares on .Net

2007-02-21T09:41:00.000+01:00

El NUG Baleares on .Net empieza a dar sus primeros pasos.
El viernes 30 de Marzo se realizará la presentación oficial del grupo y una charla sobre las novedades que traerá C# 3.0.
Será en las oficinas de Innova, más información en la web.

Presentación

2007-02-20T21:08:00.000+01:00

¡Hola!

Soy Juanma, desarrollador desde hace demasiados años. Hace algún tiempo empecé a colaborar con la comunidad escribiendo algunos artículos sobre programación en C#, pero el verdadero detonante de empezar esta bitácora ha sido el nacimiento del grupo de usuarios (NUG) Baleares On .Net

Aquí encontrareis artículos, ideas y noticias relacionadas con el NUG y con el mundo .Net en general.

¡Bienvenidos!