Question

Class—A

class ClassA
{
    public string c1()
    {
        return "Class-A";
    }

}

Class—B

class ClassB:ClassA
{
    public string c2()
    {
        return "Class-B";
    }
}

Main Class

—–Part 1——————

 ClassA obj1 = new ClassB();
 string a = obj1.c1();//Here i will get only c1
 Console.WriteLine(a);
 Console.ReadLine();

—–Part 2——————

 ClassB obj1 = new ClassA();
 string a = obj1.c2();//Her i will get both c1 and c2
 Console.WriteLine(a);
 Console.ReadLine();

In Part-1,i will get only c1.I need to know whether variable (obj) is created for ClassA in stack and assign address of ClassB from Heap.What is actually happening?

In Part -2 ,Getting(compilation error) conversion error.What is actually happening behind the screen while executing this code.

Thanks,
Joby Kurian

Answer 1

Part 1

ClassA obj1 = new ClassB();

This creates an instance of ClassB – an object.

It also declares a variable called obj1, of type ClassA. That variable’s value will always be a reference – either null or a reference to an instance of ClassA. In this case, the initial value is a reference to the newly created ClassB object. (A reference to a ClassB object can be used as a ClassA reference too, because ClassB derives from ClassA.)

When you call c1, it just calls the implementation in ClassA – but within that method, if you printed out this.GetType() it would still return ClassB‘s type, as it’s operating “within” a ClassB object.

I strongly suggest you don’t worry about the stack and the heap yet. Focus on the three different concepts:

• Objects
• References (ways of navigating to objects, or null)
• Variables (named storage locations)

Eric Lippert has blogged a lot about this sort of thing. You might want to start with The Stack Is An Implementation Detail.

Part 2

ClassB obj1 = new ClassA();

This creates an instance of ClassA, and tries to assign a reference to the new object to a variable of type ClassB. That doesn’t work, because ClassA does not derive from ClassB. You can’t use a reference of compile-time type ClassA to a variable of type ClassB. As a demonstration of why this wouldn’t work, it’s a bit like doing this:

string x = new object();
Console.WriteLine(x.Length); // What could this possibly print out?

Basically, inheritance doesn’t work that way round – you can treat an instance of ClassB as an instance of ClassA (in most cases) but you can’t treat an instance of ClassA as an instance of ClassB. You’d normally be adding more state (fields) in ClassB, so that information just wouldn’t be present in the instance of ClassA.