Wie erkenne ich, ob eine Eigenschaft in einem ExpandoObject vorhanden ist?

In Javascript können Sie mithilfe des undefinierten Schlüsselworts feststellen, ob eine Eigenschaft definiert ist:

if( typeof data.myProperty == "undefined" ) ...

Wie würden Sie dies in C # tun, indem Sie das dynamische Schlüsselwort mit ExpandoObjectund ohne Ausnahmebedingung verwenden?

Laut MSDN zeigt die Erklärung, dass IDictionary implementiert wird:

public sealed class ExpandoObject : IDynamicMetaObjectProvider, 
    IDictionary<string, Object>, ICollection<KeyValuePair<string, Object>>, 
    IEnumerable<KeyValuePair<string, Object>>, IEnumerable, INotifyPropertyChanged

Sie können dies verwenden, um festzustellen, ob ein Mitglied definiert ist:

var expandoObject = ...;
if(((IDictionary<String, object>)expandoObject).ContainsKey("SomeMember")) {
    // expandoObject.SomeMember exists.
}

Hier muss eine wichtige Unterscheidung getroffen werden.

Die meisten Antworten hier beziehen sich speziell auf das ExpandoObject, das in der Frage erwähnt wird. Eine häufige Verwendung (und ein Grund, bei der Suche auf diese Frage zu stoßen) ist die Verwendung des ASP.Net MVC ViewBag. Dies ist eine benutzerdefinierte Implementierung / Unterklasse von DynamicObject, die keine Ausnahme auslöst, wenn Sie einen beliebigen Eigenschaftsnamen auf null prüfen. Angenommen, Sie deklarieren eine Eigenschaft wie:

@{
    ViewBag.EnableThinger = true;
}

Angenommen, Sie möchten den Wert überprüfen und prüfen, ob er überhaupt festgelegt ist - ob er vorhanden ist. Folgendes ist gültig, wird kompiliert, wirft keine Ausnahmen und gibt Ihnen die richtige Antwort:

if (ViewBag.EnableThinger != null && ViewBag.EnableThinger)
{
    // Do some stuff when EnableThinger is true
}

Entfernen Sie jetzt die Deklaration von EnableThinger. Der gleiche Code wird kompiliert und ordnungsgemäß ausgeführt. Keine Notwendigkeit zum Nachdenken.

Im Gegensatz zu ViewBag wird ExpandoObject ausgelöst, wenn Sie eine nicht vorhandene Eigenschaft auf Null prüfen. Um die sanftere Funktionalität von MVC ViewBag aus Ihren dynamicObjekten herauszuholen , müssen Sie eine Implementierung von Dynamic verwenden, die nicht funktioniert.

Sie können einfach die genaue Implementierung in MVC ViewBag verwenden:

. . .
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
    result = ViewData[binder.Name];
    // since ViewDataDictionary always returns a result even if the key does not exist, always return true
    return true;
}
. . .

https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Mvc/DynamicViewDataDictionary.cs

Sie können sehen, dass es in MVC Views hier in MVC ViewPage eingebunden ist:

http://aspnetwebstack.codeplex.com/SourceControl/latest#src/System.Web.Mvc/ViewPage.cs

Der Schlüssel für das elegante Verhalten von DynamicViewDataDictionary ist die Dictionary-Implementierung in ViewDataDictionary.

public object this[string key]
{
    get
    {
        object value;
        _innerDictionary.TryGetValue(key, out value);
        return value;
    }
    set { _innerDictionary[key] = value; }
}

https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Mvc/ViewDataDictionary.cs

Mit anderen Worten, es gibt immer einen Wert für alle Schlüssel zurück, unabhängig davon, was darin enthalten ist - es gibt einfach null zurück, wenn nichts da ist. ViewDataDictionary muss jedoch an das MVC-Modell gebunden sein. Daher ist es besser, nur die eleganten Wörterbuchteile für die Verwendung außerhalb von MVC Views zu entfernen.

Es ist zu lang, um wirklich alle Eingeweide hier zu veröffentlichen - das meiste davon implementiert nur IDictionary -, aber hier ist ein dynamisches Objekt (Klasse DDict), das keine Nullprüfungen für nicht deklarierte Eigenschaften auf Github auslöst:

https://github.com/b9chris/GracefulDynamicDictionary

Wenn Sie es nur über NuGet zu Ihrem Projekt hinzufügen möchten, heißt es GracefulDynamicDictionary .

Ich habe kürzlich eine sehr ähnliche Frage beantwortet: Wie reflektiere ich über die Mitglieder eines dynamischen Objekts?

In Kürze ist ExpandoObject nicht das einzige dynamische Objekt, das Sie erhalten könnten. Die Reflexion würde für statische Typen funktionieren (Typen, die IDynamicMetaObjectProvider nicht implementieren). Für Typen, die diese Schnittstelle implementieren, ist die Reflexion grundsätzlich nutzlos. Bei ExpandoObject können Sie einfach überprüfen, ob die Eigenschaft als Schlüssel im zugrunde liegenden Wörterbuch definiert ist. Bei anderen Implementierungen kann dies eine Herausforderung sein, und manchmal besteht die einzige Möglichkeit darin, mit Ausnahmen zu arbeiten. Für Details folgen Sie dem Link oben.

