Variable not found

Llamemos a las cosas por su nombre

2012-02-08T08:55:00.000+01:00

Seguro que todos sabéis lo que es tratar con los usuarios de vuestro software: son lentos, patosos, inconscientes, atrevidos, inseguros, ignorantes, y no consiguen entender la belleza de la herramienta que con tanto esmero hemos creado. Y lo que más rabia da es que muchas veces tienen razón en los problemas que reportan de nuestras aplicaciones.

Pero afortunadamente otras veces no es así, y los problemas no son nuestros sino suyos, momento en el que pone a disposición de la dulce venganza la genial creatividad característica de nuestro gremio.

Lo que vamos a ver a continuación son siete de las formas existentes, conocidas y documentadas de cargar las culpas sobre el usuario, o simplemente llamarlo torpe, sin que éste se dé cuenta. Algo muy socorrido si, por ejemplo, debemos contarle a un compañero lo que ocurre en presencia del implicado.

Por supuesto, a partir de aquí todo es secreto, no dejéis que caiga en manos de algún desalmado ;-)

1. Error ID-10-T

El "ID-10-T" (pronunciado ID-ten-T) es un código de error que se utiliza para indicar que el usuario es simplemente idiota. De hecho, si unimos las letras (ID10T) podremos ver fácilmente que el término es la traducción a leet speak de IDIOT, lo cual no podía dejar más clara su intencionalidad y los momentos en que debemos utilizarlo.

Se rumorea que en los años noventa los equipos de soporte técnico telefónico daban instrucciones a los usuarios y clientes para que incluyeran en su archivo config.sys la línea id=10t (o combinaciones parecidas) como aviso para futuras intervenciones cuando se encontraban con un espécimen a tener en cuenta.

También podemos encontrarlo, aunque en menor medida, escrito como ID107, otra posible traducción del término al lenguaje 1337.

Curiosamente, el término se utiliza en otros ámbitos como el militar, aunque la pronunciación puede variar ligeramente: “One delta ten tango” o “Eye Dee Ten Tango”.

2. Wetware bugs

Tradicionalmente, los errores en sistema informáticos podían producirse bien en el hardware, la parte física, o bien en el software, la parte lógica. Pues en contraposición a éstos, el Wetware, hace referencia a la “parte blanda”, es decir, al individuo que los utiliza y, más en concreto, a su mente.

De esta forma, el eufemismo “fallo en el Wetware” es sólo una fórmula políticamente correcta de indicar un problema causado por el usuario, o un problema del usuario en sí ;-)

Se pueden encontrar variantes relativas al mismo concepto, como Liveware (utilizado por primera vez en 1966!) o Meatware, ambos con el mismo significado.

3. PEBCAK

Este término, todo un clásico entre el personal de soporte de sistemas, es un acrónimo de:

Problem Exists Between Chair And Keyboard
(el problema existe entre la silla y el teclado)

Por tanto, se trata de una forma indescifrable de indicar que un problema está provocado exclusivamente por el usuario que está manejando el sistema.

Existen bastantes variaciones de este término, que combinan algunos verbos con ordenadores, teclados, monitores y sillas:

EBKAC (Error Between Keyboard And Chair)
PIBCAK (Problem Is Between Chair And Keyboard)
PIBKAC (Problem Is Between Keyboard And Chair)
PLBKAC (Problem Lies Between Keyboard And Chair)
POBCAC (Problem Occurs Between Computer And Chair)
PEBCAC (Problem Exists Between Chair And Computer)
PEBMAC (Problem Exists Between Monitor And Chair)
PEBKAM (Problem Exists Between Keyboard and Monitor)

4. PICNIC

Otro acrónimo clásico, bastante más fácil de pronunciar que los anteriores, y que de la misma forma carga las culpas en el usuario del sistema:

Problem In Chair, Not In Computer
(el problema está en la silla, no en el ordenador)

Y no, no tiene nada que ver con la ergonomía del mobiliario: el “en” hace referencia a la segunda acepción que la RAE que da a esta preposición, y significa “sobre” ;-)

Este término puede ser pronunciado sin temor a duchar a nuestro interlocutor, es bastante sencillo de recordar, e incluso de utilizar con absoluta impunidad ante el propio protagonista sin temor a levantar sospechas (“estamos ante un caso picnic”).

5. Layer 8 error

En el año 1984, la Organización Internacional para la Estandarización publicó un modelo de referencia para la definición de arquitecturas de sistemas de comunicación llamado OSI (Open System Interconnection).

Este modelo conceptualizaba los componentes y sistemas involucrados en comunicaciones en base a distintos niveles: el nivel físico, el de enlace, de red, transporte, sesión, presentación y aplicación. Un total de siete capas.

¿Adivináis ya qué es el nivel 8, verdad? ;-D

Pues efectivamente. Se trata de una forma jocosa de llamar al usuario o al factor humano entre los administradores de redes, como parte imprescindible para el correcto funcionamiento de los sistemas interconectados. Si hay problemas o errores en el Layer 8, no importa lo que ocurra en el resto de niveles: simplemente las cosas no funcionan.

También suele utilizarse el término para referirse a aspectos económicos e incluso políticos cuyos intereses pueden afectar igualmente al funcionamiento de los sistemas.

6. RTFM

Este término no alude directamente a la falta de habilidad del usuario, sino a su desconocimiento de aspectos que se recogen en documentación existente que deberían haber leído. Las siglas corresponden a la expresión:

Read The Fucking Manual
(Lee el jodido manual)

Y es que no hay nada más desagradecido que trabajar durante varios días o semanas en un completo manual de usuario y recibir preguntas sobre temas que vienen perfectamente detallados en éste. ¿Es que ni siquiera se molestan en leerlo?

Bueno, si queréis podemos responder ya a la pregunta: no. Ni de coña. Pero el que esté libre de pecado que tire la primera piedra… ¿cuándo fue la última vez que te leíste un manual? El de Windows 7, ¿lo has terminado ya? ¿Y el de Visual Studio? ¿El de la impresora, tal vez? ;-P

Existe una segunda interpretación de RTFM, aunque menos usada: “Reboot The Fucking Machine” (reinicia la jodida máquina), que podría ser útil para identificar las soluciones “apaga y enciende” tan populares en los 90 y primer lustro del 2000.

7. Luser

En este caso tenemos un portmanteau o contracción entre las palabras User (usuario) y Loser (perdedor, fracasado) utilizado frecuentemente para referirse a la gente cuyos conocimientos informáticos rozan el cero absoluto, y que tanto suelen irritar a los expertos, hackers y demás fauna binaria.

El origen del término se remonta al año 1975, en el MIT, donde algún bromista pensó que sería simpático que los comandos para consultar el número de usuarios conectados los llamara losers en lugar de users (por ejemplo: “8 losers” en vez de “8 users”) y lo introdujo en el sistema ITS que manejaban. Dado que la idea no gustó mucho al resto de usuarios, fue evolucionando hasta encontrar el término lusers, políticamente más correcto y compatible con “logged users”.

Es habitual encontrar lusers preguntando cosas bastante simples, incluso absurdas, en foros y otras redes sociales. Normalmente las respuestas a sus cuestiones podrían resolverlas por ellos mismos sólo con un poco de interés, pero prefiere preguntar por comodidad. Y especialmente grave es cuando coincide además que el usuario es un leech (sanguijuela), es decir, alguien que no agradece ni aporta nada a quienes dedican su tiempo a ayudarle.

Como antídotos, destacan los famosos LMGTFY (Let me Google that for you) –con versión en español-, o la alternativa LMBTFY (Let me Bing that for you), ambos una forma muy elegante de decirle lo que piensas realmente de él y sus preguntas.

¿Y tú, cómo llamas a tus usuarios?
________________________________________
Fuentes utilizadas: Wikipedia, Wiktionary, The Jargon file

Publicado en: Variable not found.

Enlaces interesantes 70

2012-02-06T11:00:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 31 de enero al 5 de febrero de 2012. Espero que os resulten interesantes :-)

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Validación manual con Data Annotations

2012-02-01T11:47:00.000+01:00

Habitualmente asociamos la validación de entidades basadas en anotaciones de datos, o data annotations, a tecnologías como dynamic data o ASP.NET MVC, y estamos acostumbrados a que la validación se realice de forma automática, pero nada más lejos de la realidad. Podemos utilizar data annotations desde cualquier tipo de aplicación .NET (Webforms, Winforms, WPF, Consola, o cualquier otra en la que tengamos disponible System.ComponentModel.DataAnnotations), puesto que existe la posibilidad de invocar manualmente los procedimientos de validación.

En este post vamos a ver cómo realizar validaciones basadas en anotaciones de forma manual, lo cual puede tener su utilidad en gran número de escenarios.

Resumidamente, esta técnica consiste en decorar cada una de las propiedades con una serie de atributos llamados anotaciones (definidos en System.ComponentModel.DataAnnotations) que indican las comprobaciones que se aplicarán a la entidad para determinar su validez. La siguiente porción de código muestra una entidad en la que se están indicando estas restricciones en cada una de sus propiedades:

public class Friend
{
    [Required, StringLength(50)]
    public string Name { get; set; }
 
    [Range(0, 120)]
    public int Age { get; set; }
}

En el citado espacio de nombres encontramos atributos que cubren la mayoría de casos frecuentes: Required (propiedad obligatoria), RegularExpression (validar contra una expresión regular), StringLength (longitud máxima y mínima de un texto), Range (rangos de valores permitidos), y CustomValidation (validaciones personalizadas). Además, este conjunto de anotaciones puede ser extendido muy fácilmente creando atributos que hereden de ValidationAttribute, disponible también en System.ComponentModel.DataAnnotations.

Validación manual de objetos

De lo más sencillo: la clase estática Validator, disponible también en el namespace System.ComponentModel.DataAnnotations, ofrece métodos que permiten realizar las comprobaciones de forma directa sobre objetos o propiedades concretas.

En este caso, dado que lo que nos interesa es validar las entidades completas, utilizaremos el método Validator.TryValidateObject(), al que suministraremos:

el objeto a validar,
un contexto de validación (que debemos crear previamente),
una colección de ValidationResult en la que almacenaremos los errores,
y, por último, si deseamos validar todas las propiedades (indicando true), o por el contrario preferimos parar el proceso en cuanto se detecte el primer error (false).

La implementación de la validación podría ser como la que la sigue:

    private IEnumerable<ValidationResult> getValidationErrors(object obj)
    {
        var validationResults = new List<ValidationResult>();
        var context = new ValidationContext(obj, null, null);
        Validator.TryValidateObject(obj, context, validationResults, true);
        return validationResults;
    }

El método retornará una lista de errores vacía cuando el objeto haya superado las restricciones impuestas, o llena con los objetos ValidationResult que describen los problemas encontrados.

Y podríamos utilizarlo desde una aplicación de consola de la siguiente forma:

    var friend = new Friend { Age = -1, Name = "" };
    var errors = getValidationErrors(friend);
    foreach (var error in errors)
    {
        Console.WriteLine(error.ErrorMessage);
    }

The Name field is required. 

The field Age must be between 0 and 120.

Los mensajes de validación que aparecen pueden ser definidos en la misma anotación, por ejemplo así:

    [Required(ErrorMessage="Please, enter the name")]
    public string Name { get; set; }

¿Y si los metadatos están en otra clase?

Hay escenarios en los que no tenemos acceso a la clase en la que deseamos introducir las anotaciones. Un ejemplo claro lo encontramos cuando nos interesa especificar las restricciones en una clase generada por un proceso automático, como el diseñador de EDM de Entity framework; cualquier cambio realizado sobre el código generado será sobrescrito sin piedad al modificar el modelo.

En estos casos, es una práctica frecuente definir los metadatos en clases “buddy”, que son copias exactas de la entidad a anotar, pero que serán utilizadas únicamente como contenedores de anotaciones. Las clases buddy se vinculan con la entidad original utilizando el atributo MetadataType de la siguiente forma:

    // This class has been generated by a tool
    public partial class Friend
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
 
    // Let's associate the buddy class FriendMetadata
    [MetadataType(typeof(FriendMetadata))]
    public partial class Friend
    {
        
    }
 
    // Buddy class
    public class FriendMetadata
    {
        [Required]
        public string Name { get; set; }
 
        [Range(0, 120)]
        public int Age { get; set; }
    }

Observad que para poder utilizar esta técnica es necesario que la entidad a la que queremos añadir anotaciones sea creada como parcial. En caso contrario no podríamos indicarle con MetadataType dónde se encuentran definidos sus atributos de validación.

Pues bien, resulta que algunos marcos de trabajo (como ASP.NET MVC) están preparados para detectar este escenario y obtener de forma automática los metadatos desde la clase buddy, pero si estamos realizando la validación de forma manual el atributo [MetadataType] no será tenido en cuenta.

Por tanto, debemos ser nosotros los que indiquemos expresamente dónde se encuentran los metadatos, para lo que, afortunadamente, contamos con la ayuda de TypeDescriptor (definida en System.ComponentModel), desde donde podemos indicar el origen de los metadatos de clases simplemente registrando el proveedor desde el cual pueden ser obtenidos.

El procedimiento para conseguirlo es bastante simple: creamos un proveedor de descripciones basado en metadatos utilizando la clase AssociatedMetadataTypeTypeDescriptionProvider (uuf con el nombrecito ;-)) en el que vinculamos la clase “original” con la que contiene los metadatos (la clase buddy), y a continuación añadimos dicho proveedor a la primera.

Por ejemplo, para hacer que las anotaciones de la clase Friend se obtengan desde el tipo FriendMetadata podríamos incluir el siguiente código de inicialización:

var descriptionProvider = new AssociatedMetadataTypeTypeDescriptionProvider(
     typeof(Friend), 
     typeof(FriendMetadata)
);
TypeDescriptor.AddProviderTransparent(descriptionProvider, typeof(Friend));

Otra posibilidad más genérica sería implementarlo como se muestra a continuación, donde buscamos en todo el ensamblado actual clases decoradas con el atributo MetadataType, registrando el proveedor de metadatos indicado en dicho atributo de forma automática:

private static void registerBuddyClasses()
{
    var buddyAssociations = 
        from t in Assembly.GetExecutingAssembly().GetTypes()
        let md = t.GetCustomAttributes(typeof(MetadataTypeAttribute), false)
                .FirstOrDefault() as MetadataTypeAttribute
        where md != null
        select new { Type = t, Buddy = md.MetadataClassType };
 
    foreach (var association in buddyAssociations)
    {
        var descriptionProvider = 
            new AssociatedMetadataTypeTypeDescriptionProvider(
                association.Type, association.Buddy
            );
        TypeDescriptor.AddProviderTransparent(descriptionProvider, association.Type);
    }
}

De esta forma, bastará con invocar el método registerBuddyClasses() durante la inicialización de la aplicación para que las clases buddy sean registradas de forma automática.

Pero más interesante es, sin duda, que podríamos implementar nuevas fórmulas para indicar dónde se encuentran los metadatos de una clase. Por ejemplo, sería realmente sencillo modificar el método anterior para sustituir el atributo MetadataType por una convención de nombrado del tipo “las clases llamadas FooMetadata contendrán los metadatos de las clases de llamadas Foo”:

