基于运行时参数类型的方法动态选择

Question

I've seen similar questions/answers for this posted in the past, but mine differs slightly from the others that I've seen.

Essentially, I have a common interface and several classes that implement/inherit from it. Then, in a separate class, I have methods that must act upon objects given by the interface IObject. However, each of them must be acted upon in different ways, hence why there is a separate declaration of the method for each concrete type that extends IObject.

class IObject
{
    ...
}

class ObjectType1 : IObject
{
    ...
}

class ObjectType2 : IObject
{
    ...
}

class FooBar
{
    void Foo (ObjectType1 obj);
    void Foo (ObjectType2 obj);
}

Now, to me, one obvious solution is to take advantage of dynamic binding by placing the method Foo inside each individual class, which would automatically choose at runtime the correct Foo to execute. However, this is not an option here, because I am defining multiple models for how to act upon these objects, and I would rather encapsulate each individual model for handling objects in its own class, rather than stuff all of the models into the object classes.

I found this post which shows how to use a dictionary to dynamically choose at runtime the correct method implementation. I'm fine with this approach; however, suppose that I have to perform a dispatch like this once in every model. If I only have IObject and its concrete implementations, is there any way to generalize this approach so that I could call methods of any name based on the runtime type of the objects ?

I know this is probably an unclear question, but I would greatly appreciate any help.

Answer 1

The dynamic keyword is actually really good at this:

void Main()
{
    var foobar = new FooBar();
    foreach(IObject obj in new IObject[]{ new ObjectType1(), new ObjectType2()})
    {
        foobar.Foo((dynamic)obj);
    }   
    // Output:
    //  Type 1
    //  Type 2
}

class IObject
{
}

class ObjectType1 : IObject
{
}

class ObjectType2 : IObject
{
}

class FooBar
{
    public void Foo (ObjectType1 obj) {
        Console.WriteLine("Type 1");
    }
    public void Foo (ObjectType2 obj) {
        Console.WriteLine("Type 2");
    }
}

The code is super-simple, and it's got pretty decent performance .

Answer 2

Maybe you want something very close to visitor patter .

If you just want to pick a method ( Foo ) of an object ( FooBar ) by argument type you can use reflection to get all methods with given name ( Foo ) and do manual match of argument based on type of object ( ObjectTypeX ) and choices of the argument. Don't forget to handle derived classes properly.

To avoid paying cost of reflection on every call - cache results (ie by building/compiling en Expression tree).

Note that Dictionary (actions for given method name indexed by type) approach will probably easier to support/debug to start with. Later if you find it slow for you needs you may replace it with something more complicated like reflection.

Answer 3

you can just make one method that takes the interface type,then you check for the correcttype and cast it

ObjectType1 obj1 = new ObjectType1();

foo(obj1);

void foo(IObject fm)
        {
            ObjectType1 cls;
            if (fm is ObjectType1)
            {
                cls = fm as ObjectType1;
                cls.ID = 10;
                MessageBox.Show(cls.ID.ToString() + "    " + cls.GetType().ToString());
            } 
        }

thats because the classes implement IObject ,cls.ID is just an example you can put one property you implement. Please try it and let me know....best wishes.