Is there a C# equivalent to Ruby's `respond_to?` ?

Question

I'm writing a simple wrapper to "duck" a dynamic object against a known interface:

interface IFoo { string Bar(int fred); }

class DuckFoo : IFoo
{
    private readonly dynamic duck;

    public DuckFoo(dynamic duck)
    {
        this.duck = duck;
    }

    public string Bar(int fred)
    {
        return duck.Bar(fred);
    }
}

This works fine if the dynamic object can respond to the Bar signature. But if it cannot this fails only when I call Bar. I would prefer if it could fail faster, i.e., with argument validation upon construction of the DuckFoo wrapper. Something like this:

public DuckFoo(dynamic duck)
{
    if(/* duck has no matching Bar method */)
        throw new ArgumentException("duck", "Bad dynamic object");
    this.duck = duck;
}

In Ruby there is a respond_to? method that can be used to test if an object "has" a certain method. Is there a way to test that with dynamic objects in C# 4?

(I am aware that even with this check the Bar call could fail later on because the dynamic nature of the duck lets it stop responding to methods later on.)

Answer 1

You could check the methods available on the object being wrapped using Reflection, at construction time.

Just call Type.GetMethods() on the interface and the type being passed in, and make sure the appropriate methods exist.

---

Edit:

As suggested by itowlson, there is an option for handling dynamic types, as well. If you check for the existance of the IDynamicMetaObjectProvider interface on the passed object, you could then call IDynamicMetaObjectProvider.GetMetaObject().GetDynamicMemberNames(), and use this information.

If the interface does not exist, you could just revert to Type.GetMethods().

This should handle the "dynamic" types, as well.

Answer 2

Use reflection to check for methods:

if (duck.GetType().GetMethod("Bar") == null) {
    throw new ArgumentException("duck", "Bad dynamic object");
}

Answer 3

I don't know of a definite way to check if the object provides a specific method. Of course, you could use reflection, but that only works if the object is a .NET object. If you are sure that it is, than, as already said, no problem, just call GetType() on the object and check with GetMethod().

On the other hand, as you said yourself, even a check at this point doesn't guarentee that the call to the method will succeed later on, so I think that the check is useless. Just let the call fail when it actually does. It could also be that your check says the object doesn't provide a specific method, but later on, when you would actually call it, it does.