private static void registerBuddyClassesUsingConventions()
{
    var allAssemblyTypes = Assembly.GetExecutingAssembly().GetTypes().ToList();
    var buddyAssociations =
        from t in allAssemblyTypes
        let buddy = allAssemblyTypes
                    .FirstOrDefault(other => other.Name == t.Name + "Metadata")
        where buddy != null
        select new { Type = t, Buddy = buddy };
 
    foreach (var association in buddyAssociations)
    {
        var descriptionProvider =
            new AssociatedMetadataTypeTypeDescriptionProvider(
                association.Type, association.Buddy
            );
        TypeDescriptor.AddProviderTransparent(descriptionProvider, association.Type);
    }
}

¿Y si quiero usar IValidatableObject?

El interfaz IValidatableObject (definido System.ComponentModel.DataAnnotations) obliga a implementar un único método, llamado Validate(), que retornará una lista de objetos ValidationResult con los resultados de las comprobaciones.

A continuación se muestra un ejemplo de implementación de este interfaz sobre una entidad:

public class Friend : IValidatableObject
{
    public string Name { get; set; }
    public int Age { get; set; }
 
    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        if (Name.Equals("albert", StringComparison.CurrentCultureIgnoreCase))
        {
            yield return new ValidationResult("I don't like Alberts!");
        }
    }
}

El método Validate() impuesto por el interfaz será invocado automáticamente por el framework desde el mismo TryValidateObject() siempre que no encuentre errores al comprobar las restricciones especificadas mediante anotaciones. O sea, que sólo se invocará a Validate() cuando no se hayan detectado errores previos de validación (gracias, Arturo, por la aportación).

En cualquier caso, si nos interesa validar de forma manual también estos objetos, siempre podemos hacerlo como sigue:

    private static IEnumerable<ValidationResult> getIValidatableErrors(object obj)
    {
        var validationResults = new List<ValidationResult>();
        var context = new ValidationContext(obj, null, null);
        var validatable = obj as IValidatableObject;
        if(validatable!=null) 
            validationResults.AddRange(validatable.Validate(context));
 
        return validationResults;
    }

De esta forma, podríamos comprobar la ejecución como sigue:

    var friend = new Friend { Age = -1, Name = "albert" };
    var errors = getValidationErrors(friend);
    foreach (var error in errors)
    {
        Console.WriteLine(error.ErrorMessage);
    }

The field Age must be between 0 and 120. 

I don’t like Alberts!

En resumen, en este post hemos visto cómo utilizar las herramientas que ofrece el framework .NET para trabajar con validaciones basadas en data annotations de forma manual, lo que abre su ámbito de utilización a prácticamente cualquier tipo de aplicación para este marco de trabajo. Por el camino hemos repasado los mecanismos de anotaciones, y diversos escenarios como la externalización de atributos en clases buddy o el uso de la interfaz IValidatableObject.

Descargar un proyecto VS2010 con el código y pruebas desde Skydrive.

Publicado en Variable not found.

Enlaces interesantes 69

2012-01-31T08:53:00.001+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 16 al 29 de enero de 2012. Espero que os resulten interesantes. :-)

.Net

Introducing Dragonfly – another .NET HTTP server
Louis DeJardin
Inside the Concurrent Collections: ConcurrentQueue
Simon Cooper
Using Async for File Access C# Team
Aggressive Inlining in the CLR 4.5 JIT
Sasha Goldshtein
What is the defining characteristic of a local variable?
Eric Lippert
C#/.NET Little Pitfalls: Stopwatch Ticks are not TimeSpan Ticks
James Michael Hare
Inside the Concurrent Collections: ConcurrentStack
Simon Cooper

Asp.net

Adding rich Selector support for MVC
Matt Hidinger
Solving Real-world Theming Challenges with MVC4 and Sass
Harvey Kandola
Javascript and CSS Minifying/Bundling with the Microsoft.Web.Optimization Nuget package
Maxime Rouiller
Validaciones propias en ASP.NET MVC
Eduard Tomás
The flowchart of the IE rendering modes
Chun Liu
POP Forums v9.2 posted to CodePlex, with new languages, post voting and the scoring game
Jeff Putz
ASP.NET Response.Redirect
Annie Luxton
Fix: the value ‘x’ is not valid for Foo in ASP.NET MVC
Code Inside Team
Web Deploy – config Transformation
Marc Rubiño
Cómo simular otros navegadores para probar desarrollos Web
José Manuel Alarcón
10 Things ASP.NET Developers Should Know About Web.config Inheritance and Overrides
Jon Galloway
Cómo obtener rutas absolutas en ASP.NET
José Manuel Alarcón
Push con SingalR
Marc Rubiño
Tracking API usage with Google Analytics
Maarten Balliauw
MVC – get some help
Gregor Suttie

Azure / Cloud

Release de SQL Azure Import/Export
Ibon Landa
Making Windows Azure Drive Letter Persistent
Shawn Cicoria
Getting Started with Windows Azure
Scott Guthrie

Conceptos

Gof – Singleton
Sebis

Data access

What do you want to see in Entity Framework?
Julie Lerman
HeidiSQL: Windows based interface for managing MySQL and Microsoft SQL databases
Ansgar Becker
RaptorDB - The Key Value Store V2
Mehdi Gholam
OraPoco: Trabajando contra Oracle
Javier Torrecilla
Why Entity Framework vNext will be EF5 and nothing else
Diego B. Vega

Html/Css/Javascript

From jQuery to JavaScript: A Reference
Jeffrey Way
Some Thoughts On Functional JavaScript
Derick Bailey
Find the jQuery Bug #2: Point of No Return
Elijah Manor
JavaScript for C# developers: coercion
Julian M. Bucknall
Modernizr–Ejemplo práctico 2 : Utilizando Border Radius, elemento date y atributo required
Gonzalo Pérez
Server-Sent Events
Remy Sharp
Using HTML5 Web Storage in ASP.NET
Bipin Joshi
Creando objetos y aplicaciones configurables en Javascript
Carlos Benítez
10 Excellent Free Rich-Text Editors
jQuery4u
SOLID JavaScript- The Dependency Inversion Principle
Derek Greer
Easing Functions in CSS3
Kirupa Chinnathambi
How Wikipedia uses HTML5 to save bandwidth
Jef Claes
The Top 10 Javascript MVC Frameworks Reviewed
Gordon L. Hempton
Using CSS3 Transitions, Transforms and Animation
Rich Bradshaw

Visual Studio/Complementos

Importing / Exporting Templates and Patterns in ReSharper 6.1
Hadi Hariri
C# + ReSharper = Awesome: Tip #8 – Extract Class From Parameters
Alvin Ashcraft
C# + ReSharper = Awesome: Tip #7–Move String to Resource
Alvin Ashcraft's
StyleCop v4.7.6.0 disponible
Jorge Serrano

Otros

Breaking CAPTCHA with automated humans
Troy Hunt
Let's make TCP faster
Yuchung Cheng
El "Cargo Cult" de las pequeñas empresas
José Manuel Alarcón
El efecto Mateo y su influencia
José Manuel Alarcón

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Libro: Dependency injection in .NET

2012-01-25T13:25:00.000+01:00

La inyección de dependencias es uno de esos conceptos rodeados de misterio que parecen reservados a gurús, arquitectos, y otros profesionales de gama alta, y aplicables exclusivamente en proyectos mastodóndicos.

Y nada más lejos de la realidad: DI se basa en principios relativamente simples, e incluso diría intuitivos, para lograr evitar el acoplamiento entre componentes, es aplicable en todo tipo y tamaño de aplicaciones, y por tanto todas ellas pueden beneficiarse de las ventajas que aporta, como la simplicidad, mantenibilidad, extensibilidad, o facilidad para la realización de pruebas unitarias.

Pero, sinceramente, jamás pensé que el tema que pudiera dar tanto de sí como para escribir un libro. Por eso me ha sorprendido la lectura, por cortesía de Auges, del libro “Dependency Injection in .NET”, escrito por por Mark Seemann y publicado por la editorial Manning, donde he podido comprobar que mis conocimientos sobre inyección de dependencias, aunque válidos, eran bastante superficiales.

El libro se estructura en cuatro grandes bloques a través de los cuales se realiza un completo recorrido guiado por los conceptos, utilización y herramientas para aplicar DI:

“Putting Dependency Injection on the map” contiene tres capítulos introductorios, útiles para poner en contexto el patrón y las ventajas que conlleva su uso y describir los conceptos fundamentales utilizados: dependencias, tipos, tiempo de vida, intercepción, contenedores, y muchos otros.
“DI catalog” es una completa relación de patrones de uso de la inyección de dependencias, antipatrones o malos usos que podemos hacer de la misma, y refactorizaciones que podemos utilizar para solucionar escenarios frecuentes.
“DIY DI” describe técnicas asociadas a la ID, como la composición de objetos, la gestión del ciclo de vida, y la intercepción de llamadas.
“DI containers” es un completo bloque donde se describe el uso de los principales contenedores disponibles para la plataforma .NET: Castle Windsor, StructureMap, Spring.NET, Autofac, Unity y MEF.

En definitiva, se trata una lectura recomendable para desarrolladores .NET, tanto para aquellos que no hayan tenido experiencia previa con la Inyección de Dependencias y anden buscando fórmulas para reducir el acoplamiento entre componentes, como para los que ya se han enfrentado a ella y desean conocer en mayor profundidad las bases que la sustentan.
Como puntos negativos, que está disponible exclusivamente en inglés, y que algunos capítulos se hacen algo densos y requieren varias pasadas para poder asimilar las ideas transmitidas.

Enlace: http://www.manning.com/seemann/

Publicado en: Variable not found.

SignalR (II): Conexiones persistentes

2012-01-24T09:14:00.002+01:00

Hace poco estuvimos viendo por aquí conceptos básicos sobre SignalR, el componente que nos permite crear espectaculares aplicaciones en las que múltiples usuarios pueden estar colaborando de forma simultánea, asíncrona, y en tiempo real.

Entre otras cosas, comentábamos que SignalR crea una capa de abstracciones sobre una conexión virtual permanente entre cliente y servidor, sobre la que podemos trabajar de diferentes formas:

mediante conexiones persistentes, la opción de menor nivel, que proporciona mecanismos de notificación de conexión y desconexión de clientes, así como para recibir y enviar mensajes asíncronos a clientes conectados, tanto de forma individual como colectiva.
mediante el uso de “hubs”, que ofrece una interfaz de desarrollo mucho más sencilla, con una integración entre cliente y servidor que parece pura magia, y que seguro será la opción más utilizada por su potencia y facilidad de uso.

En este post estudiaremos la primera opción, conexiones persistentes. Los hubs los veremos en un artículo posterior de la serie, aunque si sois impacientes ya podéis ir leyendo el fantástico post del amigo Marc Rubiño sobre el tema, “Push con SignalR”.

Bueno, pues vamos al tema: emplearemos esta vía para implementar una funcionalidad bastante simple, pero nada trivial utilizando las herramientas habituales de ASP.NET: mostrar en una página, en tiempo real, información sobre los usuarios que están llegando a ella, los que la abandonan y el número de usuarios que hay conectados justo en ese momento, en tiempo real.

Para ello haremos lo siguiente:

En el lado servidor, implementaremos un servicio (endpoint) SignalR, que es el que procesará las conexiones y desconexiones de clientes, y enviará información actualizada por las conexiones abiertas.
Registraremos este endpoint durante la inicialización de la aplicación, asociándole una URL de acceso a las funcionalidades del servicio.
En el lado cliente implementaremos la conexión con el servicio, capturaremos la información que nos vaya enviando y la mostraremos en la página en forma de log.

El resultado lucirá tal y como se muestra en la captura de pantalla adjunta. Aunque si lo preferís, podéis verlo en vivo y en directo descargando y ejecutando el proyecto de demostración que encontraréis al final de este artículo.

Ya en el post anterior de la serie vimos cómo descargar e instalar SignalR en un proyecto, así que vamos a suponer que ese paso ya lo hemos realizado previamente.

1. Implementación del endpoint

El endpoint, o servicio SignalR, que vamos a implementar utilizando el enfoque de conexión persistente es simplemente una clase que hereda de SignalR.PersistentConnection, en la que podemos sobrescribir los métodos que necesitemos para implementar nuestras funcionalidades. En ella encontramos métodos como OnConnected(), OnDisconnect(), OnReceived(), y bastantes más, que nos permiten tomar el control cuando se producen determinados eventos de interés en la conexión:

    public class VisitorsService : PersistentConnection
    {
        protected override void  OnConnected(HttpContextBase context, string clientId) { ... }
        protected override void  OnDisconnect(string clientId) { ... }
        protected override void  OnReceived(string clientId, string data) { ... }
        // [...]
    }

Observad que el interfaz es bastante similar a la que encontramos al trabajar directamente con sockets: podemos introducir lógica cuando un nuevo cliente se conecte sobrescribiendo el método OnConnected(), cuando se desconecte, haciendo lo propio con OnDisconnect(), o cuando el cliente envíe algún tipo de mensaje al servidor, que ejecutará la funcionalidad implementada en OnReceived().

De la misma forma, la clase base PersistentConnection ofrece mecanismos para enviar mensajes directos a un cliente, a grupos de ellos, o a todos los clientes conectados.

Volviendo al sistema que estamos desarrollando, básicamente para alcanzar nuestros objetivos necesitamos:

tomar el control en el momento en que se produce una nueva conexión (método OnConnected), momento en que enviaremos al resto de clientes un mensaje con información sobre el cliente conectado y el total de conexiones activas.
tomar el control en el momento en que se produce la desconexión de un cliente (método OnDisconnect()), para notificar al resto y actualizarles el número de clientes conectados.

1.1. Notificando a los clientes las nuevas conexiones

Cuando se realiza una nueva conexión al servicio, es decir, la llegada de un nuevo cliente, SignalR invocará al método OnConnected() del endpoint suministrándole el contexto de la petición HTTP actual, y un “ClientId”. El primero nos puede ser muy interesante para acceder a información de la petición (como el navegador, IP, cookies, información de autenticación, etc.), y el segundo es un identificador único generado por SignalR para realizar el seguimiento de la conexión.

Implementamos nuestro método y lo comentamos justo a continuación:

    protected override void OnConnected(HttpContextBase context, string clientId)
    {
        var clientDescription = getClientDescription(context);
        _clients.TryAdd(clientId, clientDescription);
 
        string text = clientDescription + " arrived.";
        var msg = new NotificationMessage(text, _clients.Count);
        Connection.Broadcast(msg);
    }

Lo primero que hacemos en la implementación del método es obtener una descripción textual del cliente (que puede ser el nombre del usuario autenticado, o su IP), utilizando el método getClientDescription(), que veremos más adelante. Esta descripción, asociada al ClientId, es almacenada en el diccionario estático _clients, lo que nos permitirá conocer en todo momento los clientes conectados.

Justo después componemos el mensaje y realizamos el envío a todos los usuarios conectados invocando el método Broadcast() de la propiedad de instancia Connection, que nos da acceso al canal virtual abierto entre clientes y servidor. El parámetro que recibe este método es de tipo object, y viajará serializado en formato JSON hasta cada uno de los clientes conectados; en este caso, hemos creado una clase llamada NotificationMessage que contiene toda la información que necesitamos suministrarles:

public class NotificationMessage
{
    public NotificationMessage(string message, int onlineUsers)
    {
        OnlineUsers = onlineUsers;
        Message = message;
    }
 
    public string Date
    {
        get { return System.DateTime.Now.ToLongTimeString(); }
    }
    public string Message { get; set; }
    public int OnlineUsers { get; set; }
}

Es conveniente tener en cuenta, sin embargo, que es posible enviar cualquier tipo de objeto: tipos propios (como en el ejemplo anterior), objetos anónimos, primitivos, o lo que se nos ocurra. Simplemente será serializado como JSON y llegará al cliente de forma directa (más adelante veremos cómo).

