Tester si une propriété est disponible sur une variable dynamique

Ma situation est très simple. Quelque part dans mon code, j'ai ceci:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

Donc, fondamentalement, ma question est de savoir comment vérifier (sans lever d'exception) qu'une certaine propriété est disponible sur ma variable dynamique. Je pourrais le faire GetType()mais je préfère éviter cela car je n'ai pas vraiment besoin de connaître le type d'objet. Tout ce que je veux vraiment savoir, c'est si une propriété (ou une méthode, si cela facilite la vie) est disponible. Des pointeurs?

Je pense qu'il n'y a aucun moyen de savoir si une dynamicvariable a un certain membre sans essayer d'y accéder, à moins que vous n'ayez réimplémenté la façon dont la liaison dynamique est gérée dans le compilateur C #. Ce qui inclurait probablement beaucoup de suppositions, car il est défini par l'implémentation, selon la spécification C #.

Vous devriez donc essayer d'accéder au membre et intercepter une exception, s'il échoue:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

Je pensais que je ferais une comparaison de la réponse de Martijn et la réponse de svick ...

Le programme suivant renvoie les résultats suivants:

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

En conséquence, je suggère d'utiliser la réflexion. Voir ci-dessous.

Répondant au commentaire insipide:

Les ratios sont des reflection:exceptiongraduations pour 100 000 itérations:

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

... assez juste - si vous vous attendez à ce qu'il échoue avec une probabilité inférieure à ~ 1/47, optez pour l'exception.

Ce qui précède suppose que vous courez à GetProperties()chaque fois. Vous pourrez peut-être accélérer le processus en mettant en cache le résultat de GetProperties()chaque type dans un dictionnaire ou similaire. Cela peut être utile si vous comparez sans cesse le même ensemble de types.

Peut-être utiliser la réflexion?

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

Juste au cas où cela aiderait quelqu'un:

Si la méthode GetDataThatLooksVerySimilarButNotTheSame()renvoie un, ExpandoObjectvous pouvez également transtyper en un IDictionaryavant de vérifier.

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

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

Les deux solutions courantes à cela incluent l'appel et la capture RuntimeBinderException, l'utilisation de la réflexion pour vérifier l'appel, ou la sérialisation au format texte et l'analyse à partir de là. Le problème avec les exceptions est qu'elles sont très lentes, car lorsqu'une est construite, la pile d'appels actuelle est sérialisée. La sérialisation vers JSON ou quelque chose d'analogue entraîne une pénalité similaire. Cela nous laisse avec réflexion mais cela ne fonctionne que si l'objet sous-jacent est en fait un POCO avec de vrais membres dessus. S'il s'agit d'un wrapper dynamique autour d'un dictionnaire, d'un objet COM ou d'un service Web externe, la réflexion n'aidera pas.

Une autre solution consiste à utiliser le DynamicMetaObjectpour obtenir les noms des membres tels que le DLR les voit. Dans l'exemple ci-dessous, j'utilise une classe statique ( Dynamic) pour tester le Agechamp et l'afficher.

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 réponse de Denis m'a fait penser à une autre solution utilisant JsonObjects,

un vérificateur de propriété d'en-tête:

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

ou peut-être mieux:

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

par exemple:

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

Eh bien, j'ai fait face à un problème similaire mais lors de tests unitaires.

En utilisant SharpTestsEx, vous pouvez vérifier si une propriété existe. J'utilise cela pour tester mes contrôleurs, car comme l'objet JSON est dynamique, quelqu'un peut changer le nom et oublier de le changer dans le javascript ou quelque chose, donc tester toutes les propriétés lors de l'écriture du contrôleur devrait augmenter ma sécurité.

Exemple:

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

Maintenant, en utilisant SharTestsEx:

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

En utilisant cela, je teste toutes les propriétés existantes en utilisant "Should (). NotThrow ()".

C'est probablement hors sujet, mais peut être utile à quelqu'un.

À la suite de la réponse de @karask, vous pouvez envelopper la fonction comme une aide comme ceci:

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

Pour moi, cela fonctionne:

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

Si vous contrôlez le type utilisé comme dynamique, ne pourriez-vous pas retourner un tuple au lieu d'une valeur pour chaque accès à la propriété? Quelque chose comme...

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

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

Peut-être une implémentation naïve, mais si vous en construisez une à chaque fois en interne et que vous renvoyez cela au lieu de la valeur réelle, vous pouvez vérifier Existschaque accès à la propriété, puis frapper Valuesi c'est le cas avec value étant default(T)(et non pertinent) si ce n'est pas le cas.

Cela dit, je manque peut-être des connaissances sur le fonctionnement de la dynamique et ce n'est peut-être pas une suggestion viable.

Dans mon cas, je devais vérifier l'existence d'une méthode avec un nom spécifique, j'ai donc utilisé une interface pour cela

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

De plus, les interfaces peuvent contenir plus que de simples méthodes:

Les interfaces peuvent contenir des méthodes, des propriétés, des événements, des indexeurs ou toute combinaison de ces quatre types de membres.

De: Interfaces (Guide de programmation C #)

Élégant et pas besoin de piéger les exceptions ou de jouer avec la réflexion ...

Je sais que c'est vraiment un ancien post, mais voici une solution simple pour travailler avec dynamictaper c#.

1. peut utiliser une réflexion simple pour énumérer les propriétés directes
2. ou peut utiliser la objectméthode d'extension
3. ou utilisez la GetAsOrDefault<int>méthode pour obtenir un nouvel objet fortement typé avec une valeur s'il existe ou par défaut s'il n'existe pas.

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

Comme ExpandoObjecthérite du, IDictionary<string, object>vous pouvez utiliser la vérification suivante

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

Vous pouvez créer une méthode utilitaire pour effectuer cette vérification, qui rendra le code beaucoup plus propre et réutilisable.

Voici l'autre voie:

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