คำหลักใหม่ในลายเซ็นวิธี

ในขณะที่ทำการปรับโครงสร้างใหม่ฉันได้สร้างวิธีการดังตัวอย่างด้านล่าง ประเภทข้อมูลได้รับการเปลี่ยนแปลงเพื่อความเรียบง่าย

ก่อนหน้านี้ฉันมีคำสั่งมอบหมายเช่นนี้:

MyObject myVar = new MyObject();

มันถูกปรับโครงสร้างใหม่โดยบังเอิญ:

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

นี่เป็นผลมาจากข้อผิดพลาดในการตัด / วางในส่วนของฉัน แต่newคำหลักในprivate static newถูกต้องและคอมไพล์

คำถาม : อะไรคือnewคำสำคัญมีความหมายอย่างไรในลายเซ็นของวิธีการ? ฉันคิดว่ามันเป็นสิ่งที่แนะนำใน C # 3.0?

สิ่งนี้แตกต่างจากoverrideอย่างไร?

การอ้างอิงคำหลักใหม่จาก MSDN:

MSDN อ้างอิง

นี่คือตัวอย่างที่ฉันพบในเน็ตจาก Microsoft MVP ที่สมเหตุสมผล: ลิงก์ไปยังต้นฉบับ

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:

คุณไม่สามารถแทนที่วิธีการที่ไม่ใช่เสมือนหรือแบบคงที่ เมธอดฐานที่ถูกแทนที่ต้องเป็นเสมือนนามธรรมหรือลบล้าง

ดังนั้นจึงจำเป็นต้องใช้คำหลัก "ใหม่" เพื่อให้คุณสามารถ "ลบล้าง" วิธีการที่ไม่ใช่เสมือนและคงที่ได้

ไม่จริงแล้วมันไม่ใช่ "ใหม่" (ให้อภัยเล่นสำนวน) โดยพื้นฐานแล้วจะใช้สำหรับวิธี "ซ่อน" IE:

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

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

หากคุณทำสิ่งนี้:

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

วิธีการในฐานเป็นวิธีที่จะถูกเรียกไม่ใช่วิธีที่ได้รับ

ข้อมูลเพิ่มเติมบางส่วน: http://www.akadia.com/services/dotnet_polymorphism.html

Re ของคุณแก้ไข:ในตัวอย่างที่ผมให้ไว้ถ้าคุณจะ "override" แทนการใช้ "new" เมื่อคุณเรียก b.Method (); วิธีการของคลาสที่ได้รับจะถูกเรียกเนื่องจากความหลากหลาย

ตามที่คนอื่นอธิบายมันถูกใช้เพื่อซ่อนวิธีการที่มีอยู่ มีประโยชน์สำหรับการลบล้างเมธอดที่ไม่เสมือนในคลาสพาเรนต์

โปรดทราบว่าการสร้างสมาชิก "ใหม่" ไม่ใช่ความหลากหลาย หากคุณโยนวัตถุไปยังประเภทพื้นฐานวัตถุนั้นจะไม่ใช้สมาชิกของประเภทที่ได้รับ

หากคุณมีคลาสพื้นฐาน:

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.

จากเอกสาร:

ถ้าเมธอดในคลาสที่ได้รับนำหน้าด้วยคีย์เวิร์ดใหม่เมธอดจะถูกกำหนดให้เป็นอิสระจากเมธอดในคลาสพื้นฐาน

ความหมายในทางปฏิบัติ:

หากคุณสืบทอดจากคลาสอื่นและคุณมีวิธีการที่แชร์ลายเซ็นเดียวกันคุณสามารถกำหนดเป็น 'ใหม่' เพื่อให้เป็นอิสระจากคลาสแม่ ซึ่งหมายความว่าหากคุณมีการอ้างอิงถึงคลาส 'พาเรนต์' การใช้งานนั้นจะถูกดำเนินการหากคุณมีการอ้างอิงถึงคลาสลูกการใช้งานนั้นจะถูกดำเนินการ

โดยส่วนตัวแล้วฉันพยายามหลีกเลี่ยงคีย์เวิร์ด 'ใหม่' ตามปกติหมายความว่าฉันมีลำดับชั้นของคลาสผิด แต่ก็มีบางครั้งที่อาจมีประโยชน์ สถานที่หนึ่งสำหรับการกำหนดเวอร์ชันและความเข้ากันได้ย้อนหลัง

มีข้อมูลจำนวนมากที่อยู่ในที่ MSDN สำหรับเรื่องนี้

หมายความว่าเมธอดแทนที่เมธอดด้วยชื่อเดียวกันที่สืบทอดโดยคลาสฐาน ในกรณีของคุณคุณอาจไม่มีเมธอดตามชื่อนั้นในคลาสพื้นฐานซึ่งหมายความว่าคีย์เวิร์ดใหม่นั้นไม่จำเป็นโดยสิ้นเชิง

เรื่องสั้นขนาดยาว - ไม่จำเป็นมันเปลี่ยนพฤติกรรมไม่และมันมีไว้เพื่อให้อ่านง่าย

นั่นเป็นเหตุผลว่าทำไมใน VS คุณจะเห็นมันกระตุกเล็กน้อย แต่โค้ดของคุณจะคอมไพล์และทำงานได้ดีและเป็นไปตามที่คาดไว้

เราต้องสงสัยว่าการสร้างnewคีย์เวิร์ดนั้นคุ้มค่าหรือไม่เมื่อผู้พัฒนายอมรับว่า "ใช่ฉันรู้ว่าฉันกำลังซ่อนวิธีการพื้นฐานใช่ฉันรู้ว่าฉันไม่ได้ทำอะไรที่เกี่ยวข้องกับvirtualหรือoverriden(ความหลากหลาย) - ฉันต้องการเพียงแค่สร้างวิธีการของตัวเอง "

เป็นบิตที่แปลกประหลาดกับผม แต่อาจจะเพียงเพราะผมมาจากJavaพื้นหลังและมีความแตกต่างนี้พื้นฐานระหว่างC#มรดกและJava: ในวิธีการนี้เป็นเสมือนโดยเริ่มต้นนอกจากที่ระบุไว้โดยJava finalในC#วิธีการเป็นที่สิ้นสุด / virtualคอนกรีตโดยปริยายนอกจากที่ระบุไว้โดย

จากMSDN :

ใช้ตัวปรับแต่งใหม่เพื่อซ่อนสมาชิกที่สืบทอดมาจากคลาสพื้นฐานอย่างชัดเจน หากต้องการซ่อนสมาชิกที่สืบทอดมาให้ประกาศในคลาสที่ได้รับโดยใช้ชื่อเดียวกันและแก้ไขด้วยตัวปรับแต่งใหม่

ระวัง gotcha นี้
คุณมีวิธีการที่กำหนดไว้ในอินเตอร์เฟสที่ใช้งานในคลาสพื้นฐาน จากนั้นคุณสร้างคลาสที่ได้รับมาซึ่งซ่อนเมธอดของอินเทอร์เฟซ แต่ไม่ได้ประกาศเฉพาะคลาสที่ได้รับมาเป็นการใช้งานอินเทอร์เฟซ หากคุณเรียกใช้เมธอดผ่านการอ้างอิงไปยังอินเตอร์เฟสเมธอดของคลาสพื้นฐานจะถูกเรียกใช้ อย่างไรก็ตามหากคลาสที่ได้รับมาของคุณใช้อินเทอร์เฟซโดยเฉพาะเมธอดของมันจะถูกเรียกว่าใช้การอ้างอิงประเภทใด

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();

    }
}