c# - tipos - ¿Hay alguna manera de probar si una variable es dinámica?

variable local c#

Question

El siguiente fragmento de código siempre devolverá verdadero a menos que la variable v sea null :

v is dynamic

y la siguiente prueba no se compilará ("El operador typeof no se puede usar en el tipo dinámico"):

v.GetType() == typeof(dynamic)

Entonces, ¿hay una manera de probar si la variable es dynamic ?

Answer 1

@nawfal Lamentablemente, su método de extensión falla cuando se pasa cualquier clase de poco normal que no es dinámica.

La solución propuesta de @Marc Gravell es correcta. Creo que la confusión radica en el hecho de que aunque puedes declarar algo como dinámico. Sin embargo, cuando se crea una instancia de una clase concreta, ya no es realmente dinámico. Aquí hay algunas pruebas que tiré en él. Sólo deben pasar test2 y test3. Puede probarlo aún más intentando establecer alguna propiedad que no existe en cada dinámica. Lo que provocará una excepción en la dinámica no dinámica. :)

class Program
{
private class MyDynamic: DynamicObject
{
}
static void Main(string[] args)
{
dynamic test1 = new { Name = "Tim" };
//although I used the dynamic keyword here, it is NOT dynamic. dynamics are only dynamics if they support dynamically adding properties
//uncommenting this line will cause an exception
//test.LastName = "Jones"
if (test1 is IDynamicMetaObjectProvider) { Console.WriteLine("test1"); }
dynamic test2 = new MyDynamic();
if (test2 is IDynamicMetaObjectProvider) { Console.WriteLine("test2"); }
dynamic test3 = new ExpandoObject();
if (test3 is IDynamicMetaObjectProvider) { Console.WriteLine("test3"); }
dynamic test4 = new List<string>();
if (test4 is IDynamicMetaObjectProvider) { Console.WriteLine("test4"); }
}
}

Answer 2

En C # dinámico significa que no hay verificación de tiempo de cumplimiento y tendrá el tipo del otro lado del símbolo =. Sin embargo, GetType es una evaluación en tiempo de ejecución, por lo que siempre se recuperará el tipo declarado y no dinámico.

Puede leer un poco más aquí: http://msdn.microsoft.com/en-us/magazine/gg598922.aspx

Answer 3

En primer lugar, es necesario separar la variable y el objeto. Una variable es dinámica si se define como dynamic . Eso es todo. No hay nada mas. Un campo o propiedad se anotaría con el atributo [Dynamic] , es decir,

public dynamic Foo {get;set;}

es en realidad:

[Dynamic]
public object Foo {get;set;}

Básicamente, esto actúa como un mensaje para que el compilador acceda al objeto a través de la API dynamic lugar de hacerlo a través de la API OOP.

Un objeto admite capacidades dynamic completas si implementa IDynamicMetaObjectProvider ; sin embargo, se puede acceder a un objeto de este tipo tanto a través de la API dynamic como a través de la API OOP regular (puede tener ambas). Igualmente, se puede acceder a un objeto que no implementa IDynamicMetaObjectProvider a través de cualquiera de las API (pero: solo los miembros públicos estarán disponibles a través de dynamic ).

Answer 4

No hay ningún tipo de CLR llamado dynamic . El compilador de C # crea todos dynamic valores dynamic del tipo de object y luego llama al código de enlace personalizado para averiguar cómo manejarlos. Si se utilizó la dynamic , se mostrará como Object .

Pero puede verificar si una instancia es del tipo IDynamicMetaObjectProvider o puede verificar si el tipo implementa IDynamicMetaObjectProvider

Answer 5

Siempre habrá un tipo de tiempo de ejecución como han dicho otros.

Hay un truco para detectar variables locales, basándose en el hecho de que las variables dinámicas no admiten métodos de extensión.

static void DummyDynamicTest<T>(this T t) //extension method
{
}
dynamic test = 1;
try
{
test.DummyDynamicTest();
//not dynamic
}
catch (RuntimeBinderException)
{
//dynamic
}

Sin embargo, no puede refactorizar la funcionalidad en otro método. Esto no puede ser muy útil en ningún caso significativo, ignorarlo a cualquier costo.