Canard essais de type avec C# 4 pour les objets dynamiques

Je suis désireux d'avoir un simple duck-typing exemple en C# en utilisant des objets dynamiques. Il me semble, qu'un objet dynamique devrait avoir HasValue/HasProperty/HasMethod méthodes avec une seule chaîne de caractère en paramètre le nom de la valeur, la propriété ou la méthode que vous recherchez avant d'essayer d'exécuter contre elle. J'essaie d'éviter les blocs try/catch, et un approfondissement de la réflexion, si possible. Il semble juste être une pratique courante pour de canard en tapant dans la dynamique des langues (JS, Ruby, Python, etc) qui est à l'essai pour une propriété/méthode avant d'essayer de l'utiliser, puis revenir à un défaut ou à lancer une exception contrôlée. L'exemple ci-dessous est en gros ce que je veux accomplir.

Si les méthodes décrites ci-dessus n'existent pas, quelqu'un aurait-il premade les méthodes d'extension pour la dynamique qui va le faire?

Exemple: En JavaScript, je peux le tester pour une méthode sur un objet assez facilement.

//JavaScript
function quack(duck) {
  if (duck && typeof duck.quack === "function") {
    return duck.quack();
  }
  return null; //nothing to return, not a duck
}

Comment pourrais-je faire la même chose en C#?

//C# 4
dynamic Quack(dynamic duck)
{
  //how do I test that the duck is not null, 
  //and has a quack method?

  //if it doesn't quack, return null
}

Juste une remarque pour ceux qui cherchent... ExpandoObject (pas sûr d'autres) met en œuvre IDictionary<string, object> de sorte que vous pouvez tester avec var myDynamicAsDictionary = myDyn comme IDictionary<string, object> ensuite de tester la valeur null, et .HasKey()
double possible de dynamic, Comment tester si une propriété est disponible
la mienne a 2 jours plus tôt que l'un est lié à... je pensais juste qu'il pourrait être possible de créer une telle vérification des méthodes de type générique signatures... Duck.HasFunc<TRet, T1>(string name) comme un exemple de signature... je n'utilisez pas le C# à ce niveau, mais ce serait intéressant.
Je le vois. Parfois, il est ok pour fermer une question qui est plus âgé si la nouvelle question a reçu plus d'attention. Mais je vois votre point de vue.

InformationsquelleAutor Tracker1 | 2010-06-06

13

Essayez ceci:
```
    using System.Linq;
    using System.Reflection;
    //...
    public dynamic Quack(dynamic duck, int i)
    {
        Object obj = duck as Object;

        if (duck != null)
        {
            //check if object has method Quack()
            MethodInfo method = obj.GetType().GetMethods().
                            FirstOrDefault(x => x.Name == "Quack");

            //if yes
            if (method != null)
            {

                //invoke and return value
                return method.Invoke((object)duck, null);
            }
        }

        return null;
    }
```
Ou ce (utilise seulement dynamique):
```
    public static dynamic Quack(dynamic duck)
    {
        try
        {
            //invoke and return value
            return duck.Quack();
        }
        //thrown if method call failed
        catch (RuntimeBinderException)
        {
            return null;
        }        
    }
```
- Ce n'est pas en utilisant dynamic à tous, c'est juste la norme de la réflexion...
- Je pense que c'est la moitié de la solution. Il fonctionne si de canard-dessous est une plaine objet CLR. Si c'est un type dynamique venant de l'une des langues DLR, ou c'est un objet qui implémente l'interface idynamicmetaobjectprovider fournie par le CLR va essayer de se lier à la première, avant de recourir à la réflexion.
- D'autres suggestions sur la façon de vérifier l'existence d'une méthode?
- Je sais que le try/catch de travail, mais la réflexion est probablement plus proche de ce dont j'ai besoin, peut-être une méthode d'extension habillage dynamique, pour les chèques, juste difficile à croire, il n'y a pas quelque chose de déjà là pour cela. +1 de moi, espérant toujours pour une meilleure réponse, et peut juste jouer avec elle un peu. Voulant éviter la surcharge d'un prématuré bloc try/catch bien que, par opposition à un chèque spécifique comme cela se fait dans d'autres canard-typage des scénarios.
- Bon, ce marquage comme la bonne réponse, comme suggéré par Andrew Anderson, aurez probablement envie de conclure en une extension de la méthode, a été tout simplement l'espoir pour le meilleur de canard en tapant dans la dynamique par défaut. Il est assez commun pour tester un "Couac" de la méthode avant d'appeler le "Couac" sur la capture de l'exception... quelqu'un sait ce que le coût de la réflexion est plus juste attraper l'exception? surtout si vous savez que vous obtenez une exception dire 50% du temps?
- Notez que l'espace de noms Microsoft.CSharp.RuntimeBinder n'est pas utilisé par défaut, au moins dans mon installation de LINQPad et Visual Studio 2010. Vous devrez ajouter manuellement un using ... ou qualifier RuntimeBinderException pleinement que dans Microsoft.CSharp.RuntimeBinder.RuntimeBinderException pour la deuxième solutino de travail.
InformationsquelleAutor Simon

Si vous avez le contrôle sur tous les types d'objet qui vous permettra d'utiliser de façon dynamique, une autre option serait de les forcer à hériter d'une sous-classe de la DynamicObject classe qui est adapté pour ne pas échouer lorsqu'une méthode qui n'existe pas est invoquée:

Un rapide et sale version devrait ressembler à ceci:

public class DynamicAnimal : DynamicObject
{
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        bool success = base.TryInvokeMember(binder, args, out result);

        //If the method didn't exist, ensure the result is null
        if (!success) result = null;

        //Always return true to avoid Exceptions being raised
        return true;
    }
}

