Bueno... he estado echando un ojo a la especificación de C# 3.0 (la que vendrá con Orcas) y hay algunas novedades que me han llamado la atención:

Expresiones lambda

Es una extensión de los anonymous methods que (creo) hará las delicias de los programadores de lenguajes como Scheme o Haskell, ya que más o menos intenta trasladar algunos de los conceptos del lambda-calculus a C#. Una expresión lambda tiene la forma params => expr, donde params define los parámetros que acepta la función y expr la evaluación de los parámetros anteriores. P.ej:

x => x + 1

equivaldría a una función declarada como:

int foo (int x) { return x+1; }

Bueno... yo he puesto int como tipo de datos, pero realmente el tipo real del parámetro de la expresión lambda dependrá del delegate al que se asigne dicha expresión. Esto, si lo unimos con genéricos, tiene bastante buena pinta:

delegate R Func(A arg);
Func<int,int> f1 = x => x + 1;          // Ok
Func<int,double> f2 = x => x + 1;       // Ok
Func<double,int> f3 = x => x + 1;       // Error

El delegate declara un parámetro de tipo A y un valor de retorno de tipo R.

En la 1a asignación el tipo del parámetro (x) se mapea a int y el valor de retorno es mepado a int, y efectivamente la expresión x+1 aplicada a int devuelve int, por lo que la asignación es correcta. En la segunda asignación el tipo del parámetro (x) de mapea a int y el tipo del valor de retorno a double, y la expresión x+1 aplicada a un int, puede devolver un double (cast implícito). Por otro lado en la 3a asignación el parámetro (x) es de tipo double y el tipo del valor de retorno es de tipo int, y dado un double x, la expresión x+1 no puede devolver un int.

Creo que eso de las expresiones lamdba resuelve un problema que existe con los genéricos de C# 2.0: la imposibilidad de hacer métodos genéricos que utilicen algun elemento que no está definido ni en Object ni en ningún tipo de interfaz. P.ej, en C# 2.0 la siguiente función genérica no compila:

public T Add(T a, T b)  {
   return a+b;
}

La razón es que el operador +, no está definido para la clase Object, pero es que usar la cláusula where, tampoco nos ayuda, porque en C# los operadores se definen como métodos estáticos, así que jamás estarán definidos en una interfaz. Con las expresiones lambda este problema se soluciona (bueno, reconozco que debo comprobarlo :p):

delegate T Add(T arg1, T arg2);
Add<int,int> f1 = x, y => x + y;         
Add<double,double> f2 = x,y => x + y;

Inicializadores de objetos

Con esto podemos decir que nos podremos que olvidar de meter constructores sobrecargados...la idea es que si tenemos una classe C, con dos propiedades (públicas) pa y pb, podremos especificar el valor para dichas propiedades en el mismo momento de crear el objeto: C c = new C {pa = 100, pb=200};

Tipos de variables implícitos

Volvemos a los tiempos de javascript!!! No, pero casi porque ya tenemos la palabra clave var! Declarar una variable con var, hará que el tipo de dicha variable sea inferido del tipo resultante de la expresión a la que dicha variable se inicialice (estooo... sigue siendo C#, eh? el tipo de la variable una vez inferido no puede ser modificado ;)):

Expresiones Query

MMmm... interesante: La idea es poder utilitzar algo parecido a un lenguaje de consultas (como p.ej. SQL o XQuery) sobre objetos arbitrarios. C# permite utilizar una sintaxis especial sobre todos los objetos de clases que soporten la "query expression patern" (consist en implementar un conjunto de métodos con nombres como Where, Select, ...). En definitiva, el compilador traduce las expresiones query, a llamadas a métodos tradicionales.

Una expresión query tendrá un aspecto como:

from c in customers, o in c.Orders
where o.OrderDate.Year == 2005
orderby o.Total descending
select new { c.Name, o.OrderID, o.Total }

Y nada más por el momento... no comento nada sobre los extension methods, porque ya lo hizo Miguel en un post anterior.

Saludos!

Post a new comment about this topic

Title
Name
Url
Comments
Enter the code you see:
Remember Me?