메서드 서명의 새 키워드

리팩토링을 수행하는 동안 아래 예제와 같은 메서드를 생성했습니다. 단순성을 위해 데이터 유형이 변경되었습니다.

이전에 다음과 같은 할당 문이있었습니다.

MyObject myVar = new MyObject();

이것은 우연히 리팩토링되었습니다.

private static new MyObject CreateSomething()
{
  return new MyObject{"Something New"};
}

이것은 내 부분에서 잘라 내기 / 붙여 넣기 오류의 결과 였지만 newin 키워드 private static new가 유효하고 컴파일됩니다.

질문 : new키워드는 메소드 서명에서 무엇을 의미합니까? 나는 그것이 C # 3.0에서 도입 된 것이라고 가정합니까?

이것이 어떻게 다른 override가요?

MSDN의 새로운 키워드 참조 :

MSDN 참조

다음은 인터넷에서 찾은 Microsoft MVP의 좋은 예입니다. Link to Original

public class A
{
   public virtual void One();
   public void Two();
}

public class B : A
{
   public override void One();
   public new void Two();
}

B b = new B();
A a = b as A;

a.One(); // Calls implementation in B
a.Two(); // Calls implementation in A
b.One(); // Calls implementation in B
b.Two(); // Calls implementation in B

재정의는 매우 특정한 경우에만 사용할 수 있습니다. MSDN에서 :

비가 상 또는 정적 메서드는 재정의 할 수 없습니다. 재정의 된 기본 메서드는 가상, 추상 또는 재정의 여야합니다.

따라서 비가 상 및 정적 메서드를 '재정의'하려면 'new'키워드가 필요합니다.

아니, 사실 "새로운"것이 아닙니다 (말장난을 용서하십시오). 기본적으로 메서드를 "숨기기"에 사용됩니다. IE :

public class Base
{
   public virtual void Method(){}
}

public class Derived : Base
{
   public new void Method(){}
}

그런 다음 이렇게하면 :

Base b = new Derived();
b.Method();

Base의 메서드는 파생 된 메서드가 아니라 호출 될 메서드입니다.

추가 정보 : http://www.akadia.com/services/dotnet_polymorphism.html

다시 편집하십시오 . 내가 준 예제에서 "new"를 사용하는 대신 "재정의"하려면 b.Method (); Derived 클래스의 Method는 Polymorphism 때문에 호출됩니다.

다른 사람들이 설명했듯이 기존 메서드를 숨기는 데 사용됩니다. 부모 클래스에서 가상이 아닌 메서드를 재정의하는 데 유용합니다.

"새"멤버를 만드는 것은 다형성이 아닙니다. 개체를 기본 형식으로 캐스팅하면 파생 형식의 멤버를 사용하지 않습니다.

기본 클래스가있는 경우 :

public class BaseClass
{
    public void DoSomething() { }
}

그리고 파생 클래스 :

public class DerivedType : BaseClass
{
    public new void DoSomething() {}

}

유형을 선언 한 DerivedType다음 캐스트하면 메서드 DoSomething()는 다형성이 아니며 파생 된 메서드가 아닌 기본 클래스의 메서드를 호출합니다.

BaseClass t = new DerivedType();
t.DoSomething();// Calls the "DoSomething()" method of the base class.

문서에서 :

파생 클래스의 메서드 앞에 new 키워드가있는 경우 메서드는 기본 클래스의 메서드와 독립적 인 것으로 정의됩니다.

이것이 실제로 의미하는 바 :

다른 클래스에서 상속하고 동일한 서명을 공유하는 메서드가있는 경우이를 'new'로 정의하여 부모 클래스와 독립적으로 만들 수 있습니다. 즉, '부모'클래스에 대한 참조가 있으면 해당 구현이 실행되고, 하위 클래스에 대한 참조가 있으면 해당 구현이 실행됩니다.

개인적으로 'new'키워드는 일반적으로 내 클래스 계층 구조가 잘못되었음을 의미하므로 피하려고하지만 유용 할 수있는 경우가 있습니다. 한 곳은 버전 관리 및 이전 버전과의 호환성입니다.

