C # 'dinamik', başka bir derlemede bildirilen anonim türlerdeki özelliklere erişemez

Aşağıdaki kod, sınıfla ClassSameAssemblyaynı derlemede sınıfım olduğu sürece iyi çalışıyor Program. Ancak sınıfı ClassSameAssemblyayrı bir derlemeye taşıdığımda , a RuntimeBinderException(aşağıya bakın) atılıyor. Çözmek mümkün mü?

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: 'nesne', 'Ad' için bir tanım içermiyor

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

Sorunun, anonim tipin olarak oluşturulduğuna inanıyorum internal, bu yüzden bağlayıcı gerçekten "bilmiyor".

Bunun yerine ExpandoObject kullanmayı deneyin:

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

Bunun biraz çirkin olduğunu biliyorum, ama şu anda düşünebildiğim en iyisi ... Onunla bir nesne başlatıcı bile kullanabileceğinizi sanmıyorum, çünkü güçlü bir şekilde yazılmışken ExpandoObjectderleyici ne yapacağını bilemeyecek "Ad" ve "Yaş" ile. Bunu yapabilirsiniz :

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

ama bu daha iyi değil ...

Sen olabilir , potansiyel olarak yansıma yoluyla aynı içerikli bir EXPANDO isimsiz bir türünü dönüştürmek için bir uzantısı yöntem yazmak. O zaman yazabilirsin:

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

Yine de bu oldukça korkunç :(

[assembly: InternalsVisibleTo("YourAssemblyName")]Montaj iç elemanlarını görünür kılmak için kullanabilirsiniz .

Benzer bir problemle karşılaştım ve Jon Skeets'in cevabına başka bir seçenek daha olduğunu eklemek istiyorum. Bulmamın nedeni, Asp MVC3'teki birçok uzantı yönteminin html öznitelikleri sağlamak için giriş olarak anonim sınıfları kullandığını fark etmemdi (yeni {alt = "Image alt", style = "padding-top: 5px"} =>

Her neyse - bu işlevler RouteValueDictionary sınıfının yapıcısını kullanır. Bunu kendim denedim ve kesinlikle işe yarıyor - sadece ilk seviye olsa da (çok seviyeli bir yapı kullandım). SO - kodda bu şöyle olacaktır:

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

SO ... Burada gerçekten neler oluyor? RouteValueDictionary içine bir göz atmak bu kodu gösterir (yukarıdaki ~ = o değerleri):

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 - TypeDescriptor.GetProperties (o) kullanarak, anonim tip ayrı bir derlemede dahili olarak inşa edilmesine rağmen özellikleri ve değerleri elde edebilirdik! Ve elbette bunu yinelemeli hale getirmek için genişletmek oldukça kolay olacaktır. Ve isterseniz bir uzatma yöntemi yapmak.

Bu yardımcı olur umarım!

/ Victor

İşte ToExpandoObject için bir uzatma yönteminin ilkel bir versiyonu, eminim ki parlatma için yer vardır.

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

Daha temiz bir çözüm şu şekilde olacaktır:

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

Bu artık bir ExpandoObject.

Referans vermeyi unutmayın:

Microsoft.CSharp.dll

Konsol uygulama projelerimde aşağıdaki çözüm benim için çalıştı

Bu [assembly: InternalsVisibleTo ("YourAssemblyName")] işlevini dinamik nesne döndüren ayrı bir projenin \ Properties \ AssemblyInfo.cs içine koyun.

"YourAssemblyName", çağıran projenin derleme adıdır. Bunu Assembly.GetExecutingAssembly (). FullName aracılığıyla proje çağrısında çalıştırarak elde edebilirsiniz.

Cesur olanlar için ToExpando uzatma yöntemi (Jon'un cevabında bahsedilmiştir)

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

Projenizde zaten Newtonsoft.Json kullanıyorsanız (veya bu amaçla eklemeye istekliyseniz), Jon Skeet'in şu şekilde yanıtında bahsettiği o korkunç genişletme yöntemini uygulayabilirsiniz :

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