การตรวจสอบพารามิเตอร์ Constructor ใน C # - แนวปฏิบัติที่ดีที่สุด

แนวปฏิบัติที่ดีที่สุดสำหรับการตรวจสอบความถูกต้องของพารามิเตอร์คอนสตรัคเตอร์คืออะไร?

สมมติว่า C # เป็นเรื่องง่าย:

public class MyClass
{
    public MyClass(string text)
    {
        if (String.IsNullOrEmpty(text))
            throw new ArgumentException("Text cannot be empty");

        // continue with normal construction
    }
}

มันจะเป็นที่ยอมรับที่จะโยนข้อยกเว้น?

ทางเลือกที่ฉันพบคือการตรวจสอบความถูกต้องก่อนที่จะสร้างอินสแตนซ์:

public class CallingClass
{
    public MyClass MakeMyClass(string text)
    {
        if (String.IsNullOrEmpty(text))
        {
            MessageBox.Show("Text cannot be empty");
            return null;
        }
        else
        {
            return new MyClass(text);
        }
    }
}

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

if (string.IsNullOrEmpty(text))
    throw new ArgumentException("message", "text");

หากคุณใช้. NET 4 คุณสามารถทำได้ หลักสูตรนี้ขึ้นอยู่กับว่าคุณพิจารณาสตริงที่มีเฉพาะ white space ว่าไม่ถูกต้อง

if (string.IsNullOrWhiteSpace(text))
    throw new ArgumentException("message", "text");

ผู้คนจำนวนมากระบุว่าผู้สร้างไม่ควรโยนข้อยกเว้น ตัวอย่างเช่นKyleG ในหน้านี้ทำแบบนั้น สุจริตฉันไม่สามารถคิดเหตุผลว่าทำไมไม่

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

C # ไม่สามารถรั่วไหลของหน่วยความจำจากการโทรไม่สำเร็จไปยังตัวสร้าง แม้แต่บางคลาสใน. NET Framework ก็จะมีข้อยกเว้นในตัวสร้าง

โยนข้อยกเว้น IFF ชั้นเรียนไม่สามารถอยู่ในสถานะที่สอดคล้องกับการใช้ความหมายของมัน ไม่อย่างนั้นทำไม่ได้ ไม่อนุญาตให้วัตถุมีอยู่ในสถานะไม่สอดคล้องกัน ซึ่งรวมถึงการไม่ให้ตัวสร้างที่สมบูรณ์ (เช่นมีตัวสร้างที่ว่างเปล่า + เริ่มต้น () ก่อนที่วัตถุของคุณจะถูกสร้างขึ้นจริง ๆ ) ... เพียงแค่บอกว่าไม่มี!

ในไม่ช้าทุกคนทำมัน เมื่อวันก่อนฉันทำมันเพื่อวัตถุที่แคบมาก ๆ สักวันบนถนนฉันหรือคนอื่นอาจจะจ่ายราคาสำหรับสลิปในทางปฏิบัติ

ฉันควรทราบว่าโดย "นวกรรมิก" ฉันหมายถึงสิ่งที่ลูกค้าเรียกเพื่อสร้างวัตถุ นั่นอาจเป็นสิ่งอื่นที่ไม่ใช่โครงสร้างที่เกิดขึ้นจริงโดยใช้ชื่อว่า "Constructor" ตัวอย่างเช่นสิ่งนี้ใน C ++ จะไม่ละเมิดหลักการ IMNSHO:

struct funky_object
{
  ...
private:
  funky_object();
  bool initialize(std::string);

  friend boost::optional<funky_object> build_funky(std::string);
};
boost::optional<funky_object> build_funky(std::string str)
{
  funky_object fo;
  if (fo.initialize(str)) return fo;
  return boost::optional<funky_object>();
}

