basic question on method overloading

method overloading is done at compile time, not at run time, so you won't see any polymorphism with it. Whatever the calling code knows the type to be is going to specify which method is called.

if you want to call the second method you can either cast to the type SubOfPArent or you can instead put those methods into the classes and then call it to get polymorphism:

public class Parent 
{
  public virtual void doStuff() {}
}

public class SubOfPArent : Parent
{
  public override void doStuff() {}
}

...

Parent obj = getASubOfPArent();
obj.doStuff();

You probably called the method with a variable of type Parent.

Since method overloads are resolved at compile time, the compiler can only select an overload based on the static compile-time types of the parameters.

Therefore, even though your variable might actually contain a SubOfParent instance at runtime, the compiler doesn't know that and will therefore choose the first overload.

Virtual methods, by contrast, are resolved at runtime based on the actual type of the instance involved.
Therefore, had SubOfParent overridden a virtual method, calling that method on a variable of type Parent would correctly call the overridden method if the instance is in fact of type SubOfParent.

I think you are casting to Parent in your code, or otherwise providing a Parent type. So I think the behaviour is correct and what you are expecting to happen is incorrect.

It is correct that both overloads are valid for a SubOfParent reference, but the overload resolution logic will look for more specific methods and should therefore find the most specific overload.

SubOfParent p = new SubOfParent();

doStuff((Parent)p); // Calls base overload
doStuff(p); // Calls specific overload

If you're ok with using the dynamic keyword, you could consider doing something like this:

private static void doStuffImpl(Parent obj) {
   Console.WriteLine("I'm a Parent!");
}

private static void doStuffImpl(SubOfParent obj) {
   Console.WriteLine("I'm a Sub of Parent!");
}

public static void doStuff(Parent obj) {
    try {
      doStuffImpl(obj as dynamic);
    }
    catch (RuntimeBinderException ex) {
        // Not implemented !
    }
}

It could be useful if you have a lot of sub classes.

doStuffImpl(obj as dynamic); will be evaluated at run-time. doStuffImpl will be called with obj's real type.

Method overloading is done at Compile time and therefore depends on the static type at compile time to determine the overloaded method. In your example, the following could happen:

public static void Main(string[] args)
{
    SubOfParent a = new SubOfParent();
    doStuff(a); // doStuff(SubOfParent) is called
}

The static type of a at compile time is SubOfParent, so the expected overload would be called.

public static void Main(string[] args)
{
    Parent a = new SubOfParent();
    doStuff(a); // doStuff(Parent) is called
}

The static type (that of the type at declaration) is Parent. In this case, the other overloaded version would be chosen regardless of the value a.GetType() returns at runtime.

To call doStuff(SubOfPArent in) you need something like this:

SubOfPArent.doStuff(new SubOfPArent());

But I think you dont know the type until runtime right?

What tster says is more elegant. I think that is the right thing.

Basically, the compiler resolves what method gets called on an object (i.e., when that object is passed as a parameter) based on that object's declared type. So if you have a variable typed as Parent and you pass it to doStuff, the compiler will resolve that method call to be the overload taking a Parent, even if at runtime that object turns out to be a SubOfParent.

Method calls by an object (i.e., instance methods of a class) exhibit polymorphism at runtime: the method executed is based on the object's actual type.

So if you had this:

class Parent
{
    public virtual void doStuff() { }
}

class SubOfParent : Parent
{
    public override void doStuff() { }
}

Parent p  = new SubOfParent();
p.doStuff();

Then the code would work as you expect.

you can overload functions by declaring multiple function with same name and different arguments