เหตุใดการจับที่ว่างเปล่าจึงปิดกั้นความคิดที่ไม่ดี [ปิด]

ฉันเพิ่งเห็นคำถามเกี่ยวกับลองจับซึ่งคน (รวมถึง Jon Skeet) ว่าบล็อกว่างเปล่าจับเป็นความคิดที่ไม่ดีจริง ๆ ทำไมเป็นเช่นนี้ ไม่มีสถานการณ์ที่จับเปล่าไม่มีการตัดสินใจออกแบบที่ผิดหรือเปล่า?

ตัวอย่างเช่นฉันหมายถึงบางครั้งคุณต้องการรับข้อมูลเพิ่มเติมจากที่อื่น (เว็บเซอร์, ฐานข้อมูล) และคุณไม่สนใจว่าคุณจะได้รับข้อมูลนี้หรือไม่ ดังนั้นคุณพยายามที่จะรับมันและหากมีอะไรเกิดขึ้นก็ไม่เป็นไรฉันจะเพิ่ม "catch (ข้อยกเว้นละเว้น) {}" และนั่นคือทั้งหมด

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

มันเทียบเท่ากับการเขียนโปรแกรมการใส่เทปสีดำบนไฟเตือนเครื่องยนต์

ผมเชื่อว่าวิธีการที่คุณจัดการกับข้อยกเว้นขึ้นอยู่กับสิ่งที่ชั้นของซอฟต์แวร์ที่คุณกำลังทำงานอยู่ใน: ข้อยกเว้นในป่าฝนเขตร้อน

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

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

ฉันจะไม่ยืดสิ่งต่าง ๆ เท่าที่จะบอกได้ว่าใครใช้บล็อก catch ว่างเปล่าเป็นโปรแกรมเมอร์ที่ไม่ดีและไม่รู้ว่าเขากำลังทำอะไร ...

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

ตัวอย่างเช่นลองพิจารณาไลบรารี่เซิร์ฟเวอร์ http บางตัวฉันไม่สนหรอกถ้าเซิร์ฟเวอร์มีข้อยกเว้นเนื่องจากไคลเอ็นต์ได้ยกเลิกการเชื่อมต่อและindex.htmlไม่สามารถส่งได้

มีอินสแตนซ์ที่หายากซึ่งสามารถพิสูจน์ได้ ใน Python คุณมักจะเห็นสิ่งก่อสร้างประเภทนี้:

try:
    result = foo()
except ValueError:
    result = None

ดังนั้นมันอาจจะโอเค (ขึ้นอยู่กับใบสมัครของคุณ):

result = bar()
if result == None:
    try:
        result = foo()
    except ValueError:
        pass # Python pass is equivalent to { } in curly-brace languages
 # Now result == None if bar() returned None *and* foo() failed

ในโครงการ. NET ล่าสุดฉันต้องเขียนรหัสเพื่อระบุ DLLs ของปลั๊กอินเพื่อค้นหาคลาสที่ใช้อินเทอร์เฟซที่แน่นอน บิตของรหัสที่เกี่ยวข้อง (ใน VB.NET, ขอโทษ) คือ:

    For Each dllFile As String In dllFiles
        Try
            ' Try to load the DLL as a .NET Assembly
            Dim dll As Assembly = Assembly.LoadFile(dllFile)
            ' Loop through the classes in the DLL
            For Each cls As Type In dll.GetExportedTypes()
                ' Does this class implement the interface?
                If interfaceType.IsAssignableFrom(cls) Then

                    ' ... more code here ...

                End If
            Next
        Catch ex As Exception
            ' Unable to load the Assembly or enumerate types -- just ignore
        End Try
    Next

แม้ว่าในกรณีนี้ฉันยอมรับว่าการบันทึกความล้มเหลวบางแห่งอาจเป็นการปรับปรุง

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

ในบันทึกที่เกี่ยวข้องคนส่วนใหญ่ไม่ทราบว่าสามารถลอง {} บล็อกด้วยการจับ {} หรือในที่สุด {} จำเป็นต้องมีเพียงหนึ่งรายการเท่านั้น

