// A better example

​

using System;

​

// Regular old abstract base class

// *classes must be abstract to contain abstract methods

abstract class AbstractBaseClass

{

    // Regular old public method

    public void BaseMethod() {

        Console.WriteLine("AbstractBaseClass::BaseMethod() called!");   

    }

    // Abstract public method

    // Abstract == No implmentation in base class; forced override

    public abstract void AbstractBaseMethod();

    // Virtual public method

    // Virtual == implemented in base class; option to override

    public virtual void VirtualBaseMethod() {

        Console.WriteLine("AbstractBaseClass::VirtualBaseMethod() called!");    

    }

}

​

class DerivedClass1 : AbstractBaseClass

{

    // We are forced by the compiler to implement this method

    // because it was marked abstract

    public override void AbstractBaseMethod()

    {

        Console.WriteLine("DerivedClass1::AbstractBaseMethod() called!");

    }

    // We are not going to override the virtual base method here

}

​

class DerivedClass2 : AbstractBaseClass

{

    // We are forced by the compiler to implement this method

    // because it was marked abstract

    public override void AbstractBaseMethod()

    {

        Console.WriteLine("DerivedClass2::AbstractBaseMethod() called!");

    }

    // this time we are going to override

    public override void VirtualBaseMethod()

    {

        Console.WriteLine("DerivedClass2::VirtualBaseMethod() called!");

    }

}

​

class DerivedClass3 : AbstractBaseClass 

{

    // We don't want the base class' crap here!

    public new void BaseMethod() {

        Console.WriteLine("DerivedClass3::BaseMethod() called!");

    }

    // We are forced by the compiler to implement this method

    // because it was marked abstract

    public override void AbstractBaseMethod()

    {

        Console.WriteLine("DerivedClass3::AbstractBaseMethod() called!");

    }

    // this time we are going to override

    public override void VirtualBaseMethod()

    {

        Console.WriteLine("DerivedClass3::VirtualBaseMethod() called!");

    }

}

​

class DerivedClass4 : AbstractBaseClass 

{

    // We don't want the base class' crap here!

    public new void BaseMethod() {

        Console.WriteLine("DerivedClass4::BaseMethod() called!");

        // Get a little frisky

        Console.Write("Now calling base: ");

        base.BaseMethod();

    }

    // We are forced by the compiler to implement this method

    // because it was marked abstract

    public override void AbstractBaseMethod()

    {

        Console.WriteLine("DerivedClass4::AbstractBaseMethod() called!");

    }

    // this time we are going to override

    public override void VirtualBaseMethod()

    {

        Console.WriteLine("DerivedClass4::VirtualBaseMethod() called!");

        // Get frisky again

        Console.Write("Now calling base: ");

        base.VirtualBaseMethod();

    }

}

​

static class ActorCompiler

{

    public static void CompileClass(AbstractBaseClass abc)

    {

        abc.BaseMethod();

        abc.AbstractBaseMethod();

        abc.VirtualBaseMethod();

        Console.WriteLine();

    }

}

​

public class Program

{

    public static void Main()

    {

        DerivedClass1 x = new DerivedClass1();

        DerivedClass2 y = new DerivedClass2();

        DerivedClass3 z = new DerivedClass3();

        DerivedClass4 a = new DerivedClass4();

        ActorCompiler.CompileClass(x);

        ActorCompiler.CompileClass(y);

        ActorCompiler.CompileClass(z);

        ActorCompiler.CompileClass(a);

        // For methods hidden with the new keyword (i.e. not using abstract/virtual),

        // an instance of the derived class is required.

        z.BaseMethod();

        Console.WriteLine();

        a.BaseMethod();

    }

}