Los miembros auxiliares utilizados en el código anterior son los siguientes:

    private static ConcurrentDictionary<string, string> _clients =
        new ConcurrentDictionary<string, string>();
 
    private static string getClientDescription(HttpContextBase context)
    {
        var browser = context.Request.Browser.Browser + " " +
                        context.Request.Browser.Version;
        var name = context.Request.IsAuthenticated ?
                    "User " + context.User.Identity.Name :
                    "IP " + context.Request.UserHostAddress;
        return name + " (" + browser + ")";
    }

Observad que el diccionario donde almacenamos la información sobre las conexiones ha sido definido como ConcurrentDictionary para evitar problemas de concurrencia durante las actualizaciones, y es estático para que su información sea compartida entre todas las instancias del servicio.

1.2. Notificando a los clientes las desconexiones

Cuando SignalR detecta que un cliente se ha desconectado, invocará al método virtual OnDisconnect() del endpoint, lo cual nos permite introducir lógica de gestión del evento. En nuestro caso, simplemente necesitamos eliminar al cliente del diccionario donde los estamos almacenando,

De la misma forma, debemos controlar las desconexiones para notificar este hecho a los clientes aún conectados, para lo que sobrescribimos el método OnDisconnect():

    protected override void OnDisconnect(string clientId)
    {
        string text, clientDescription;
 
        if (_clients.TryRemove(clientId, out clientDescription))
            text = clientDescription + " is leaving.";
        else
            text = "Unknown user leaving.";
 
        var msg = new NotificationMessage(text, _clients.Count);
        Connection.Broadcast(msg);
    }

En este método recibimos el ClientId que SignalR asignó al cliente en el momento de iniciar la conexión; lo único que hacemos es buscarlo en el diccionario de clientes donde los estamos almacenando, eliminarlo, y enviar un mensaje broadcast al resto de usuarios indicando la desconexión que se ha producido.

Cuando implementéis funcionalidades en la desconexión, tened en cuenta que SignalR tarda unos segundos en darse cuenta de las desconexiones (recordad que con el transporte utilizado por defecto se trata de una conexión persistente virtual) por lo que puede aparecer un leve retraso en las notificaciones. Estos tiempos, en cualquier caso, pueden ser configurados (en el proyecto de demostración podéis ver cómo hacerlo).

[Actualización]: como bien indica Arturo en un comentario del post, para que las desconexiones sean notificadas correctamente es necesario utilizar IIS o IIS Express. Con Cassini (el servidor web integrado en VS) no funcionará bien este mecanismo.

1.3. Algunas observaciones adicionales

Al principio de comenzar a jugar con conexiones persistentes de SignalR, una de las cosas que pueden llamar la atención es que si en la implementación del método OnConnected() enviamos un broadcast a todos los usuarios conectados, el usuario actual (el que ha provocado la llamada a OnConnected) no recibirá el mensaje; o en otras palabras, el broadcast llegará a todos los clientes excepto al que acaba de realizar la conexión.

Desconozco si se trata de un comportamiento por diseño, si es algo que se modificará en posteriores revisiones de SignalR (recordemos que en estos momentos es todavía una versión preliminar), o si simplemente se trata de un nombre para el método poco afortunado, pues en mi opinión da a entender que la conexión ya ha sido realizada y, por tanto, el broadcast debería llegarle también.

Pero en cualquier caso, en la implementación del proyecto de pruebas que podéis descargar al final de este post veréis cómo lo he solucionado incluyendo una llamada explícita (“ping”) desde el cliente al servidor para forzar el envío de un mensaje de actualización justo después de completarse la conexión. Conceptualmente, lo que se hace es:

desde el cliente, una vez se ha realizado la conexión, realizar un envío de datos al servidor, algo similar a un “ping”,
en el método OnReceived() del servidor, capturar el mensaje enviado desde el cliente y responderle de forma directa con la información que nos interese hacerle llegar, que podría ser un mensaje de bienvenida y, como en otras ocasiones, el número de usuarios conectados:
```
    protected override void OnReceived(string clientId, string data)
    {
        var msg = new NotificationMessage("Hi!", _clients.Count);
        Send(clientId, msg);
    }
```

Más adelante, cuando tratemos la parte cliente del servicio, veremos cómo está implementado el envío desde el cliente de este “ping”.

2. Registro de ruta

Una vez tenemos el servicio implementado, debemos registrar en el sistema de routing de ASP.NET una URL a través de la cual será posible acceder al mismo. El lugar idóneo para hacerlo, como siempre que se trata de cargar la tabla de rutas, es en el global.asax, para que se ejecute durante la inicialización de la aplicación.

Por ejemplo, en una aplicación ASP.NET MVC podría ser algo así:

    public static void RegisterSignalrConnections(RouteCollection routes)
    {
        routes.MapConnection<VisitorsService>("Visitors", "VisitorsService/{*operation}");
    }
 
    protected void Application_Start()
    {
        RegisterSignalrConnections(RouteTable.Routes);
        [...]
    }

Observad que lo único que estamos haciendo es añadir a la tabla de rutas una entrada en la que asociamos el servicio, en este caso nuestra clase VisitorsService, a la dirección “VisitorsService/{*operation}”, que será la URL de acceso al mismo.

El primer parámetro que enviamos al método MapConnection() es simplemente el nombre de la entrada en la tabla de rutas, no tiene demasiada importancia.

3. Implementación del cliente web

La implementación de clientes web para las conexiones persistentes desarrolladas con SignalR es bastante simple, y comienza incluyendo en la página o vista una referencia hacia la biblioteca cliente de este componente:

<script src="@Url.Content("~/Scripts/jquery.signalR.js")" type="text/javascript"></script>

Como siempre, esta inclusión puede realizarse a nivel de página, o bien en la Master o Layout si queremos aplicarlo a todas las vistas del sistema.

Nota: si queremos dar soporte a clientes antiguos que no soportan deserialización JSON de forma nativa (por ejemplo, IE7), será necesario descargar desde Nuget la biblioteca de scripts json2.js y referenciarla en la página antes de la carga de SignalR.js. En caso contrario, se lanzará una excepción con el error:

“SignalR: No JSON parser found. Please ensure json2.js is referenced before the SignalR.js file if you need to support clients without native JSON parsing support, e.g. IE<8”

Centrándonos en nuestra aplicación, el marcado HTML será tan simple como el que se muestra a continuación, lo único que hacemos es dejar un “hueco” en el que introduciremos los mensajes que se vayan recibiendo del servidor:

<h2>Log</h2>
<div id="log"></div>

A continuación, necesitamos implementar el código de script que realice las siguientes tareas:

iniciar la conexión con el endpoint,
tras ello, enviar un “ping” para recibir el mensaje de bienvenida (recordad lo que os comentaba previamente de que el broadcast no se recibe por el cliente que inicia la conexión),
mostrar en el log la información recibida del servidor.

Y el código de script tampoco puede ser más sencillo:

<script type="text/javascript">
    $(function () {
        var conn = $.connection("VisitorsService");
        conn.received(function (data) {
            var text = data.Date + " - " + data.Message + " " +
                data.OnlineUsers + " users online.";
            
            $('#log').prepend("<div>" + text + "</div>");
        });
 
        conn.start(function () {
            conn.send("ping");
        });
    });
</script>

Lo comentamos muy rápidamente:

en la variable conn obtenemos una referencia hacia el endpoint, identificado por el nombre de la conexión persistente, en este caso, VisitorsService.
sobre ella, definimos la función received(), que será invocada cuando el servidor envíe información. El parámetro que recibe la función anónima es la información enviada desde el servidor, que, recordaréis, en este caso se trataba en objetos de tipo NotificationMessage. Dado que la serialización y deserialización se realizan de forma automática, podemos acceder directamente a sus miembros, como podéis ver en el código para montar el mensaje e introducirlo en el log.
por último, iniciamos la conexión invocando al método start() de la conexión. Observad que este método admite un callback que será llamado cuando la conexión se haya establecido, momento que aprovechamos para enviar el “ping” al servidor que nos permitirá recibir el mensaje de bienvenida.

Y ¡esto es todo!

Si tenéis un ratillo, no dejéis de descargar el proyecto de prueba y jugar un rato con él. Y sobre todo, observad las pocas líneas de código que hemos tenido que emplear para resolver esta funcionalidad y comparadlo con lo que supondría implementarla de forma artesana, con las técnicas tradicionales.
Descargar proyecto de prueba.

En el próximo post de la serie veremos cómo utilizar los Hubs de SignalR, un planteamiento con una abstracción aún mayor sobre la conexión y una integración entre cliente y servidor simplemente espectacular.

Publicado en Variable not found.

Introducción a SignalR (I): Conceptos básicos

2012-01-17T20:58:00.000+01:00

Una aplicación que mezcla internet, asincronía, y múltiples usuarios colaborando e interactuando al mismo tiempo siempre es merecedora de un “¡uau!”. Seguro que, al igual que un servidor, en algún momento os habéis quedado maravillados con la interactividad que presentan algunos sistemas web modernos, como Facebook, Google Docs, o muchos otros, en las que estamos recibiendo actualizaciones, prácticamente en tiempo real, sin necesidad de recargar la página.

Por ejemplo, en Google Docs, si estamos editando un documento online y otro usuario accede al mismo, podemos ver sobre la marcha que ha entrado, e incluso las modificaciones que va realizando sobre el documento. O algo más cotidiano, en un simple chat vía web van apareciendo los mensajes tecleados por nuestros compañeros de sala como por arte de magia. Ambos sistemas utilizan el mismo tipo de solución: el envío asíncrono de datos entre servidor y clientes en tiempo real.

En esta serie de artículos veremos cómo podemos implementar sorprendentes funcionalidades de este tipo utilizando SignalR, un framework open source desarrollado por gente del equipo de ASP.NET, que nos facilitará bastante la tarea.

¿Cómo puede el servidor enviar eventos al cliente de forma asíncrona?

Crear este tipo de sistemas usando herramientas convencionales nos puede causar algunos dolores de cabeza, principalmente porque los protocolos que sustentan la web están basados en un modelo cliente-servidor síncrono: uno o varios clientes realizan una conexión hacia el servidor y le transmiten una acción a realizar, éste la procesa y les retorna la respuesta, cerrándose la conexión de forma inmediata.

A priori, no hay forma de que el servidor sea el que notifique a los clientes los cambios de estado (por ejemplo, la llegada en un chat de un mensaje procedente de otro usuario), salvo que éstos utilicen un mecanismo de polling, es decir, que estén continuamente estableciendo conexiones con el servidor para ver si hay algún nuevo evento a tener en cuenta.

Aunque válido en determinados escenarios, hay otros en los que se trata de una solución demasiado costosa, sobre todo cuando hay que gestionar un alto número de clientes conectados.

El ideal sería utilizar una conexión persistente, siempre abierta, entre cliente y servidor, que permitiría el envío y recepción de mensajes y eventos de forma bidireccional entre ambos. De esta forma, si el servidor tiene algo que enviar a sus clientes, simplemente tendría que transmitirlo por el canal que mantendría abierto con cada uno de ellos.

Sin embargo, hasta ahora esto sólo se podía conseguir usando sockets, lo cual, en entorno web, requería la existencia de algún tipo de elemento activo sobre la página (Silverlight, Flash, o applets Java, por ejemplo) capaz de establecer este tipo de comunicaciones.

Afortunadamente, la W3C parece dispuesta a cambiar esta situación al introducir de forma nativa los famosos WebSockets, cuya definición se encuentra todavía en borrador. Esta nueva API permitirá abrir conexiones directas desde el navegador usando Javascript, por lo que podría ayudarnos bastante una vez su implementación sea universal en los agentes de usuario. De momento no es así, aunque ya está disponible en algunos de ellos (podéis ver una demo simple aquí con Chrome).

También existe otra iniciativa de la W3C que podría ayudar a enviar mensajes o eventos desde el servidor a los clientes suscritos, llamada Server-Sent Events. Como en el caso anterior, se encuentra en borrador, aunque ya algunos navegadores lo implementan (podéis ver una demo aquí con Chrome), por lo que todavía no podemos utilizarla de forma segura.

Por esta razón, existen hoy en día múltiples soluciones que permiten solventar las limitaciones del protocolo, como las englobadas bajo la denominación Server push o Comet, aprovechando los recursos existentes en los protocolos utilizados para crear, o al menos simular, este canal abierto continuo entre cliente y servidor utilizando polling, long polling, HTTP streaming, y otros artificios.

Por ejemplo, el mecanismo long polling utiliza peticiones HTTP para crear una conexión “pseudopersistente”. El servidor, en lugar de procesar la petición y retornar la respuesta de forma inmediata, espera hasta que haya disponible algún evento o mensaje a enviar al cliente; en este momento, lo retorna como respuesta a la petición original y cierra la conexión. El cliente, por su parte, procesa esta respuesta y realiza inmediatamente después una nueva petición al servidor, que volverá a quedar abierta a la espera de mensajes, y así sucesivamente.

En definitiva, se trata de un mecanismo más limpio y eficiente que el polling, puesto que evita gran cantidad de peticiones absurdas que se producen cuando en el servidor no hay eventos pendientes de notificar. Además, dado que utiliza HTTP estándar, es válida para todo tipo de agentes de usuario, y bastante amigable para proxies, filtros, firewalls y otros inconvenientes que puede haber por el camino entre los dos extremos.

Y en este punto es donde entra en escena SignalR, un conjunto de componentes desarrollados por Damian Edwards y David Fowler, miembros del equipo de ASP.NET en Microsoft, que nos abstrae de los detalles subyacentes y nos ofrece la visión y ventajas de un entorno conectado en el que podemos comunicar cliente y servidor bidireccionalmente, de forma asíncrona, y con una sencillez pasmosa. SignalR nos hace ver como si cliente y servidor estuvieran conectados de forma continua y facilita el envío de mensajes asíncronos bidireccionales entre ambos extremos.

Por último, es importante decir que SignalR no es específico para ASP.NET MVC, ni para WebForms: podemos utilizarlo con cualquier tipo de proyecto web. De hecho, incluso se puede utilizar en otro tipo de proyectos usando un servidor self-hosted :-)

SignalR, conceptualmente

SignalR ofrece una visión a muy alto nivel de la comunicación entre el servidor y los múltiples clientes que se encuentren a él conectados. Y cuando digo “alto nivel”, creedme que estoy hablando de muchos metros de altura ;-)

Como desarrolladores, trabajaremos sobre una conexión virtualmente siempre abierta: en servidor podremos detectar cuándo se ha conectado un nuevo cliente, cuándo se ha desconectado, recibir mensajes de éstos, enviar mensajes a los clientes conectados…, en definitiva, todo lo que podemos necesitar para crear aplicaciones asíncronas multiusuario.

Sin embargo, en realidad estas conexiones persistentes no existen, o no tienen por qué existir. Se trata de una abstracción creada por SignalR, que el que se encargará del trabajo sucio que hay por debajo, manteniendo la conexión de los clientes con el servidor mediante distintos mecanismos denominados “transportes”, que son el conjunto de tecnologías utilizadas para mantener crear la conexión continua, o al menos la ilusión de su existencia.

Lo interesante de los protocolos de transporte es que pueden ser sustituidos de forma transparente sin afectar a nuestras aplicaciones, que trabajarán aisladas de estos detalles. Nuestros sistemas funcionarán exactamente igual sea cual sea el transporte utilizado, lo que permite que éste sea elegido en cada escenario en función de la disponibilidad de las tecnologías en ambos extremos.

