มันเพียงพอสำหรับวิธีการที่จะโดดเด่นเพียงแค่ชื่ออาร์กิวเมนต์ (ไม่พิมพ์)?

มันเพียงพอสำหรับวิธีการที่จะโดดเด่นเพียงแค่ชื่ออาร์กิวเมนต์ (ไม่พิมพ์) หรือมันจะดีกว่าที่จะตั้งชื่ออย่างชัดเจนมากขึ้น?

ยกตัวอย่างเช่นVST Find<T>(int id)T FindById<T>(int id)

มีเหตุผลที่ดีที่จะตั้งชื่ออย่างชัดเจนยิ่งขึ้น (เช่นการเพิ่มById) และการเก็บชื่ออาร์กิวเมนต์เพียงอย่างเดียวหรือไม่

เหตุผลหนึ่งที่ฉันคิดได้ก็คือเมื่อลายเซ็นของวิธีการเหมือนกัน แต่มีความหมายแตกต่างกัน

FindByFirstName(string name) และ FindByLastName(string name)

แน่นอนว่ามีเหตุผลที่ดีในการตั้งชื่อให้ชัดเจนยิ่งขึ้น

มันไม่ได้เป็นส่วนใหญ่จะเป็นวิธีการที่ความหมายที่ควรจะเป็นตัวอธิบาย แต่วิธีการใช้งาน และในขณะที่findById(string id)และfind(string id)มีทั้งอธิบายตนเองมีความแตกต่างกันมากระหว่างและfindById("BOB") find("BOB")ในกรณีก่อนหน้านี้คุณรู้ว่าตัวอักษรแบบสุ่มในความเป็นจริงแล้วเป็นรหัส ในกรณีหลังคุณไม่แน่ใจ - อาจเป็นชื่อจริงหรืออย่างอื่นโดยสิ้นเชิง

ข้อดีของการ FindById ()

1. อนาคตพิสูจน์อักษร : ถ้าคุณเริ่มต้นด้วยFind(int)และต่อมามีการเพิ่มวิธีการอื่น ๆ ( FindByName(string), FindByLegacyId(int), FindByCustomerId(int), FindByOrderId(int)ฯลฯ ) FindById(int)คนอย่างผมมักจะใช้ทุกเพศทุกวัยที่กำลังมองหา ไม่ใช่ปัญหาหากคุณสามารถและจะเปลี่ยนFind(int)เป็นFindById(int)เมื่อจำเป็น - การพิสูจน์ในอนาคตเกี่ยวกับสิ่งเหล่านี้ถ้า s

2. ให้อ่านง่ายขึ้น Findเป็นอย่างดีดีถ้าโทรลักษณะชอบrecord = Find(customerId);แต่จะง่ายขึ้นเล็กน้อยสำหรับการอ่านถ้ามันFindByIdrecord = FindById(AFunction());

3. ความมั่นคง คุณสามารถใช้FindByX(int)/ FindByY(int)รูปแบบได้อย่างสม่ำเสมอทุกที่ แต่Find(int X)/ Find(int Y)เป็นไปไม่ได้เพราะขัดกัน

ข้อดีของการค้นหา ()

• จูบ. Findเรียบง่ายและตรงไปตรงมาและอยู่ข้างoperator[]หนึ่งในสองชื่อฟังก์ชันที่คาดหวังมากที่สุดในบริบทนี้ (บางทางเลือกที่ได้รับความนิยมเป็นget, lookupหรือfetchขึ้นอยู่กับบริบท)
• ตามกฎของหัวแม่มือหากคุณมีชื่อฟังก์ชั่นซึ่งเป็นคำที่รู้จักกันดีซึ่งอธิบายถึงสิ่งที่ฟังก์ชันใช้อย่างถูกต้อง แม้ว่าจะมีชื่อหลายคำที่ยาวกว่าซึ่งดีกว่าเล็กน้อยในการอธิบายสิ่งที่ฟังก์ชั่นทำ ตัวอย่าง: ความยาว VS NumberOfElements มีการแลกเปลี่ยนกันและตำแหน่งที่จะลากเส้นนั้นเป็นเรื่องของการถกเถียง
• เป็นเรื่องปกติที่จะหลีกเลี่ยงความซ้ำซ้อน ถ้าเราดูFindById(int id)เราสามารถลบความซ้ำซ้อนได้อย่างง่ายดายโดยเปลี่ยนเป็นFind(int id)แต่มีการแลกเปลี่ยน - เราสูญเสียความชัดเจน

