หากคุณส่งข้อมูลขั้นต่ำเปล่าไปยังฟังก์ชั่นในกรณีเช่นนี้เสมอ

สมมติว่าฉันมีฟังก์ชั่นIsAdminที่จะตรวจสอบว่าผู้ใช้เป็นผู้ดูแลระบบหรือไม่ สมมติว่าการตรวจสอบของผู้ดูแลระบบทำได้โดยการจับคู่ id ผู้ใช้ชื่อและรหัสผ่านกับกฎบางประเภท (ไม่สำคัญ)

ในหัวของฉันมีสองลายเซ็นฟังก์ชันที่เป็นไปได้สำหรับสิ่งนี้:

public bool IsAdmin(User user);
public bool IsAdmin(int id, string name, string password);

ฉันมักจะไปที่ลายเซ็นประเภทที่สองโดยคิดว่า:

• ฟังก์ชั่นลายเซ็นช่วยให้ผู้อ่านมีข้อมูลมากขึ้น
• ตรรกะที่มีอยู่ในฟังก์ชั่นไม่จำเป็นต้องรู้เกี่ยวกับUserชั้นเรียน
• มันมักจะส่งผลให้รหัสน้อยลงเล็กน้อยภายในฟังก์ชั่น

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

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

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

ฉันเองชอบวิธีแรกเพียง IsAdmin(User user)

มันใช้งานง่ายกว่ามากและหากเกณฑ์ IsAdmin ของคุณเปลี่ยนแปลงในภายหลัง (อาจขึ้นอยู่กับบทบาทหรือ isActive) คุณไม่จำเป็นต้องเขียนลายเซ็นวิธีของคุณใหม่ทุกที่

อาจมีความปลอดภัยมากกว่าเนื่องจากคุณไม่ได้โฆษณาคุณสมบัติใดที่กำหนดว่าผู้ใช้เป็นผู้ดูแลระบบหรือไม่หรือผ่านคุณสมบัติรหัสผ่านทุกที่ และsyrionทำให้เป็นจุดที่ดีว่าเกิดอะไรขึ้นเมื่อคุณidไม่ตรงกับname/ password?

ความยาวของรหัสในฟังก์ชั่นไม่ควรสำคัญว่าจะให้วิธีการทำงานได้อย่างไรและฉันค่อนข้างจะมีรหัสแอปพลิเคชันที่สั้นและง่ายกว่าโค้ดวิธีใช้ตัวช่วย

ลายเซ็นแรกนั้นเหนือกว่าเพราะช่วยให้การห่อหุ้มของตรรกะที่เกี่ยวข้องกับผู้ใช้ในUserวัตถุนั้น มันไม่มีประโยชน์ที่จะมีตรรกะสำหรับการสร้าง "id, ชื่อ, รหัสผ่าน" tuple เกลื่อนกลาดเกี่ยวกับฐานรหัสของคุณ ยิ่งไปกว่านั้นมันทำให้isAdminฟังก์ชั่นซับซ้อน: เกิดอะไรขึ้นถ้ามีคนผ่านไปในidที่ไม่ตรงกับnameตัวอย่างเช่น? ถ้าคุณต้องการตรวจสอบว่าผู้ใช้ที่ได้รับเป็นผู้ดูแลระบบจากบริบทที่คุณไม่ควรรู้รหัสผ่านหรือไม่

นอกจากนี้โปรดทราบว่าจุดที่สามของคุณสนับสนุนรูปแบบที่มีข้อโต้แย้งพิเศษ; มันอาจส่งผลให้ "โค้ดน้อยลงภายในฟังก์ชั่น" แต่ตรรกะนั้นไปไหน? มันไม่สามารถหายไปได้! แต่มันแพร่กระจายไปทั่วทุกที่ที่มีการเรียกใช้ฟังก์ชัน ในการบันทึกรหัสห้าบรรทัดในที่เดียวคุณต้องจ่ายเงินห้าบรรทัดต่อการใช้ฟังก์ชัน!

ครั้งแรก แต่ไม่ (เท่านั้น) สำหรับเหตุผลที่คนอื่นได้ให้

