valid - summary param name c#

Devuelve/consume tipo anónimo dinámico a través de los límites de la asamblea

Question

El siguiente código funciona muy bien. Si los métodos Get y Use están en ensamblajes diferentes, el código falla con una RuntimeBinderException. Esto se debe a que el sistema de tiempo de ejecución .Net solo garantiza el carácter común de los tipos anónimos ( <string, int> en este caso) dentro de los ensamblados.

¿Hay alguna manera de engañar al sistema de tiempo de ejecución para superar esto? Puedo inspeccionar el objeto en el depurador en el lado de Use , y el depurador puede ver las propiedades relevantes.

class Program
{
    static void Main(string[] args)
    {
        UsePerson();
        Console.ReadLine();
    }

    public static void UsePerson()
    {
        var person = GetPerson();

        Console.WriteLine(person.Name);
    }

    public static dynamic GetPerson()
    {
        return new { Name = "Foo", Age = 30 };
    }
}

Answer 1

Aquí hay una solución para un pobre hombre; Newtonsoft.Json al rescate, ya que la serialización de ida y vuelta genera instancias de tipo dinámico visibles para su ensamblado / trabajo.

public static class TypeExt
{
  // roundtrip json serialization to enable access to dynamic members and properties originating from another assembly
  public static T JClone<T>( this T source ) { return JsonConvert.DeserializeObject<T>( JsonConvert.SerializeObject( source ) ); }
}

Answer 2

La causa del problema es que los tipos anónimos son internos a las asambleas. Es por eso que Dynamic Language Runtime no le permite acceder a las propiedades de otro ensamblaje.

Una solución se explica en esta post . Puede poner un atributo personalizado en el ensamblaje que define el tipo anónimo permitiendo que el otro ensamble acceda a sus partes internas.

Otra solución es devolver un objeto de una clase pública (con propiedades públicas). Eso, por supuesto, matará las ventajas del tipo anónimo.

Una tercera solución sería usar un ExpandoObject como lo sugiere Reed Copsey .

Si aún desea usar el tipo anónimo, podría escribir una clase dinámica que "decore" cualquier tipo anónimo y exponga a sus miembros. Tal clase tendría que implementar la interfaz IDynamicMetaObjectProvider y acceder al objeto decorado a través de la reflexión. Posiblemente, esto ya fue implementado por alguien allá afuera.

Answer 3

Otra buena solución podría ser utilizar tuplas, que se introdujeron en .Net 4: http://msdn.microsoft.com/en-us/library/dd268536.aspx

Answer 4

Use un ExpandoObject lugar de un tipo anónimo. Esto debería permitirle cruzar los límites de la instalación de forma segura:

public static dynamic GetPerson()
{
    dynamic person = new ExpandoObject();
    person.Name = "Foo";
    person.Age = 30;

    return person;
}

En general, los tipos anónimos solo deberían usarse en el mismo método en el que se generan. Devolver un tipo anónimo de un método es, en general, causar más problemas de los que resuelve.

Answer 5

interfaz improvisada

http://code.google.com/p/impromptu-interface/

Te permitirá usar la instancia de tipo anónimo más allá de los límites, pero debes declarar una interfaz que coincida con su firma o al menos a la que quieras acceder desde su firma.