C # 'динамічний' не може отримати доступ до властивостей анонімних типів, оголошених в іншій збірці

Наведений нижче код працює добре, якщо я маю клас ClassSameAssemblyв тій самій збірці, що і клас Program. Але коли я переношу клас ClassSameAssemblyв окрему збірку, RuntimeBinderExceptionвикидається (див. Нижче). Чи можна це вирішити?

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: "об'єкт" не містить визначення "Ім'я"

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

Я вважаю, що проблема полягає в тому, що анонімний тип генерується як internal, тому сполучна речовина насправді не "знає" про нього як такого.

Спробуйте замість цього використовувати ExpandoObject:

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

Я знаю, що це трохи потворно, але це найкраще, що я можу придумати на даний момент ... Я не думаю, що ви навіть можете використовувати з ним ініціалізатор об'єкта, тому що, хоча він набраний сильно, оскільки ExpandoObjectкомпілятор не знатиме, що робити з "Ім'я" та "Вік". Ви можете зробити це:

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

але це не набагато краще ...

Ви потенційно можете написати метод розширення для перетворення анонімного типу в експандон із однаковим вмістом за допомогою відображення. Тоді ви могли написати:

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

Це досить жахливо :(

Ви можете використовувати, [assembly: InternalsVisibleTo("YourAssemblyName")]щоб зробити внутрішні елементи збірки видимими.

Я зіткнувся з подібною проблемою і хотів би додати до Джона Скітса відповідь, що є ще один варіант. Причиною, яку я дізнався, було те, що я зрозумів, що багато методів розширення в Asp MVC3 використовують анонімні класи як вхідні дані для надання атрибутів html (new {alt = "Image alt", style = "padding-top: 5px"} =>

У будь-якому випадку - ці функції використовують конструктор класу RouteValueDictionary. Я спробував це сам, і, звичайно, це працює - хоча лише перший рівень (я використовував багаторівневу структуру). ТАК - у коді це буде:

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"]);

ТАК ... Що тут насправді відбувається? Зазирнути всередину RouteValueDictionary розкриває цей код (значення ~ = o вище):

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);
}

ТАК - за допомогою TypeDescriptor.GetProperties (o) ми змогли б отримати властивості та значення, незважаючи на те, що анонімний тип будується як внутрішній в окремій збірці! І, звичайно, це було б досить легко розширити, щоб зробити його рекурсивним. І зробити метод розширення, якщо хочете.

Сподіваюся, це допомагає!

/ Віктор

Ось елементарна версія методу розширення для ToExpandoObject, який, я впевнений, має місце для полірування.

    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);
    }

Більш чистим рішенням буде:

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

Що зараз є ExpandoObject.

Не забувайте посилатися:

Microsoft.CSharp.dll

Наведене нижче рішення працювало для мене в проектах консольних додатків

Помістіть цей [Assembly: InternalsVisibleTo ("YourAssemblyName")] в \ Properties \ AssemblyInfo.cs окремого проекту з функцією, що повертає динамічний об'єкт.

"YourAssemblyName" - це назва збірки проекту, що викликає. Ви можете отримати це через Assembly.GetExecutingAssembly (). FullName, виконавши його у виклику проекту.

Метод розширення ToExpando (згаданий у відповіді Джона) для сміливих

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;
    }
}

Якщо ви вже використовуєте Newtonsoft.Json у своєму проекті (або ви готові додати його для цієї мети), ви можете реалізувати той жахливий метод розширення, на який посилається Джон Скіт у своїй відповіді так:

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