public bool IsAdmin(User user);

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

public bool IsAdmin(int id, string name, string password);

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

สันนิษฐานว่าทั้งสองฟังก์ชั่นต้องการ user.getId (), user.getName () และ user.getPassword () ถูกเรียกทั้งในฟังก์ชั่น (ในกรณีแรก) หรือก่อนที่จะเรียกฟังก์ชั่น (ในครั้งที่สอง) ดังนั้น ปริมาณของคัปปลิ้งก็เหมือนกัน ที่จริงแล้วเนื่องจากฟังก์ชั่นนี้ใช้ได้เฉพาะกับผู้ใช้ใน Java ฉันจะกำจัดข้อโต้แย้งทั้งหมดและทำให้มันเป็นวิธีการเช่นในวัตถุผู้ใช้:

user.isAdmin();

เนื่องจากฟังก์ชั่นนี้เชื่อมโยงกับผู้ใช้อย่างแน่นหนาจึงเหมาะสมที่จะทำให้มันเป็นส่วนหนึ่งของผู้ใช้

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

หากภาษาที่คุณเลือกไม่ผ่านโครงสร้างตามค่า(User user)ตัวแปรก็ดูดีกว่า ถ้าวันหนึ่งคุณตัดสินใจที่จะลบชื่อผู้ใช้และใช้ ID / รหัสผ่านเพื่อระบุผู้ใช้

นอกจากนี้วิธีการนี้ยังนำไปสู่การเรียกใช้เมธอดที่ยาวนานและเกินกำหนดหรือไม่สอดคล้องกัน การผ่าน 3 ข้อโต้แย้งตกลงไหม แล้วประมาณ 5 ล่ะ หรือ 6 ทำไมคิดอย่างนั้นถ้าผ่านวัตถุมีราคาถูกในแง่ของทรัพยากร (แม้ราคาถูกกว่าผ่านข้อโต้แย้ง 3 อาจ)?

และฉัน (เรียงลำดับ) ไม่เห็นด้วยที่วิธีที่สองให้ข้อมูลเพิ่มเติมแก่ผู้อ่านโดยสังหรณ์ใจการเรียกใช้เมธอดจะถามว่า "ผู้ใช้มีสิทธิ์ของผู้ดูแลระบบ" หรือไม่

ดังนั้นหากผ่านUserวัตถุจะส่งผลให้มีการคัดลอกโครงสร้างขนาดใหญ่วิธีแรกคือสะอาดและมีเหตุผลมากขึ้นกับฉัน

ฉันอาจจะมีทั้ง คนแรกเป็น API ภายนอกด้วยความหวังของความมั่นคงในเวลา อันที่สองเป็นการดำเนินการส่วนตัวที่เรียกว่าโดย API ภายนอก

หากในภายหลังฉันต้องเปลี่ยนกฎการตรวจสอบฉันจะเขียนฟังก์ชันส่วนตัวใหม่พร้อมลายเซ็นใหม่ที่เรียกโดยภายนอก

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

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

กล่าวอีกนัยหนึ่งถ้าคุณกำลังจัดการกับฐานข้อมูลผู้ใช้จะเป็นเรกคอร์ดในขณะที่ id รหัสผ่านและล็อกอินจะเป็นฟิลด์ในเรกคอร์ดนั้น

มีอยู่คนหนึ่งจุดลบที่จะส่งเรียน (ประเภทอ้างอิง) วิธีการเป็นและนั่นคือมวลของ USPTO ช่องโหว่ ลองจินตนาการว่าแทนที่จะเป็นIsAdmin(User user)วิธีฉันมีUpdateUser(User user)วิธี

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

ฉันจะไปกับวิธีนี้:

public bool IsAdmin(this IUser user) { /* ... */ }

public class User: IUser { /* ... */ }

public interface IUser
{
    string Username {get;}
    string Password {get;}
    IID Id {get;}
}

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

