Receta No. 3-18 en C#: Cómo Crear un Tipo Dinámico Personalizado

Tabla de Contenido

0. Introducción
1. Problema
2. Solución
3. Discusión de la Solución
3.1 Clase DynamicObject
3.1.1 Método TryGetMember
3.1.2 Método TrySetMember
3.2 Ejemplo de herencia de DynamicObject
4. Práctica: Código Fuente C#
5. Conclusiones
6. Glosario
7. Literatura & Enlaces

0. Introducción

Esta última receta de la serie dominios de aplicación, reflection, y metadatos, aprenderemos cómo crear un tipo personalizado de forma dinámica: establecimiento y recuperación de miembros (propiedades). Usaremos una de las clases introducidas en DLR (.NET Framework 4.0): DynamicObject. Esta clase nos proveerá la maquinaria necesaria para la agregación de propiedades, métodos, índices, &c. a un tipo en tiempo de ejecución. (Los ejemplos mostrados representan una introducción a DLR, que desde luego, será extendida en futuros artículos y/o recetas.)

1. Problema

Ahora damos a paso a un nivel más abstracto y exigente: requerimos de un método que nos permita la adición de comportamiento personalizado a un tipo, y que en consecuencia podamos invocar sus miembros de forma dinámica.

2. Solución

El nombre de espacios System.Dynamic (que hace parte de .NET Framework y que principalmente agrega funcionalidades dinámicas de lenguaje a la CLR) contiene la clase base DynamicObject que nos va a permitir especificar comportamiento dinámico en tiempo de ejecución. Esta clase tendremos que extenderla y sobrescribir los métodos virtual TryXXX (XXX para referirse a los postfijos de la nomenclatura).

3. Discusión de la Solución

3.1 Clase DynamicObject

La clase DynamicObject, es la clase base que facilita la especificación de comportamiento dinámico en tiempo de ejecución para los tipos derivados de esta. No es posible crear instancias directas de esta clase, para lograrlo tendremos que crear una jerarquía de herencia y crear subtipos que hereden de DynamicObject y sobrescribir varios de sus miembros que inician con el prefijo Try (en la Figura 1 [1] se enumeran varios de estos métodos).

Figura 1. Métodos virtual de la clase DynamicObject.

De acuerdo con la documentación de esta clase en [2] es importante incluir (literalmente) este comentario:

"The DynamicObject class enables you to define which operations can be performed on dynamic objects and how to perform those operations. For example, you can define what happens when you try to get or set and object property, call a method, or perform standard mathematical operations such as addtion and multiplication."

Además, esta nota:

Figura 2. Nota sobre el uso de ExpandoObject y IDynamicMetaObjectProvider [2].

Adicionalmente, el hecho de contar con tipos personalizados que deriven de esta clase nos va a permitir crear definiciones de código más intuitivas para los clientes del tipo concreto, por ejemplo:

En lugar de tener una definición como esta

obj.SetProperty ("Contador", 1);

los métodos sobrescritos de DynamicObject en una subclase, facilitan este medio 

obj.Contador = 1;

