为什么在c＃的继承方法中使用override而不是function

Question

I wanted to know that while inheritance can be used to inherit properties and methods in derived class.

Why we don't write functions in the derived classes instead declaring them as override.

Following example will explain more about my question.

class Net
{
    public virtual void Act()
    {
    }
}

class Perl : Net
{
    public override void Act()
    {
    Console.WriteLine("Perl.Act");
    }
}

class Python : Net
{
    public override void Act()
    {
    Console.WriteLine("Python.Act");
    }
}

// Use base class and derived types in a List.
List<Net> nets = new List<Net>();
nets.Add(new Perl());
nets.Add(new Python());

// Call virtual method on each instance.
foreach (Net net in nets)
{
    net.Act();
}

In above example act function can be declared as "NEW" functions why should we opt for overriding the base function??

Edit: Suppose i have a case as follow

class Net
{
    public virtual void Act()
    {
    }

    public virtual void secondMethod()
    {
    }
}

class Perl 
{
    public override void Act()
    {
        Console.WriteLine("Perl.Act");
    }

    public override void secondMethod()
    {
        Console.WriteLine("Perl.Act");
    }
}

class Python 
{
    public new void Act()
    {
        Console.WriteLine("Python.Act");
    }

    public override void secondMethod()
    {
        Console.WriteLine("Perl.Act");
    }
}

What should i do then. In above case i want the base class to be inherited but The functionality i am implementing may be different. In such cases should i use override or write a complete different method.

Answer 1

Because without that virtual method on your base class you would not be able to call Act withing your loop:

foreach (Net net in nets)
{
    net.Act();
}

And foreach is not the only place you can use that. Imagine you have a method called Foo which takes Net instance as parameter:

public static void Foo(Net net)
{
    net.Act();
}

You can still pass both Python and Perl to that method, and they will both execute their own Act method logic.

virtual is useful everywhere you want to provide some basic, default functionality and be able to override that default one within derived classes.

You should read Knowing When to Use Override and New Keywords (C# Programming Guide)

Answer 2

new keyword is used for method hiding, mainly for versioning purposes, but note that both methods are still available in derived class! and can be accessed with a simple cast . But on the other hand, with method overriding, you override the behavior (this is what we call polymorphism ), so in a derived class, the overridden method will totally replace the base method, therefore cannot be accessed via an instance of the derived class even with an upcast to the base class! because the virtual method is replaced by the overridden method. Let me show you this concept with an example:

public class Base
{
    public virtual void VirtualMethod() { }
    public void NewMethod() { }
}

public class Derived : Base
{
    public override void  VirtualMethod() { }
    public new void NewMethod() { }
}

...

Base derived = new Derived();
derived.VirtualMethod(); // Derived.VirtualMethod()
derived.NewMethod(); // Base.NewMethod()
((Derived)derived).NewMethod(); // Derived.NewMethod()

Answer 3

In above example act function can be declared as "NEW" functions why should we opt for overriding the base function

Inheritance is meant to use what base class provide along with extra functionality where necessary. Why would you inherit in first place if you don't want to use the functionality of base class?