C # 'dinâmico' não pode acessar propriedades de tipos anônimos declarados em outro assembly

O código abaixo está funcionando bem, contanto que eu tenha aula ClassSameAssemblyna mesma montagem da classe Program. Mas quando eu movo a classe ClassSameAssemblypara uma montagem separada, um RuntimeBinderException(veja abaixo) é lançado. É possível resolver isso?

using System;

namespace ConsoleApplication2
{
    public static class ClassSameAssembly
    {
        public static dynamic GetValues()
        {
            return new
            {
                Name = "Michael", Age = 20
            };
        }
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            var d = ClassSameAssembly.GetValues();
            Console.WriteLine("{0} is {1} years old", d.Name, d.Age);
        }
    }
}

Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: 'objeto' não contém uma definição para 'Nome'

at CallSite.Target(Closure , CallSite , Object )
at System.Dynamic.UpdateDelegates.UpdateAndExecute1[T0,TRet](CallSite site, T0 arg0)
at ConsoleApplication2.Program.Main(String[] args) in C:\temp\Projects\ConsoleApplication2\ConsoleApplication2\Program.cs:line 23

Eu acredito que o problema é que o tipo anônimo é gerado como internal, então o fichário realmente não "sabe" sobre ele como tal.

Tente usar ExpandoObject em vez disso:

public static dynamic GetValues()
{
    dynamic expando = new ExpandoObject();
    expando.Name = "Michael";
    expando.Age = 20;
    return expando;
}

Eu sei que é um tanto feio, mas é o melhor que consigo pensar no momento ... Não acho que você possa usar um inicializador de objeto com ele, porque embora seja fortemente tipado como ExpandoObjecto compilador não saberá o que fazer com "Nome" e "Idade". Você pode ser capaz de fazer isso:

 dynamic expando = new ExpandoObject()
 {
     { "Name", "Michael" },
     { "Age", 20 }
 };
 return expando;

mas isso não é muito melhor ...

Você poderia potencialmente escrever um método de extensão para converter um tipo anônimo a um expando com o mesmo conteúdo através de reflexão. Então você pode escrever:

return new { Name = "Michael", Age = 20 }.ToExpando();

Mas isso é horrível :(

Você pode usar [assembly: InternalsVisibleTo("YourAssemblyName")]para tornar visíveis os internos da montagem.

Encontrei um problema semelhante e gostaria de acrescentar à resposta de Jon Skeets que há outra opção. A razão pela qual descobri foi que percebi que muitos métodos de extensão no Asp MVC3 usam classes anônimas como entrada para fornecer atributos html (new {alt = "Image alt", style = "padding-top: 5px"} =>

De qualquer forma - essas funções usam o construtor da classe RouteValueDictionary. Eu mesmo tentei fazer isso e, com certeza, funciona - embora apenas o primeiro nível (usei uma estrutura de vários níveis). SO - no código seria:

object o = new {
    name = "theName",
    props = new {
        p1 = "prop1",
        p2 = "prop2"
    }
}
SeparateAssembly.TextFunc(o)

//In SeparateAssembly:
public void TextFunc(Object o) {
  var rvd = new RouteValueDictionary(o);

//Does not work:
Console.WriteLine(o.name);
Console.WriteLine(o.props.p1);

//DOES work!
Console.WriteLine(rvd["name"]);

//Does not work
Console.WriteLine(rvd["props"].p1);
Console.WriteLine(rvd["props"]["p1"]);

ASSIM ... O que realmente está acontecendo aqui? Uma espiada dentro do RouteValueDictionary revela este código (valores ~ = o acima):

foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(values))
    object obj2 = descriptor.GetValue(values);
    //"this.Add" would of course need to be adapted
    this.Add(descriptor.Name, obj2);
}

SO - usando TypeDescriptor.GetProperties (o), poderíamos obter as propriedades e valores apesar do tipo anônimo ser construído como interno em uma montagem separada! E, claro, isso seria muito fácil de estender para torná-lo recursivo. E fazer um método de extensão se você quiser.

Espero que isto ajude!

/Vencedor

Aqui está uma versão rudimentar de um método de extensão para ToExpandoObject que tenho certeza que tem espaço para polimento.

    public static ExpandoObject ToExpandoObject(this object value)
    {
        // Throw is a helper in my project, replace with your own check(s)
        Throw<ArgumentNullException>.If(value, Predicates.IsNull, "value");

        var obj = new ExpandoObject() as IDictionary<string, object>;

        foreach (var property in value.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
        {
            obj.Add(property.Name, property.GetValue(value, null));
        }

        return obj as ExpandoObject;
    }

    [TestCase(1, "str", 10.75, 9.000989, true)]
    public void ToExpandoObjectTests(int int1, string str1, decimal dec1, double dbl1, bool bl1)
    {
        DateTime now = DateTime.Now;

        dynamic value = new {Int = int1, String = str1, Decimal = dec1, Double = dbl1, Bool = bl1, Now = now}.ToExpandoObject();

        Assert.AreEqual(int1, value.Int);
        Assert.AreEqual(str1, value.String);
        Assert.AreEqual(dec1, value.Decimal);
        Assert.AreEqual(dbl1, value.Double);
        Assert.AreEqual(bl1, value.Bool);
        Assert.AreEqual(now, value.Now);
    }

Uma solução mais limpa seria:

var d = ClassSameAssembly.GetValues().ToDynamic();

Que agora é um ExpandoObject.

Lembre-se de fazer referência:

Microsoft.CSharp.dll

Método de extensão ToExpando (mencionado na resposta de Jon) para os corajosos

public static class ExtensionMethods
{
    public static ExpandoObject ToExpando(this object obj)
    {
        IDictionary<string, object> expando = new ExpandoObject();
        foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(obj))
        {
            var value = propertyDescriptor.GetValue(obj);
            expando.Add(propertyDescriptor.Name, value == null || new[]
            {
                typeof (Enum),
                typeof (String),
                typeof (Char),
                typeof (Guid),
                typeof (Boolean),
                typeof (Byte),
                typeof (Int16),
                typeof (Int32),
                typeof (Int64),
                typeof (Single),
                typeof (Double),
                typeof (Decimal),
                typeof (SByte),
                typeof (UInt16),
                typeof (UInt32),
                typeof (UInt64),
                typeof (DateTime),
                typeof (DateTimeOffset),
                typeof (TimeSpan),
            }.Any(oo => oo.IsInstanceOfType(value))
                ? value
                : value.ToExpando());
        }

        return (ExpandoObject)expando;
    }
}

A solução abaixo funcionou para mim em meus projetos de aplicativos de console

Coloque este [assembly: InternalsVisibleTo ("YourAssemblyName")] em \ Properties \ AssemblyInfo.cs do projeto separado com a função que retorna o objeto dinâmico.

"YourAssemblyName" é o nome do assembly do projeto de chamada. Você pode obter isso por meio de Assembly.GetExecutingAssembly (). FullName executando-o na chamada do projeto.

Se você já estiver usando Newtonsoft.Json em seu projeto (ou se estiver disposto a adicioná-lo para essa finalidade), poderá implementar aquele método de extensão horrível ao qual Jon Skeet se refere em sua resposta da seguinte maneira:

public static class ObjectExtensions
{
    public static ExpandoObject ToExpando(this object obj)
        => JsonConvert.DeserializeObject<ExpandoObject>(JsonConvert.SerializeObject(obj));
}