[C#] 파생 클래스에서 메서드를 호출하면 기본 클래스 메서드가 호출되는 이유는 무엇입니까?

Achratt의 답변 을 작성 하고 싶습니다 . 완전성을 위해, 차이점은 OP가 new파생 클래스의 메소드에서 키워드가 기본 클래스 메소드를 대체 할 것으로 예상한다는 것입니다. 실제로하는 것은 기본 클래스 메소드를 숨기는 것입니다.

C #에서 다른 답변이 언급했듯이 기존의 메서드 재정의는 명시 적이어야합니다. 기본 클래스 메소드는로 표시되어야 virtual하고 파생 클래스는 구체적 override으로 기본 클래스 메소드 여야합니다 . 이것이 완료되면 객체가 기본 클래스 또는 파생 클래스의 인스턴스로 취급되는지 여부는 중요하지 않습니다. 파생 된 메소드를 찾아서 호출합니다. 이것은 C ++에서와 비슷한 방식으로 수행됩니다. 컴파일 될 때 “가상”또는 “재정의”로 표시된 메소드는 참조 된 오브젝트의 실제 유형을 판별하고 변수 유형에서 실제 오브젝트 유형으로 트리를 따라 아래로 오브젝트 계층 구조를 순회하여 “지연”(런타임)으로 분석됩니다. 변수 유형으로 정의 된 메소드의 가장 파생 된 구현을 찾으십시오.

이것은 “암시 적 재정의”를 허용하는 Java와 다릅니다. 예를 들어 메소드 (정적이 아닌)의 경우, 동일한 서명 (이름 및 번호 / 유형의 매개 변수)의 메소드를 정의하면 서브 클래스가 수퍼 클래스를 대체합니다.

제어하지 않는 비가 상 메서드의 기능을 확장하거나 재정의하는 것이 유용한 경우가 많으므로 C #에는 new문맥 키워드 도 포함됩니다 . new대신을 재정의 키워드 “가죽”부모 방법. 상속 가능한 메소드는 가상이든 아니든 숨길 수 있습니다. 이를 통해 개발자는 그렇지 않은 멤버를 해결하지 않고도 부모로부터 상속하려는 멤버를 활용할 수 있으며 코드 소비자에게 동일한 “인터페이스”를 제공 할 수 있습니다.

숨기기는 숨기기 방법이 정의 된 상속 수준 이하에서 객체를 사용하여 사람의 관점에서 재정의하는 것과 유사하게 작동합니다. 질문의 예에서 Teacher를 만들고 Teacher 유형의 변수에 해당 참조를 저장하는 코더는 Teacher에서 ShowInfo () 구현의 동작을 볼 수 있습니다. 그러나 Person 레코드 컬렉션에서 객체를 사용하는 사람은 ShowInfo ()의 Person 구현 동작을 볼 수 있습니다. Teacher의 메소드는 부모 (Person.ShowInfo ()도 가상이어야 함)를 대체하지 않기 때문에 Person 추상화 레벨에서 작업하는 코드는 Teacher 구현을 찾지 못하고 사용하지 않습니다.

또한 new키워드가이를 명시 적으로 수행 할 뿐만 아니라 C #에서는 암시 적 메서드 숨기기를 허용합니다. override또는 없이 부모 클래스 메서드와 동일한 서명을 가진 메서드를 정의하면 메서드 new가 숨겨집니다 (ReSharper 또는 CodeRush와 같은 특정 리팩토링 도우미에서 컴파일러 경고 또는 불만 사항이 발생하지만). 이것이 C #의 디자이너가 C ++의 명시 적 재정의와 Java의 암시 적 재정의 사이에서 겪은 타협입니다. 우아하지만 우아하지만 이전 언어 중 하나의 배경에서 온 경우 항상 예상되는 동작을 생성하지는 않습니다.

새로운 내용은 다음과 같습니다 . 긴 상속 체인에서 두 키워드를 결합하면 복잡해집니다. 다음을 고려하세요:

class Foo { public virtual void DoFoo() { Console.WriteLine("Foo"); } }
class Bar:Foo { public override sealed void DoFoo() { Console.WriteLine("Bar"); } }
class Baz:Bar { public virtual void DoFoo() { Console.WriteLine("Baz"); } }
class Bai:Baz { public override void DoFoo() { Console.WriteLine("Bai"); } }
class Bat:Bai { public new void DoFoo() { Console.WriteLine("Bat"); } }
class Bak:Bat { }

Foo foo = new Foo();
Bar bar = new Bar();
Baz baz = new Baz();
Bai bai = new Bai();
Bat bat = new Bat();

foo.DoFoo();
bar.DoFoo();
baz.DoFoo();
bai.DoFoo();
bat.DoFoo();

Console.WriteLine("---");

Foo foo2 = bar;
Bar bar2 = baz;
Baz baz2 = bai;
Bai bai2 = bat;
Bat bat2 = new Bak();

foo2.DoFoo();
bar2.DoFoo();
baz2.DoFoo();
bai2.DoFoo();

Console.WriteLine("---");

Foo foo3 = bak;
Bar bar3 = bak;
Baz baz3 = bak;
Bai bai3 = bak;
Bat bat3 = bak;

foo3.DoFoo();
bar3.DoFoo();
baz3.DoFoo();
bai3.DoFoo();
bat3.DoFoo();

산출:

Foo
Bar
Baz
Bai
Bat
---
Bar
Bar
Bai
Bai
Bat
---
Bar
Bar
Bai
Bai
Bat

첫 번째 다섯 세트는 모두 예상됩니다. 각 레벨에는 구현이 있으며 인스턴스화 한 것과 동일한 유형의 오브젝트로 참조되므로 런타임은 변수 유형이 참조하는 상속 레벨에 대한 각 호출을 분석합니다.

두 번째 5 세트는 각 인스턴스를 직계 상위 유형의 변수에 할당 한 결과입니다. 이제는 행동의 차이가 있습니다. foo2는 실제로 Bar캐스트 Foo된이며 실제 객체 유형 Bar의 파생 된 메소드를 계속 찾습니다. bar2A는 Baz하지만,과는 달리 foo2바즈가 명시 적으로 바의 구현을 재정의하지 않기 때문에, (이 할 수없는 바 sealed“하향식 (top-down)”를 찾고 때), 그것은 런타임에서 볼 수없는, 그래서 바의 구현 대신이라고합니다. Baz는 new키워드 를 사용할 필요가 없습니다 . 키워드를 생략하면 컴파일러 경고가 표시되지만 C #에서 암시적인 동작은 부모 메서드를 숨기는 것입니다. baz2A는 Bai, 어떤 재정 Baz의new구현이므로 동작은와 비슷합니다 foo2. Bai에서 실제 객체 유형의 구현이 호출됩니다. bai2는 Bat부모 Bai의 메소드 구현 을 다시 숨기고 bar2Bai의 구현이 봉인되지 않은 것과 동일하게 작동 하므로 이론적으로 Bat이 메소드를 숨기는 대신 대체 할 수 있습니다. 마지막으로, bat2A는 Bak두 종류의 오버라이드 (override) 구현이없는, 단순히 부모의 것을 사용합니다.

세 번째 다섯 세트는 전체 하향식 해결 동작을 보여줍니다. 모든 것은 실제로 체인에서 가장 파생 된 클래스의 인스턴스를 참조 Bak하지만 모든 수준의 변수 유형에서 해결은 상속 체인의 해당 수준에서 시작하여 가장 파생 된 메서드의 명시 적 재정의로 드릴 다운하여 수행 됩니다. 이들의 Bar, Bai,와 Bat. 따라서 메소드 숨기기는 우선하는 상속 체인을 “파괴”합니다. 숨기기 방법을 사용하려면 메서드를 숨기는 상속 수준 또는 그 이하의 객체로 작업해야합니다. 그렇지 않으면 숨겨진 방법이 “발견”되어 대신 사용됩니다.

답변

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Calls the old method.

namespace TestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.foo();        // A.foo()
            a.foo2();       // A.foo2()

            a = new B();
            a.foo();        // B.foo()
            a.foo2();       // A.foo2()
            //a.novel() is not available here

            a = new C();
            a.foo();        // C.foo()
            a.foo2();       // A.foo2()

            B b1 = (B)a;
            b1.foo();       // C.foo()
            b1.foo2();      // B.foo2()
            b1.novel();     // B.novel()

            Console.ReadLine();
        }
    }


    class A
    {
        public virtual void foo()
        {
            Console.WriteLine("A.foo()");
        }

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

    class B : A
    {
        public override void foo()
        {
            // This is an override
            Console.WriteLine("B.foo()");
        }

        public new void foo2()      // Using the 'new' keyword doesn't make a difference
        {
            Console.WriteLine("B.foo2()");
        }

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

    class C : B
    {
        public override void foo()
        {
            Console.WriteLine("C.foo()");
        }

        public new void foo2()
        {
            Console.WriteLine("C.foo2()");
        }
    }
}

A a = new B();
a.foo();