หรือคุณจะได้รับประโยชน์จากทั้งคู่โดยใช้รหัสที่พิมพ์อย่างมาก:

CustomerRecord Find(Id<Customer> id) 
// Or, depending on local coding standards
CustomerRecord Find(CustomerId id) 

การติดตั้งใช้งานId<>: พิมพ์ค่า ID อย่างมากใน C #

ความคิดเห็นที่นี่รวมทั้งในลิงก์ด้านบนทำให้เกิดข้อกังวลหลายประการเกี่ยวกับการId<Customer>ที่ฉันต้องการจะกล่าวถึง:

• ข้อกังวลที่ 1: เป็นการใช้ชื่อสามัญอย่างไม่เหมาะสม CustomerIdและOrderIDเป็นประเภทที่แตกต่างกัน ( customerId1 = customerId2;=> ดี, customerId1 = orderId1;=> ไม่ดี) แต่การใช้งานของพวกเขาเกือบจะเหมือนกันดังนั้นเราจึงสามารถนำไปใช้งานได้ด้วยการคัดลอกหรือวาง ในขณะที่มีค่าในการอภิปรายเกี่ยวกับการเปิดเผยหรือซ่อนทั่วไป metaprogramming เป็นสิ่งที่ generics มีไว้สำหรับ
• ความกังวลที่ 2: มันไม่ได้หยุด mistakes./It's ง่ายวิธีการแก้ปัญหาในการค้นหาของปัญหาDoSomething(int customerId, int orderId, int productId)ปัญหาหลักที่ถูกลบออกโดยใช้ขอพิมพ์รหัสเป็นคำสั่งอาร์กิวเมนต์ไม่ถูกต้องในการเรียกไปยัง รหัสที่พิมพ์อย่างมากยังป้องกันปัญหาอื่น ๆ รวมถึง OP ที่ถามด้วย
• ข้อกังวลที่ 3: มันเป็นการปิดบังรหัสจริงๆ เป็นการยากที่จะบอกว่ามี ID อยู่int aVariableหรือไม่ ง่ายที่จะบอกว่ามีการถือครองรหัสId<Customer> aVariableและเราสามารถบอกได้ว่าเป็นรหัสลูกค้า
• ข้อกังวลที่ 4: รหัสเหล่านี้ไม่มีประเภทที่แข็งแกร่งเพียงแค่ห่อหุ้ม เป็นเพียงเสื้อคลุมรอบString byte[]การห่อหุ้มหรือการห่อหุ้มไม่ได้ขัดแย้งกับการพิมพ์ที่รัดกุม
• ข้อกังวลที่ 5: มันผ่านการออกแบบมา ต่อไปนี้เป็นรุ่นที่น้อยที่สุด แต่ฉันขอแนะนำให้เพิ่มoperator==และoperator!=เช่นกันถ้าคุณไม่ต้องการพึ่งพาเฉพาะในEquals:

.

public struct Id<T>: {
    private readonly int _value ;
    public Id(int value) { _value = value; }
    public static explicit operator int(Id<T> id) { return id._value; }
}

วิธีคิดอีกอย่างคือการใช้ความปลอดภัยของภาษา

คุณสามารถใช้วิธีการเช่น:

Find(FirstName name);

โดยที่ FirstName เป็นออบเจ็กต์ธรรมดาที่ล้อมรอบสตริงซึ่งมีชื่อและหมายความว่าจะไม่มีความสับสนเกี่ยวกับวิธีการทำงานหรือในอาร์กิวเมนต์ที่เรียกใช้

ฉันจะลงคะแนนเพื่อการประกาศอย่างชัดเจนเช่น FindByID .... ซอฟต์แวร์ควรได้รับการสร้างขึ้นเพื่อการเปลี่ยนแปลง ควรจะเปิดและปิด (SOLID) ดังนั้นคลาสจึงเปิดเพื่อเพิ่มวิธีการค้นหาที่คล้ายกันเช่นสมมติว่า FindByName .. เป็นต้น

แต่ FindByID ถูกปิดและการใช้งานนั้นถูกทดสอบหน่วย

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

ฉันประหลาดใจที่ไม่มีใครแนะนำให้ใช้คำกริยาดังต่อไปนี้:

User Find(Predicate<User> predicate)

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

หากนั่นยังไม่เพียงพอคุณสามารถขยายความต้องการของคุณได้เสมอ