Novedades C# 4.0

Desde que Anders Hejlsberg dio la conferencia a cerca de la nueva version de este version 4.0 de C#, he estado estudiando cuales son sus nuevas caracteristicas, ha sufrido muchos cambios, nuevas cosas, y vamos a platicar un poco de cada una de ellas.

1. Parametros opcionales y nombrados
2. Covarianza y contravarianza en interfaces y delegados
3. Mejoras en la interoperabilidad con COM
4. Tipado dinámico
5. Programación concurrente

Parametros opcionales y nombrados

Veamos un ejemplo, el siguiente codigo muestra la sobrecarga principal.

public StreamReader OpenTextFile(
    string path,
    Encoding encoding,
    bool detectEncoding,
    int bufferSize);

Ahora vemos las sobrecargas secundarias

public StreamReader OpenTextFile(
    string path,
    Encoding encoding,
    bool detectEncoding);

public StreamReader OpenTextFile(
    string path,
    Encoding encoding);

public StreamReader OpenTextFile(
    string path);

El siguiente código muestra como definir los parametros opcionales (estos siempre deberán ir al final):

public StreamReader OpenTextFile(
    string path,
    Encoding encoding = null,
    bool detectEncoding = true,
    int bufferSize = 1024);

Utilizamdo los parametros opcionales de la siguiente manera:

OpenTextFile("foo.txt", Encoding.UTF8);

Y asi se utilizarian los parametros nombrados (los parametros nombrados deberan ir al final):

OpenTextFile("foo.txt", Encoding.UTF8, bufferSize: 4096);

Los argumento nombrados pueden ir en cualquier orden siempre y cuando no falten los obligatorios:

OpenTextFile(
    bufferSize: 4096,
    path: "foo.txt",
    detectEncoding: false);

Covarianza y contravarianza en interfaces y delegados

La covarianza y contravarianza proporcionan cierta flexibilidad al confrontar las firmas de métodos con tipos de delegado. La covarianza permite que un método tenga un tipo de valor devuelto más derivado que lo que se define en el delegado. La contravarianza permite un método con tipos de parámetro que se deriven menos que en el tipo de delegado. Caracteristicas:

Para interfaces y delegados:

Se comprueba estáticamente en el punto de definición

Los tipos valor siempre son invariantes

IEnumerable<int> no es IEnumerable<object>

Reglas similares a las existentes para arrays

Los parámetros ref y out necesitan un tipo invariante

Los arrays de .NET son covariantes, pero de manera no segura

string[] strings = GetStringArray();
Process(strings);

void Process(object[] objects) {
   objects[0] = "Hello";       // Ok
   objects[1] = new Button();  // ¡Excepción!
}

Hasta ahora los genéricos de C# han sido invariantes, C# 4.0 soporta covarianza y contravarianza seguras

List<string> strings = GetStringList();
Process(strings);

void Process(IEnumerable<object> objects) {
   // IEnumerable<T> es de solo lectura
   // y por tanto covariante de manera segura
}

En el siguiente codigo:

public interface IEnumerable<out T>
{
   IEnumerator<T> GetEnumerator();
}

out = CovarianteSolo posiciones de salida

public interface IEnumerator<out T>
{
   T Current { get; }
   bool MoveNext();
}

Puede ser tratada como menos derivada

IEnumerable<string> strings = GetStrings();
IEnumerable<object> objects = strings;

En este otro ejemplo:

public interface IComparer<in T>
{
   int Compare(T x, T y);
}

in = ContravarianteSolo posiciones de entrada

Puede ser tratada como más derivada

IComparer<object> objComp = GetComparer();
IComparer<string> strComp = objComp;

Mejoras en la interoperabilidad con COM

Objeto automático -> mapeo dinámico
Parámetros opcionales y nombrados
Propiedades indexadas
Modificador "ref" opcional
Posibilidad de embeber tipos de interoperabilidad ("No PIA")

Tipado dinámico

El tipado dinamico permite que una variable puede tomar valores de distinto tipo en distintos momentos. Ejemplo:

dynamic calc = GetCalculator();
int sum = calc.Add(10, 20);

Donde, Su tipo estático es dynamic, es convertido de forma dinamica al momento de la asignacion de la llamada dinámica.

De la forma Tipado estatico quedaria:

ScriptObject calc = GetCalculator();
object res = calc.Invoke("Add", 10, 20);
int sum = Convert.ToInt32(res);

Cuando los operandos son dynamic:

La selección de miembros se difiere a tiempo de ejecución

En ejecución, se sustituye dynamic por el tipo real

El tipo estático del resultado de la operación es dynamic

Programación concurrente (multicore), ya que la tendencia es añadir más y más procesadores.