Por ejemplo, el transporte Websockets es capaz de crear una conexión con el servidor y mantenerla abierta de forma continua, aunque requiere que esta tecnología esté disponible tanto en el cliente (en el caso de clientes web, es necesario que el navegador implemente Websockets) como en el servidor.

Debido a ello, y para asegurar la máxima compatibilidad con los clientes, actualmente se utiliza por defecto el transporte denominado Long polling, que ya hemos comentado anteriormente.

Observad que, a pesar de la relativa complejidad que supondría implementar algo así a mano, nosotros no tendremos que hacer nada: SignalR se encarga de llevar a cabo todas estas tareas para ofrecernos la sensación de estar siempre conectados.

Su componente cliente será el encargado de realizar las conexiones, mantenerse a la espera de noticias del servidor, reconectar cuando se reciban eventos o cuando por cualquier otra causa se haya perdido la conectividad, etc., ofreciéndonos una superficie de desarrollo muy simplificada.

El lado servidor de SignalR, por otra parte, será el encargado de recibir la conexión y mantenerla en espera, almacenar los mensajes recibidos, realizar el seguimiento de clientes conectados, enviar mensajes a través de un bus interno, etc., y de la misma forma, ofreciéndonos un API bastante simple para implementar nuestros servicios.

Implementación de servicios con SignalR

SignalR nos ofrece dos fórmulas para trabajar sobre las conexiones que crea con el servidor:

usando “conexiones persistentes”, es la de más bajo nivel y proporciona mecanismos simples para registrar conexiones y desconexiones de clientes y comunicarse de forma bidireccional con ellos. De hecho, esta forma de crear servicios es bastante similar a como hacemos utilizando sockets.
usando “hubs”, que ofrece una abstracción aún mayor, permitiendo la comunicación entre cliente y servidor de forma casi mágica. Esta es la opción que convendrá utilizar en la mayoría de ocasiones, por la potencia que aporta y su gran comodidad de uso.

En cualquiera de los dos casos, y ya centrándonos en el entorno web más habitual, donde el servidor es una aplicación ASP.NET y los clientes van a ser las páginas o vistas en las que tendremos un motor de scripting, la implementación de servicios consistirá en:

en el servidor, crear el servicio (también llamado endpoint) con las funcionalidades que nos interese, utilizando las clases disponibles en el ensamblado SignalR.
en cliente, crear el consumidor del servicio utilizando las clases disponibles en la biblioteca de scripts jQuery.SignalR.js (o su correspondiente versión minimizada).

Cada una de las dos fórmulas citadas tiene sus particularidades, por lo que las estudiaremos mediante el desarrollo de ejemplos independientes en futuros posts de la serie.

Pero primero, veamos rápidamente cómo podemos incluir este componente en nuestros proyectos, aunque desde luego más sencillo no puede ser… ;-)

Instalación de SignalR

El sitio web oficial del producto (signalr.net), a día de hoy, es una simple redirección hacia Github, donde se encuentra la documentación y el código fuente del proyecto. Aunque podríamos descargarlo desde ahí, la opción más sencilla, como siempre, es utilizar Nuget:

PM> Install-Package signalr
Attempting to resolve dependency 'SignalR.Server (≥ 0.3.5)'.
Attempting to resolve dependency 'Microsoft.Web.Infrastructure (≥ 1.0.0.0)'.
Attempting to resolve dependency 'SignalR.Js (≥ 0.3.5)'.
Attempting to resolve dependency 'jQuery (≥ 1.6)'.
Successfully installed 'Microsoft.Web.Infrastructure 1.0.0.0'.
Successfully installed 'SignalR.Server 0.3.5'.
Successfully installed 'SignalR.Js 0.3.5'.
Successfully installed 'SignalR 0.3.5'.
Successfully added 'Microsoft.Web.Infrastructure 1.0.0.0' to SignalRDemo.
Successfully added 'SignalR.Server 0.3.5' to SignalRDemo.
Successfully added 'SignalR.Js 0.3.5' to SignalRDemo.
Successfully added 'SignalR 0.3.5' to SignalRDemo.

Esta instalación incluye, además de algún elemento infraestructural, dos componentes de SignalR:

SignalR.Server, que es la biblioteca de servidor principal para integrar en aplicaciones ASP.NET.
SignalR.Js, la biblioteca Javascript necesaria para conectar desde cliente (páginas web) con el servidor.

Existen también otros clientes específicos para .NET, como SignalR.Client (cliente genérico), SignalR.Client.Silverlight (específico para SL), o SignalR.Client.WP7 (específico para Windows Phone 7), que podemos instalar de forma independiente.

Además, tanto en Nuget como en el sitio web del producto podéis encontrar otros paquetes interesantes a los que vale la pena echar un vistazo, como SignalR.Sample, un ejemplo completo de uso de este componente, SignalR.SelfHost, que permite activar el servidor sin usar ASP.NET, o SignalR.Websockets, un adaptador (o transporte, en argot SignalR) para usar Websockets para el mantenimiento de la conexión entre cliente y servidor.

Observaréis que en todos los casos se trata de versiones muy preliminares pero que podemos ir probando y disfrutando desde ya, porque funcionan bastante bien. Podéis comprobarlo accediendo a http://jabbr.net/, un chat implementado sobre SignalR donde podréis encontrar charlando hasta a los mismísimos padres de la criatura. :-)

En el próximo post veremos cómo implementar clientes y servicios SignalR utilizando conexiones persistentes, el enfoque de menor nivel ofrecido por este fantástico componente.

Publicado en: Variable not found.

Enlaces interesantes 68

2012-01-16T09:28:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 9 al 15 de enero de 2012. Espero que os resulten interesantes. :-)

.Net

DateTime.UtcNow is generally preferable to DateTime.Now
Kirill Osenkov
C# Static Field Initialisation Order
BlackWasp
Inside the Concurrent Collections
Simon Cooper
C#/.NET Little Wonders: The DateTime TryParse() and ParseExact() Methods
James Michael Hare

Asp.net

AttributeRouting for MVC
Gregor Suttie
The new .NET HttpClient class
Pedro Félix
Creating Printer Friendly Pages
Kirupa Chinnathambi
A Really Empty ASP.NET MVC 3 Project Template
Phil Haack
Different ASP.NET MVC master page for authenticated and unauthenticated users
Tero Teelahti
Modernizr–Ejemplo práctico 1 : Utilizando Placeholder
Gonzalo Pérez
The evolution of asynchronous controllers in ASP.NET MVC
Simone Chiaretta
Plantillas de lado cliente con JavaScript: ¿Qué tecnología utilizar?
José Manuel Alarcón
ASP.NET session hijacking with Google and ELMAH
Troy Hunt

Azure / Cloud

Node.js & Windows Azure – ¿Qué es realmente Node.js? ¿Por dónde empiezo? Creando mi Web server
Gisela Torres
Windows Azure Libraries for Java Available, including support for Service Bus
Ram Jeyaraman

Data access

EF 4.3 Beta 1 Released
ADO.NET Team blog
EF 4.X: Sql Federations
Unai Zorrilla
Comparativa ORM-Lite, EF y ADO.NET
Javier Torrecilla
MongoDb cheat sheet
Cheat Sheets
MongoDb Enterprise Design with C# .NET, the Repository Pattern, and NoSQL
Kory Becker
[ORM-Lite] PetaPoco
Javier Torrecilla
[ORM-Lite] Massive
Javier Torrecilla

Html/Css/Javascript

El valor de this en Javascript: cómo manejarlo correctamente
Carlos Benítez
jQuery UI 1.8.17 released
Scott González
Using HTML5 Canvas for Data Visualization
Brandon Satrom
Advanced Random Numbers in JS
Kyle Delaney
Why is there the Flash in the HTML5 version of Cut the Rope?
Robby Ingebretsen
Adding your own callbacks to existing JavaScript functions
Dave Ward
Controlling Selection with CSS user-select
IE Blog
The contenteditable attribute
Jack Osborne
Textarea Auto Resize
Louis Lazaris
Curso gratuito de HTML5
MSDN
SOLID JavaScript- The Interface Segregation Principle
Derek Greer
Understanding JavaScript OOP
Quildreen Motta
Speech Javascript API, habla con las páginas web
Andrés Nieto

Visual Studio/Complementos

Advanced Debugging in Visual Studio
Pankaj Chamria

Otros

Cut the rope online
The 10 rules of the pragmatic programmer
Alexis Sukrieh
Programar no es tan complicado
Lucas Ontivero

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Establecer el foco automáticamente, versión declarativa

2012-01-10T10:24:00.000+01:00

Hace poco escribía un post en el que mostraba cómo se podía conseguir establecer el foco inicialmente en un control de edición, algo que era posible con Webforms pero no directamente con las herramientas que ASP.NET MVC trae de fábrica.

La solución propuesta consistía en introducir en la vista código de script para desplazar el foco hasta el control indicado mediante una llamada al helper Html.SetFocusTo(), que implementábamos en el mismo post, aunque hay otras formas para conseguirlo.

Unos días después, un amigo de Variable not found preguntaba en un comentario si no había una forma de conseguir lo mismo utilizando una sintaxis más declarativa, al estilo de la especificación de metadatos o validadores basados en atributos o data annotations.

En primer lugar he de decir que no creo que sea muy conveniente hacerlo, puesto en casi todos los escenarios posicionar el foco en un elemento es pura presentación, no suele haber decisiones de negocio tras ello, y por tanto no es algo que debamos sacar de la Vista. Pero bueno, independientemente de eso, vamos a ver cómo podríamos conseguirlo.

Una forma relativamente sencilla de hacerlo sería utilizando atributos de metadatos personalizados de forma muy similar al ejemplo que vimos también en un post anterior.

Lo primero que necesitamos es definir un atributo que implemente IMetadataAware, lo que indica que incluye información sobre metadatos, y aprovechar el método OnMetadataCreated() para introducir en la colección de metadatos adicionales una señal que permita más adelante detectar la propiedad a “enfocar”:

public class FocusedAttribute : Attribute, IMetadataAware
{
    public const string MetadataKey = "Focused";
    public void OnMetadataCreated(ModelMetadata metadata)
    {
        metadata.AdditionalValues[MetadataKey] = true;
    }
}

De esta forma, para activar el foco inicialmente sobre el editor de una propiedad concreta, simplemente deberíamos marcarla con el atributo [Focused], como se muestra en el código siguiente:

public class Friend
{
    [Focused]
    public string Name { get; set; }
 
    public string Email { get; set; }
    public string Phone { get; set; }
    public string Fax { get; set; }
 
}

Una vez finalizados los preparativos, tenemos que ver cómo implementarlo en la vista. Lo más sencillo en este caso sería crear el helper Html.Autofocus(), que será encargado de localizar la propiedad con el atributo [Focused] y generar sobre la vista el script que mueva el foco a la misma:

public static class HtmlExtensions
{
    public static MvcHtmlString Autofocus(this HtmlHelper html)
    {
        var template = html.ViewData.TemplateInfo;
        var focusedProperty = 
             (from property in html.ViewData.ModelMetadata.Properties
              where property.AdditionalValues.Any(
                     a => a.Key == FocusedAttribute.MetadataKey && (bool) a.Value)
              select template.GetFullHtmlFieldId(property.PropertyName)
             ).FirstOrDefault();
        if (focusedProperty != null)
        {
            return createAutofocusScript(focusedProperty);
        }
 
        return null;
    }
 
    private static MvcHtmlString createAutofocusScript(string focusedProperty)
    {
        string script = "<script type='text/javascript'>" +
                        "$(function() { $('#" + focusedProperty + "').focus(); });" +
                        "</script>";
        return MvcHtmlString.Create(script);
    }
}

Por último, basta con introducir en la vista la siguiente llamada. O mejor aún, si queremos que esta funcionalidad esté activa en todas las vistas, podemos añadirla al final del Layout que estemos empleando para ellas:

@Html.Autofocus()

Hay que tener en cuenta que nada impide que el atributo Focused sea empleado en más de una propiedad, en cuyo caso el foco se establecerá en la primera ocurrencia localizada. Esto se podría evitar llevando el atributo a nivel de clase e indicando como parámetro el valor de la propiedad (algo así como [DefaultProperty("Name")] sobre la propia entidad). En el proyecto de demostración podréis encontrar también esta implementación.

Descargar proyecto de demostración (VS2010+MVC 3) desde Skydrive.

Publicado en Variable not found.

Enlaces interesantes 67

2012-01-09T09:30:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter en la primera semana del año 2012. Espero que os resulten interesantes. :-)

.Net

C# Básico: Eventos
Eduard Tomás
PerfView performance analysis tool
Vance Morrison
Resumen de las versiones de .NET
Jorge Serrano
Test-Driven Development, Generate from Usage and Continuous Testing
Peter Vogel

Asp.net

Paging, sorting, and searching using EF Code first and MVC 3
Nadeem Afana
Web Forms with HTML5
Mark Michaelis
Essential guide to ASP.NET MVC3 performance
Leon Cullens
Web Scraping con HTML Agility Pack
Juan María Hernández
Using The Themes Helper In Razor Web Pages
Mike Brind

Data access

Dapper Dot Net
Javier Torrecilla

Html/Css/Javascript

Compresor, Ofuscador, Minificador, Validador de JavaScript
Patrick J. O'Neil (vía @chalalo)
Profiling CSS for fun and profit. Optimization notes.
Juriy Zaytsev
Cross Browser HTML5 Progress Bars In Depth
Zoltan Hawryluk
Hashtables vs. Arrays
Kirupa Chinnathambi
JavaScript for C# developers: the Module Pattern (part 3)
Julian M Bucknall
Battery Status API, controla la carga de la batería de tus usuarios con Javascript
Andrés Nieto
JavaScript for C# developers: the Module Pattern (part 2)
Julian M Bucknall

Visual Studio/Complementos

Visual Basic Improvements in Visual Studio 11
Joe Kunk
Optimizing Assembly References with ReSharper 6.1
by Jura Gorohovsky

Otros

Windows 7 “God Mode” gives lots more options
Andy Twine
Notes on Scalability
Jeremiah Peschka
Microsoft da detalles acerca del "reset" y el "refresh" de Windows 8
Manu Mateos
Errors: Handle with care
Hadi Hariri
8 Things clients need to learn about software development
Leon Cullens
Artesanos del conocimiento
José Manuel Alarcón
91 Ways to become the Coolest Developer in the World
Pulkit Arora

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Enlaces interesantes 66

2012-01-04T09:06:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter en la última semana del año 2011. Espero que os resulten interesantes. :-)

.Net

The concept of async/await
Buaya Eshet
December Headline: C++ about to be dethroned by C#
TIOBE (vía @lluisfranco)

Asp.net

Eight Different Ways to Transfer Data from One Page to Another Page
Peter Bromberg
ASP.NET Security Update Shipping Thursday, Dec 29th
Scott Guthrie (vía @CampusMVP)
Validaciones en ASP.NET MVC
Eduard Tomás
Client-side routing with ASP.NET MVC
Geek Stuff
Control level request validation in ASP.NET 4.5
Abhijit Jana
Dealing with Profile Access in ASP.NET MVC Applications
Bipin Joshi
ASP.NET MVC 3 Real Time Collaborative Apps with SignalR
Sumit Maitra
Implementar un sitio web privado con ASP.NET MVC
Óscar Sotorrío

Azure / Cloud

