อะไรคือการใช้ downcasting ที่เหมาะสม?

Downcasting หมายถึงการคัดเลือกจากคลาสพื้นฐาน (หรืออินเทอร์เฟซ) ไปยังคลาสย่อยหรือคลาสลีฟ

ตัวอย่างของการดาวน์สตรีมอาจเป็นหากคุณส่งจากSystem.Objectประเภทอื่น

Downcasting นั้นเป็นที่นิยมอาจจะเป็นกลิ่นรหัส: หลักคำสอนเชิงวัตถุนั้นต้องการที่จะยกตัวอย่างเช่นการกำหนดและการเรียกวิธีเสมือนหรือนามธรรมแทนที่จะเป็นการลดทอน

• หากมีกรณีใดบ้างเป็นกรณีการใช้งานที่เหมาะสมและเหมาะสมสำหรับการลดความเร็ว? นั่นคือในสถานการณ์ใดมันเป็นสิ่งที่เหมาะสมในการเขียนรหัสที่ downcasts?
• หากคำตอบของคุณคือ "none" ดังนั้นทำไมระบบ downcasting จึงรองรับภาษานี้

นี่คือการใช้ downcasting ที่เหมาะสม

และฉันก็ไม่เห็นด้วยอย่างรุนแรงกับคนอื่น ๆ ที่กล่าวว่าการใช้ downcasts เป็นกลิ่นรหัสแน่นอนเพราะฉันเชื่อว่าไม่มีวิธีอื่นที่เหมาะสมในการแก้ปัญหาที่เกี่ยวข้อง

Equals:

class A
{
    // Nothing here, but if you're a C++ programmer who dislikes object.Equals(object),
    // pretend it's not there and we have abstract bool A.Equals(A) instead.
}
class B : A
{
    private int x;
    public override bool Equals(object other)
    {
        var casted = other as B;  // cautious downcast (dynamic_cast in C++)
        return casted != null && this.x == casted.x;
    }
}

Clone:

class A : ICloneable
{
    // Again, if you dislike ICloneable, that's not the point.
    // Just ignore that and pretend this method returns type A instead of object.
    public virtual object Clone()
    {
        return this.MemberwiseClone();  // some sane default behavior, whatever
    }
}
class B : A
{
    private int[] x;
    public override object Clone()
    {
        var copy = (B)base.Clone();  // known downcast (static_cast in C++)
        copy.x = (int[])this.x.Clone();  // oh hey, another downcast!!
        return copy;
    }
}

Stream.EndRead/Write:

class MyStream : Stream
{
    private class AsyncResult : IAsyncResult
    {
        // ...
    }
    public override int EndRead(IAsyncResult other)
    {
        return Blah((AsyncResult)other);  // another downcast (likely ~static_cast)
    }
}

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

Downcasting นั้นเป็นที่นิยมอาจจะเป็นกลิ่นรหัส

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

ในกรณีใด [s] มันเหมาะสมที่จะเขียนรหัสที่ downcasts?

ไม่ว่าในกรณีใด:

• คุณมีความรู้ที่ถูกต้อง 100%เกี่ยวกับข้อเท็จจริงเกี่ยวกับชนิดรันไทม์ของนิพจน์ที่เฉพาะเจาะจงมากกว่าประเภทเวลารวบรวมของนิพจน์และ
• คุณจำเป็นต้องใช้ประโยชน์จากข้อเท็จจริงดังกล่าวเพื่อใช้ความสามารถของวัตถุที่ไม่มีอยู่ในประเภทเวลารวบรวมและ
• มันเป็นการใช้เวลาและความพยายามในการเขียนตัวละครได้ดีกว่าการสร้างโปรแกรมใหม่เพื่อกำจัดจุดสองจุดแรก

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

ทำไม downcasting จึงรองรับภาษา

C # ถูกคิดค้นโดยโปรแกรมเมอร์ในทางปฏิบัติที่มีงานต้องทำสำหรับโปรแกรมเมอร์ในทางปฏิบัติที่มีงานต้องทำ ผู้ออกแบบ C # ไม่ใช่คนเจ้าระเบียบ OO และระบบประเภท C # นั้นไม่สมบูรณ์แบบ; โดยการออกแบบให้ประเมินข้อ จำกัด ที่สามารถวางลงบนชนิดรันไทม์ของตัวแปรได้

