Nota: Este post ha sido importado de mi blog de geeks.ms. Es posible que algo no se vea del todo "correctamente". En cualquier caso puedes acceder a la versión original aquí

Aunque sería para unos reyes que pasaran más allá del 2010, pero bueno… por pedir que no quede 😛

Estas son las cosas que me gustaría que algun dia se incorporasen a C#. Como son fiestas mágicas, pues aquí van para ver si los chicos de Redmond se animan y para algún milenio las tenemos…

Pongo ideas al margen de si son posibles/factibles con el CLR actual… simplemente son cosas que me gustarían que estuviesen en el lenguaje. Solo pongo las ideas y un ejemplo de lo que me gustaría, sin desarrollarlas a fondo… 🙂

1. Conceptos en genéricos

La idea es poder representar como restricción de un tipo genérico algo más allá que una interfaz. Por ejemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

concept HasHandle
{
    IntPtr Handle{ get; }        
}
class Foo
{
    public static void Main(string[] args)
    {
        new Foo().Bar(new Form());
    }

    public void Bar<T> (T t)
        where T : HasHandle
        {
            DoWork(t.Handle);
        }
}

Este código deberia compilar porque el concepto HasHandle define una propiedad llamada Handle de tipo IntPtr. El mètode genérico Bar utiliza esta propiedad. Y la llamada a Bar con un paramétro Form satisface el concepto, puesto que la clase Form tiene una propiedad IntPtr llamada Handle.

Los conceptos deberían poder ser genéricos a su vez:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

concept HasXXX<T>
{
    T XXX{ get; set;}        
}
class Foo
{
    public void Bar<T,U> (T t)
        where T : HasXXX<U>
        {
            U u = t.XXX;
        }
}

El método Bar<T,U> debería poder llamarse con cualquier tipo T que tuviese una propiedad U XXX {get; set;}

Los conceptos deberían poder hacer referencia a la existencia de métodos estáticos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

concept Comparable<T>
{
    bool operator > (T t1, T t2);
}
class Foo
{
    void Bar<T> (IEnumerable<T> items)
        where T : Comparable<T>
    {
    }
}

El método Bar debería poder llamarse con cualquier tipo T que tuviese definido el operador ‘>’ (aunque este esté definido de forma estática).

2. Constantes binarias

Pues eso mismo…

1

int i = 0b00001100;

Fácil, no??

3. Tipos anónimos que puedan implementar una interfaz

Los tipos anónimos tal y como estan ahora sirven para poco más que para LINQ. Sería interesante que pudiesen implementar una interfaz y que pudiesen ser devueltos a través de referencias a dicha interfaz:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

interface ISomeInterface
{
    int Foo(int);
}
class Bar
{
    ISomeInterface Baz()
    {
        return new ISomeInterface  { void Foo(int i) { return i+1;} };
    }
}

El tipo anónimo creado en el método Baz, implementa la interfaz ISomeInterface y es devuelto a través de una referencia a dicha interfaz.

4. Referencias const

Al estilo de C++. Mira que esto es simple y útil y no se porque no lo han metido… Para más info: http://www.cprogramming.com/tutorial/const_correctness.html.

5. Enumeraciones con cualquier tipo

Estaría bien que los enums pudieran tener cualquier tipo base:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Planeta
{
    long Diametro { get; set; }
    long DistanciaSol { get; set; }
}
enum SistemaSolar<Planeta>
{
    Mercurio = new Planeta() { Diametro=4879, DistanciaSol=46000000},
    Tierra = new Planeta() { Diametro=12742, DistanciaSol=150000000}
}
class Foo()
{
    Bar () { this.Baz(SistemaSolar.Mercurio);}
    Baz(SistemaSolar p)
    {
        if (p.Diametro > 10000) { ... }
    }
}

El enum SistemaSolar se define como una enumeración de objetos de la clase Planeta.

El método Foo.Baz acepta como parámetro sólo SistemaSolar.Mercurio o SistemaSolar.Tierra. Pasarle cualquier otro objeto Planeta no debería compilar.

Felices fiestaaaaaaaaaaaaaaaaaaaaaaas!

Bueno… paro ya de pedir cosas, jejeeee… 🙂

Solo desearos a todos los geeks unas felices fiestas, llenas de alegría, familia, ceros y unos…

… y que el tió os cague muchos regaloooooooooooooooooooooooooooooooos!!!!