เนื่องจากวิธีเดียวในการสร้าง a funky_objectคือการเรียกbuild_funkyใช้หลักการของการไม่อนุญาตให้วัตถุที่ไม่ถูกต้องยังคงอยู่ถึงแม้ว่า "Constructor" ที่แท้จริงจะไม่ทำงานให้เสร็จ

นั่นเป็นงานพิเศษมากมาย แต่เพื่อผลประโยชน์ที่น่าสงสัย ฉันยังต้องการเส้นทางยกเว้น

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

public class MyClass
{
    private MyClass(string text)
    {
        //normal construction
    }

    public static MyClass MakeMyClass(string text)
    {
        if (String.IsNullOrEmpty(text))
            return null;
        else
            return new MyClass(text);
    }
}
public class CallingClass
{
    public MyClass MakeMyClass(string text)
    {
        var cls = MyClass.MakeMyClass(text);
        if(cls == null)
             //show messagebox or throw exception
        return cls;
    }
}

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

• ตัวสร้างไม่ควรมีผลข้างเคียงใด ๆ
  • สิ่งใดที่มากกว่าการกำหนดค่าเริ่มต้นของฟิลด์ส่วนตัวควรถูกมองว่าเป็นผลข้างเคียง
  • ตัวสร้างที่มีผลข้างเคียงจะทำลาย Single-Responsibilty-Principle (SRP) และทำงานตรงกันข้ามกับจิตวิญญาณของการเขียนโปรแกรมเชิงวัตถุ (OOP)
• คอนสตรัคควรเบาและไม่ควรล้มเหลว
  • ตัวอย่างเช่นฉันมักจะสั่นเมื่อเห็นบล็อกแบบลองจับภายในตัวสร้าง ตัวสร้างไม่ควรโยนข้อยกเว้นหรือบันทึกข้อผิดพลาด

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

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

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

ดังนั้นมันขึ้นอยู่กับว่าข้อความพารามิเตอร์ที่สำคัญคือวิธีการ - วัตถุทำให้รู้สึกกับค่า Null หรือเปล่า?

ความชอบของฉันคือการตั้งค่าเริ่มต้น แต่ฉันรู้ว่า Java มีห้องสมุด "Apache Commons" ที่ทำสิ่งนี้และฉันคิดว่านั่นเป็นความคิดที่ดีเช่นกัน ฉันไม่เห็นปัญหาในการขว้างข้อยกเว้นหากค่าที่ไม่ถูกต้องจะทำให้วัตถุอยู่ในสถานะที่ใช้ไม่ได้ สตริงไม่ใช่ตัวอย่างที่ดี แต่ถ้าเป็นเพราะ DI ของคนจน คุณไม่สามารถใช้งานได้หากมีการnullส่งผ่านค่าแทนที่ICustomerRepositoryส่วนติดต่อ ในสถานการณ์เช่นนี้การโยนข้อยกเว้นเป็นวิธีที่ถูกต้องในการจัดการสิ่งต่าง ๆ ฉันจะบอกว่า

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

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

public class MyClass
{
    private string _text;
    public string Text 
    {
        get
        {
            return _text;
        } 
        set
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Text cannot be empty");
            _text = value;
        } 
    }

    public MyClass(string text)
    {
        Text = text;
        // continue with normal construction
    }
}

การโยนข้อยกเว้นจะเป็นความเจ็บปวดอย่างแท้จริงสำหรับผู้ใช้ในชั้นเรียนของคุณ หากการตรวจสอบเป็นปัญหาจากนั้นฉันมักจะสร้างวัตถุเป็นกระบวนการ 2 ขั้นตอน

1 - สร้างอินสแตนซ์

2 - เรียกวิธีการเตรียมใช้งานด้วยผลลัพธ์ส่งคืน

หรือ

เรียกเมธอด / ฟังก์ชันที่สร้างคลาสให้กับคุณที่สามารถทำการตรวจสอบได้

หรือ

มีธง isValid ซึ่งฉันไม่ชอบเป็นพิเศษ แต่บางคนก็ทำ