นอกจากนี้ downcasting มีความปลอดภัยมากใน C # เรามีการรับประกันที่ดีว่า downcast จะถูกตรวจสอบที่ runtime และหากไม่สามารถตรวจสอบได้โปรแกรมจะทำสิ่งที่ถูกต้องและขัดข้อง มันวิเศษมาก หมายความว่าหากความเข้าใจที่ถูกต้อง 100% ของคุณเกี่ยวกับซีแมนทิกส์ประเภทเปลี่ยนเป็น 99.99% ถูกต้องโปรแกรมของคุณจะทำงาน 99.99% ของเวลาและหยุดเวลาที่เหลือแทนการทำงานที่ไม่คาดคิดและทำลายข้อมูลผู้ใช้ 0.01% ของเวลา .

การออกกำลังกาย: มีอย่างน้อยหนึ่งวิธีในการสร้าง downcast ใน C # โดยไม่ต้องใช้ตัวดำเนินการคาสต์ที่ชัดเจน คุณนึกถึงสถานการณ์แบบนั้นบ้างไหม? เนื่องจากสิ่งเหล่านี้ยังมีกลิ่นของรหัสที่เป็นไปได้คุณคิดว่าปัจจัยการออกแบบใดที่นำไปสู่การออกแบบคุณลักษณะที่อาจทำให้เกิดความผิดพลาดจากการดาวน์สตรีมโดยไม่ต้องมีการส่งรายการในโค้ด

MethodName(object sender, EventArgs e)จัดการเหตุการณ์มักจะมีลายเซ็น ในบางกรณีเป็นไปได้ที่จะจัดการกับเหตุการณ์โดยไม่คำนึงถึงประเภทsenderใดหรือแม้กระทั่งโดยไม่ใช้senderเลย แต่ในบางกรณีsenderจะต้องใช้ชนิดที่เจาะจงมากขึ้นเพื่อจัดการกับเหตุการณ์

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

private void TextBox_TextChanged(object sender, EventArgs e)
{
   TextBox box = (TextBox)sender;
   box.BackColor = string.IsNullOrEmpty(box.Text) ? Color.Red : Color.White;
}

ใช่ในตัวอย่างนี้คุณสามารถสร้างคลาสย่อยของคุณเองTextBoxซึ่งทำภายในได้ แม้ว่าจะไม่ได้ใช้งานหรือเป็นไปได้เสมอไป

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

decimal value;
Donation d = user.getDonation();
if (d is CashDonation) {
     value = ((CashDonation)d).getValue();
}
if (d is ItemDonation) {
     value = itemValueEstimator.estimateValueOf(((ItemDonation)d).getItem());
}
System.out.println("Thank you for your generous donation of $" + value);

ไม่นี่ไม่ได้กลิ่นที่ดี ในโลกที่สมบูรณ์แบบDonationจะมีวิธีที่เป็นนามธรรมgetValueและแต่ละการใช้ย่อยจะมีการใช้งานที่เหมาะสม

แต่ถ้าชั้นเรียนเหล่านี้มาจากห้องสมุดคุณไม่สามารถหรือไม่ต้องการที่จะเปลี่ยน? จากนั้นไม่มีตัวเลือกอื่น

เพื่อเพิ่มคำตอบของ Eric Lippertเนื่องจากฉันไม่สามารถแสดงความคิดเห็น ...

คุณมักจะสามารถหลีกเลี่ยงการดาวน์สตรีมด้วยการปรับโครงสร้าง API ใหม่เพื่อใช้ข้อมูลทั่วไป แต่generics ไม่ได้เพิ่มภาษาจนถึงรุ่น 2.0 ดังนั้นแม้ว่ารหัสของคุณไม่จำเป็นต้องสนับสนุนภาษาโบราณคุณอาจพบว่าคุณใช้คลาสดั้งเดิมที่ไม่ได้กำหนดพารามิเตอร์ ตัวอย่างเช่นคลาสบางคลาสอาจถูกกำหนดให้มีเพย์โหลดประเภทObjectซึ่งคุณถูกบังคับให้ส่งไปยังประเภทที่คุณรู้ว่าเป็นจริง

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

มีโครงสร้าง "ไม่ปลอดภัย" ที่ช่วยให้คุณทำการยืนยันที่ไม่ได้พิสูจน์ให้คอมไพเลอร์ ตัวอย่างเช่นการโทรแบบไม่มีเงื่อนไขNullable.Value, downcasts ที่ไม่มีเงื่อนไข, dynamicวัตถุ, ฯลฯ พวกเขาอนุญาตให้คุณยืนยันการอ้างสิทธิ์ ("ฉันยืนยันว่าวัตถุaนั้นเป็นStringถ้าฉันผิดโยนInvalidCastException") โดยไม่จำเป็นต้องพิสูจน์มัน สิ่งนี้มีประโยชน์ในกรณีที่การพิสูจน์ว่าหนักกว่าคุ้มค่าอย่างมาก

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