ข้อยกเว้นควรถูกโยนหากมีข้อยกเว้นอย่างแท้จริง - มีบางสิ่งที่เกิดขึ้นเกินกว่ามาตรฐาน บล็อกการจับที่ว่างเปล่าโดยทั่วไปบอกว่า "มีบางสิ่งไม่ดีเกิดขึ้น แต่ฉันไม่สนใจ" นี่เป็นความคิดที่ไม่ดี

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

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

แต่ถึงแม้ในกรณีนั้นข้อความดีบั๊กอาจอยู่ในลำดับ

Per Josh Bloch - รายการที่ 65: อย่าเพิกเฉยข้อยกเว้นของJava ที่มีประสิทธิภาพ :

1. บล็อก catch ว่างเปล่าเอาชนะวัตถุประสงค์ของข้อยกเว้น
2. อย่างน้อยที่สุดบล็อก catch ควรมีข้อคิดเห็นที่อธิบายว่าทำไมจึงสมควรละเว้นข้อยกเว้น

บล็อก catch ว่างเปล่ากำลังพูดว่า "ฉันไม่ต้องการทราบว่ามีข้อผิดพลาดอะไรเกิดขึ้นฉันแค่จะเพิกเฉยต่อข้อผิดพลาดเหล่านั้น"

มันคล้ายกับของ VB6 On Error Resume Nextยกเว้นว่าสิ่งใดในบล็อกลองหลังจากโยนข้อยกเว้นจะถูกข้าม

ซึ่งไม่ได้ช่วยอะไรเลยเมื่อมีบางสิ่งเกิดขึ้น

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

ฉันคิดว่าการบล็อก catch ว่างเปล่าอย่างสมบูรณ์เป็นความคิดที่ไม่ดีเพราะไม่มีวิธีที่จะอนุมานได้ว่าการละเว้นข้อยกเว้นนั้นเป็นพฤติกรรมตามที่ตั้งใจไว้ของโค้ด ไม่จำเป็นที่จะกลืนข้อยกเว้นและส่งคืนค่าเท็จหรือค่า Null หรือค่าอื่น ๆ ในบางกรณี เฟรมเวิร์ก. net มีวิธี "ลอง" มากมายที่ทำหน้าที่นี้ ตามกฎทั่วไปหากคุณกลืนข้อยกเว้นให้เพิ่มความคิดเห็นและคำสั่งบันทึกหากแอปพลิเคชันรองรับการบันทึก

เพราะถ้ามีข้อยกเว้นจะโยนคุณจะไม่เคยเห็นมัน - ความล้มเหลวอย่างเงียบ ๆ เป็นตัวเลือกที่เลวร้ายที่สุด - คุณจะได้รับพฤติกรรมที่ผิดพลาดและไม่มีความคิดที่จะมองไปที่มันเกิดขึ้น อย่างน้อยใส่ข้อความบันทึกไว้ที่นั่น! แม้ว่าจะเป็นสิ่งที่ 'ไม่สามารถเกิดขึ้นได้'!

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

ฉันพบว่าคำสั่ง catch ที่น่ารำคาญที่สุดคือเมื่อโปรแกรมเมอร์รายอื่นทำมัน สิ่งที่ฉันหมายถึงคือเมื่อคุณต้องการแก้จุดบกพร่องรหัสจากบุคคลอื่นใด ๆ คำสั่ง catch ที่ว่างเปล่าทำให้งานนั้นยากขึ้นกว่าที่คุณต้องการ IMHO catch statement ควรแสดงข้อความแสดงข้อผิดพลาดบางประเภทเสมอ - แม้ว่าข้อผิดพลาดจะไม่ได้รับการจัดการอย่างน้อยก็ควรตรวจจับได้ (alt. เปิดเฉพาะในโหมดดีบักเท่านั้น)

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

try
{
    // Do some processing.
}
catch (FileNotFound fnf)
{
    HandleFileNotFound(fnf);
}
catch (Exception e)
{
    if (!IsGenericButExpected(e))
        throw;
}