SQL Azure to Developers: Some Basic Concepts
Dhananjay Kumar
Modificar el tiempo de vida del token proporcionado por Windows Azure AppFabric Access Control
Gisela Torres
Aumentar el timeout en las operaciones al servicio de blobs de Windows Azure Storage
Gisela Torres
Aumentar el tiempo de invisibilidad o el contenido de un mensaje en Windows Azure Storage Queues
Gisela Torres

Data access

The O/RM and the chicken/egg dilemma
Dino Esposito
Lanzamiento Oficial Driver Oracle para Entity Framework
Javier Torrecilla

Html/Css/Javascript

22 Most Popular jQuery Plugins of 2011
More tech tips
The async and defer Script Attributes in HTML5
Gil Fink
JavaScript for C# developers: the Module Pattern (part 1)
Julian M Bucknall
Working with the JavaScript “this” Keyword
Dan Wahlin

Visual Studio/Complementos

ReSharper 6.1: Improvements in IntelliSense Options
Hadi Hariri
Packaging a JavaScript Library with Nuget
Sumit Maitra

Otros

[Tip] Un huevo de pascua llamado “dnndev.me”
David Rodríguez

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Adzure, la nube gratuita soportada por publicidad

2011-12-28T01:31:00.000+01:00

Microsoft es una compañía que nos tiene acostumbrados a giros extraños en sus políticas de comercialización y distribución de productos, y está claro que la nube no iba a permanecer ajena a ellos.

Hace un par de días, ante el asombro de los presentes, Fred Swarm (cloud manager para la región EMEA) anunció la próxima apertura de Adzure, la edición gratuita del servicio Windows Azure soportada por publicidad.

Esto supone una auténtica revolución en el mundo de los servicios en la nube, que pasan del tradicional enfoque pay-per-use hacia un modelo de negocio basado en los ingresos publicitarios. Es decir, serán los anunciantes los que soportarán los costes de mantener en funcionamiento los roles e instancias de nuestras aplicaciones en la nube, la ocupación en disco, transferencia, uso de CDN, etc., sólo a cambio de que dejemos que se inserten anuncios publicitarios en determinados puntos de nuestros sistemas.

A cambio, no tendremos restricción alguna en cuanto al número de procesadores, memoria, ni ocupación de la infraestructura del gigante de Redmond. Podemos utilizar todos los recursos que necesitemos, y de hecho, se anima a que así sea: si una aplicación web debe escalar de forma brutal es porque tiene muchos visitantes… y visitantes es igual a impactos publicitarios, por lo que sería el escenario ideal para todos.

Una de las cosas más curiosas de este servicio es precisamente que la inserción de la publicidad se realizará de forma automática, los desarrolladores no tendremos que hacer nada al respecto: simplemente, los anuncios aparecerán en puntos donde la plataforma considere oportuno.

Esto es posible gracias a la nueva tecnología AdInsight®, que se encarga de analizar nuestro software una vez lo hemos desplegado en Adzure e inyectar en ellos la lógica de generación de anuncios publicitarios. Está claro que este automatismo a veces puede provocar pequeñas intrusiones como la que veis en la captura de pantalla adjunta, pero estaréis de acuerdo en que es un precio bastante razonable teniendo en cuenta el valor y potencia de la infraestructura que estamos usando de forma gratuita :-)

Según se desprende del documento de notas de la revisión, existen tres únicos puntos de inserción publicitaria automática:

las páginas web generadas por un WebRole podrán ser modificadas de forma automática para incluirle código de script para la generación de anuncios contextuales.
el servicio de almacenamiento blob para contenidos digitales (imágenes, html, PDF, PPTs, vídeos, etc.) podrá introducir contenidos publicitarios en el interior de estos archivos, aunque casi siempre de forma no intrusiva.
los mails enviados y recibidos a través del servicio Adzure Mail Connector®, el motor que hay por detrás de Hotmail, también llevarán un mensaje publicitario contextualizado a la temática del mensaje.

El resto de servicios en la nube (como el almacenamiento en tablas, SQL Server, queues, buses, etc., de momento están libres de publicidad y pueden ser utilizados libremente y sin restricciones.

Los anuncios se seleccionan de forma automática teniendo en cuenta la temática de la aplicación, el contexto en el que se insertan, el perfil del usuario conectado, y varios factores más. Sin embargo, en lugar de ser gestionados por la plataforma Microsoft Advertising, han preferido llegar a un acuerdo con Google e integrar la inteligencia de marketing de Adsense, bastante depurada, certera y que tantas alegrías nos da a sus usuarios.

Pero, ¿y qué ocurre con los ingresos generados por publicidad en las aplicaciones desplegadas en Adzure? Pues una nueva sorpresa: Microsoft los compartirá con los desarrolladores o propietarios del sitio en una proporción del 40% al 60% dependiendo del tráfico. Es decir, no sólo no nos costará utilizar la infraestructura de Adzure, sino que además podemos ganar dinero con ello :-)

Pues no sé qué os parecerá a ustedes, pero yo veo la idea interesantísima. Adzure permite el uso de todos los servicios de la nube de forma gratuita, lo que abre un campo enorme a pequeñas empresas y startups que necesitan disponer de la gran capacidad de la nube, pero sin incurrir en coste alguno, simplemente a cambio de permitir la inserción automática de estos anuncios publicitarios en sus servicios, lo cual en algunos escenarios no tiene por qué ser un problema grave; de hecho, Gmail lo hace y no nos quejamos demasiado ;-)

Además, el hecho de que aspectos infraestructurales como los servidores, anchos de banda, seguridad, etc., pasen de ser un coste a una fuente de ingresos me parece una vuelta de tuerca absolutamente necesaria.

De hecho, ya he comenzado a migrar todos mis desarrollos a Adzure, y el resultado está bastante bien (podéis ver una captura en el lateral); sin tocar una línea de código, sólo desplegarlo en la nube, la publicidad insertada se integra perfectamente en los diseños e incluso diría que lo mejoran, y por no hablar de que en unos días ya he conseguido algunos centimillos que nunca vienen mal.

Por cierto, actualmente estos servicios están en fase de beta privada y sólo se puede acceder por invitación, pero tengo treinta invitaciones para repartir entre los lectores del blog que estén realmente interesados en probarlo. Simplemente poneos en contacto conmigo por la vía que os sea más cómoda (por ejemplo ésta) y os iré enviando la URL y password personal de acceso en riguroso orden de llegada.

Y si preferís esperar, el servicio se abrirá al público en general el próximo uno de abril.

[Actualizado 29/12]
Nota para despistados: obviamente la noticia no es real, se trata simplemente de una broma del Día de los Inocentes. Por tanto, lamento comunicaros a los (muchos) que estáis esperando una invitación que de momento no va a poder ser ;-P

Publicado en Variable not found.

Enlaces interesantes 65

2011-12-27T10:08:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 18 al 23 de diciembre de 2011. Espero que os resulten interesantes. :-)

.Net

Mono in 2011
Miguel de Icaza

Asp.net

How to combine a Worker Role with a MVC4 Web Role into a single instance
Liam Cavanagh
ASP.NET MVC + Selenium + IISExpress
Stephen Walther
Model Binding with Dropdown List in ASP.NET 4.5
Abhijit Jana
Knockout 2.0.0 released
Steve Sanderson
Free eBook: OWASP Top 10 for .NET developers
Troy Hunt
Solving Duplicate Content with Distinct URLs Issue in ASP.NET MVC
Imran Baloch's
New Request validation features in ASP.Net 4.5
K. G. Sreeju Nair
Using CORS to access ASP.NET services across domains
Dave Ward
HttpRequestBase vs HttpRequest
Eduard Tomás
Debugging Application_Start and Module Initialization with IIS and Visual Studio
Rick Strahl
Rotate an ASP.NET Image Control using HTML 5 Canvas
Suprotim Agarwal
Retoques a MVC y Razor para proyectos grandes–Una recomendación
Lucas Ontivero
High-Performance ASP.NET Caching
Peter Vogel
Microsoft blogging platform gains 33% performance boost after adopting RequestReduce
Matt Wrocks

Azure / Cloud

Azure Monitor for Windows Phone 7 is out!
Ibon Landa
Libro gratuito sobre Windows Azure (Parte IV): Diseño y herramientas
CampusMVP
SQL Azure Q4 2011 Service Release
Ibon Landa

Data access

MongoDB Best Practices
Inés Sombra
Inserciones masivas en SQL Server CE vs SQL Server vs MongoDb (y II)
Josué Yeray
Raven DB VI, La hora de las consultas…
Unai Zorrilla

Html/Css/Javascript

JavaScript as a First Language
John Resig
The output element in HTML5
Richard Clark
Excssive, herramienta online para comprimir archivos CSS
Zach Will (Vía desarrolloweb.com)
Meet the CSS4 selectors
Catalin Rosu
JavaScript for C# developers: calling functions and the ‘this’ variable
Julian M. Bucknall
Top 10 “Must Follow” JavaScript Best Practices
Salman Siddiqui
Online Javascript Compression Tool
BrightBit
The rise and rise of JavaScript
Dan North
Using the JavaScript Prototype Property to Structure and Extend Code
Dan Wahlin's
Multiple Attribute Values
Chris Coyier
The Seven Deadly Sins Of JavaScript Implementation
Christian Heilmann (vía @alegrebandolero)

Visual Studio/Complementos

C# + ReSharper = Awesome: Tip #5 – Replace Constructor with Factory Method
Alvin Ashcraft
ReSharper 6.1, dotCover 1.2 and dotTrace 4.5.2 Performance Released
Hadi Hariri
C# + ReSharper = Awesome: Tip #4 – Convert Abstract Class to Interface
Alvin Ashcraft
C# + ReSharper = Awesome: Tip #3 – Convert Into LINQ Expression
Alvin Ashcraft

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

¡Felices fiestas & 2012!

2011-12-23T12:52:00.001+01:00

Desearos a todos unas muy felices fiestas en las que podáis disfrutar de la compañía de todos aquellos que os importan.

Y ya de paso, desearos también que el próximo año 2012 venga cargado de alegrías, prosperidad y nada más que cosas buenas. Al menos a ver si es para todos un pelín mejor de lo que ha sido el año que ahora cerramos ;-)

Nos seguimos viendo por aquí.

IMetadataAware, atributos de metadatos personalizados

2011-12-20T09:20:00.000+01:00

Hace pocas semanas profundizamos en los mecanismos de obtención de metadatos del modelo en ASP.NET MVC y vimos cómo extender el framework para dotarlo de vías alternativas desde las que obtener esta información usando un proveedor personalizado.

Sin embargo, no es este el único mecanismo de extensión del framework a este respecto: también podemos crear fácilmente nuevos atributos que aporten información extra de metadatos a las clases y propiedades del Modelo. Y esta es la razón de ser del interfaz IMetadataAware.

El interfaz IMetadataAware

Definido en System.Web.Mvc e introducido con la tercera versión del framework, este interfaz permite crear atributos que encajen muy suavemente en el sistema de generación y obtención de metadatos de ASP.NET MVC, evitando en muchos escenarios la necesidad de escribir proveedores personalizados.
Como podemos ver a continuación, su definición es de lo más simple:

public interface IMetadataAware
{
    void OnMetadataCreated(ModelMetadata metadata);
}

¿Y cómo se utiliza esto internamente? Pues la respuesta la podemos encontrar buceando un poco en el código fuente del framework.

Durante el proceso de obtención de metadatos, el proveedor DataAnnotationsModelMetadataProvider (en conjunción con su tipo base AssociatedMetadataProvider), obtiene los metadatos “estándar” y los introduce en un objeto de tipo ModelMetadata.

Una vez tenemos ya esta información, obtenida según el comportamiento por defecto desde los atributos conocidos que decoran las propiedades del Modelo, se ejecuta el método estático ApplyMetadataAwareAttributes(), que tiene la siguiente pinta:

private static void ApplyMetadataAwareAttributes(
                          IEnumerable<Attribute> attributes, 
                          ModelMetadata result)
{
    foreach (IMetadataAware awareAttribute in attributes.OfType<IMetadataAware>())
    {
        awareAttribute.OnMetadataCreated(result);
    }
}

Como se puede deducir a la vista del código, el método es invocado suministrándole, por una parte, todos los atributos localizados en la clase del Modelo, y por otra, el objeto ModelMetadata que contiene la información de metadatos obtenidos hasta el momento.

Ya en su interior, lo único que se hace es obtener todos aquellos atributos que implementen el interfaz IMetadataAware y llamar a su único método OnMetadataCreated() con objeto de que actualicen los metadatos con la información que necesiten.

Por tanto, en la práctica, si queremos crear un atributo que introduzca información adicional de metadatos, o simplemente modifique los existentes, debemos:

crear un atributo como siempre, heredando de Attribute,
hacer que la clase implemente el interfaz IMetadataAware,
implementar en el método OnMetadataCreated() para introducir la metainformación que nos interese en el objeto ModelMetadata que recibimos como parámetro .

Por ejemplo:

public class MyMetadataAttribute: Attribute, IMetadataAware
{
    public void OnMetadataCreated(ModelMetadata metadata)
    {
        // Set properties...
        metadata.DisplayName = "My text";
 
        // ... or add new properties to AdditionalValues
        metadata.AdditionalValues["MyKey"] = "My value";

}
}

Observad que en el cuerpo del método tenemos acceso a todas las propiedades de metadatos, así como a su diccionario AdditionalValues, donde podemos introducir cualquier tipo de información que nos interese poner a disposición de la Vista.

¿Un ejemplo rápido?

Vamos a desarrollar un atributo de metadatos personalizado al que llamaremos Important, y que hará lo siguiente:

en primer lugar, añadirá al DisplayName de la propiedad (el texto que aparece en su correspondiente etiqueta) el sufijo “important!”.
añadirá a la colección AdditionalValues un valor que permita a la vista destacar el editor de la propiedad visualmente.

(Ojo, que hay otras formas para conseguir este mismo resultado, pero el post trata sobre IMetadataAware, así que tendremos que quedarnos con esta ;-))

public class ImportantAttribute: Attribute, IMetadataAware
{
    public void OnMetadataCreated(ModelMetadata metadata)
    {
        metadata.DisplayName = metadata.GetDisplayName() + " (important!)";
        metadata.AdditionalValues["Important"] = true;
    }
}

Eso es todo lo que necesitamos en nuestro atributo. Hecho esto, ya podemos utilizarlo en una clase del Modelo como se muestra a continuación:

public class Friend
{
    [Important]
    public string Name { get; set; }
 
    public string Email { get; set; }
 
    [Important]
    public string Phone { get; set; }
 
    public string Fax { get; set; }
 
}

El simple hecho de decorar las propiedades Name y Phone con nuestro flamante atributo [Important] hará que sus etiquetas descriptivas aparezcan ya con el sufijo “important!”, puesto que estamos modificando directamente su DisplayName. Si queremos además destacar los editores necesitaremos inyectar un poco de lógica en la vista, cosa que podemos hacer de forma relativamente sencilla implementando un helper o modificando las plantillas de edición por defecto para los tipos utilizados (en este caso, strings).

Una implementación rápida de un helper que genere código script para destacar las propiedades importantes podría ser la siguiente. Si os fijáis, lo único que hace es obtener aquellas propiedades en cuyos metadatos exista la entrada de AdditionalValues establecida en el atributo [Important], y establecer en sus editores la clase CSS “important” para darles un poco de color:

public static class HtmlExtensions
{
    public static MvcHtmlString HighlightImportant(this HtmlHelper html)
    {
        var template = html.ViewData.TemplateInfo;
        var importantProps = from property in html.ViewData.ModelMetadata.Properties
                                where property.AdditionalValues.Any(
                                    a => a.Key == "Important" && (bool)a.Value)
                                select template.GetFullHtmlFieldId(property.PropertyName);
                                       
        if (importantProps.Any())
        {
            string commaIds = string.Join(",#", importantProps);
            string script = "<script type='text/javascript'>" +
                            "$(function() { $('#" + commaIds + "').addClass('important'); });" +
                            "</script>";
            return MvcHtmlString.Create(script);
        }
        return null;
    }
}

Obviamente, tendríamos que incluir una llamada al helper Html.HighlightImportant() en las vistas o, si queremos mayor comodidad, en el Layout del sitio web.

En la captura de pantalla de la derecha podéis ver el resultado de este ejemplo en funcionamiento. Y si queréis probarlo y juguetear un rato con él, podéis descargar el proyecto para Visual Studio y ASP.NET MVC 3 desde mi Skydrive.

Publicado en Variable not found.

Enlaces interesantes 64

2011-12-19T09:25:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 12 al 17 de diciembre de 2011. Espero que os resulten interesantes. :-)

Aprovecho además para pediros opinión sobre un nuevo formato de presentación de los enlaces, usando categorizaciones. De esta forma podréis acceder directamente a aquellos cuya temática os interese, en lugar de tener que leerlos todos para ver si hay alguno que al que valga la pena echar el vistazo. ¿Qué os parece? ¿Mejor así?

.Net

Formatting Enumeration Constants
BlackWasp
Install-Package Roslyn
Kirill Osenkov
Return Multiple Values from Methods with Tuples
Peter Vogel
C# Fundamentals: Returning Zero or One Item As IEnumerable<T>
James Michael Hare
.Net Reflector y ILSpy, ¿podrían inferir mejor el código a partir del IL?
Lucas Ontivero

Asp.net

[Video] ASP.NET vNext - Filtrado de datos - Value Provider Attributes
Luis Ruiz
How to use SignalR and Knockout in an ASP.NET MVC 3 web application to handle real-time UX updates
Justin Schwartzenberger
MVC and HTML5 Web Workers
Dean hume
Introducing SignalR.EventStream
Ben Dornis
Update jqGrid Html helper for ASP.NET MVC
Robin van der Knaap
Implement secure ASP.NET MVC applications
Jovan Popovic
Which is the Fastest Webserver? Apache, IIS, Nginx, LightHttpd or G-Wan?
WebPerformance (vía @campusmvp)
OWASP Top 10 for .NET developers part 10: Unvalidated Redirects and Forwards
Troy Hunt
Espresso Tip: IHttpHandler and IsReusable
David Neal
Introducción a less
Sergio León
Automatically trim html controls in a asp.net mvc project
Richard Wilde
On deploying ASP.NET MVC site as a desktop application
Andrei Marukovich
Todo sobre AutoEventWireUp en páginas ASP.NET Web Forms
José Manuel Alarcón
Using QUnit with Razor Layouts
Phil Haack
ASP.NET MVC ViewModel usage and pick your best pattern
Kazi Manzur Rashid
MVC Route/URL Generation Unit Tester
Codeplex
Easy URL rewriting in ASP.NET 4.0 web forms
Jalpesh Vadgama
Looking into Web performance in ASP.Net applications
Nikolaos Kantzelis
[Vídeo] ASP.NET vNext - Selección de datos (SelectMethod)
Luis Ruiz
Using SignalR to broadcast a slide deck
Marteen Balliauw

Azure / Cloud

Utilizar Windows Azure AppFabric Caching como session provider
Gisela Torres
VMware Cloud Foundry cloud platform now supports .Net
Mary-Joe Foley
Now Available: SQL Azure Q4 2011 Service Release
Azure Team (vía @ibonilm)
The SQL Azure Team Unveils a New Server Management UI
Roger Jennings
Differences Between the Storage Emulator and Windows Azure Storage Services
MSDN

Conceptos

Algorithms Course Materials
Jeff Erickson
Hash Functions
Bret Mulvey

Data access

RavenDB (IV) La identidad de los documentos
Unai Zorrilla
Data Access Performance Comparison in .NET
Luis Rocha

Html/Css/Javascript

10 Best jQuery Form Plugins
jQuery4u
Your jQuery: Now With 67% Less Suck
Scott Kosman
JavaScript – Add Commas To Number
Shai Raiten
Frontend SPOF
Steve Souders
The 30 Most Effective jQuery Plugins
Awcore
Animations in HTML5
Florian Rappl
HTML 5 Input Types - How useful is this really going to be?
Rick Strahl
The CSS profilers are coming!
Lennart Schoors
A Key Code Checker for DOM Keyboard Events
Rick Strahl

Visual Studio/Complementos

[HowTo] Agregar Ficheros a un Proyecto Existente
Javier Torrecilla
C# + ReSharper = Awesome: Tip #2 – Create Field
Alvin Ashcraft
NuGet 1.6 Release Notes
Nuget Team
[How To] Agregar un elemento de menú a Visual Studio.
Javier Torrecilla
Go To Definition for JavaScript Functions in Visual Studio 2011
Abhijit Jana
Introducing CSSCop - FxCop for stylesheets
Mads Kristensen

Otros

La fruta más alta siempre sabe mejor
José Manuel Alarcón

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

[Auges] Inyección de dependencias en ASP.NET

2011-12-19T08:50:00.000+01:00

Mañana, martes 20 de diciembre de 2011, a las 19:00h (GMT+1) en AUGES tendremos el placer de contar con la presencia de Luis Ruiz Pavón, alma mater del grupo y gran conocido en la comunidad de desarrolladores .NET, para explicarnos qué es, para qué sirve y cómo se usa la Inyección de Dependencias, especialmente enfocado al desarrollo con ASP.NET.

En este WebCast veremos una introducción a la inyección de dependencias en ASP.NET con ejemplos prácticos:

¿Qué es la inyección de dependencias?

¿Que nos aporta?

Patrones y anti-patrones.

¿Dónde se construye el grafo?

Tiempo de vida de las dependencias.

Contenedores de dependencias (IoC Containers)

¿Cómo se aplica todo esto en ASP.NET?

Ponente: Luis Ruiz Pavón (Spenta - Beezy) - miembro y fundador de AUGES (www.auges.org) y uno de los grandes colaboradores de la comunidad de desarrolladores. Puedes seguirlo a través de su blog técnico (www.luisruizpavon.com) y de Twitter (@luisruizpavon).

Como siempre, se trata de un Webcast de asistencia es gratuita al que podéis registraros a través de la siguiente dirección:

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032499034&Culture=es-ES

En resumen, se trata de un evento que no deberíais perderos si queréis construir aplicaciones y componentes ASP.NET mejor estructurados, flexibles, desacoplados, muy mantenibles y fáciles de probar usando pruebas unitarias.

Esperamos veros por allí ;-)

Publicado en Variable not found.

ASP.NET MVC: establecer el foco en un control al cargar la página

2011-12-14T09:04:00.000+01:00

Uno de los aspectos más criticados por los desarrolladores cuando comienzan a trabajar con ASP.NET MVC es el hecho de tener que volver a resolver problemas que estaban ya más que solucionados en Webforms.

Y uno de estos casos es un detallito muy simple pero útil: establecer el foco de edición en un control concreto al cargar una página. En Webforms era suficiente con asignar al atributo defaultFocus del tag <form> el nombre del control que nos interesara, y ya lo teníamos solucionado; ASP.NET MVC no trae ninguna solución “de serie” para conseguirlo, aunque, como veremos en este post, no es mucho más complicado que la alternativa Webforms una vez hemos preparado la infraestructura necesaria.

En líneas generales, la solución consiste en utilizar un pequeño script que, una vez cargada la página, mueva el foco hacia el control que nos interese. Por ejemplo, si quisiéramos que el campo con identificador “Nombre” obtenga el foco automáticamente, podríamos utilizar jQuery de la siguiente forma:

<script type="text/javascript">
    $(function () {
        $("#Nombre").focus();
    });
</script>

Aunque eficaz, es una solución demasiado trabajosa e introduce una dependencia en el código, difícilmente manejable, hacia el nombre del control. Si quisiéramos introducir este código en múltiples puntos de nuestra aplicación tendríamos que copiar y pegar en cada vista, y sustituir el id del control apropiado en cada caso, lo cual es bastante incómodo.

¿No podríamos mejorar esto un poco?

El helper SetFocusTo()

Una posible solución, realmente rápida de implementar, sería crear un helper personalizado, al que llamaremos SetFocusTo(), que genere el código por nosotros partiendo únicamente de la información de la propiedad a editar.

Y para evitar la dependencia hacia el nombre de la propiedad y hacerlo más flexible, incluso podríamos crear la versión fuertemente tipada del mismo, de forma que podamos utilizarlo de cualquiera de las siguientes formas:

// Usando el nombre de la propiedad:
@Html.SetFocusTo("Nombre")

// Usando la versión fuertemente tipada:
@Html.SetFocusTo(model=>model.Nombre)

El código del helper es el siguiente:

public static class HtmlHelpers
{
    public static MvcHtmlString SetFocusTo<TModel, TProperty>(
                    this HtmlHelper<TModel> html,
                    Expression<Func<TModel, TProperty>> expression)
    {
        var prop = ExpressionHelper.GetExpressionText(expression);
        return html.setFocusTo(prop);
    }

    public static MvcHtmlString SetFocusTo(this HtmlHelper html, 
                                           string propertyName)
    {
        var prop = ExpressionHelper.GetExpressionText(propertyName);
        return html.setFocusTo(prop);
    }

    private static MvcHtmlString setFocusTo(this HtmlHelper html, 
                                            string property)
    {
        string id = html.ViewData.TemplateInfo.GetFullHtmlFieldId(property);
        var script = "<script type='text/javascript'>" +
                        "$(function() {" +
                            "$('#" + id + "').focus();" +
                        "});" +
                        "</script>";
        return MvcHtmlString.Create(script);
    }

}

Recordad que para que estos helpers estén visible en las vistas y podáis usarlos normalmente, debéis incluir el espacio de nombres en el que están definidos bien sea añadiendo una directiva @using en la vista, o bien en la sección <namespaces> del archivo web.config que encontraréis en la carpeta /Views (o en la del área correspondiente).

¡Y eso es todo! De esta forma tan simple, ya volvemos a disponer de la posibilidad de establecer el foco por defecto sobre un control de forma muy rápida, compacta, y cómoda de utilizar.

Publicado en: Variable not found.

Funciones constructoras en Javascript

2011-12-13T09:23:00.000+01:00

Blogger invitado

Óscar Sotorrío Sánchez

Desarrollador independiente, MCP C#

Eterno aprendiz en esto de las tecnologías .NET y en especial con ASP.NET. Admirador de la filosofía de Internet y entusiasta de los nuevos modelos de negocio que rigen este mundillo.
Blog: oscarsotorrio.com

En un artículo anterior vimos una pequeña introducción de los objetos en JavaScript en el que se mostraron algunas características esenciales de los objetos en sí mismos. Continuamos ahora hablando de objetos y profundizando un poco en algunos conceptos.

Como ya sabemos, en la programación orientada a objetos (POO) es habitual tratar con los conceptos de encapsulación, herencia y polimorfismo. Puede que haya autores, y por qué no, también lectores, que tengan sus reservas a la hora de considerar JavaScript como un lenguaje totalmente orientado a objetos. La intención de este artículo no es entrar en este tipo de polémicas, pero lo que sí podemos considerar es que JavaScript, como hemos visto anteriormente, soporta objetos y hace una simulación muy personal de otros conceptos como clases o herencia.

JavaScript no tiene una notación formal de clase y recurre a las funciones constructoras para este fin. Mencionar también que JavaScript utiliza los prototipos de los objetos para propagar la herencia, algo que sin duda cuesta entender al principio y al que dedicaremos un artículo independiente más adelante.

Función constructora

Una función constructora es una función normal y corriente de JavaScript que se utiliza para definir una especie de plantilla para nuestros objetos personalizados. Veamos un ejemplo:

    function Cliente(nombre, fecha, direccion) {
 
        this._nombre = nombre;
        this._fechaNacimiento = fecha;
        this._direccion = direccion;
    }

Como podemos observar, se trata de una típica función de JavaScript que admite una serie de parámetros de entrada aunque estos no son obligatorios en absoluto. La única particularidad de esta función es que se utiliza la palabra reservada this de JavaScript para definir una serie de propiedades (también podrán ser métodos) que formarán parte de nuestros objetos personalizados.

En la ilustración lateral vemos cómo podemos utilizar esta función constructora para crear instancias de nuestros objetos personalizados.

El operador new utilizado junto a una función de JavaScript es lo que nos permite obtener un objeto constructor o función constructora. Lo que sucede por debajo es que new primeramente crea un objeto sin propiedades y posteriormente llama a la función pasándole el nuevo objeto como valor de la palabra reservada this. Finalmente, la función nos devuelve un nuevo objeto con las propiedades y métodos definidos dentro de la constructora.

Como se aprecia en el intellisense de la imagen observamos que el nuevo objeto miCliente tiene todas las propiedades definidas anteriormente dentro del constructor.

Como hemos comentado, no es necesario que el constructor tome parámetros, podemos crear una plantilla en blanco e ir rellenando los objetos con datos cuando lo necesitemos:

    //Constructor vacío
    function Cliente() {
 
        this._nombre;
        this._fechaNacimiento;
        this._direccion;
    }
 
    //Creamos el objeto y le asignamos valores
    var cliente = new Cliente();
    cliente._nombre = "Cristina Rodriguez";
    cliente._fechaNacimiento = new Date(1987, 3, 25);
    cliente._direccion = "Plaza Bilbao 25";

Cuando hablamos de los objetos en JavaScript, vimos que se podían definir por medio de la notación JSON. Pues bien, también podemos definir objetos por medio de una función que devuelva un literal de objeto. En este caso, la función constructora hace de envoltorio para el código JSON de definición del objeto permitiéndonos reutilizar el código para crear distintas instancias del mismo:

    function Cliente(nombre, fecha, direccion) {
        return {
            _nombre: nombre,
            _fechaNacimiento: fecha,
            _direccion: direccion
        };
    }

Debemos tener en cuenta que siempre que utilicemos un return dentro de una función constructora, el objeto devuelto ocultará al resto de miembros que intentamos definir. No importa si la función devuelve un objeto literal, una cadena, un número, etc. Esto siempre ocultará a los demás miembros públicos que hayamos definido:

    function Cliente(nombre, fecha, direccion, email) {
 
        this._email = email;
 
        return {
            _nombre: nombre,
            _fechaNacimiento: fecha,
            _direccion: direccion
        };
    }

En este ejemplo cabría esperar que un objeto creado a partir de esta función constructora tuviera 4 propiedades públicas, pero no es así. La propiedad email queda oculta por el objeto que se devuelve con return, por lo que obtendríamos un objeto idéntico al del ejemplo anterior.

Miembros de instancia

Las propiedades y métodos definidos dentro de la función constructora se pueden denominar miembros de instancia dado que cada objeto creado a partir de la función constructora guardará su propia copia de los miembros definidos. Veamos ahora cómo podemos diferenciar entre miembros de instancia públicos y privados.