• ฉันยังเพิ่มคำหลักthisเพื่อทำให้ฟังก์ชันเป็นวิธีส่วนขยายของคลาส IUser ทั้งหมด วิธีนี้คุณสามารถเขียนโค้ดด้วยวิธีที่เป็นมิตรกับ OO และใช้ฟังก์ชันนี้ในการค้นหา Linq ยังง่ายกว่านี้คือการกำหนดฟังก์ชั่นนี้ใน IUser และผู้ใช้ แต่ฉันคิดว่ามีเหตุผลบางอย่างที่คุณตัดสินใจที่จะวางวิธีนี้นอกคลาสนั้น

• ฉันใช้อินเทอร์เฟซที่กำหนดเองIIDแทนที่จะintเป็นเช่นนี้ช่วยให้คุณกำหนดคุณสมบัติของ ID ของคุณ; เช่นเคยคุณควรจะต้องเปลี่ยนจากintการlong, Guidหรือสิ่งอื่น นั่นอาจเกินความจริง แต่ก็เป็นการดีที่จะพยายามทำให้สิ่งต่าง ๆ มีความยืดหยุ่นเช่นที่คุณไม่ได้ถูกล็อคไว้ก่อนการตัดสินใจ

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

ปฏิเสธความรับผิดชอบ:

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

ฉันยังพิจารณาที่จะเทียบเท่ากับuser.isAdmin() IsAdmin(User user)นั่นเป็นตัวเลือกสำหรับคุณที่จะทำ

ตอบ:

คำแนะนำของฉันคือสำหรับผู้ใช้เท่านั้น:

public bool IsAdmin(User user);

หรือใช้ทั้งคู่ตามแนวของ:

public bool IsAdmin(User user); // calls the private method below
private bool IsAdmin(int id, string name, string password);

เหตุผลสำหรับวิธีการสาธารณะ:

เมื่อเขียนวิธีการสาธารณะมักจะเป็นความคิดที่ดีที่จะคิดเกี่ยวกับวิธีการใช้

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

เหตุผลสำหรับวิธีการส่วนตัว:

วิธีส่วนตัวที่ได้รับชุดพารามิเตอร์ที่ต้องการขั้นต่ำอาจเป็นสิ่งที่ดีในบางครั้ง บางครั้งก็ไม่มาก

ข้อดีอย่างหนึ่งของการแยกวิธีการเหล่านี้คือคุณสามารถเรียกรุ่นส่วนตัวจากวิธีสาธารณะหลายวิธีในชั้นเรียนเดียวกัน ตัวอย่างเช่นหากคุณต้องการ (ด้วยเหตุผลใดก็ตาม) จะมีตรรกะที่แตกต่างกันเล็กน้อยสำหรับLocaluserและRemoteUser(อาจมีการตั้งค่าให้เปิด / ปิดผู้ดูแลระบบระยะไกลหรือไม่):

public bool IsAdmin(Localuser user); // Just call private method
public bool IsAdmin(RemoteUser user); // Check if setting is on, then call private method
private bool IsAdmin(int id, string name, string password);

นอกจากนี้หากด้วยเหตุผลใดก็ตามคุณจำเป็นต้องเปิดเผยวิธีการส่วนตัวให้เป็นสาธารณะ ... คุณทำได้ มันเป็นเรื่องง่ายเหมือนเพียงแค่เปลี่ยนไปprivate publicดูเหมือนว่าจะไม่ได้เปรียบอย่างมากสำหรับกรณีนี้ แต่บางครั้งมันก็เป็นจริง

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

public bool IsAdmin(int id, string name, string password);

ไม่ดีสำหรับเหตุผลที่ระบุไว้ นั่นไม่ได้หมายความว่า

public bool IsAdmin(User user);

เป็นสิ่งที่ดีโดยอัตโนมัติ โดยเฉพาะอย่างยิ่งถ้าผู้ใช้เป็นวัตถุที่มีวิธีการเช่น: getOrders(), getFriends(), getAdresses()...

คุณอาจพิจารณา refactoring โดเมนที่มีประเภท UserCredentials ที่มี id ชื่อรหัสผ่านและส่งผ่านไปยัง IsAdmin แทนข้อมูลผู้ใช้ที่ไม่จำเป็นทั้งหมด