Vous pouvez ensuite effectuer les opérations suivantes:

public class Duck : DynamicAnimal
{
    public string Quack()
    {
        return "QUACK!";
    }
}

public class Cow : DynamicAnimal
{
    public string Moo()
    {
        return "Mooooo!";
    }
}
class Program
{
    static void Main(string[] args)
    {
        var duck = new Duck();
        var cow = new Cow();

        Console.WriteLine("Can a duck quack?");
        Console.WriteLine(DoQuack(duck));
        Console.WriteLine("Can a cow quack?");
        Console.WriteLine(DoQuack(cow));
        Console.ReadKey();
    }

    public static string DoQuack(dynamic animal)
    {
        string result = animal.Quack();
        return result ?? "... silence ...";
    }
}

Et votre sortie serait:

Can a duck quack?
QUACK!
Can a cow quack?
... silence ...

Edit: je tiens à noter que c'est la partie émergée de l'iceberg si vous êtes en mesure d'utiliser cette approche et de construire sur DynamicObject. Vous pouvez écrire des méthodes comme bool HasMember(string memberName) si vous le souhaité.

+1 pour moi... Simon réponse est plus proche de ce que je veux.. aurez besoin de les envelopper dans un HasMethod méthode d'extension, mais devrait être en mesure de le faire.. espérais juste pour plus de la boîte.

InformationsquelleAutor Andrew Anderson

Mise en œuvre de la HasProperty méthode pour chaque idynamicmetaobjectprovider fournie par SANS jeter RuntimeBinderException.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Dynamic;
using Microsoft.CSharp.RuntimeBinder;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
namespace DynamicCheckPropertyExistence
{
class Program
{        
static void Main(string[] args)
{
dynamic testDynamicObject = new ExpandoObject();
testDynamicObject.Name = "Testovaci vlastnost";
Console.WriteLine(HasProperty(testDynamicObject, "Name"));
Console.WriteLine(HasProperty(testDynamicObject, "Id"));            
Console.ReadLine();
}
private static bool HasProperty(IDynamicMetaObjectProvider dynamicProvider, string name)
{
var defaultBinder = Binder.GetMember(CSharpBinderFlags.None, name, typeof(Program),
new[]
{
CSharpArgumentInfo.Create(
CSharpArgumentInfoFlags.None, null)
}) as GetMemberBinder;
var callSite = CallSite<Func<CallSite, object, object>>.Create(new NoThrowGetBinderMember(name, false, defaultBinder));
var result = callSite.Target(callSite, dynamicProvider);
if (Object.ReferenceEquals(result, NoThrowExpressionVisitor.DUMMY_RESULT))
{
return false;
}
return true;
}
}
class NoThrowGetBinderMember : GetMemberBinder
{
private GetMemberBinder m_innerBinder;        
public NoThrowGetBinderMember(string name, bool ignoreCase, GetMemberBinder innerBinder) : base(name, ignoreCase)
{
m_innerBinder = innerBinder;            
}
public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
{
var retMetaObject = m_innerBinder.Bind(target, new DynamicMetaObject[] {});            
var noThrowVisitor = new NoThrowExpressionVisitor();
var resultExpression = noThrowVisitor.Visit(retMetaObject.Expression);
var finalMetaObject = new DynamicMetaObject(resultExpression, retMetaObject.Restrictions);
return finalMetaObject;
}
}
class NoThrowExpressionVisitor : ExpressionVisitor
{        
public static readonly object DUMMY_RESULT = new DummyBindingResult();
public NoThrowExpressionVisitor()
{
}
protected override Expression VisitConditional(ConditionalExpression node)
{
if (node.IfFalse.NodeType != ExpressionType.Throw)
{
return base.VisitConditional(node);
}
Expression<Func<Object>> dummyFalseResult = () => DUMMY_RESULT;
var invokeDummyFalseResult = Expression.Invoke(dummyFalseResult, null);                                    
return Expression.Condition(node.Test, node.IfTrue, invokeDummyFalseResult);
}
private class DummyBindingResult {}       
}
}

InformationsquelleAutor Rene Stein

2

http://code.google.com/p/impromptu-interface/ Semble être une belle Interface mappeur pour les objets dynamiques... C'est un peu plus de travail que ce que j'espérais, mais semble être le plus propre de la mise en œuvre des exemples présentés... en Gardant Simon réponse comme correcte, puisque c'est toujours la plus proche de ce que je voulais, mais l'Impromptu de méthodes d'interface sont vraiment sympa.

InformationsquelleAutor Tracker1
1

Le chemin le plus court serait de l'appeler, et de gérer l'exception, si la méthode n'existe pas. Je viens de Python où cette méthode est courante dans de canard-typage, mais je ne sais pas si il est largement utilisé en C#4...

Je n'ai pas testé moi-même puisque je n'ai pas de CR 2010 sur ma machine
```
dynamic Quack(dynamic duck)
{
try
{
return duck.Quack();
}
catch (RuntimeBinderException)
{ return null; }
}
```
InformationsquelleAutor CharlesB

Vous devez vous connecter pour publier un commentaire.