Stylecop en Visual Studio 2010

Esta disponible la versión 4.4.0 RTW de esta útil herramienta para refactorizar nuestro código y que ya habíamos comentado más en detalle anteriormente. Esta versión tiene como principal característica el soporte completo para Visual Studio 2010 y C# 4.0.

Stylecop

Stylecop

La descarga la pueden hacer desde el sitio oficial del proyecto. Les comento que para poder instalar la nueva versión, anteriormente tuve que desinstalar la versión que tenía en mi máquina.

Anuncios

Conociendo a C# 4.0: Programación dinámica

Tengo que contarles que desde hace tiempo vengo programando en C# y la verdad es uno de mis lenguajes preferidos, el que más conozco y con el que me siento más cómodo. Recientemente salió la versión 4.0 y trajo algunas novedades que son más que interesantes.

Uno de los cambios principales en C# 4.0 radica en la programación dinámica, es por eso que en este primer post nos vamos a centrar en esta nueva característica.

Pero qué es un lenguaje dinámico?  Un lenguaje dinámico realiza ciertos tipos de tareas en tiempo de ejecución que a diferencia de los lenguajes estáticos se hacen en tiempo de compilación, algunas de estas tareas son re-definir o alterar tipos de datos, analizar expresiones…

Algunos ejemplos de lenguajes dinámicos son:

– Python (antes que diga algo Ariel :))
–  Ruby
–  Visual Basic y COM con su capacidad para hacer late binding

Comencemos con C# 4.0 ahora!

Tipo dynamic

En esta versión surge un nuevo tipo de datos llamado dynamic, que es la forma en que .NET le dice al compilador que no verifique los datos en tiempo de compilación y si lo haga en tiempo de ejecución, que queremos decir con esto, que errores como validaciones de tipo de datos, solo aparecerán cuando estemos ejecutando nuestro programa.

Vayamos al grano, supongamos que tenemos definido lo siguiente:

dynamic dinamico = "hola";

El compilador hasta que no ejecutemos esa porción de código, no sabe que tipo de objeto es la variable dinamico. Por lo tanto podríamos tener lo siguiente sin que nos de error en tiempo de compilación:

dynamic dinamico = "hola";
int suma = 1 + dinamico;

Ahora en tiempo de ejecución cuando lleguemos a dicha línea nos dará un error de tipo de conversión de datos, lo cual es lógico 🙂 .

Veamos otro ejemplo, supongamos que tenemos la clase definida de la siguiente manera:

public class Cuenta
{
    public Cuenta()
    {
        this.Saldo = 0;
    }

    decimal Saldo { get; set; }

    public void Depositar(decimal monto)
    {
        this.Saldo += monto;
    }
}

Ahora veamos cómo funciona nuestro tipo de datos dinámico:

Cuenta cuentaEstatica = new Cuenta();
cuentaEstatica.Depositar(1000, 100); // Error en tiempo de compilación: cantidad de parámetros incorrectos

dynamic cuentaDinamica = new Cuenta();
cuentaDinamica.Depositar(1000, 100);

Como podremos ver, la cuenta estática no nos permitirá compilar nuestra aplicación, ya que el método Depositar no acepta dos argumentos, a diferencia de nuestra cuenta dinámica que “sí” nos permite poner dos parámetros al método Depositar y compilar nuestra aplicación, pero porqué? … porque dicha expresión recién será resuelta en tiempo de ejecución.

Dynamic no es var

Leyendo lo anterior, alguien podría preguntarse, el tipo de datos dynamic no es lo mismo que var?, la respuesta es no.

Vemos el siguiente ejemplo:

dynamic tipoDinamico = "1";
var tipoVar = "1";

int sumaDinamica = 1 + tipoDinamico;
int sumaVar = 1 + tipoVar; // Error de tipo en tiempo de compilación

Si probamos compilar esta porción de código, vamos a ver que la línea 4 nos va a dar error de tipos. En este caso para el tipo var es el compilador el que infiere el tipo de datos, por lo tanto ya lo conoce antes de ejecutarlo (tipoVar sigue siendo un valor tipeado estático).

Dynamic no es object

Actualmente cuando algún método recibía o devolvía algún objeto del cual desconocíamos su tipo, utilizábamos el tipo object. Un método que retorna un tipo object pone a disposición del desarrollador la transformación al tipo que verdaderamente necesita.

Veamos el siguiente ejemplo:

public static class AdministradorDeCuentas
{
    public static object DevolverCuentaUsuario(int id)
    {
         Cuenta cuenta = new Cuenta();
         …
        return cuenta;
    }
}

Supongamos que tenemos una clase que se encarga de administrar cuentas, y un método que nos retorna un object que en este caso representaría una cuenta (no tiene demasiado sentido que devuelva un tipo object, pero a fines del ejemplo nos sirve).

Ahora supongamos que obtenemos dos “cuentas” de la siguiente forma:

dynamic cuentaDinamica = AdministradorDeCuentas.DevolverCuentaUsuario(1);
cuentaDinamica.Depositar(1000);

object cuentaObject = AdministradorDeCuentas.DevolverCuentaUsuario(1);
cuentaObject.Depositar(1000); // Error en tiempo de compilación

Como podemos ver, la cuenta dinámica si nos permite invocar al método Deposito, ya la misma será evaluada en tiempo de ejecución. En cambio, la cuenta object no se ejecutará ya que el compilador no sabe de qué tipo se trata, por lo tanto para poder hacer el depósito deberíamos tener que hacer una conversión de tipos previamente.

Espero que le sea de utilidad. Les dejos el enlace a 2 post con muy buena informaci[on sobre el tema: Miguel Angel Morán y  C# LifeStyle .