First case:
    class Parent
    {
        public void Me()
        {
            Console.WriteLine(this);
        }
    }
    class Child : Parent
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child();
            child.Me();
        }
    }
The output is "Child" rather than "Parent". Can you explain what is the concept behind it?



Second case:
    class Parent
    {
        public void Me()
        {
            Console.WriteLine(base.ToString());
        }
    }
    class Child : Parent
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child();
            child.Me();
        }
    }
The output is still "Child" rather than "Parent". Can you explain what is the concept behind it?

Here is the IL for your first case:

The overlaod of the WriteLine method that takes an object as a parameter is called. The ToString method of the object type (Child) is called to return a string representation of the object. Keyword ‘this’ refers to an instance of the Child class, which simply inherits (and invokes) a member implementation defined in its base class, Parent. It is not the case that an object of type Parent is invoking the Me method.

Here is the IL for your second case:

Here the Child class calls its base class’s implementation of the ToString method (as indicated by keyword 'base'). However, the parameterless ToString method is defined in System.Object (the Parent class’s direct base class). So the Child class is ultimately using System.Objects implementation of ToString which simply returns a string representation of the object, hence Child.

Child inherits the member implementations defined in the Parent class. When those implementations are invoked in your code, however, they are invoked by an object of type Child, not an object of type Parent.

Anyway, that's my story, and I'm sticking to it...for now...

HTH,

Bob

Should mention that in the first case the ToString method defined in System.Object is also used when Child.ToSting() is called by the System.Console.WriteLine method. Child objects derive from System.Object also, as do all reference types.

So in both cases, System.Object's definition of ToString is simply returning a string representation of a Child object. Your code just invokes System.Object.ToSting() in two different ways.

Bob

Thanks for your reply. I can understand your well explanation.
If I want to print out the fully qualified name of the Parent class from the Child class, how to do it?
Is it possible to obtain it from the "base" keyword?

The BaseType property of the Type class will return the type from which the current type directly inherits. Here's a DisplayBaseType method for your Child class:

Thanks Bob for your reply.
In C++ we can declare an alias of a varible using the following

AnyType var1(...);
AnyType& var2=var1;

or using the same mechanism in function parameter as follows

void Foo(AnyType& arg)
{
...
}


In C# we can do the second case above as follows

void Foo(ref AnyType arg)
{
...
}

Even though the first case seems useless in practical sense,
how to do it (the first case) in C#? Is it possible?


Andi Setiawan

Hi Andi,

Not quite sure this is what you're looking for. If not, its always a good idea to post a new question on a new thread. Better chance of someone tossing the the right solution out there.

using System;

class RefType {
    public int i;
    public double d;
    public RefType(int i, double d) {
        this.i = i;
        this.d = d;
    }
    public override string ToString() {
        return "(" + i + ", " + d + ")";
    }
}

public class App {
    public static void Main() {

        RefType r1;
        r1 = new RefType(1, 1.1);
        Console.WriteLine("r1 = " + r1);

        RefType r2;
        r2 = r1;

        // r2 and r1 now contain the same memory address of a
        // single object on the managed heap. So any operation
        // on one variable will affect the object referenced by
        // the other variable.

        r2.i++; r2.d++;
        Console.WriteLine("r1 = " + r1);
    }
}


HTH,

Bob

Thanks for your reply.
I am sorry, it is not what I mean.

You are right that both r1 and r2 refer to the same object in managed heap.
But r1 is not an ALIAS of r2. It means that if we change r1 to refer to a new object, now both r1 and r2 refer to distinct objects.

In C++, if r1 is an alias of r2 then r1's address must be equal to r2's address (&r1 == &r2 must return true).

When we use ref keyword in method's parameter in C#, it works like C++ alias.
In C++ we can declare aliases both in method's body and method's parameters.
Thus, I just want to know whether or not C# support alias in method's body.

Andi Setiawan