Mi carta a los reyes…

 ·  ☕ 4 min  ·  ✍️ eiximenis

    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!!!!

    Si quieres, puedes invitarme a un café xD

    eiximenis
    ESCRITO POR
    eiximenis
    Compulsive Developer