Do sostenido 4.0

dynamicSe introduce un nuevo pseudotipo en el sistema de tipos de C# . Se trata como System.Object, pero además, se permite cualquier acceso a miembros (llamada a método, campo, propiedad o acceso a indexador, o invocación de delegado) o la aplicación de un operador sobre un valor de dicho tipo sin ninguna comprobación de tipo, y su resolución se pospone hasta el tiempo de ejecución. Esto se conoce como tipado dinámico (duck typing) . Por ejemplo:

// Devuelve el valor de la propiedad o campo Length de cualquier objeto int GetLength ( dynamic obj ) { return obj . Length ; } GetLength ( "Hello, world" ); // una cadena tiene una propiedad Length, GetLength ( new int [] { 1 , 2 , 3 }); // y también un array, GetLength ( 42 ); // pero no un entero: se lanzará una excepción en el método GetLength en tiempo de ejecución.

Las llamadas a métodos dinámicos se activan mediante un valor de tipo dynamicparámetro implícito o explícito (y no solo un receptor). Por ejemplo:

void Print ( dynamic obj ) { System.Console.WriteLine ( obj ); // En tiempo de ejecución se decide qué sobrecarga de WriteLine() llamar }Imprimir ( 123 ); // termina llamando a WriteLine(int) Imprimir ( "abc" ); // termina llamando a WriteLine(string)

La búsqueda dinámica se realiza mediante tres mecanismos distintos: COM IDispatch para objetos COM, IDynamicMetaObjectProviderinterfaz DLR para objetos que implementan dicha interfaz y reflexión para todos los demás objetos. Por lo tanto, cualquier clase de C# puede interceptar llamadas dinámicas en sus instancias implementando IDynamicMetaObjectProvider.

En el caso de llamadas a métodos e indexadores dinámicos, la resolución de sobrecarga se produce en tiempo de ejecución según los tipos reales de los valores pasados ​​como argumentos, pero en otros casos según las reglas habituales de resolución de sobrecarga de C#. Además, en los casos en que el receptor en una llamada dinámica no sea dinámico, la resolución de sobrecarga en tiempo de ejecución solo considerará los métodos que se exponen en el tipo declarado en tiempo de compilación del receptor. Por ejemplo:

clase Base { void Foo ( double x ); }clase Derivada : Base { void Foo ( int x ); }dynamic x = 123 ; Base b = new Derived (); b.Foo ( x ); // elige Base.Foo(double) porque b es de tipo Base, y Derived.Foo(int) no está expuesto dynamic b1 = b ; b1.Foo ( x ) ; // elige Derived.Foo(int)

Cualquier valor devuelto por un acceso dinámico a un miembro es de tipo dynamic. Los valores de tipo dynamicson implícitamente convertibles tanto desde como hacia cualquier otro tipo. En el ejemplo de código anterior, esto permite GetLengthque la función trate el valor devuelto por una llamada a Lengthcomo un entero sin ninguna conversión explícita. En tiempo de ejecución, el valor real se convertirá al tipo solicitado.

Las interfaces y delegados genéricos pueden tener sus parámetros de tipo marcados como covariantes o contravariantes mediante las palabras clave outy, inrespectivamente. Estas declaraciones se respetan para las conversiones de tipo, tanto implícitas como explícitas, y tanto en tiempo de compilación como en tiempo de ejecución. Por ejemplo, la interfaz existente IEnumerable<T>se ha redefinido de la siguiente manera:

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

Por lo tanto, cualquier clase que implemente IEnumerable<Derived>para alguna clase Derivedtambién se considera compatible con IEnumerable<Base>para todas las clases e interfaces Baseque Derivedextienden, directa o indirectamente. En la práctica, esto permite escribir código como:

void PrintAll ( IEnumerable < object > objects ) { foreach ( object o in objects ) { System . Console . WriteLine ( o ); } }IEnumerable < string > strings = new List < string > (); PrintAll ( strings ); // IEnumerable<string> se convierte implícitamente en IEnumerable<object>

Para la contravarianza, la interfaz existente IComparer<T>se ha redefinido de la siguiente manera:

interfaz pública IComparer < in T > { int Compare ( T x , T y ); }

Por lo tanto, cualquier clase que implemente IComparer<Base>para alguna clase Basetambién se considera compatible con IComparer<Derived>para todas las clases e interfaces Derivedque se extienden desde Base. Esto permite escribir código como:

IComparer < objeto > objectComparer = GetComparer (); IComparer < cadena > stringComparer = objectComparer ;

La refpalabra clave para los llamadores de métodos ahora es opcional al llamar a métodos proporcionados por interfaces COM . Dado un método COM con la firma

void Incremento ( referencia int x );

La invocación ahora se puede escribir como

Incremento ( 0 ); // Ya no es necesario "ref" ni una variable de marcador de posición.

o

int x = 0 ; Incremento ( ref x );

C# 4.0 introduce parámetros opcionales con valores predeterminados, como se ve en Visual Basic y C++ . Por ejemplo:

void Incremento ( ref int x , int dx = 1 ) { x += dx ; }int x = 0 ; Incremento ( ref x ); // dx toma el valor predeterminado de 1, después de que el método devuelve x == 1 Incremento ( ref x , 2 ); // dx toma el valor 2, después de que el método devuelve x == 3

Además, para complementar los parámetros opcionales, es posible especificar explícitamente los nombres de los parámetros en las llamadas a métodos, lo que permite al programador pasar selectivamente cualquier subconjunto de parámetros opcionales para un método. La única restricción es que los parámetros con nombre deben colocarse después de los parámetros sin nombre. Se pueden especificar nombres de parámetros tanto para parámetros opcionales como obligatorios, y se pueden usar para mejorar la legibilidad o para reordenar arbitrariamente los argumentos en una llamada. Por ejemplo:

Stream OpenFile ( string name , FileMode mode = FileMode . Open , FileAccess access = FileAccess . Read ) { ... }OpenFile ( "file.txt" ); // usar valores predeterminados para "mode" y "access" OpenFile ( " file.txt" , mode : FileMode.Create ) ; // usar valor predeterminado para "access" OpenFile ( "file.txt" , access : FileAccess.Read ) ; // usar valor predeterminado para "mode" OpenFile ( name : "file.txt" , access : FileAccess.Read , mode : FileMode.Create ) ; // nombrar todos los parámetros para mayor legibilidad, // y usar un orden diferente al de la declaración del método

Los parámetros opcionales facilitan la interoperabilidad con COM. Anteriormente, C# tenía que pasar todos los parámetros al método del componente COM, incluso aquellos que eran opcionales. Por ejemplo:

objeto fileName = "Test.docx" ; objeto missing = System . Reflection . Missing . Value ;doc.SaveAs ( ref fileName , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing ) ;​

Con soporte para parámetros opcionales, el código se puede acortar como

doc.SaveAs ( ref fileName ) ;​

Lo cual, debido a la refpalabra clave ahora opcional al usar COM, se puede abreviar aún más como

doc.SaveAs ( fileName ) ;​

Ahora se reconocen las propiedades indexadas (y las propiedades predeterminadas) de los objetos COM, pero los objetos C# todavía no las admiten.