Difference between Overriding & Method Shadowing

class Base
{
        public void PrintOnScreen()
        {
            Console.WriteLine("Base Method");
        }
}
class Derive : Base
{
        public new void PrintOnScreen()
        {
            Console.WriteLine("Derive Method");
        }
}
class MethodShadowingDemo
{
        public static void Main(string[] args)
        {
            Base objDerive = new Derive();
            objDerive.PrintOnScreen();
            Console.ReadLine();
        }
}

The output would be

Base Method

Because the base class method is not marked as virtual. If it is marked as virtual and if there is any overridable method is available then you will get "Derive Method" output.

Now I am changing the code

class Base
{
        public virtual void PrintOnScreen()
        {
            Console.WriteLine("Base Method");
        }
}
class Derive : Base
{
        public new void PrintOnScreen()
        {
            Console.WriteLine("Derive Method");
        }
}
class MethodShadowingDemo
{
        public static void Main(string[] args)
        {
            Base objDerive = new Derive();
            objDerive.PrintOnScreen();
            Console.ReadLine();
        }
}

still the output would be

Base Method

because even the base class method is marked as virtaul but it doesnot have any overridable method in the derived class. Even if you remove the "new" keyword from the Base class method.

You will get output as "Derive Method" only if you marked child class function as overridable and parent class function as virtual.

class Base
{
        public virtual void PrintOnScreen()
        {
            Console.WriteLine("Base Method");
        }
}
class Derive : Base
{
        public override void PrintOnScreen()
        {
            Console.WriteLine("Derive Method");
        }
}
class MethodShadowingDemo
{
        public static void Main(string[] args)
        {
            Base objDerive = new Derive();
            objDerive.PrintOnScreen();
            Console.ReadLine();
        }
}

Hope you can understand now.

These guys were pretty clear about the topic :) Thumbs up, codeproject is getting better by the day :D

In addition to those, just a small point of view on why and when you should use new keyword

Ok, back to the basics. When you inherit from a class, the methods marked with either public or protected will be available to the child class. right? So while designing, you decide that I might need more expanded behavior or different behavior from these methods. Let's take an example.

public class Bird {
     public void Eat() {
          Console.WriteLine("Eating....");
     }

     public virtual void Fly() {
          Console.WriteLine("Flying....");          
     }
}

Few things to notice, since every bird is eating, you know that's not going to change, so you don't intend to change it's behavior in child classes. But some birds can't fly, so you know it's going to change, so you are marking that method with virtual keyword. You can achieve the same thing, by abstract classes but it's a different lesson :)

So let's implement 2 birds classes

public class Robin : Bird {
     public override void Fly() {
          Console.WriteLine("Flying Fast....");
     }
}
public class Ostrich : Bird {
     public override void Fly() {
          Console.WriteLine("Cannot fly");
     }
}

Now, I am going do something crazy :D Laugh all you want, but I could not come up with a better example this quickly. But I know it'll help you understand the concept.

So let's imagine, you are want to include disabled birds who can't eat. Now this was not expected in the original design. I.e. it was not intended in the design. So you can go back to the original design and decorate the Eat() method with override.

But this is not possible when you are using someone else's code. I.e. you don't have the source code to edit and update but only the compiled DLL. So now what? That's where new keyword helps you out.

public class DisabledBird : Bird {
     public override void Fly() {
          Console.WriteLine("Cannot fly :(");
     }

     public new void Eat() {
          Console.WriteLine("Cannot eat :(");
     }
}

The new keyword serves 2 purposes.
1. Allows you to hide methods of parent classes and implement a different method for the same signature.
2. Allows you to keep track of methods that you did like that. So that it would not confuse you when you look in to the code later on.

NOTE: This is NOT mean that you should not design your code or overriding can be just ignored. If you do that, you'll quickly lose the ability to maintain your code. This should be only used for exceptional cases like when you are using a toolkit or a library.

Damn, this turned out to be an article :P Apologies

Hope this helps :) Regards