Hace unos instantes hemos definido una serie de propiedades públicas en nuestros objetos por medio de variables JavaScript y la palabra reservada this. Para definir métodos públicos procederemos de la misma forma, con la salvedad de que utilizaremos una función de JavaScript. También podemos definir propiedades y métodos privados al objeto simplemente definiendo variables y funciones JavaScript dentro de la función constructora utilizando el var de toda la vida. Es decir, para definir miembros públicos utilizaremos this y para los miembros privados utilizaremos var.

Veamos un ejemplo de código simplificado para clarificar todo esto.

    function Cliente(nombre, fecha, direccion) {
 
        //Propiedades privadas
        var edad;
 
        //Métodos privados
        var calcularEdad = function() {
            var actual = new Date().getYear();
            var nacimiento = fecha.getYear();
 
            if (actual <= nacimiento)
                edad = "Error: no se ha podido calcular";
            else
                edad = actual - nacimiento;
        };
 
        //Propiedades públicas
        this._nombre = nombre;
        this._fechaNacimiento = fecha;
        this._edad = edad;
        this._direccion = direccion;
 
        //Métodos públicos
        this._presentarse = function() {
            calcularEdad();
 
            document.write(
                "Hola, mi nombre es " + this._nombre + 
                " y tengo " + this._edad + " años."
            );
        };
    }

Existen autores, como Douglas Crockford, que hacen una pequeña distinción entre métodos públicos y métodos privilegiados. Esta distinción se basa en el hecho de que existe otra forma de definir métodos públicos en los objetos por medio del prototipo de la función constructora. Ya hemos comentado que hablaremos de los prototipos en otro artículo cuando hablemos también de la herencia.

Pero para los impacientes les adelanto que con métodos privilegiados se refiere precisamente a los métodos definidos dentro del cuerpo de la función con la palabra reservada this, dado que estos métodos tienen el privilegio de tener acceso a las variables y métodos privados. Mientras que los métodos definidos por medio del prototipo de la función constructora no tendrán nunca este acceso o privilegio y son denominados simplemente métodos públicos. Podéis leer sobre esta original idea en este artículo escrito por el propio Crockford.

Creo que es importante mencionar también que desde un método privado no tendremos acceso directo a miembros públicos. Esto es así porque como hemos comentado anteriormente this hace referencia al objeto devuelto por la función constructora y para la función privada este objeto se encuentra fuera de ámbito. De hecho, existe una solución a este aparente inconveniente que pasa por utilizar una potente característica de JavaScript, los closures, que estudiaremos a fondo en otra ocasión. Veamos ahora qué sucede si intentamos el acceso directo:

    function Constructor(msjPrivado, msjPublico) {
 
        var propiedadPrivada = msjPrivado;
        this.propiedadPublica = msjPublico;
 
        var metodoPrivado = function () {
            alert(propiedadPrivada);
            alert(this.propiedadPublica);
        };
 
        this.metodoPublico = function () {
            metodoPrivado();
        };
    }
 
    var obj = new Constructor("mensaje privado", "mensaje público");
    obj.metodoPublico();

Cuando ejecutemos este código recibiremos dos alertas, aunque una de ellas, la que intenta mostrar el valor de la propiedad pública nos notificará un undefined. Es aún peor si intentamos acceder a la propiedad pública sin la sentencia this, directamente tendremos un error del tipo variable no definida.

Miembros estáticos

Los miembros estáticos o también llamados miembros de clase son aquellos estados o comportamientos comunes a todas las instancias de la clase. En estos casos puede tener mucho más sentido no definirlos dentro de la función constructora, dado que todas las instancias de los objetos creadas a partir de ella contendrán una copia de estos miembros que son comunes a todos los objetos creados.

Supongamos que en nuestro ejemplo Cliente queremos tener una propiedad que almacene el IVA que se les va aplicar a todos nuestros clientes sin excepción.

    function Cliente() {
 
        //Definimos los miembros de instancia...   
    }

 
    //Definimos una propiedad estática
    Cliente.IVA = 18;
 
    //En otro punto del código hacemos uso del IVA
    var total = neto + (neto * (Cliente.IVA / 100));

Igualmente, si tenemos un método que devuelva siempre el mismo objeto o valor, deberíamos definirlo a nivel de la función constructora. Este podría ser el caso de un método que devuelva una instancia de inicialización con valores por defecto para nuestro objeto Cliente.

Si es la primera vez que el lector se asoma a la programación de objetos con JavaScript puede resultarle extraño este proceder, pero muchos objetos nativos de JavaScript siguen este criterio. Por ejemplo, el objeto Number utiliza una propiedad estática que devuelve el mayor número posible en JavaScript, Number.MAX_VALUE. Y el objeto Date utiliza un método estático para analizar una fecha en formato cadena y devolver su representación en milisegundos desde una fecha siempre constante en JavaScript, Date.parse(string).

Comprobar la función constructora de un objeto

Todos los objetos de JavaScript, ya sean nativos o de usuario, tienen una propiedad constructor que heredan del objeto genérico Object, la cual hace referencia a la función constructora que inicializa el objeto lo que en principio (ahora veremos por qué digo esto) nos permite determinar la función constructora de un objeto, y casi por extensión, la clase de éste:

    function Cliente() {
 
        //Definición de miembros de Cliente...
    }
 
    var unCliente = new Cliente();
 
    if (unCliente.constructor == Cliente) {
 
        //Hacer algo con el objeto unCliente
    }

Por otro lado, también podríamos utilizar el operador instanceof para determinar la constructora de un objeto, pero con algunas diferencias. El operador instanceof , a diferencia del anterior, comprueba la jerarquía del objeto, por lo tanto podríamos preguntar directamente sobre el objeto padre con idénticos resultados:

    unCliente instanceof Cliente // es true

    unCliente instanceof Object // es true

Lamentablemente en JavaScript nada es tan sencillo como parece. Las cosas se complican cuando hablamos de modificar el prototipo de un objeto y la propiedad constructor parece perder la referencia a la función constructora. Pero todo esto es harina de otro costal y se sale por completo de la intención de este artículo. Recomiendo al lector que lea Constructors considered mildly confusing para comprender bien el comportamiento de la propiedad constructor y el operador instanceof.

Y para complicar más la cosa, también tenemos a nuestra disposición el operador unitario typeof. De nuevo, recomiendo a los lectores interesados en profundizar en estos temas los artículos The Secret Life of JavaScript Primitives y Fixing the JavaScript typeof operator.

Autor: Óscar Sotorrío Sánchez
Publicado en Variable not found

Enlaces interesantes 63

2011-12-12T09:55:00.000+01:00

Esta semana no he tenido tiempo para ir publicando en Variable not found en Facebook y Twitter los habituales links, pero sí que he podido recopilar algunos, así que ahí van los hallazgos realizados del 4 al 11 de diciembre de 2011. Espero que os resulten interesantes. :-)

ASP.NET MVC Routing Extensibility
Simone Chiaretta
That “JavaScript not available” case
Christian Heilmann
jQuery 1.7 Visual Cheat Sheet
Antonio Lupetti
Set the AsyncTimeout attribute for your async controllers
Simone Chiaretta
Providing Intellisense, Navigation and more for Custom Helpers in ASP.NET MVC
Hadi Hariri
QUnit layout for JavaScript testing in ASP.net MVC3
Jonathan Creamer
HTML5 Form features you should know
Bipin Joshi
Usar el atributo Obsolete (.NET: ObsoleteAttribute Class)
Sergio Tarrillo
Como crear un Profiler para .Net
Lucas Ontivero
[Windows Phone 7.5] Inserciones masivas en SQL Server CE vs SQL Server vs MongoDb
Josué Yeray
Public Service Announcement: Careful With Your Nested Border-Radii
Chris Coyier
Understanding CSS’s vertical-align Property
Louis Lazaris
Inside ASP.NET MVC: Instantiation of Controller
Alexander Beletsky
What's the difference? Remainder vs Modulus
Eric Lippert
Avoid “Duplicate Content” with IIS7 – Domain with or without www
Code Inside Team
Lateral On-Scroll Sliding with jQuery
Mary Lou
New NuGet.org Deployed!
Phil Haack
Custom Validation in ASP.NET MVC 3 using DataAnnotationsModelValidator
Mahesh Sabnis
Búsquedas de Texto con MongoDB y VB.NET ASP.NET Webform
Gonzalo Pérez
Obtaining a MAC Address
BlackWasp
[Vídeo] ASP.NET vNext - Instalando paquetes con Nuget
Luis Ruiz
Trabajando con Singleton utilizando UNITY
Bruno Capuano
[Vídeo] ASP.NET vNext - Strongly Typed Data Controls
Luis Ruiz
RavenDB II: Los documentos
Unai Zorrilla
Lucene.net 2.9.4 is out, now with NuGet
Simone Chiaretta
Mejoras del editor de CSS en Visual Studio
Scott Guthrie (traducido por Juan Laó)
Getting a Base Exception
BlackWasp
RavenDB I: Empezamos
Unai Zorrilla

Y no olvidéis que habitualmente podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Enlaces interesantes 62

2011-12-05T10:11:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 28 se noviembre al 3 de diciembre de 2011. Espero que os resulten interesantes. :-)

Vídeo: ASP.NET vNext - Smart Tasks y generación de eventos de controles desde la vista HTML
Luis Ruiz
Tutorial MongoDB con ASP.NET MVC - Ejemplo Práctico
Gonzalo Pérez
5 jQuery Infinite Scrolling Demos
jQuery4u (vía @etnassoft)
Disponible una nueva entrega del libro GRATUITO de Azure : AppFabric y WIF
Vía @ibonilm
Generador de CSS3
Vía @boagworld
Why Many Developers Hate ASP.NET… and Why They’re Wrong
Jeremy McPeak
Scott Hanselman's 2011 Ultimate Developer and Power Users Tool List for Windows
Scott Hanselman
Building a Windows Azure App using Azure Queue, Azure Table and ASP.NET MVC Web Role
Shiju Varghese
ASP.NET MVC Controls Toolkit 1.5.5 released and available to download
Vía @campusmvp
New ASP.NET website launched
Scott Hanselman
Unobtrusive jQuery UI with AJAX support
Andy Cohen
25 Amazing HTML5 Tricks and How to Make Them
DevStand
The Script Tag
Chris Coyier
Global HandleErrorAttribute in ASP.net MVC3
Jonathan Creamer
De vuelta a lo básico, codificar html, javascript y url
Sergio León
Web API preview 6 is out: how to get a RESTful mind
Simone Chiaretta
jQuery Time Entry with Time Navigation Keys
Rick Strahl
EF Migrations, EF 4.3 y que nos deparará el futuro
Unai Zorrilla
Code First Migrations: Beta 1 Released
ADO.NET Team
La cuarta preview the IE10
Juan Laó
The craziest Javascript implementations
Vía @etnassoft
Custom Action Method Selector in MVC
Jigar Bagadai
HTML5 for Applications: The Fourth IE10 Platform Preview
IEBlog
Entity Framework Batch Update and Future Queries
Paul Welter (vía @osotorrio)
Vistas y View Engines en ASP.NET MVC
Marc Rubiño
Techniques for real-time client-server communication on the web (SignalR to the rescue)
Maarten Balliauw
Uso de IDisposable
Juan Laó
AppFabric Service Bus Test Client
Ibon Landa
Storage Queues vs Service Bus queues
Ibon Landa
Relayed Messaging y Brokered Messaging
Ibon Landa
¿Y si todo lo que haces llevara tu nombre grabado?
José Manuel Alarcón
How To Write a Plugin in jQuery
Shakeel Iqbal
Google Maps API V3 for ASP.NET
S V Sai Chandra (vía @osotorrio)
Phil Haack deja Microsoft
Phil Haack
Writing a Fluent ASP.NET MVC Recursive TreeView Helper
Matt Hidinger
CSS Editor Hierarchical Indentation in Visual Studio 2011 Developer Preview
Abhijit Jana
Task Cancellation
BlackWasp
Añadir dlls en la GAC de las máquinas de Windows Azure
Gisela Torres
Composing Entity Framework Fluent Configurations
K. Scott Allen
Nuevo soporte de Empaquetado y Minificación (ASP.NET 4.5)
Juan Laó
New Bundling and Minification Support (ASP.NET 4.5 Series)
Scott Guthrie (traducido por Juan Laó)
Razor Donut Caching
Phil Haack

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

Mamá, ¿de dónde vienen los metadatos?

2011-11-29T10:31:00.000+01:00

En ASP.NET MVC normalmente utilizamos atributos para aportar información adicional a las propiedades del Modelo, incluyendo detalles como su descripción textual, formato de presentación, tipo de datos, etc. Esta información puede ser utilizada desde la capa vista para generar etiquetas, editores y, en algunos casos, incluso lógica de edición o presentación en la página.

Sin embargo, los atributos en el propio código de la clase no son la única vía para especificar metadatos en el framework. En este post veremos cómo extender el framework para crear nuevas vías para especificar esta información.

1. Proveedores de metadatos

Como decíamos, ASP.NET MVC viene de fábrica con componentes que nos permiten introducir anotaciones directamente sobre las propiedades de las clases que manejamos. En el siguiente ejemplo podemos ver una entidad en la que se están introduciendo metadatos según este mecanismo:

public class Friend
{
    [Required]
    [Display(Name="Full name")]
    public string FullName { get; set; }

    [Required]
    [DataType(DataType.EmailAddress)]
    [Display(Name = "Email address")]
    public string EmailAddress { get; set; }

    [Required]
    [DataType(DataType.Url)]
    [Display(Name = "Blog url")]
    public string BlogUrl { get; set; }

    [Display(Name="Birth year")]
    public int BirthYear { get; set; }
}

Cuando el framework necesita obtener los metadatos relativos a una clase, utiliza un metadata provider, un componente que se encarga de obtener los metadatos desde donde se encuentren definidos. El proveedor usado por defecto se llama DataAnnotationsModelMetadataProvider, y es el responsable de leer los atributos desde la definición de la clase, pero podemos sustituirlo fácilmente por otro proveedor que obtenga los metadatos desde otros orígenes, como archivos de configuración, bases de datos, o simplemente introducir lógica durante la generación de los mismos.

Sea cual sea su origen, los metadatos siempre se representan como objetos del tipo ModelMetadata, cuya estructura podéis ver a la derecha. Los providers deben incluir la lógica para obtener los metadatos desde donde corresponda, pero siempre retornarán objetos ModelMetadata, en los que, entre otra información, podemos encontrar los siguientes datos:

descripción del elemento,
cadena de formato cuando es visualizado,
tipo de datos que contiene (emails, urls, fechas, horas, etc.),
orden en el que debe aparecer la propiedad si se generan interfaces de edición o visualización de la entidad,
representación textual para los nulos,
si el dato es obligatorio, o de sólo lectura,
si debe ser mostrado en edición, o en visualización,
la plantilla de edición o visualización que debe utilizarse,
… y muchos más. Podéis consultar la referencia completa en MSDN.

Es importante tener en cuenta que el proveedor es invocado una vez para obtener los metadatos de la clase en sí, y otra vez por cada una de sus propiedades.

¿Y cómo determina el framework MVC qué proveedor de metadatos utilizar?

En primer lugar, intenta utilizar el dependency resolver para obtener una instancia de un tipo que implemente ModelMetadataProvider , que es la clase base para todos los proveedores. Este punto de extensión permite definir un proveedor personalizado muy fácilmente, y sobre todo si utilizamos contenedores IoC.

Si no ha sido posible obtener un proveedor desde el dependency resolver, el framework utilizará el establecido en la propiedad ModelMetadataProviders.Current. Por defecto, esa propiedad contiene una un objeto de la clase DataAnnotationsModelMetadataProvider, pero podemos sustituirlo por cualquier otro descendiente de ModelMetadataProvider .

