Casting Deriving Class as Base Class

Question

Suppose I have this:

using System;

public class Program
{
    public static void Main()
    {
        BaseClass bc = new DerivedClass();
        bc.Method1();
        bc.Method2();
        Console.WriteLine(bc.GetType().FullName);

        // Output
        // Derived - Method1 (override)
       // Base - Method2
       // DerivedClass
    }
}

public class BaseClass
{
    public virtual void Method1()
    {
        Console.WriteLine("Base - Method1");
    }

    public virtual void Method2()
    {
        Console.WriteLine("Base - Method2");
    }
}

public class DerivedClass : BaseClass
{
    public override void Method1()
    {
        Console.WriteLine("Derived - Method1 (override)");
    }

    public new void Method2()
    {
        Console.WriteLine("Derived - Method2 (new)");
    }
}

If the instance variable of the deriving class is cast to the base class and that instance variable is used to call the overridden methods, the method overridden with the override keyword will execute the implementation in the deriving class whereas the one overridden with the new keyword will execute the implementation in the base class.

How is the variable bc in the above example cast to the Base Class?

I know that the new keyword will override the method implementation in the deriving class and it will be executed when an instance variable of the deriving class is used to call the overridden method, but I don't know what type of Conversion it is.. Doesn't seem to be Implicit nor Explicit, may be Type Conversion but I am confused by the syntax.

Any explanation is appreciated.

It seems you don't fully understand how `virtual` works. Read [this](http://stackoverflow.com/q/1334254/1997232). — Sinatr, Aug 31 '16 at 12:52

Ondrej Tucny · Accepted Answer · 2016-08-31T12:50:08.270

I know that the new keyword will override the method implementation in the deriving class

No. It does not override the base class's method. It declares a new, independent method, that's just named the same and has the same signature. The effect is it hide the same-signature method declared in the base class, effectively complicating the invocation of the same-signature method declared in the base class.

In your example there are no 'type conversions' whatsoever. Think of a type cast as providing a specific view of the instance—exposing the specific part of the class's contract to the user. It's nothing more, nothing less.

Example:

// instance of DerivedClass exposing its full contract via the 'dc' variable
DerivedClass dc = new DerivedClass();

// the same instance of DerivedClass exposing its contract limited to what's declared in BaseClass
BaseClass bc = dc;

// calling Method2 as newly declared in DerivedClass
dc.Method2();

// calling Method2 as declared in BaseClass—the following two lines are equivalent
bc.Method2();
((BaseClass)dc).Method2();

just edited my post, to clear up what i meant in that line – Grizzly Aug 31 '16 at 12:45 — Grizzly, Aug 31 '16 at 12:45

score 1 · Answer 2 · answered Aug 31 '16 at 12:52

Practically speaking, there is no conversion. There is only the way you look at the object.

If you look at it with base-class-glasses, you will see all base-class-methods, which includes the overridden Method1 from the derived class, but it will not include the new Method2 from the derived class, so you will only see Method2 from the base class.
If you look at it with derived-class-glasses, you will see all base-class-methods, which includes the overridden Method1 from the derived class, but it will now also include the new Method2 from the derived class. The original virtual Method1 from the base class, will not be visible.

score 0 · Answer 3 · answered Aug 31 '16 at 12:49

0

How is the variable bc in the above example cast to the Base Class?

It is an implicit cast which is performed when you assign your new DerivedClass instance to a variable of the BaseClass type:

BaseClass bc = new DerivedClass();

answered Aug 31 '16 at 12:49

fknx

1,775
13
19

score 0 · Answer 4 · answered Aug 31 '16 at 12:54

Ahh I just found this, and I was wrong with saying that it didn't seem to be an implicit conversion... I must've over-read this.

For reference types, an implicit conversion always exists from a class to any one of its direct or indirect base classes or interfaces. No special syntax is necessary because a derived class always contains all the members of a base class.

Derived d = new Derived();
Base b = d; // Always OK.

Casting Deriving Class as Base Class

4 Answers4

Linked