Desde luego que para nosotros esta última definición es mucho más intuitiva, pues resulta más simple y directa en cuanto a especificación sintáctica (como las propiedades -cfr. Propiedades en C#-)

Para lograr este grado de afinidad sintáctica tendremos que sobrescribir los métodos:

• TryGetMember
• TrySetMember

3.1.1 Método virtual TryGetMember

El método TryGetMember [6] se invoca implícitamente cuando intentamos obtener un valor por medio de una propiedad. En la versión sobrescrita en la subclase (herencia de DynamicObject) se especifica el comportamiento dinámico para las operaciones de obtención de valores. Esta es su firma [5]:

public virtual bool TryGetMember(GetMemberBinder binder, out Object result)

Descripción puntual:

• Parámetros:
• binder: es el generador de la información del objeto que invoca el comportamiento dinámico.
• result: resultado de la operación de la operación de obtención de valor (debe establecer un valor independiente de si se ha encontrado un valor o no, esto debido a que su especificación incluye el modificador out).
• Retorno: true si la operación de establecimiento de valor fue satisfactoria, false en caso contrario. (En este último caso se suelen lanzar excepciones.)

3.1.2 Método virtual TrySetMember

El método TrySetMember [5] permite especificar las operaciones que se han de llevar a cabo para el establecimiento de valores de un miembro. Este método puede ser sobrescrito por el tipo derivado de DynamicObject, y esencialmente se usa para especificar el comportamiento dinámico que de ejecutarse al cambiar el valor de una propiedad. Esta es su firma:

public virtual bool TrySetMember(SetMemberBinder binder, Object value)

Descripción puntual:

• Parámetros:
• binder: es el generador de la información del objeto que invoca el comportamiento dinámico.
• value: instancia de object con la información a establecer sobre el miembro (e.g., propiedad)
• Retorno: true si la operación de establecimiento de valor fue satisfactoria, false en caso contrario.

3.2 Ejemplo de herencia de DynamicObject

Para facilitar la comprensión del uso de la clase DynamicObject, he decidido hacer una adaptación de código fuente del ejemplo presentado por Anoob Madhusudanan en su artículo acerca de las capacidades dinámicas de .NET 4.0 en [6]:

Archivo de código fuente ClaseDinamica.cs [enlace alternativo]:

En la línea 7 especificamos que la clase ClaseDinamica hereda directamente desde DynamicObject. Creamos una instancia de la colección clave/valor Dictionary<TKey, TValue> [7] para almacenar los miembros que agregamos dinámicamente a una instancia de la clase dinámica ClaseDinamica.

Continuando, en las líneas 19-30 sobrescribimos el método TryGetMember para recuperar el valor de un miembro agregado dinámica. La operación contraria ocurre con el método sobrescrito TrySetMember (líneas 38-51). Con el método TryInvokeMember (líneas 60-71) invocamos un miembro (delegado) utilizando las capacidades dinámicas heredadas de la clase DynamicObject. Más adelante, en las líneas 77-80, sobrescribimos el método GetDynamicMemberNames para descubrir las miembros agregados en tiempo de ejecución a la instancia de ClaseDinamica.

En la región de código cliente, líneas 82-103, definimos una variable del tipo dynamic (cfr. Invocación Dinámica de Miembros de un Tipo) con el identificador -dyn-. Envolvemos una instancia (línea 88) de ClaseDinamica sobre la variable anterior. Más adelante, en la línea 82 creamos de forma dinámica la propiedad Contador y le asignamos el valor literal entero 13. (Para este caso se ha invocado implícitamente el método TrySetMember).

Por otro lado, sobre la línea 95 creamos un delegado a partir del delegado genérico Action<T> (cfr. Tipos Genéricos en C# - Parte 8: Delegados Genéricos) con la expresión lambda texto => Console.WriteLine (texto). A continuación, en la línea 98, lo asignamos al miembro EscribirEnConsola. Para finalizar, invocamos el delegado recién creado y asignado y le pasamos como argumento la representación string de la propiedad dinámica Contador.

Compilación:

1. csc /target:exe ClaseDinamica.cs

Ejecución assembly:

1. .\ClaseDinamica.exe

Resultado:

Figura 2. Prueba de ejecución de instancia de la clase dinámica ClaseDinamica.

4. Práctica: Código Fuente C#

Sección idónea para que afiancemos el entendimiento sobre las potencialidades de la herencia de DynamicObject. Creamos la herencia correspondiente, y agregaremos miembros de forma dinámica a una instancia de la clase hija (subclase).

Archivo de código fuente DiccionarioDinamico.cs [enlace alternativo]:

Compilación:

1. csc /target:exe DiccionarioDinamico.cs

Ejecución assembly:

1. .\DiccionarioDinamico.exe

Resultado:

Figura 3. Prueba de ejecución de instancia de la clase dinámica DiccionarioDinamico.

5. Conclusiones

A pesar del grado de complejidad (puede ser subjetivo) del uso de DynamicObject, hemos obtenido un conocimiento básico, claro, y conciso de esta clase. En los ejemplos prácticos quedó demostrado la capacidad dinámica sobre los miembros de tipo que introduce el uso conjugado del tipo dynamic y la instanciación de una subclase DynamicObject.

Glosario

• CLR
• Dinámico
• DLR

Literatura & Enlaces

[1]: Visual C# 2010 Recipes by Allen Jones and Adam Freeman. Copyright 2010 Allen Jones and Adam Freeman, 978-1-4302-2525-6.
[2]: DynamicObject Class (System.Dynamic) - http://msdn.microsoft.com/en-us/library/system.dynamic.dynamicobject(v=vs.110).aspx
[3]: Dynamic Language Runtime Overview - http://msdn.microsoft.com/en-us/library/dd233052(v=vs.110).aspx
[4]: Propiedades en C# | OrtizOL - Experiencias Construcción Software (xCSw) http://ortizol.blogspot.com/2013/10/propiedades-en-c.html
[5]: DynamicObject.TryGetMember Method (System.Dynamic) - http://msdn.microsoft.com/en-us/library/system.dynamic.dynamicobject.trygetmember(v=vs.110).aspx
[6]: Adventures with C# 4.0 dynamic - ExpandoObject, ElasticObject, and a Twitter client in 10 minutes - CodeProject - http://www.codeproject.com/Articles/62839/Adventures-with-C-dynamic-ExpandoObject-Elasti
[7]: Dictionary(TKey, TValue) Class (System.Collections.Generic) - http://msdn.microsoft.com/en-us/library/xfhwa508(v=vs.110).aspx
[8]: Tipos Genéricos en C# - Parte 8: Delegados Genéricos - http://ortizol.blogspot.com/2014/05/tipos-genericos-en-c-parte-8-delegados.html

J

Receta No. 3-17 en C#: Invocación Dinámica de Miembros de un Tipo

Tabla de Contenido

0. Introducción
1. Problema
2. Solución
3. Discusión de la Solución
3.1 dynamic
4. Práctica: Código Fuente C#
5. Conclusiones
6. Glosario
Literatura & Enlaces

0. Introducción

Esta receta nos presentará una alternativa a reflection a través del uso de la construcción dynamic. Conoceremos los escenarios en donde es apropiado su uso, y también, cuando debemos obviar su uso por asuntos de pérdida del rendimiento de una aplicación, y en particular, por la pérdida de la comprobación estática de tipos.

1. Problema

En la receta 1-19 (Creación de un Tipo Dinámico usando ExpandoObject) aprendimos acerca del uso de la construcción dynamic para la representación de tipos de forma dinámica, es decir, en tiempo de ejecución. Ahora que ya sabemos de su existencia en C#, queremos aplicarla para invocar miembros de un tipo de forma dinámica.

2. Solución

La solución a este requerimiento consiste en la conjugación del conocimiento y práctica adquiridos en la receta anterior (Invocar un Miembro de un Tipo con Reflection), donde aprendimos cómo invocar los miembros de un tipo usando la técnica .NET Reflection: uso del método InvokeMember (System.Type) y el método Invoke (System.Reflection.MemberInfo), y el uso de la construcción dynamic.

3. Discusión de la solución

Gracias a [1] sabemos que el uso de la construcción dynamic [3] de C# representa un enfoque alternativo a reflection, esto, para la invocación de miembros de un tipo usando el soporte con el que cuenta la versión 4.0 de .NET 4.0: DLR (Dynamic Language Runtime) [4].

Veamos en breve la definición uso de dynamic.

3.1 dynamic

Desde la versión 4.0 de .NET en C# podemos utilizar dynamic para la resolución de operaciones sobre tipos en tiempo de ejecución. Mientras que en tiempo de compilación, la comprobación de tipos, casting, boxing y unboxing, &c., son descartados por el compilador.

En este ejemplo podemos encontrar la diferencia entre la comprobación en tiempo de compilación y en tiempo de ejecución.

Archivo de código fuente PruebaDynamicObject.cs [enlace alternativo]:

En la línea 10 declaramos una variable de dynamic -dyn-, y la inicializamos con la literal entera 1;en la siguiente línea una instancia de object -obj-, con el valor entero 1 (boxing). Más adelante sobre la línea 13 sumamos 3 al valor 1 que tiene encapsulado el tipo dynamic (línea 10).

Continuando, si intentamos hacerlo mismo, es decir 

obj = ((object)obj) + 3;

El compilador de C# generará el error CS0019 [5] debido a que no es posible aplicar el operador + sobre un tipo object y una literal entera (en su lugar, era necesario hacer casting: ((object)obj) + 3). Notemos que esto ha ocurrido en tiempo de compilación, y por supuesto, nos genera una ventaja significativa sobre la comprobación de tipos en tiempo de ejecución. Demostrémolo a través del intento de invocar un miembro no definido sobre la variable dynamic -dyn-:

dyn.MetodoInexistente ()

La compilación del programa en el archivo de código fuente PruebaDynamicObject.cs no generará ningún error en tiempo de compilación, sin embargo, cuando intentemos ejecutar el assembly:

1. .\PruebaDynamicObject.exe

obtendremos el siguiente mensaje de error:

Figura 1. Intento de invocar método inexistente en una variable dynamic.

En el mensaje de error que aparece en la Figura 1 se informa que ha ocurrido la excepción RuntimeBinderException (N:Microsoft.CSharp.RuntimeBinder) [6] que se traduce en el intento de enlazar (binding) miembros de un tipo inexistentes en tiempo de ejecución.

Antes de finalizar, sobre el artículo en DotNetPerls [2, 7] nos advierten sobre el uso de dynamic:

Dynamic is advanced functionality. It can be useful. But usually it should be avoided. It erases many benefits of the C# language.

Además:

The dynamic keyword influences compilation. A dynamic variable, parameter or field can have any type. Its type can change during runtime. The downside is that performance suffers and you lose compile-time checking.

[Nota: Recomiendo la lectura de la receta Creación de un Tipo Dinámico usando ExpandoObject en donde podrán encontrar una explicación más extensa sobre este tipo .]

4. Práctica: Código Fuente C#

En este ejemplo crearemos la versión con uso de dynamic en contraste con la versión de la sección práctica de la receta 3.16 [9]:

Archivo de código fuente VersionDynamic.cs [enlace alternativo]:

Empezando la sección de código cliente (líneas 15-27), exactamente en la línea 17 declaramos la variable dynamic -dyn-. En la línea 20, asignamos a esta variable una instancia de la clase VersionDynamic. Invocamos al método ImprimirMensaje con los parámetros formales de su firma. En esta última parte debemos asegurarnos que el miembro que estamos invocando existe, y que los argumentos son aplicados tal cual como se especifican la firma (tipos y orden).

Compilación:

1. csc /target.exe VersionDynamic.cs

Ejecución assembly:

1. .\VersionDynamic.cs

Resultado:

Figura 2. Prueba ejecución de receta con uso de dynamic.

5. Conclusiones

Creamos una receta en la que aprendimos a invocar miembros de un tipo de forma dinámica a través del uso de la construcción dynamic (que fue introducida en la versión 4.0 de .NET Framework). En la sección práctica se demostró que invocar miembros de un tipo es mucho más simple que utilizar la técnica .NET Reflection, sin embargo, como se menciono dynamic empobrece el rendimiento de una aplicación, además de disuadir la comprobación de tipos en tiempo de compilación.

6. Glosario

• Comprobación de tipos
• Dinámico
• DLR
• Miembro de tipo
• Reflection
• Tiempo de compilación
• Tiempo de ejecución

7. Literatura & Enlaces

[1]: Visual C# 2010 Recipes by Allen Jones and Adam Freeman. Copyright 2010 Allen Jones and Adam Freeman, 978-1-4302-2525-6.
[2]: C# Dynamic Keyword - http://www.dotnetperls.com/dynamic
[3]: dynamic (C# Reference) - http://msdn.microsoft.com/en-us/library/dd264741.aspx
[4]: Dynamic Language Runtime Overview - http://msdn.microsoft.com/en-us/library/dd233052(v=vs.110).aspx
[5]: Compiler Error CS0019 - http://msdn.microsoft.com/en-us/library/a63h61ky.aspx
[6]: RuntimeBinderException Class (Microsoft.CSharp.RuntimeBinder) - http://msdn.microsoft.com/en-us/library/microsoft.csharp.runtimebinder.runtimebinderexception(v=vs.110).aspx
[7]: C# Tutorial: Dot Net Perls - http://www.dotnetperls.com/
[8]: Receta No. 1-19 en C#: Creación de un Tipo Dinámico usando ExpandoObject | OrtizOL Experiencias Construcción Software - http://ortizol.blogspot.com/2014/02/receta-no-1-19-en-c-creacion-de-un-tipo.html
[9]: Receta No. 3-16 en C#: Invocar un Miembro de un Tipo con Reflection | OrtizOL - Experiencias Construcción Software (xCSw) - http://ortizol.blogspot.com/2014/06/receta-no-3-16-en-csharp-invocar-un-miembro-de-un-tipo-con-reflection.html

J

Receta No. 3-16 en C#: Invocar un Miembro de un Tipo con Reflection

Tabla de Contenido

0. Introducción
1. Problema
2. Solución
3. Discusión de la Solución
3.1 Método InvokeMember
3.2 Método Invoke
4. Práctica: Código Fuente C#
5. Conclusiones
6. Glosario
7. Literatura & Enlaces

0. Introducción

Ahora que tenemos el conocimiento y práctica suficientes y necesarios sobre cómo obtener los miembros de un tipo (Uso Programático para Investigar y Descubrir los Miembros de un Tipo), es momento de entender cómo podemos invocar el miembro de un tipo usando la técnica .NET Reflection.

1. Problema

Necesitamos conocer la forma en que podemos invocar los miembros de un tipo usando .NET Reflection.

2. Solución

En .NET Framework existen dos formas disponibles para invocar los miembros de los que dispone un tipo:

1. Método InvokeMember de Type, o 
2. Método Invoke de la clase MemberInfo, o cualquiera que derive de esta:
1. MethodInfo
2. PropertyInfo
3. ConstructorInfo

3. Discusión de la Solución

Conozcamos la forma programática de invocar los miembros de un tipo usando las dos formas mencionadas en la sección 2.

3.1 Método InvokeMember

El método InvokeMember [3] posee las siguientes versiones de firmas sobrecargadas:

Figura 1. Lista sobrecargada de Type.InvokeMember [3].

Para ejemplificar su uso vamos utilizar la primera versión, es decir, la que posee la firma:

public Object InvokeMember(string name, BingingFlags invokeAttr, Binder binder, Object target, Object[] args)

Descripción puntual:

• Parámetro name: cadena de caracteres con el nombre del miembro (constructor, método, propiedad, etc.)
• Parámetro invokeAttr: determina la forma en que se realizará la búsqueda a través de reflection. Consiste en la especificación bitwise OR de la enumeración BindingFlags [5].
• Parámetro binder: especificador de propiedades o características que ayudan a resolver el miembro sobrecargado a invocar, por ejemplo.
• Parámetro target: objeto sobre el que se invocará el miembro. (Si null es para señalar que se trata de un constructor.)
• Parámetro args: arreglo con los argumentos a pasar al miembro a invocar.
• Tipo de retorno Object: Representa el valor de retorno del miembro que se ha invocado.

Ejemplo de uso:

Archivo de código fuente UsoInvokeMember.cs [enlace alternativo]:

En las línea 7-36 declaramos la clase ClaseDemo con varios miembros (un campo, un constructor, una propiedad, y el método ToString sobrescrito). En la línea 43 creamos la representación Type para la clase ClaseDemo. Creamos un arreglo de elementos object con un sólo elemento (valor 8) en la línea 46. Con la línea 50 probamos el valor de args[0] antes de invocar el constructor de ClaseDemo. 

Continuando, entre las líneas 53-56, invocamos al método InvokeMember pasando los siguientes argumentos:

• Nombre de miembro null: para señalar que vamos a invocar un constructor (ClaseDemo (ref int x))
• Valores de la enumeración BindingFlags:
• DeclaredOnly: especifica que sólo buscará entre los miembros declarados en el tipo especificado. Omitirá la búsqueda de miembros heredados.
• NonPublic: especifica que los miembros ~public serán incluidos en la búsqueda.
• Public: especifica que los miembros public serán incluidos en la búsqueda.
• Instance: especifica que los miembros de instancia serán incluidos en la búsqueda.
• CreateInstance: especifica que a través de reflection se debe crear la instancia del tipo especificado.
• Binder null: uso de los atributos por defecto para búsqueda de miembros sobrecargados.
• Objetivo null: indica que se va a crear una instancia del tipo especificado a través del invoca al método InvokeMember.
• Argumentos args: los argumentos con los que se creará la instancia de ClaseDemo.

En la línea 58 se muestra en la salida estándar el tipo concreto devuelto por las líneas comentadas anteriormente. Sobre la ínea 59, mostramos el valor de args[0]; el cual fue pasado como referencia al constructor (línea 26) de ClaseDemo.

De forma análoga, aunque con evidente diferencia en la configuración de la invocación del método InvokeMember, se establece y obtiene valores para los miembros en el resto de código fuente:

• campo (lineas 65-75),
• ToString (líneas 79-82), y 
• Propiedad (líneas 90-9)

> Prueba de ejecución.

Resultado:

Figura 2. Prueba de ejecución con el uso del método InvokeMember.

3.2 Método Invoke

Para mostrar las capacidades del método Invoke, utilizaremos la implementación de este sobre la clase ConstructorInfo [6] que se haya en [7]. Empero, recurriremos a la versión sobrecargada con firma [8]:

public Object Invoke(Object[] parameters)

Descripción puntual:

• Parámetro Object[]: arreglo con los parámetros del constructor.
• Tipo de retorno Object: retorna instancia del tipo especificado.

Ejemplo de uso:

Archivo de código fuente CreacionStringBuilder.cs [enlace alternativo]:

En la línea 25 obtenemos la representación Type de StringBuilder [11] con el uso del operador typeof. Con la sentencia 

Type[] argsTipos = new Type[] { typeof (String), typeof(Int32)};

en la línea 29 especificamos la lista de los tipos de los parámetros para un constructor de StringBuilder ([12]). La variable argsTipos la pasamos como argumento al método GetConstructor (línea 32) para obtener la información del constructor sobre una instancia ConstructorInfo. Los argumentos para la firma del constructor recién creado los especificamos en un arreglo object en la línea 35. Finalmente, ya podemos crear la instancia invocando al método Invoke en la sentencia de la línea 38. El código cliente (líneas 9-20) comprende el uso de una instancia de StringBuilder.

Compilación:

1. csc /target.exe CreacionStringBuilder.cs

> Prueba de ejecución.

Resultado:

Blog xCSw

4. Práctica: Código Fuente C#

Con este ejemplo vamos a recapitular (con el fin de afianzar el conocimiento adquirido) el uso del método InvokeMethod y el método Invoke:

Archivo de código fuente ReflectionConInvokeMethod.cs [enlace alternativo]:

Compilación:

1. csc /target.exe ReflectionConInvokeMethod.cs

Ejecución:

1. .\ReflectionConInvokeMethod.exe

Resultado:

Valores de `param1`: Blog xCSw; `param2`: 235; `param3`: #

Valores de `param1`: Blog xCSw; `param2`: 235; `param3`: #

5. Conclusiones

Utilizamos los artefactos (métodos) de las clases ConstructorInfo, MethodInfo, y Type para demostrar el uso de los métodos Invoke y InvokeMember para demostrar el proceso de invocación de miembros de tipo en tiempo de ejecución usando .NET Reflection. En la siguiente receta (penúltima de esta serie de dominios de aplicación, meta-datos, y reflection) conoceremos el proceso de invocar de forma dinámica el miembro de un tipo.

6. Glosario

• Invocar
• Invoke
• InvokeMember
• Miembro
• Reflection

Literatura & Enlaces

[1]: Visual C# 2010 Recipes by Allen Jones and Adam Freeman. Copyright 2010 Allen Jones and Adam Freeman, 978-1-4302-2525-6.
[2]: Type.InvokeMember Method (System) - http://msdn.microsoft.com/en-us/library/system.type.invokemember(v=vs.110).aspx
[3]: Type.InvokeMember Method (System) - http://msdn.microsoft.com/en-us/library/system.type.invokemember(v=vs.110).aspx
[4]: Type.InvokeMember Method (String, BindingFlags, Binder, Object, Object[]) (System) - http://msdn.microsoft.com/en-us/library/66btctbe(v=vs.110).aspx
[5]: BindingFlags Enumeration (System.Reflection) - http://msdn.microsoft.com/en-us/library/system.reflection.bindingflags(v=vs.110).aspx
[6]: ConstructorInfo Class (System.Reflection) - http://msdn.microsoft.com/en-us/library/system.reflection.constructorinfo(v=vs.110).aspx
[7]: ConstructorInfo.Invoke Method (System.Reflection) - http://msdn.microsoft.com/en-us/library/system.reflection.constructorinfo.invoke(v=vs.110).aspx
[8]: ConstructorInfo.Invoke Method (Object[]) (System.Reflection) - http://msdn.microsoft.com/en-us/library/6ycw1y17(v=vs.110).aspx

M