C # 'डायनामिक' अन्य विधानसभा में घोषित गुमनाम प्रकारों से संपत्तियों तक नहीं पहुंच सकता है

Question 1

नीचे दिए गए कोड तब तक अच्छी तरह से काम कर रहे हैं जब तक कि मेरे पास क्लास 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

Question 2

मेरा मानना है कि समस्या यह है कि अनाम प्रकार के रूप में उत्पन्न होता है 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();

हालांकि यह बहुत भयानक है :(

Question 3

आप का उपयोग [assembly: InternalsVisibleTo("YourAssemblyName")]कर सकते हैं आप विधानसभा आंतरिक दिखाई देने के लिए।

Question 4

मैं एक similair समस्या में भाग गया और जॉन स्कीट्स के जवाब में जोड़ना चाहूंगा कि एक और विकल्प है। इसका कारण मुझे पता चला कि मुझे एहसास हुआ कि एस्प एमवीसी 3 में कई विस्तार विधियाँ html विशेषताएँ प्रदान करने के लिए इनपुट के रूप में अनाम कक्षाओं का उपयोग करती हैं (नई {alt = "छवि ऊंचाई", शैली = "पैडिंग-टॉप: 5 पीएक्स"}} =>

वैसे भी - उन कार्यों में रूटवैल्यूडर क्लास के कंस्ट्रक्टर का उपयोग किया जाता है। मैंने खुद कोशिश की, और निश्चित रूप से यह काम करता है - हालांकि केवल पहला स्तर (मैंने एक बहु-स्तरीय संरचना का उपयोग किया है)। एसओ - कोड में यह होगा:

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

तो ... वास्तव में यहाँ क्या हो रहा है? रूटवैल्यूडॉर के अंदर एक झांकने से इस कोड (मान ~ = 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);
}

SO - TypeDescriptor.GetProperties (o) का उपयोग करके हम एक अलग असेंबली में आंतरिक के रूप में निर्मित किए जा रहे अनाम प्रकार के बावजूद गुण और मान प्राप्त कर सकेंगे! और निश्चित रूप से इसे पुनरावर्ती बनाने के लिए विस्तार करना काफी आसान होगा। और यदि आप चाहते हैं तो एक विस्तार विधि बनाने के लिए।

उम्मीद है की यह मदद करेगा!

/ विक्टर

Question 5

यहाँ 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);
    }

Question 6

एक क्लीनर समाधान होगा:

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

जो अब एक ExpandoObject है।

संदर्भ के लिए याद रखें:

Microsoft.CSharp.dll

Question 7

नीचे दिए गए समाधान ने मेरे कंसोल एप्लिकेशन प्रोजेक्ट्स में मेरे लिए काम किया

इस [असेंबली: इंटरनैशनलविजेंटलो ("YourAssemblyName")] को अलग-अलग प्रोजेक्ट के in \ गुण \ फंक्शन में डायनामिक ऑब्जेक्ट लौटाते हुए डालें।

"YourAssemblyName" कॉलिंग प्रोजेक्ट का असेंबली नाम है। आप असेंबली के माध्यम से प्राप्त कर सकते हैं। GetExecutingAssembly ()। फुलनाम को कॉलिंग प्रोजेक्ट में निष्पादित करके।

Question 8

बहादुर लोगों के लिए 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;
    }
}

Question 9

यदि आप पहले से ही अपने प्रोजेक्ट में Newtonsoft.Json का उपयोग कर रहे हैं (या आप इसे इस उद्देश्य के लिए जोड़ना चाहते हैं), तो आप उस भयानक एक्सटेंशन विधि को लागू कर सकते हैं जो जॉन स्कीट इस तरह से अपने उत्तर में कर रहा है :

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