public bool IsGenericButExpected(Exception exception)
{
    var expected = false;
    if (exception.Message == "some expected message")
    {
        // Handle gracefully ... ie. log or something.
        expected = true;
    }

    return expected;
}

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

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

ตัวอย่างอื่น: CLR 2.0 เปลี่ยนวิธีการจัดการข้อยกเว้นที่ไม่ได้จัดการในเธรด finalizer ก่อนหน้า 2.0 กระบวนการได้รับอนุญาตให้อยู่รอดในสถานการณ์นี้ ใน CLR ปัจจุบันกระบวนการจะถูกยกเลิกในกรณีที่มีข้อยกเว้นที่ไม่สามารถจัดการได้บนเธรด finalizer

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

ตัวอย่างเช่นฉันหมายถึงบางครั้งคุณต้องการรับข้อมูลเพิ่มเติมจากที่อื่น (เว็บเซอร์, ฐานข้อมูล) และคุณไม่สนใจว่าคุณจะได้รับข้อมูลนี้หรือไม่ ดังนั้นคุณพยายามที่จะรับมันและหากมีอะไรเกิดขึ้นก็ไม่เป็นไรฉันจะเพิ่ม "catch (ข้อยกเว้นละเว้น) {}" และนั่นคือทั้งหมด

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

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

มีสถานการณ์ที่คุณอาจใช้พวกเขา แต่พวกเขาควรจะไม่บ่อยนัก สถานการณ์ที่ฉันอาจใช้อย่างใดอย่างหนึ่งรวมถึง:

• การบันทึกข้อยกเว้น; ขึ้นอยู่กับบริบทคุณอาจต้องการข้อยกเว้นที่ไม่สามารถจัดการได้หรือโพสต์ข้อความแทน

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

• โปรแกรมที่ไม่สามารถล้มเหลวได้แต่อย่างน้อยก็ควรมีการบันทึกบางอย่าง

สำหรับแอปพลิเคชัน winforms ส่วนใหญ่ฉันพบว่าพอเพียงที่จะมีคำสั่งลองเดียวสำหรับผู้ใช้ทุกคน ฉันใช้วิธีการต่อไปนี้: (AlertBox เป็นเพียง MessageBox.Show wrapper)

  public static bool TryAction(Action pAction)
  {
     try { pAction(); return true; }
     catch (Exception exception)
     {
        LogException(exception);
        return false;
     }
  }

  public static bool TryActionQuietly(Action pAction)
  {
     try { pAction(); return true; }
     catch(Exception exception)
     {
        LogExceptionQuietly(exception);
        return false;
     }
  }

  public static void LogException(Exception pException)
  {
     try
     {
        AlertBox(pException, true);
        LogExceptionQuietly(pException);
     }
     catch { }
  }

  public static void LogExceptionQuietly(Exception pException)
  {
     try { Debug.WriteLine("Exception: {0}", pException.Message); } catch { }
  }

จากนั้นตัวจัดการเหตุการณ์ทุกคนสามารถทำสิ่งที่ชอบ:

  private void mCloseToolStripMenuItem_Click(object pSender, EventArgs pEventArgs)
  {
     EditorDefines.TryAction(Dispose);
  }

หรือ

  private void MainForm_Paint(object pSender, PaintEventArgs pEventArgs)
  {
     EditorDefines.TryActionQuietly(() => Render(pEventArgs));
  }

ในทางทฤษฎีคุณอาจมี TryActionSilently ซึ่งอาจดีกว่าสำหรับการแสดงผลการโทรเพื่อที่ข้อยกเว้นจะไม่สร้างข้อความจำนวนไม่รู้จบ

หากคุณไม่รู้ว่าต้องทำอย่างไรใน catch block คุณสามารถบันทึกข้อยกเว้นนี้ได้ แต่อย่าปล่อยว่างไว้

        try
        {
            string a = "125";
            int b = int.Parse(a);
        }
        catch (Exception ex)
        {
            Log.LogError(ex);
        }

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