ลอง / catch + using, ไวยากรณ์ที่ถูกต้อง

อันไหน:

using (var myObject = new MyClass())
{
   try
   {
      // something here...
   }
   catch(Exception ex)
   {
      // Handle exception
   }
}

หรือ

try
{
   using (var myObject = new MyClass())
   {
      // something here...
   }
}
catch(Exception ex)
{
   // Handle exception
}

ฉันชอบอันที่สอง อาจดักจับข้อผิดพลาดที่เกี่ยวข้องกับการสร้างวัตถุเช่นกัน

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

MyClass myObject = null;
try {
  myObject = new MyClass();
  //important stuff
} catch (Exception ex) {
  //handle exception
} finally {
  if(myObject is IDisposable) myObject.Dispose();
}

มันขึ้นอยู่กับ. หากคุณใช้ Windows Communication Foundation (WCF) using(...) { try... }จะไม่ทำงานอย่างถูกต้องหากพร็อกซีในusingคำสั่งอยู่ในสถานะข้อยกเว้นนั่นคือการทิ้งพร็อกซีนี้จะทำให้เกิดข้อยกเว้นอื่น

โดยส่วนตัวแล้วฉันเชื่อในวิธีการจัดการที่น้อยที่สุดนั่นคือจัดการกับข้อยกเว้นเพียงอย่างเดียวที่คุณทราบ ณ ตอนที่ทำการประหารชีวิต ในคำอื่น ๆ ถ้าคุณรู้ว่าการเริ่มต้นของในตัวแปรอาจจะโยนข้อยกเว้นเฉพาะอย่างยิ่งผมห่อมันด้วยusing try-catchในทำนองเดียวกันถ้าภายในusingร่างกายมีบางสิ่งบางอย่างที่อาจเกิดขึ้นซึ่งไม่เกี่ยวข้องกับตัวแปรโดยตรงusingฉันจะหุ้มมันด้วยอีกtryข้อยกเว้นนั้น ฉันไม่ค่อยได้ใช้Exceptionในcatches ของฉัน

แต่ฉันชอบIDisposableและusingแม้ว่าฉันอาจจะลำเอียง

หากคำสั่ง catch ของคุณต้องการเข้าถึงตัวแปรที่ประกาศใน statement โดยใช้คำสั่ง inside เป็นตัวเลือกเดียวของคุณ

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

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

เมื่อใดก็ตามที่ฉันมี scenerio คล้ายกับนี้บล็อก try-catch มักจะอยู่ในวิธีการที่แตกต่างกันต่อไปขึ้นสแตกการโทรจากการใช้ มันไม่ใช่เรื่องปกติสำหรับวิธีที่จะรู้วิธีจัดการกับข้อยกเว้นที่เกิดขึ้นภายในแบบนี้

ดังนั้นคำแนะนำทั่วไปของฉันจึงอยู่ข้างนอก - ข้างนอก

private void saveButton_Click(object sender, EventArgs args)
{
    try
    {
        SaveFile(myFile); // The using statement will appear somewhere in here.
    }
    catch (IOException ex)
    {
        MessageBox.Show(ex.Message);
    }
}

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

มีสิ่งสำคัญสิ่งหนึ่งที่ฉันจะเรียกออกมาที่นี่: สิ่งแรกที่จะไม่จับข้อยกเว้นใด ๆ ที่เกิดขึ้นจากการเรียกตัวMyClassสร้าง

จาก C # 8.0 ฉันชอบใช้อันที่สองแบบนี้

public class Person : IDisposable
{
    public Person()
    {
        int a = 0;
        int b = Id / a;
    }
    public int Id { get; set; }

    public void Dispose()
    {
    }
}

แล้ว

static void Main(string[] args)
    {

        try
        {
            using var person = new Person();
        }
        catch (Exception ex) when
        (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
        ex.TargetSite.MemberType == System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Constructor Person");
        }
        catch (Exception ex) when
       (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
       ex.TargetSite.MemberType != System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Person");
        }
        catch (Exception ex)
        {
            Debug.Write(ex.Message);
        }
        finally
        {
            Debug.Write("finally");
        }
    }

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

ในสถานการณ์ของฉันฉันต้องเปิดไฟล์และฉันกำลังส่ง filePath ในตัวสร้างของวัตถุที่ฉันเริ่มต้นในบล็อก Using () และมันอาจส่งข้อยกเว้นถ้า filePath ผิด / ว่างเปล่า ดังนั้นในกรณีนี้ไวยากรณ์ที่สองจึงสมเหตุสมผล

รหัสตัวอย่างของฉัน: -

try
{
    using (var obj= new MyClass("fileName.extension"))
    {

    }
}
catch(Exception ex)
{
     //Take actions according to the exception.
}

จากC # 8.0 บนคุณสามารถทำให้usingคำสั่งง่ายขึ้นภายใต้เงื่อนไขบางอย่างเพื่อกำจัดบล็อกที่ซ้อนกันและจากนั้นจะใช้กับบล็อกที่ล้อมรอบ

ดังนั้นตัวอย่างสองตัวอย่างของคุณสามารถลดลงเป็น:

using var myObject = new MyClass();
try
{
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

และ:

try
{
   using var myObject = new MyClass();
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

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