Por tanto, para crear un proveedor personalizado de metadatos, basta con:

crear una clase descendiente de ModelMetadataProvider . Por comodidad, usaremos normalmente como base algunos de los siguientes tipos, más concretos:
- DataAnnotationsModelMetadataProvider, si lo que pretendemos es extender el sistema por defecto, basado en la captura de metadatos desde las anotaciones (atributos) de la clase.
- AssociatedMetadataProvider, si lo que queremos es saltarnos por completo la obtención de metadatos desde la propia clase e implementar otros mecanismos.
indicar al framework que debe utilizar nuestro nuevo proveedor, que podemos hacerlo:
- o bien usando el dependency resolver,
- o bien estableciendo una instancia del nuevo provider en ModelMetadataProviders.Current.

Pero mejor veámoslo con un ejemplo…

2. Creando un metadata provider

Vamos a implementar un proveedor de metadatos sencillo con objeto de que podáis entender su funcionamiento.

Como sabéis, al mostrar en una vista las etiquetas (labels) asociadas a una propiedad del Modelo, el texto que aparece es obtenido desde los metadatos de la entidad, desde el atributo Display o DisplayName (en ese orden); en caso de no existir, se asume como descripción el nombre de la propiedad.

Pues bien, nuestro objetivo es conseguir generar de forma automática estas las descripciones (DisplayName) de cada campo partiendo del nombre de la propiedad, y teniendo en cuenta el “camel casing”, de forma que podremos ahorrarnos el teclear esta descripción en muchos casos. Por ejemplo, a una propiedad que se llame FullName se le asociará automáticamente la descripción “Full Name”, o EmailAddress se describirá como “Email Address”. De esta forma la entidad anterior podremos simplificarla un poco:

public class Friend
{
    [Required]
    public string FullName { get; set; }

    [Required]
    [DataType(DataType.EmailAddress)]
    public string EmailAddress { get; set; }

    [Required]
    [DataType(DataType.Url)]
    public string BlogUrl { get; set; }

    public int BirthYear { get; set; }
}

Fijaos que hemos eliminado los atributos [Display], y el resultado en ejecución de un editor de esta entidad se mostrará como en la captura de pantalla lateral, donde las etiquetas de cada campo han sido generadas automáticamente.

Para ello, dado que queremos conservar el comportamiento del proveedor por defecto DataAnnotationsModelMetadataProvider, lo extenderemos y añadiremos la lógica deseada a su método CreateMetadata(), que es el invocado para obtener los metadatos de la entidad y cada una de las propiedades:

public class DisplayNameModelMetadataProvider : DataAnnotationsModelMetadataProvider
{
    protected override ModelMetadata CreateMetadata(
            IEnumerable<Attribute> attributes, Type containerType,
            Func<object> modelAccessor, Type modelType, string propertyName)
    {
        var metadata = base.CreateMetadata(attributes, containerType,
                                            modelAccessor, modelType, propertyName);
 
        if (metadata.PropertyName != null && metadata.DisplayName == null)
        {
            metadata.DisplayName = splitCamelCase(metadata.PropertyName);
        }
 
        return metadata;
    }
 
    static string splitCamelCase(string input)
    {
        return Regex.Replace(input, "([A-Z])", " $1", 
            System.Text.RegularExpressions.RegexOptions.Compiled).Trim();
    }
}

La implementación del método CreateMetadata() no es nada del otro mundo:

En primer lugar, llamamos a la clase antecesora para obtener los metadatos a partir de las anotaciones del modelo.
A continuación, si no se ha obtenido ningún valor de metadatos para el DisplayName, y siempre que se esté evaluando una propiedad, la establecemos, generándola mediante el método splitCamelCase().
El método splitCamelCase() no tiene mucho misterio (bueno, sí, usa expresiones regulares ;-)), y lo único que hace es buscar las letras mayúsculas e insertar delante de ellas un espacio. Es algo tosco, pero me vale para no desviar la atención del post a este detalle sin importancia (y por cierto, el mérito de este método no es mío, sino de Jon Galloway).

Y esto es todo. Ahora vamos a registrar el proveedor para el framework pueda utilizarlo, y veremos cómo hacerlo de las dos formas que he comentado antes: de forma directa, y usando el dependency resolver.

2.1. Registro del proveedor directamente

La fórmula más rápida y sencilla consiste en establecer directamente una instancia del nuevo proveedor en la propiedad ModelMetadataProviders.Current, durante la inicialización de la aplicación, por ejemplo así:

    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();
 
        ModelMetadataProviders.Current = new DisplayNameModelMetadataProvider();
 
        RegisterGlobalFilters(GlobalFilters.Filters);
        RegisterRoutes(RouteTable.Routes);
    }

Esto es todo lo que necesitamos hacer para que nuestro flamante proveedor entre en funcionamiento.

2.2. Registro del proveedor usando el dependency resolver

Si estáis utilizando un contenedor de IoC, quizás sea más coherente introducir la resolución de este proveedor en el mismo.

Cuando el framework intenta obtener el proveedor de metadatos actual, antes de nada intenta localizarlo utilizando el dependency resolver. Si estamos utilizando un contenedor IoC como Unity o StructureMap, podemos utilizarlos para gestionar esta dependencia, asociando la clase abstracta ModelMetadataProvider al tipo concreto DisplayNameModelMetadataProvider.

Por ejemplo, en el caso de Unity, lo más sencillo es instalar el paquete Unity.MVC3 desde Nuget, y ya simplemente tendríamos que incluir la siguiente línea en el registro de tipos (en el archivo bootstrapper.cs):

    private static IUnityContainer BuildUnityContainer()
    {
        var container = new UnityContainer();
        container.RegisterType<ModelMetadataProvider, DisplayNameModelMetadataProvider>();
        container.RegisterControllers();
        return container;
    }

Una vez registrado el provider, sea directamente o mediante este último mecanismo, el sistema obtendrá los metadatos desde éste. Así, tendríamos el siguiente resultado:

Clase del Modelo

Vista

Resultado

public class Friend
{
 [Required]
 public string FullName { get; set; }

 [Required]
 [DataType(DataType.EmailAddress)]
 public string EmailAddress 
               { get; set; }
 [Required]
 [DataType(DataType.Url)]
 public string BlogUrl { get; set; }
 
 public int BirthYear { get; set; }
}

@using (Html.BeginForm())
{
    @Html.EditorForModel()
 
    <div>
        <input type="submit" />
    </div>
}

Puedes descargar el proyecto de ejemplo (VS2010 + MVC 3) desde mi Skydrive.

En definitiva, en este post hemos visto que en ASP.NET MVC los metadatos no proceden de una ubicación fija, sino que son obtenidos a través de un proveedor configurable. Esto nos permite modificar el comportamiento por defecto del framework y adaptarlo a nuestras necesidades, generarlos de forma dinámica, como en el ejemplo que hemos visto, u obtenerlo desde algún almacén de persistencia (como podría ser un archivo de configuración o una bases de datos), y siempre de forma muy sencilla aprovechando la magnífica extensibilidad del marco de trabajo :-)

Publicado en: Variable not found.

Enlaces interesantes 61

2011-11-28T09:16:00.000+01:00

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 21 al 27 de noviembre de 2011. Espero que os resulten interesantes. :-)

C#/.NET Little Wonders: The Predicate, Comparison, and Converter Generic Delegates
James Michael
MVC Data URI HTML Helper
Dean Hume
Lazy Remote Validation with ASP.NET MVC 3
Pietro Brambati (vía @osotorrio)
Download Free eBook: Razor View Engine in MVC 3
Abhimanyu Kumar Vatsa (vía @lluisfranco)
Adding Personality with CSS3 Transitions and Animations
IEBlog
Modernizr.js: Polyfills
K. Scott Allen
Associations in EF 4.1 Code First
Morteza Manavi (vía @osotorrio)
Helpers para formularios (ASP.NET MVC)
Eduard Tomás (vía @JTorrecilla)
Web Platform Installer v4 command line (WebPICMD.exe) Preview Release
WebPICmd Team (Vía @wasat)
Microsoft Translator API
Juan María Laó (vía @lluisfranco)
Coffee delivers jolt deep in the brain
Laura Sanders
Getting Query Parameters in Javascript
Phubar Baz (!)
Contour Analysis for Image Recognition in C#
Greg Duncan
ReSharper Settings in 6.1
Hadi Hariri
Poster: What’s new in .NET Framework 4.5?
Heikniemi Hardcoded
Inserciones Masivas en MongoDB vs SQL Server (IV)
Pablo Doval
DDD: 2- Framework de IoC (Service Pack 1)
Omar del Valle
El nuevo objeto jQuery $.Callbacks()
Carlos Benítez
jQuery 1.7.1. released
jQuery Team
Crear un archivo .ZIP con JavaScript
Pablo Suárez (vía @osotorrio)
HTML5 Semantics
Bruce Lawson
Integrating JavaScript Unit Tests with Visual Studio
Stephen Walther
Embedding RavenDB into an ASP.NET MVC 3 Application
Justin Schwartzenberger
Aclarando CQRS [traducción]
Pablo Núñez & Co.
Task Support for Asynchronous Controllers in MVC 4
Malcolm Sheridan
Fechas UTC, JavaScript, jQuery timeago, templates y otras hierbas
Luis Ruiz Pavón
Saber si un elemento tiene un evento jQuery asignado
Sergio León
Bloquear los botones mientras se envía un formulario
José Manuel Alarcón
Agilismo Vs Modelo waterfall tradicional. Muy interesante y resumidito.
Juan Palacio
Desarrollo de una aplicación Metro en C# y XAML
Eduard Tomás (vía @Jtorrecilla)
Large-scale JavaScript Application Architecture
Addy Osmani
Aggregating RSS Feeds in C# and ASP.NET MVC 3
Wade Wegner
6 Tips to Help You Build a Great Web Application
Greg & Adrian
Los nuevos métodos jQuery on() y off()
Carlos Benítez
DDD: 2- Framework de IoC (parte 1) y DDD- 2- Framework de IoC (parte 2)
Omar del Valle
HOT:Inserciones masivas en Sql Sersver vs Mongo DB (III)
Unai Zorrilla

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

[Auges] ASP.NET MVC + HTML5 + CSS3 + JQuery = La unión perfecta

2011-11-23T10:25:00.000+01:00

Lo primero, para el que aún no lo sepa, se ha cancelado por causas de fuerza mayor la charla de Luis Ruíz Pavón sobre inyección de dependencias en ASP.NET que estaba prevista para el próximo martes 29 de noviembre. Sentimos las molestias que esto pueda causar, pero lo primero es lo primero :-).

Sin embargo, como ya teníamos el cuerpo hecho a aprender cosas interesantes la semana que viene, tendremos el placer de contar con el gran Marc Rubiño, MVP en ASP.NET y fundador de LoNetCamp, que nos mostrará el lunes 28 de noviembre a las 19:00h (horario peninsular español) la potencia que aporta la unión de tecnologías como ASP.NET MVC, HTML5, CSS3 y JQuery.

Descripción del evento:

ASP.NET MVC + HTML5 + CSS3 + Jquery = La unión perfecta
Las aplicaciones web modernas nos exigen cada vez más utilizar estándares para dotar a nuestra aplicación de una vistosidad y usabilidad nunca visto hasta el momento. Con ASP.NET MVC podemos separar las responsabilidades de nuestra aplicación de una forma sencilla y con HTML5 y CSS3 podemos obtener los mejores resultados independientemente del navegador gracias a librerías como modernizr.

En este Webcast lo que veremos es cómo de una forma totalmente práctica y con Visual Studio 2010 podemos crear una aplicación web totalmente funcional.

¿Qué utilizaremos en esta práctica?

ASP.NET MVC v.3: Es una plataforma gratuita, Open Source y está incluida en .NET 4.0. Nos sirve para realizar aplicaciones ASP.NET utilizando el patrón MVC, separando las responsabilidades ofreciéndonos beneficios como desarrollo orientado a pruebas “TDD”, mejor soporte de SEO con URLs más limpias, etc.

HTML v.5: La quinta revisión del veterano HTML no finalizada, pero los navegadores se han lanzado a una lucha frenética para adaptar sus especificaciones. Esta versión ha tenido en cuenta las nuevas necesidades y nos ofrece una web semántica.

CSS3: La tercera revisión de la hoja de estilos en cascada, que nos permite separar la estructura del documento de su presentación.

JQuery: Librería script que encapsula la complejidad de JavaScript y nos permite realizar animaciones, interactuar con el DOM y extender la aplicación de una manera muy sencilla y viene incluido en los proyectos ASP.NET MVC.

Modernizr: Librería que nos permite validar si el navegador soporta alguna de las nuevas funcionalidades de HTML 5 y nos permite actuar en consecuencia. Para hacer nuestra aplicación realmente cross-browser.

Como siempre, podéis asistir desde casa o el trabajo (es un Webcast online), y la asistencia al evento es totalmente gratuita. Para acceder, simplemente debéis registraros en la siguiente dirección:

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032500294&Culture=es-ES

Ah, y los que ya teníais la fecha del 29 reservada para disfrutar con un Webcast de categoría, recordaros que ese mismo día podéis encontrar a Lluis Franco, MVP C# y un fenómeno de la naturaleza, hablando sobre programación paralela en SecondNug, a las 19:30h (GMT+1).

Buena semana de eventos tenemos por delante, ¿eh?

Publicado en: Variable not found.

Variable not found

Llamemos a las cosas por su nombre

1. Error ID-10-T

2. Wetware bugs

3. PEBCAK

4. PICNIC

5. Layer 8 error

6. RTFM

7. Luser

Enlaces interesantes 70

.Net

Asp.net

Data access

Html/Css/Javascript

Visual Studio/Complementos

Otros

Validación manual con Data Annotations

Validación manual de objetos

¿Y si los metadatos están en otra clase?

¿Y si quiero usar IValidatableObject?

Enlaces interesantes 69

.Net

Asp.net

Azure / Cloud

Conceptos

Data access

Html/Css/Javascript

Visual Studio/Complementos

Otros

Libro: Dependency injection in .NET

SignalR (II): Conexiones persistentes

1. Implementación del endpoint

1.1. Notificando a los clientes las nuevas conexiones

1.2. Notificando a los clientes las desconexiones

1.3. Algunas observaciones adicionales

2. Registro de ruta

3. Implementación del cliente web

Introducción a SignalR (I): Conceptos básicos

¿Cómo puede el servidor enviar eventos al cliente de forma asíncrona?

SignalR, conceptualmente

Implementación de servicios con SignalR

Instalación de SignalR

Enlaces interesantes 68

.Net

Asp.net

Azure / Cloud

Data access

Html/Css/Javascript

Visual Studio/Complementos

Otros

Establecer el foco automáticamente, versión declarativa

Enlaces interesantes 67

.Net

Asp.net

Data access

Html/Css/Javascript

Visual Studio/Complementos

Otros

Enlaces interesantes 66

.Net

Asp.net

Azure / Cloud

Data access

Html/Css/Javascript

Visual Studio/Complementos

Otros

Top posts 2011 en Variable not found

La cosecha de 2011

Cosechas anteriores a 2011

Adzure, la nube gratuita soportada por publicidad

Enlaces interesantes 65

.Net

Asp.net

Azure / Cloud

Data access

Html/Css/Javascript

Visual Studio/Complementos

¡Felices fiestas & 2012!

IMetadataAware, atributos de metadatos personalizados

El interfaz IMetadataAware