Abstract vs Virtual vs Override vs New keyword

Virtual Keyword

The virtual keyword is used for the base class function and override keyword in the derived class function to implement function/method overriding.

// Base Class  
class A  
{  
    public virtual void show()  
    {  
        Console.WriteLine("Hello: Base Class!");  
        Console.ReadLine();  
    }  
}

Override Keyword

The override keyword is used in the derived class function in order to override the base class function:

// Base Class  
class A  
{  
    public virtual void show()  
    {  
        Console.WriteLine("Hello: Base Class!");  
        Console.ReadLine();  
    }  
}  
  
// Derived Class  
class B : A  
{  
    public override void show()  
    {  
        Console.WriteLine("Hello: Derived Class!");  
        Console.ReadLine();  
    }  
}

Method Overriding: an example

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Generics  
{  
    class A  
    {  
        public virtual void show()  
        {  
            Console.WriteLine("Hello: Base Class!");  
            Console.ReadLine();  
        }  
    }  
  
    class B : A  
    {  
        public override void show()  
        {  
            Console.WriteLine("Hello: Derived Class!");  
            Console.ReadLine();  
        }  
    }  
      
    class Polymorphism  
    {  
        public static void Main()  
        {  
            A a1 = new A();  
            a1.show();  
            B b1 = new B();  
            b1.show();  
            A a2 = new B();  
            a2.show();  
        }  
    }  
}

Output:

Hello: Base Class!
Hello: Derived Class!
Hello: Derived Class!

New Keyword (Method Hiding)

Using the "new" keyword, we can hide the base class member.
It is implemented as:

class A  
{  
    public void show()  
    {  
        Console.WriteLine("Hello: Base Class!");  
        Console.ReadLine();  
    }  
}  
  
class B : A  
{  
    public new void show()  
    {  
        Console.WriteLine("Hello: Derived Class!");  
        Console.ReadLine();  
    }  
} 

class Polymorphism  
    {  
        public static void Main()  
        {  
            A a1 = new A();  
            a1.show();  
            B b1 = new B();  
            b1.show();   
            A a2 = new B();  
            a2.show();  
        }  
    }

Output:

Hello: Base Class!
Hello: Derived Class!
Hello: Base Class!

Abstract Keyword

The abstract keyword enables you to create classes and class members that are incomplete and must be implemented in a derived class.
The sealed keyword enables you to prevent the inheritance of a class or certain class members that were previously marked virtual.
Classes can be declared as abstract by putting the keyword abstract before the class definition. For example:
```
public abstract class A
{
	// Class members here.
}
```
An abstract class cannot be instantiated.
The purpose of an abstract class is to provide a common definition of a base class that multiple derived classes can share.
For example, a class library may define an abstract class that is used as a parameter to many of its functions, and require programmers using that library to provide their own implementation of the class by creating a derived class.
Abstract classes may also define abstract methods. This is accomplished by adding the keyword abstract before the return type of the method. For example:
```
public abstract class A
{
	public abstract void DoWork(int i);
}
```
Abstract methods have no implementation, so the method definition is followed by a semicolon instead of a normal method block.
Derived classes of the abstract class must implement all abstract methods.

When an abstract class inherits a virtual method from a base class, the abstract class can override the virtual method with an abstract method. For example:

// compile with: -target:library
public class D
{
	public virtual void DoWork(int i)
	{
    	// Original implementation.
	}
}
 
public abstract class E : D
{
	public abstract override void DoWork(int i);
}
 
public class F : E
{
	public override void DoWork(int i)
	{
    	// New implementation.
	}
}

If a virtual method is declared abstract, it is still virtual to any class inheriting from the abstract class. A class inheriting an abstract method cannot access the original implementation of the method—in the previous example, DoWork on class F cannot call DoWork on class D. In this way, an abstract class can force derived classes to provide new method implementations for virtual methods.

Sealed Classes and Class Members

Classes can be declared as sealed by putting the keyword sealed before the class definition. For example:

public sealed class D
{
	// Class members here.
}

A sealed class cannot be used as a base class. For this reason, it cannot also be an abstract class. Sealed classes prevent derivation. Because they can never be used as a base class, some run-time optimizations can make calling sealed class members slightly faster.

A method, indexer, property, or event, on a derived class that is overriding a virtual member of the base class can declare that member as sealed. This negates the virtual aspect of the member for any further derived class. This is accomplished by putting the sealed keyword before the override keyword in the class member declaration. For example:

public class D : C
{
	public sealed override void DoWork() { }
}