c# 新手：这段代码不像我预期的那样工作......为什么？

Question

Trying to learn more about less common constructs in C#, I ran into this code sample on codingsight.com:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClassB b = new MyClassB();
            MyClassA a = b;
            a.abc();
            Console.ReadLine();
        }
    }

    class MyClassA
    {
        public MyClassA()
        {
            Console.WriteLine("constructor A");
        }

        public void abc()
        {
            Console.WriteLine("A");
        }
    }

    class MyClassB : MyClassA
    {
        public MyClassB()
        {
            Console.WriteLine("constructor B");
        }

        public void abc()
        {
            Console.WriteLine("B");
        }
    }
}

The challenge is to predict the output. Running the code in a console there appears:

constructor A
constructor B
A

I had bet my last cent that the 3rd line of the output would be "B", or an "unitialized variable" error, but in fact it is "A". Why?

Answer 1

Why?

Because it's a concept of the .NET language called hiding through inheritance . It's defined that way and there's no reasoning given by Microsoft why it was done that way. They could have chosen any other behavior as well, but they didn't.

In the comments you say:

What the computer did is "something", but clearly not what the intention of the code was.

Actually, we don't know what the intention was. We would need to ask the author of that code snippet. I would say it was intended the way it is, because it is a great question to see whether or not someone has understood the principles of inheritance.

In the title, you mention that there is a warning - and that warning is exactly a warning to the author that he didn't express his intention well enough. Or it's a warning to you as a reader that the writer has not expressed his intention well enough.

The warning is

warning CS0108: 'MyClassB.abc()' hides inherited member 'MyClassA.abc()'. Use the new keyword if hiding was intended.

That warning also tells us that the author should have used the new keyword on MyClassB.abc() to definitely tell readers that he's using "hiding through inheritance" explicitly.

Now, what's the alternative? If you want to have inheritance as expected by you, MyClassA.abc() needs to be marked as virtual .

This change alone, hoewever, does not fix the inheritance as expected by you. There's another compiler warning

warning CS0114: 'MyClassB.abc()' hides inherited member 'MyClassA.abc()'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.

which clearly states that MyClassB.abc() also needs to be marked as override .

It seems you're most confused about the statement

MyClassA a = b;

That statement is equivalent to

MyClassA a = (MyClassA) b;

but the cast is redundant because of implicit reference conversion :

The implicit reference conversions are:

[...]

From any class_type S to any class_type T , provided S is derived from T .

(where S is MyClassB and T is MyClassA)