Verifica se una proprietà è disponibile su una variabile dinamica

La mia situazione è molto semplice. Da qualche parte nel mio codice ho questo:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

//How to do this?
if (myVariable.MyProperty.Exists)   
//Do stuff

Quindi, sostanzialmente la mia domanda è come verificare (senza generare un'eccezione) che una determinata proprietà sia disponibile sulla mia variabile dinamica. Potrei farlo, GetType()ma preferirei evitarlo poiché non ho davvero bisogno di conoscere il tipo di oggetto. Tutto quello che voglio davvero sapere è se è disponibile una proprietà (o metodo, se ciò semplifica la vita). Qualche puntatore?

Penso che non ci sia modo di scoprire se una dynamicvariabile ha un determinato membro senza tentare di accedervi, a meno che non sia stata implementata nuovamente la modalità di gestione dell'associazione dinamica nel compilatore C #. Il che probabilmente includerebbe molte ipotesi, perché è definito dall'implementazione, secondo la specifica C #.

Quindi dovresti effettivamente provare ad accedere al membro e prendere un'eccezione, se fallisce:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

try
{
    var x = myVariable.MyProperty;
    // do stuff with x
}
catch (RuntimeBinderException)
{
    //  MyProperty doesn't exist
} 

Ho pensato di fare un confronto tra la risposta di Martijn e la risposta di svick ...

Il seguente programma restituisce i seguenti risultati:

Testing with exception: 2430985 ticks
Testing with reflection: 155570 ticks

void Main()
{
    var random = new Random(Environment.TickCount);

    dynamic test = new Test();

    var sw = new Stopwatch();

    sw.Start();

    for (int i = 0; i < 100000; i++)
    {
        TestWithException(test, FlipCoin(random));
    }

    sw.Stop();

    Console.WriteLine("Testing with exception: " + sw.ElapsedTicks.ToString() + " ticks");

    sw.Restart();

    for (int i = 0; i < 100000; i++)
    {
        TestWithReflection(test, FlipCoin(random));
    }

    sw.Stop();

    Console.WriteLine("Testing with reflection: " + sw.ElapsedTicks.ToString() + " ticks");
}

class Test
{
    public bool Exists { get { return true; } }
}

bool FlipCoin(Random random)
{
    return random.Next(2) == 0;
}

bool TestWithException(dynamic d, bool useExisting)
{
    try
    {
        bool result = useExisting ? d.Exists : d.DoesntExist;
        return true;
    }
    catch (Exception)
    {
        return false;
    }
}

bool TestWithReflection(dynamic d, bool useExisting)
{
    Type type = d.GetType();

    return type.GetProperties().Any(p => p.Name.Equals(useExisting ? "Exists" : "DoesntExist"));
}

Di conseguenza, suggerirei di usare la riflessione. Vedi sotto.

Risposta al commento insipido:

I rapporti sono reflection:exceptiontick per 100000 iterazioni:

Fails 1/1: - 1:43 ticks
Fails 1/2: - 1:22 ticks
Fails 1/3: - 1:14 ticks
Fails 1/5: - 1:9 ticks
Fails 1/7: - 1:7 ticks
Fails 1/13: - 1:4 ticks
Fails 1/17: - 1:3 ticks
Fails 1/23: - 1:2 ticks
...
Fails 1/43: - 1:2 ticks
Fails 1/47: - 1:1 ticks

... abbastanza giusto - se ti aspetti che fallisca con una probabilità con meno di ~ 1/47, allora vai per eccezione.

Quanto sopra presuppone che tu stia funzionando GetProperties()ogni volta. È possibile accelerare il processo memorizzando nella cache il risultato di GetProperties()ciascun tipo in un dizionario o simile. Ciò può essere utile se stai verificando più volte lo stesso set di tipi.

Forse usi la riflessione?

dynamic myVar = GetDataThatLooksVerySimilarButNotTheSame();
Type typeOfDynamic = myVar.GetType();
bool exist = typeOfDynamic.GetProperties().Where(p => p.Name.Equals("PropertyName")).Any(); 

Nel caso in cui aiuti qualcuno:

Se il metodo GetDataThatLooksVerySimilarButNotTheSame()restituisce un ExpandoObject, puoi anche eseguire il cast su un IDictionaryprima di controllare.

dynamic test = new System.Dynamic.ExpandoObject();
test.foo = "bar";

if (((IDictionary<string, object>)test).ContainsKey("foo"))
{
    Console.WriteLine(test.foo);
}

Le due soluzioni comuni a questo includono fare la chiamata e catturare RuntimeBinderException, usando la riflessione per verificare la chiamata, o eseguire la serializzazione in un formato di testo e analizzare da lì. Il problema con le eccezioni è che sono molto lenti, perché quando ne viene costruito uno, lo stack di chiamate corrente viene serializzato. La serializzazione su JSON o qualcosa di analogo comporta una penalità simile. Questo ci lascia con la riflessione ma funziona solo se l'oggetto sottostante è in realtà un POCO con membri reali su di esso. Se si tratta di un wrapper dinamico attorno a un dizionario, un oggetto COM o un servizio Web esterno, la riflessione non sarà di aiuto.

Un'altra soluzione consiste nell'utilizzare il DynamicMetaObjectper ottenere i nomi dei membri come li vede il DLR. Nell'esempio seguente, utilizzo una classe statica ( Dynamic) per verificare il Agecampo e visualizzarlo.

class Program
{
    static void Main()
    {
        dynamic x = new ExpandoObject();

        x.Name = "Damian Powell";
        x.Age = "21 (probably)";

        if (Dynamic.HasMember(x, "Age"))
        {
            Console.WriteLine("Age={0}", x.Age);
        }
    }
}

public static class Dynamic
{
    public static bool HasMember(object dynObj, string memberName)
    {
        return GetMemberNames(dynObj).Contains(memberName);
    }

    public static IEnumerable<string> GetMemberNames(object dynObj)
    {
        var metaObjProvider = dynObj as IDynamicMetaObjectProvider;

        if (null == metaObjProvider) throw new InvalidOperationException(
            "The supplied object must be a dynamic object " +
            "(i.e. it must implement IDynamicMetaObjectProvider)"
        );

        var metaObj = metaObjProvider.GetMetaObject(
            Expression.Constant(metaObjProvider)
        );

        var memberNames = metaObj.GetDynamicMemberNames();

        return memberNames;
    }
}

La risposta di Denis mi ha fatto pensare a un'altra soluzione usando JsonObjects,

un controllo proprietà dell'intestazione:

Predicate<object> hasHeader = jsonObject =>
                                 ((JObject)jsonObject).OfType<JProperty>()
                                     .Any(prop => prop.Name == "header");

o forse meglio:

Predicate<object> hasHeader = jsonObject =>
                                 ((JObject)jsonObject).Property("header") != null;

per esempio:

dynamic json = JsonConvert.DeserializeObject(data);
string header = hasHeader(json) ? json.header : null;

Bene, ho affrontato un problema simile ma nei test unitari.

Utilizzando SharpTestsEx è possibile verificare l'esistenza di una proprietà. Uso questo test sui miei controller, perché poiché l'oggetto JSON è dinamico, qualcuno può cambiare il nome e dimenticare di cambiarlo nel javascript o qualcosa del genere, quindi testare tutte le proprietà quando si scrive il controller dovrebbe aumentare la mia sicurezza.

Esempio:

dynamic testedObject = new ExpandoObject();
testedObject.MyName = "I am a testing object";

Ora, usando SharTestsEx:

Executing.This(delegate {var unused = testedObject.MyName; }).Should().NotThrow();
Executing.This(delegate {var unused = testedObject.NotExistingProperty; }).Should().Throw();

Usando questo, collaudo tutte le proprietà esistenti usando "Should (). NotThrow ()".

Probabilmente è fuori tema, ma può essere utile per qualcuno.

Seguendo la risposta di @karask, potresti avvolgere la funzione come aiuto in questo modo:

public static bool HasProperty(ExpandoObject expandoObj,
                               string name)
{
    return ((IDictionary<string, object>)expandoObj).ContainsKey(name);
}

Per me questo funziona:

if (IsProperty(() => DynamicObject.MyProperty))
  ; // do stuff



delegate string GetValueDelegate();

private bool IsProperty(GetValueDelegate getValueMethod)
{
    try
    {
        //we're not interesting in the return value.
        //What we need to know is whether an exception occurred or not

        var v = getValueMethod();
        return v != null;
    }
    catch (RuntimeBinderException)
    {
        return false;
    }
    catch
    {
        return true;
    }
}

Se controlli il tipo utilizzato come dinamico, non potresti restituire una tupla anziché un valore per ogni accesso alla proprietà? Qualcosa di simile a...

public class DynamicValue<T>
{
    internal DynamicValue(T value, bool exists)
    {
         Value = value;
         Exists = exists;
    }

    T Value { get; private set; }
    bool Exists { get; private set; }
}

Forse un'implementazione ingenua, ma se costruisci uno di questi internamente ogni volta e restituisci quello invece del valore effettivo, puoi controllare Existsogni accesso alla proprietà e poi premere Valuese lo fa con valore essendo default(T)(e irrilevante) se non lo fa.

Detto questo, potrei mancare alcune conoscenze su come funziona la dinamica e questo potrebbe non essere un suggerimento praticabile.

Nel mio caso, dovevo verificare l'esistenza di un metodo con un nome specifico, quindi ho usato un'interfaccia per quello

var plugin = this.pluginFinder.GetPluginIfInstalled<IPlugin>(pluginName) as dynamic;
if (plugin != null && plugin is ICustomPluginAction)
{
    plugin.CustomPluginAction(action);
}

Inoltre, le interfacce possono contenere più di semplici metodi:

Le interfacce possono contenere metodi, proprietà, eventi, indicizzatori o qualsiasi combinazione di questi quattro tipi di membri.

Da: interfacce (Guida per programmatori C #)

Elegante e non c'è bisogno di intrappolare le eccezioni o giocare con la riflessione ...

So che questo è un post molto vecchio, ma qui è una soluzione semplice per lavorare con il dynamictipo c#.

1. può usare una semplice riflessione per enumerare le proprietà dirette
2. o può usare il objectmetodo di estensione
3. oppure usa il GetAsOrDefault<int>metodo per ottenere un nuovo oggetto fortemente tipizzato con valore se esiste o predefinito se non esiste.

public static class DynamicHelper
{
    private static void Test( )
    {
        dynamic myobj = new
                        {
                            myInt = 1,
                            myArray = new[ ]
                                      {
                                          1, 2.3
                                      },
                            myDict = new
                                     {
                                         myInt = 1
                                     }
                        };

        var myIntOrZero = myobj.GetAsOrDefault< int >( ( Func< int > )( ( ) => myobj.noExist ) );
        int? myNullableInt = GetAs< int >( myobj, ( Func< int > )( ( ) => myobj.myInt ) );

        if( default( int ) != myIntOrZero )
            Console.WriteLine( $"myInt: '{myIntOrZero}'" );

        if( default( int? ) != myNullableInt )
            Console.WriteLine( $"myInt: '{myNullableInt}'" );

        if( DoesPropertyExist( myobj, "myInt" ) )
            Console.WriteLine( $"myInt exists and it is: '{( int )myobj.myInt}'" );
    }

    public static bool DoesPropertyExist( dynamic dyn, string property )
    {
        var t = ( Type )dyn.GetType( );
        var props = t.GetProperties( );
        return props.Any( p => p.Name.Equals( property ) );
    }

    public static object GetAs< T >( dynamic obj, Func< T > lookup )
    {
        try
        {
            var val = lookup( );
            return ( T )val;
        }
        catch( RuntimeBinderException ) { }

        return null;
    }

    public static T GetAsOrDefault< T >( this object obj, Func< T > test )
    {
        try
        {
            var val = test( );
            return ( T )val;
        }
        catch( RuntimeBinderException ) { }

        return default( T );
    }
}

Come ExpandoObjecteredita IDictionary<string, object>è possibile utilizzare il seguente controllo

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

if (((IDictionary<string, object>)myVariable).ContainsKey("MyProperty"))    
//Do stuff

È possibile creare un metodo di utilità per eseguire questo controllo, che renderà il codice molto più pulito e riutilizzabile

Ecco l'altro modo:

using Newtonsoft.Json.Linq;

internal class DymanicTest
{
    public static string Json = @"{
            ""AED"": 3.672825,
            ""AFN"": 56.982875,
            ""ALL"": 110.252599,
            ""AMD"": 408.222002,
            ""ANG"": 1.78704,
            ""AOA"": 98.192249,
            ""ARS"": 8.44469
}";

    public static void Run()
    {
        dynamic dynamicObject = JObject.Parse(Json);

        foreach (JProperty variable in dynamicObject)
        {
            if (variable.Name == "AMD")
            {
                var value = variable.Value;
            }
        }
    }
}