将具有相同接口或基类的类传递给重载的方法

Question

I have a base class with has x amount of properties, I then have derived classes with more properties. How do I process the common fields in a method and then send the object to another method which can process its additional properties?

Example:

public Interface IAnimal {
    int NoOfFeet;
}

class Animal: IAnimal {
    int NoOfFeet {get;set;}
}

class Elephant: Animal {
   bool hasTrunk {get;set;}
}

class Dog:Animal {
   string canBark {get;set;}
}

Method1(IAnimal a) {
    //process NoOfFeet     ...

    //process fields for derived type
    DoSomething(IAnimal a)
}    

DoSomething(Elephant e) {
     //process trunk
}

DoSomething(Dog d) {
     //process canbark
}

Answer 1

It sounds like you basically want overload resolution at execution time. (I'm assuming you can't introduce a virtual method to do the right thing, and implement it in each class. That would be the cleanest way if it's reasonable for the implementations to know what you're doing with them, but that's not always the case.) The simplest way of achieving that is using dynamic , as introduced in C# 4:

public void Method(IAnimal animal)
{
    // We don't want to call Handle with a null reference,
    // or we'd get an exception to due overload ambiguity
    if (animal == null)
    {
        throw new ArgumentNullException("animal");
    }
    // Do things with just the IAnimal properties
    Handle((dynamic) animal);
}

private void Handle(Dog dog)
{
    ...
}

private void Handle(Elephant elephant)
{
    ...
}

private void Handle(object fallback)
{
    // This method will be called if none of the other overloads
    // is applicable, e.g. if a "new" implementation is provided
}

Answer 2

The best way without getting into advanced strategies is to use the is keyword.

For example:

Method1(IAnimal a) {
    // process NoOfFeet

    if (a is Elephant)
        DoSomething((Elephant)a);
    else if (a is Dog)
        DoSomething((Dog)a);
}

If Elephant and Dog , etc. might have additional subclasses that you need to specifically address, then you will need to use typeof instead of is :

Method1(IAnimal a) {
    // process NoOfFeet

    if (a.GetType() == typeof(Elephant))
        DoSomething((Elephant)a);
    else if (a.GetType() == typeof(Dog))
        DoSomething((Dog)a);
}

Answer 3

Make the method a part of the class and override it.

public Interface IAnimal {
    int NoOfFeet;
    void DoSomething()
}

Class Animal: IAnimal {
    int NoOfFeet {get;set;}
    public virtual void DoSomething() {...}
}

Class Elephant: Animal {
    bool hasTrunk {get;set;}
    public override void DoSomething() {...}
}

Class Dog:Animal {
    string canBark {get;set;}
    public override void DoSomething() {...}
}

Method1(IAnimal a) {
    //process NoOfFeet     ...

    //process fields for derived type
    a.DoSomething();
}

Answer 4

Sounds like you could use the Template method pattern

abstract class Animal
{
    public void DoSomething()
    {
        // do stuff all animals have here

        DoSomethingVirtual(); // call virtual method to do stuff for specific animal
    }

    private abstract void DoSomethingVirtual();
}

class Elephant : Animal
{
    private override void DoSomethingVirtual()
    {
        // do elephant stuff here
    }
}

Now when you call DoSomething() on any animal object, the base class will handle the common functionality, then pass down execution to the derived class to for