C# 4.0 introduce un nuevo tipo: dinámico, que es un tipo estático, pero una instancia de objeto de este tipo puede eludir el proceso de comprobación de tipos estáticos. En la mayoría de los casos, el tipo funciona como una clase objeto. En tiempo de compilación, una instancia de una clase dinámica soporta cualquier operación, por lo que no hay que preocuparse de si el objeto se toma de una API COM, o de un lenguaje dinámico como IronPython, del DOM HTML, de la reflexión o de cualquier otro lugar del programa. Sin embargo, si el código hace algo inválido, el error se detecta en tiempo de ejecución.
Por ejemplo, el ejemplo de método exampleMethod1 en el siguiente fragmento de código tiene solo un parámetro, y el compilador puede identificar que es inválido al llamar a ec.exampleMethod1(10,4) en tiempo de compilación; Esto es un error de compilación. La segunda llamada dynamic_ec.exampleMethod1(10,4) no se comprueba para tipos estáticos. Por lo tanto, el compilador no informa de errores de compilación. Sin embargo, el bicho no se oculta para siempre; Se detectará en tiempo de ejecución y activará una excepción en tiempo real.
static void Main(string[] args){
ExampleClass ec = nueva ExampleClass();
dinámico dynamic_ec = nueva ExampleClass();
dynamic_ec.ejemploMétodo1(10, 4);
dynamic_ec.someMethod ("algún argumento", 7, nulo);
dynamic_ec.métodoInexistente();
}
clase EjemploClase {
ExampleClass() pública { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
ejemploMétodo 2(string str) { }
}
Aquí tienes un ejemplo de cómo usar dinámica para llamar a IronPython:
usando IronPython.Hosting;
usando Microsoft.scrip{filtering}ting. Presentación;
Console.WriteLine("Loading random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
Dinámico aleatorio = Py. UseFile("random.py");
Console.WriteLine("random.py cargado!");
ítems var = Enumerable. Rango(1, 7). ToArray();
para (int s = 0; s < 10000; s++) {
aleatorio.barajado(objetos);
Console.Write("Sequence {0}: ", s);
foreach (int i en ítems) {
Console.Write("{0} ", i);
}
Consola.WriteLine();
}
Para objetos u expresiones de dinámica de tipos, el papel del compilador es encapsular las acciones que se espera que realice cada expresión y, en el momento de la ejecución, comprobar la información almacenada, y cualquier sentencia inválida desencadenará una excepción en tiempo de ejecución.
El tipo de resultado de la mayoría de las operaciones dinámicas también es dinámico. Por ejemplo, si pasas el cursor con el puntero del ratón sobre el testSum en el siguiente ejemplo, el prompt inteligente mostrará un testSum dinámico (variable local).
dinámico d = 1;
var testSum = d + 3;
Coloca el puntero del ratón sobre el testSum de abajo.
System.Console.WriteLine(testSum);
Conversión de tipos
La transición entre instancias de tipo dinámico y otros tipos de instancias es sencilla, y los desarrolladores pueden cambiar fácilmente entre comportamientos dinámicos y no dinámicos. Cualquier instancia puede convertirse implícitamente en una instancia de tipo dinámico, véase el siguiente ejemplo:
dinámico d1 = 7;
dinámico d2 = "una cuerda";
dinámico d3 = System.DateTime.Today;
dinámico d4 = System.Diagnostics.Process.GetProcesses();
Por el contrario, una conversión implícita puede aplicarse dinámicamente a cualquier expresión de dinámica de tipos.
Y viceversa, cualquier expresión de dinámica de tipos también puede convertirse implícitamente en otros tipos.
int i = d1;
string str = d2;
FechaHora dt = d3;
System.Diagnostics.Process[] procs = d4;
Problema de sobrecarga con parámetros dinámicos de tipo en el método
Si se llama a un método pasa un objeto de dinámica de tipos, o el objeto llamado es dinámico de tipos, entonces el juicio de sobrecarga ocurre en tiempo de ejecución y no en tiempo de compilación.
DLR de ejecución dinámica en tiempo de ejecución del lenguaje
El tiempo de ejecución dinámico del lenguaje es . NET Framework 4 Beta 1 es un nuevo conjunto de APIs que ofrecen soporte para tipos dinámicos en C# y también implementan lenguajes de programación dinámica como IronPython e IronRuby.
Interoperabilidad COM
C# 4.0 incluye varias características que mejoran la interoperabilidad con interfaces tradicionales de la API COM, como la automatización de Office. Los tipos dinámicos, parámetros nombrados y parámetros opcionales también forman parte de la mejora.
Muchos métodos COM permiten que sus parámetros y valores de retorno sean de tipo objeto, por lo que para lenguajes fuertemente tipados como C#, se requiere mucha conversión forzada de tipos. Sin embargo, en C# 4.0, si añades la opción /link en tiempo de compilación, el tipo dinámico tiene un nuevo efecto: hace que el tipo de objeto (tipo de parámetro o tipo de retorno) en la firma del método de la interfaz COM se considere dinámico, evitando así mucha conversión de tipos. Por ejemplo, la siguiente afirmación contrasta esto.
No se utiliza dinámica.
((Excel.Rango)excel. Células[1, 1]). Value2 = "Nombre";
Excel.Rango = (Excel.Rango)excel. Células[1, 1];
Fue una dinámica.
Excel. Células[1, 1]. Valor = "Nombre";
Excel. Rango de rango = excel. Células[1, 1]; |
Publicado en 7/7/2016 10:23:00
|
|
|