AKTUALISIERT: Sie können Delegaten verwenden und versuchen, einen Wert aus der dynamischen Objekteigenschaft abzurufen, falls vorhanden. Wenn keine Eigenschaft vorhanden ist, fangen Sie einfach die Ausnahme ab und geben Sie false zurück.

Schau mal, es funktioniert gut für mich:

class Program
{
    static void Main(string[] args)
    {
        dynamic userDynamic = new JsonUser();

        Console.WriteLine(IsPropertyExist(() => userDynamic.first_name));
        Console.WriteLine(IsPropertyExist(() => userDynamic.address));
        Console.WriteLine(IsPropertyExist(() => userDynamic.last_name));
    }

    class JsonUser
    {
        public string first_name { get; set; }
        public string address
        {
            get
            {
                throw new InvalidOperationException("Cannot read property value");
            }
        }
    }

    static bool IsPropertyExist(GetValueDelegate getValueMethod)
    {
        try
        {
            //we're not interesting in the return value. What we need to know is whether an exception occurred or not
            getValueMethod();
            return true;
        }
        catch (RuntimeBinderException)
        {
            // RuntimeBinderException occurred during accessing the property
            // and it means there is no such property         
            return false;
        }
        catch
        {
            //property exists, but an exception occurred during getting of a value
            return true;
        }
    }

    delegate string GetValueDelegate();
}

Die Ausgabe des Codes ist die folgende:

True
True
False

Ich wollte eine Erweiterungsmethode erstellen , damit ich Folgendes tun kann:

dynamic myDynamicObject;
myDynamicObject.propertyName = "value";

if (myDynamicObject.HasProperty("propertyName"))
{
    //...
}

... aber Sie können keine Erweiterungen ExpandoObjectgemäß der C # 5-Dokumentation erstellen (weitere Informationen hier ).

Also habe ich einen Klassenhelfer geschaffen:

public static class ExpandoObjectHelper
{
    public static bool HasProperty(ExpandoObject obj, string propertyName)
    {
        return ((IDictionary<String, object>)obj).ContainsKey(propertyName);
    }
}

Um es zu benutzen:

// If the 'MyProperty' property exists...
if (ExpandoObjectHelper.HasProperty(obj, "MyProperty"))
{
    ...
}

Warum möchten Sie Reflection nicht verwenden, um eine Reihe von Typ-Eigenschaften zu erhalten? So was

 dynamic v = new Foo();
 Type t = v.GetType();
 System.Reflection.PropertyInfo[] pInfo =  t.GetProperties();
 if (Array.Find<System.Reflection.PropertyInfo>(pInfo, p => { return p.Name == "PropName"; }).    GetValue(v,  null) != null))
 {
     //PropName initialized
 } 

Diese Erweiterungsmethode prüft, ob eine Eigenschaft vorhanden ist, und gibt dann den Wert oder null zurück. Dies ist nützlich, wenn Sie nicht möchten, dass Ihre Anwendungen unnötige Ausnahmen auslösen, zumindest solche, denen Sie helfen können.

    public static object Value(this ExpandoObject expando, string name)
    {
        var expandoDic = (IDictionary<string, object>)expando;
        return expandoDic.ContainsKey(name) ? expandoDic[name] : null;
    }

Wenn als solches verwendet werden kann:

  // lookup is type 'ExpandoObject'
  object value = lookup.Value("MyProperty");

oder wenn Ihre lokale Variable 'dynamisch' ist, müssen Sie sie zuerst in ExpandoObject umwandeln.

  // lookup is type 'dynamic'
  object value = ((ExpandoObject)lookup).Value("PropertyBeingTested");

Abhängig von Ihrem Anwendungsfall können Sie Ihr ExpandoObject in ein DynamicJsonObject verwandeln, wenn null als mit undefiniert identisch angesehen werden kann.

    dynamic x = new System.Web.Helpers.DynamicJsonObject(new ExpandoObject());
    x.a = 1;
    x.b = 2.50;
    Console.WriteLine("a is " + (x.a ?? "undefined"));
    Console.WriteLine("b is " + (x.b ?? "undefined"));
    Console.WriteLine("c is " + (x.c ?? "undefined"));

Ausgabe:

a is 1
b is 2.5
c is undefined

(authorDynamic as ExpandoObject).Any(pair => pair.Key == "YourProp");

Hey Leute, hört auf, Reflection für alles zu verwenden, was viele CPU-Zyklen kostet.

Hier ist die Lösung:

public class DynamicDictionary : DynamicObject
{
    Dictionary<string, object> dictionary = new Dictionary<string, object>();

    public int Count
    {
        get
        {
            return dictionary.Count;
        }
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        string name = binder.Name;

        if (!dictionary.TryGetValue(binder.Name, out result))
            result = "undefined";

        return true;
    }

    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        dictionary[binder.Name] = value;
        return true;
    }
}

Probier diese

public bool PropertyExist(object obj, string propertyName)
{
 return obj.GetType().GetProperty(propertyName) != null;
}