เมื่อใดที่“ ลอง” ควรจะใช้ในชื่อเมธอด C #

เรากำลังพูดคุยกับเพื่อนร่วมงานของเราเกี่ยวกับความหมายว่าถ้าชื่อวิธีการขึ้นต้นด้วย "ลอง"

มีความคิดเห็นดังต่อไปนี้:

• ใช้ "ลอง" เมื่อวิธีสามารถคืนค่าเป็นศูนย์ได้
• ใช้ "ลอง" เมื่อวิธีการจะไม่เกิดข้อยกเว้น

คำจำกัดความอย่างเป็นทางการคืออะไร "ลอง" พูดในชื่อวิธีการอะไร? มีแนวทางที่เป็นทางการเกี่ยวกับเรื่องนี้หรือไม่?

สิ่งนี้เรียกว่ารูปแบบTryParseและได้รับการรับรองโดย Microsoft หน้าข้อยกเว้นอย่างเป็นทางการและประสิทธิภาพของ MSDN ระบุว่า :

พิจารณารูปแบบ TryParse สำหรับสมาชิกที่อาจเกิดข้อยกเว้นในสถานการณ์ทั่วไปเพื่อหลีกเลี่ยงปัญหาด้านประสิทธิภาพที่เกี่ยวข้องกับข้อยกเว้น

ดังนั้นหากคุณมีรหัสซึ่งกรณีการใช้งานปกติอาจหมายความว่ามันอาจจะมีข้อยกเว้น (เช่นการแยกวิเคราะห์ int) รูปแบบTryParse มีเหตุผล

(แก้ไขแล้ว)มีแนวทางอย่างเป็นทางการตามที่ Erik แนะนำ

เมื่อฉันเห็นTrySomethingวิธีฉันถือว่ามัน

• ไม่โยน
• ผลตอบแทน bool
• ถ้าฉันคาดหวังค่ามันจะถูกส่งกลับผ่านพารามิเตอร์ 'ออก'
• มีSomethingวิธีการอยู่ที่อนุญาตให้ฉันจัดการกับข้อยกเว้นใด ๆ ด้วยตัวเอง (แก้ไขแนะนำโดย Jesse Webb)

ฉันคิดว่าคุณควรใช้tryเมื่อคุณต้องการดำเนินการต่อ มันไม่สำคัญว่าเมธอดจะส่งคืนค่าบางค่าหรือไม่

กรณีที่ 1: หากผลตอบแทนดีคุณสามารถดำเนินการต่อในทางใดทางหนึ่ง

กรณีที่ 2: หากยังไม่ส่งคืน: ยังคงใช้ได้ คุณสามารถดำเนินการในวิธีอื่น

และถ้าคุณคาดหวังว่าค่าบางอย่างเป็นผลลัพธ์ของวิธีการนั้นให้ใช้outพารามิเตอร์

ตัวอย่าง

int value
if (dictionary.TryGetValue("key", out value))
{
    // Proceed in some way
}
else
{
    // Proceed in some other way
}

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

ในตอนท้ายข้อตกลงทั้งหมดนี้เกี่ยวกับการตั้งชื่อที่คุณตัดสินใจใช้ในกลุ่มของคุณ

ตรวจสอบให้แน่ใจว่าได้รวมtryไว้ใน methodname ของคุณหาก:

• คุณไม่ได้โยนข้อยกเว้นใด ๆ
• วิธีการของคุณมีลายเซ็นต่อไปนี้: bool TrySomething(input, out yourReturn)

ดังนั้นโดยทั่วไปถ้าเราใช้ - tryวิธีเราจะได้รับผลบูลีนกลับมา

ดังนั้นรหัสต่อไปนี้จะไม่ส่งข้อยกเว้นใด ๆ :

string input = "blabla";
int number;
if (int.TryParse(input, out number))
{
// wooohooo we got an int!
} else
{
//dooh!
}

ในขณะที่รหัสนี้สามารถ (และในกรณีนี้) โยนข้อยกเว้น:

string input = "blabla";
int number;
try
{
     number = int.Parse(input); //throws an exception
}
catch (Exception)
{
     //dooh!
}

การใช้วิธีการทดลองเป็นวิธีที่ปลอดภัยและป้องกันรหัส นอกจากนี้ข้อมูลโค้ด # 2 ยังใช้ประสิทธิภาพในการดำเนินการมากขึ้นหากไม่ใช่จำนวนเต็ม

ลุงบ๊อบให้ตัวอย่างด้านล่างนี้ในหนังสือของเขารหัสสะอาด เมื่อใดก็ตามที่เราคาดว่าจะมีข้อผิดพลาดเกิดขึ้นเราสามารถใช้Tryคำนำหน้ากับชื่อเมธอด:

public void sendShutDown()
{
    try{
        tryToShutDown();
    } catch (DeviceShutDownError e) {
        logger.log(e);            
    }
}

และจากนั้น (ดัดแปลง):

private void tryToShutDown()
{
    //some code with no error handling, but
    //something might go wrong here
}

tryToShutDownวิธีการไม่ได้ทำให้จัดการข้อผิดพลาดใด ๆ เนื่องจากว่าเป็นความรับผิดชอบของsendShutDownวิธีการ

TryParseรูปแบบของไมโครซอฟท์ละเมิดแนวทางรหัสสะอาดที่บอกว่าเราควรหลีกเลี่ยงพารามิเตอร์ที่ส่งออก

หากเราไม่ได้พัฒนา C # เวอร์ชันใหม่เราไม่จำเป็นต้องปฏิบัติตามแนวทางทั้งหมดของ Microsoft บางครั้งพวกเขาก็ไม่ได้ดีที่สุด