การดาวน์สตรีมจะถือว่าไม่ดีด้วยเหตุผลสองประการ ในขั้นต้นฉันคิดว่าเพราะมันต่อต้าน OOP

OOP จะชอบมันมากถ้าคุณไม่เคยเศร้าใจเลยเพราะ '' raison-d'etre '' คือ polymorphism หมายความว่าคุณไม่ต้องไปไหน

if(object is X)
{
    //do the thing we do with X's
}
else
{
    //of the thing we do with Y's
}

คุณทำ

x.DoThing()

และรหัสอัตโนมัติอย่างน่าอัศจรรย์ทำสิ่งที่ถูกต้อง

มีเหตุผลบางอย่าง 'ยาก' ที่จะไม่ยอมแพ้:

• ใน C ++ มันช้า
• คุณได้รับข้อผิดพลาด runtime หากคุณเลือกประเภทที่ไม่ถูกต้อง

แต่ทางเลือกในการลดความเร็วในบางสถานการณ์อาจดูน่าเกลียด

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

คุณสามารถใช้ Double Dispatch เพื่อแก้ไขปัญหา ( https://en.wikipedia.org/wiki/Double_dispatch ) ... แต่นั่นก็มีปัญหาเช่นกัน หรือคุณเพียงแค่มองหารหัสง่ายๆที่มีความเสี่ยงจากเหตุผลที่ยากเหล่านั้น

แต่นี่เป็นก่อนที่ Generics ถูกประดิษฐ์ขึ้น ตอนนี้คุณสามารถหลีกเลี่ยงการดาวน์สตรีมด้วยการระบุประเภทที่ระบุรายละเอียดในภายหลัง

MessageProccesor<T> สามารถเปลี่ยนแปลงพารามิเตอร์วิธีการและค่าส่งคืนตามประเภทที่ระบุ แต่ยังคงมีฟังก์ชั่นทั่วไป

แน่นอนว่าไม่มีใครบังคับให้คุณเขียนรหัส OOP และมีคุณสมบัติภาษามากมายที่ให้ไว้ แต่ขมวดคิ้วเช่นภาพสะท้อน

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

โดยทั่วไปการไม่ใช้บางสิ่งบางอย่างจนกระทั่งทุกวันนี้ไม่ได้บ่งบอกถึงบางสิ่งที่ไร้ประโยชน์เสมอ ;-)

การใช้ downcasting ที่พบบ่อยที่สุดในงานของฉันเป็นเพราะคนบ้าบางคนทำลายหลักการทดแทนของ Liskov

ลองนึกภาพว่ามีอินเทอร์เฟซใน lib บุคคลที่สามบางส่วน

public interface Foo
{
     void SayHello();
     void SayGoodbye();
 }

และ 2 คลาสที่ติดตั้ง และBar มีความประพฤติดีQuxBar

public class Bar
{
    void SayHello()
    {
        Console.WriteLine(“Bar says hello.”);
    }
    void SayGoodbye()
    {
         Console.WriteLine(“Bar says goodbye”);
    }
}

แต่Quxก็ไม่ได้ประพฤติดี

public class Qux
{
    void SayHello()
    {
        Console.WriteLine(“Qux says hello.”);
    }
    void SayGoodbye()
    {
        throw new NotImplementedException();
    }
}

อืม ... ตอนนี้ฉันไม่มีทางเลือก ฉันต้องพิมพ์การตรวจสอบและ (อาจ) downcast เพื่อหลีกเลี่ยงการให้โปรแกรมของฉันหยุดชะงัก

อีกตัวอย่างจริงของโลกเป็นของ VisualTreeHelperWPF มันใช้เศร้าใจที่จะโยนDependencyObjectไปและVisual Visual3Dยกตัวอย่างเช่นVisualTreeHelper.GetParent ดาวน์สตรีมเกิดขึ้นในVisualTreeUtils.AsVisualHelper :

private static bool AsVisualHelper(DependencyObject element, out Visual visual, out Visual3D visual3D)
{
    Visual elementAsVisual = element as Visual;

    if (elementAsVisual != null)
    {
        visual = elementAsVisual;
        visual3D = null;
        return true;
    }

    Visual3D elementAsVisual3D = element as Visual3D;

    if (elementAsVisual3D != null)
    {
        visual = null;
        visual3D = elementAsVisual3D;
        return true;
    }            

    visual = null;
    visual3D = null;
    return false;
}