C# Language
Características de C # 4.0

Parámetros opcionales y argumentos nombrados

Podemos omitir el argumento en la llamada si ese argumento es un argumento opcional. Cada argumento opcional tiene su propio valor predeterminado. Tomará el valor predeterminado si no proporcionamos el valor. El valor predeterminado de un argumento opcional debe ser un

1. Expresión constante.
2. Debe ser un tipo de valor como enum o struct.
3. Debe ser una expresión del formulario por defecto (valueType)

Debe establecerse al final de la lista de parámetros

Parámetros del método con valores por defecto:

public void ExampleMethod(int required, string optValue = "test", int optNum = 42)
{
    //...
}

Según lo dicho por MSDN, un argumento con nombre,

Le permite pasar el argumento a la función al asociar el nombre del parámetro. No es necesario recordar la posición de los parámetros que no conocemos siempre. No es necesario mirar el orden de los parámetros en la lista de parámetros de la función llamada. Podemos especificar el parámetro para cada argumento por su nombre.

Argumentos con nombre:

// required = 3, optValue = "test", optNum = 4
ExampleMethod(3, optNum: 4);
// required = 2, optValue = "foo", optNum = 42
ExampleMethod(2, optValue: "foo");
// required = 6, optValue = "bar", optNum = 1
ExampleMethod(optNum: 1, optValue: "bar", required: 6);

Limitación de usar un argumento con nombre

La especificación de argumento con nombre debe aparecer después de que se hayan especificado todos los argumentos fijos.

Si usa un argumento con nombre antes de un argumento fijo, obtendrá un error de tiempo de compilación de la siguiente manera.

La especificación del argumento con nombre debe aparecer después de que se hayan especificado todos los argumentos fijos

Diferencia

Las interfaces genéricas y los delegados pueden tener sus parámetros de tipo marcados como covariantes o contravariantes usando las palabras clave de out y in palabras clave respectivamente. Estas declaraciones se respetan para las conversiones de tipo, tanto implícitas como explícitas, y tanto el tiempo de compilación como el tiempo de ejecución.

Por ejemplo, la interfaz existente IEnumerable<T> se ha redefinido como covariante:

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

La interfaz existente IComparer se ha redefinido como contravariante:

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

Palabra clave de referencia opcional al utilizar COM

La palabra clave ref para quienes llaman a los métodos ahora es opcional al llamar a los métodos proporcionados por las interfaces COM. Dado un método COM con la firma

void Increment(ref int x);

La invocación ahora se puede escribir como cualquiera

Increment(0); // no need for "ref" or a place holder variable any more

Búsqueda dinámica de miembros

Se introduce una nueva dynamic pseudo tipo en el sistema de tipo C #. Se trata como System.Object , pero además, se permite el acceso de cualquier miembro (llamada de método, campo, propiedad o acceso de indexador, o una invocación de delegado) o la aplicación de un operador a un valor de tal tipo sin ningún tipo de verificación de tipo, y su resolución se pospone hasta el tiempo de ejecución. Esto se conoce como tipificación de pato o encuadernación tardía. Por ejemplo:

// Returns the value of Length property or field of any object
int GetLength(dynamic obj)
{
    return obj.Length;
}
  
GetLength("Hello, world");        // a string has a Length property,
GetLength(new int[] { 1, 2, 3 }); // and so does an array,
GetLength(42);                    // but not an integer - an exception will be thrown
                                  // in GetLength method at run-time

En este caso, el tipo dinámico se utiliza para evitar una Reflexión más detallada. Todavía usa Reflection bajo el capó, pero generalmente es más rápido gracias al almacenamiento en caché.

Esta función está dirigida principalmente a la interoperabilidad con lenguajes dinámicos.

// Initialize the engine and execute a file
var runtime = ScriptRuntime.CreateFromConfiguration();
dynamic globals = runtime.Globals;
runtime.ExecuteFile("Calc.rb");

// Use Calc type from Ruby
dynamic calc = globals.Calc.@new();
calc.valueA = 1337;
calc.valueB = 666;
dynamic answer = calc.Calculate();

El tipo dinámico tiene aplicaciones incluso en el código de tipo estático en su mayoría, por ejemplo, hace posible el doble envío sin implementar el patrón de visitante.