이에 대한 MSDN 에는 많은 정보가 있습니다.

이는 메서드가 기본 클래스에서 상속 한 동일한 이름으로 메서드를 대체 함을 의미합니다. 귀하의 경우에는 기본 클래스에 해당 이름의 메서드가 없을 것입니다. 즉, 새 키워드가 완전히 불필요합니다.

짧게 말하면 필수 사항이 아니며 동작을 변경하지 않으며 가독성을 위해 순전히 있습니다.

그렇기 때문에 VS에서 약간 구불 구불하게 보일 수 있지만 코드는 예상대로 완벽하게 잘 컴파일되고 실행됩니다.

new개발자가 "예, 기본 메서드를 숨기고 있다는 것을 알고 있습니다. 예, virtualor overriden(다형성) 와 관련된 작업을 수행하지 않는다는 것을 알고 있습니다."라고 인정하는 경우 키워드를 만드는 것이 정말 가치가 있는지 궁금해해야합니다. 나는 정말로 그것만의 방법을 만들고 싶다. "

그것은 나에게 조금 이상한,하지만 어쩌면 단지 난에서 온 때문에 Java배경 사이의 근본적인 차이가있어 C#상속과는 Java:에서가 Java지정하지 않는 한 방법이 기본적으로 가상 있습니다 final. 에서가 C#지정하지 않는 한 방법은 기본적으로 최종 / 콘크리트입니다 virtual.

에서 MSDN :

new 한정자를 사용하여 기본 클래스에서 상속 된 멤버를 명시 적으로 숨 깁니다. 상속 된 멤버를 숨기려면 동일한 이름을 사용하여 파생 클래스에서 선언하고 새 수정 자로 수정합니다.

이 문제를 조심하십시오.
기본 클래스에 구현 된 인터페이스에 정의 된 메서드가 있습니다. 그런 다음 인터페이스의 메서드를 숨기는 파생 클래스를 만들지 만 인터페이스를 구현하는 것으로 파생 클래스를 명시 적으로 선언하지 않습니다. 그런 다음 인터페이스에 대한 참조를 통해 메서드를 호출하면 기본 클래스의 메서드가 호출됩니다. 그러나 파생 클래스가 인터페이스를 구체적으로 구현하는 경우 해당 메서드는 사용되는 참조 유형에 관계없이 호출됩니다.

interface IMethodToHide
{
    string MethodToHide();
}

class BaseWithMethodToHide : IMethodToHide
{
    public string MethodToHide()
    {
        return "BaseWithMethodToHide";
    }
}

class DerivedNotImplementingInterface   : BaseWithMethodToHide
{
    new public string MethodToHide()
    {
        return "DerivedNotImplementingInterface";
    }
}

class DerivedImplementingInterface : BaseWithMethodToHide, IMethodToHide
{
    new public string MethodToHide()
    {
        return "DerivedImplementingInterface";
    }
}

class Program
{
    static void Main()
    {
        var oNoI = new DerivedNotImplementingInterface();
        IMethodToHide ioNoI = new DerivedNotImplementingInterface();

        Console.WriteLine("reference to the object type DerivedNotImplementingInterface calls the method in the class " 
            + oNoI.MethodToHide());
        // calls DerivedNotImplementingInterface.MethodToHide()
        Console.WriteLine("reference to a DerivedNotImplementingInterface object via the interfce IMethodToHide calls the method in the class " 
            + ioNoI.MethodToHide());
        // calls BaseWithMethodToHide.MethodToHide()
        Console.ReadLine();

        var oI = new DerivedImplementingInterface();
        IMethodToHide ioI = new DerivedImplementingInterface();

        Console.WriteLine("reference to the object type DerivedImplementingInterface calls the method in the class " 
            + oI.MethodToHide());
        // calls DerivedImplementingInterface.MethodToHide()
        Console.WriteLine("reference to a DerivedImplementingInterface object via the interfce IMethodToHide calls the method in the class " 
            + ioI.MethodToHide());
        // calls DerivedImplementingInterface.MethodToHide()
        Console.ReadLine();

    }
}