วิธีการนำคุณสมบัติไปใช้กับคลาส A ซึ่งอ้างถึงคุณสมบัติของอ็อบเจ็กต์ลูกของคลาส A

เรามีรหัสนี้ซึ่งเมื่อทำให้ง่ายขึ้นจะมีลักษณะเช่นนี้:

public class Room
{
    public Client Client { get; set; }

    public long ClientId
    {
        get
        {
            return Client == null ? 0 : Client.Id;
        }
    }
}

public class Client 
{
    public long Id { get; set; }
}

ตอนนี้เรามีสามมุมมอง

1) นี่เป็นรหัสที่ดีเพราะClientควรตั้งค่าคุณสมบัติ (เช่นไม่ใช่โมฆะ) ดังนั้นClient == nullจะไม่เกิดขึ้นและค่ารหัส0แสดงถึงรหัสเท็จอย่างไรก็ตาม (นี่คือความเห็นของผู้เขียนรหัส ;-))

2) คุณไม่สามารถพึ่งพาผู้เรียกได้ว่า0เป็นค่าเท็จIdและเมื่อ Clientควรตั้งค่าคุณสมบัติคุณควรโยนexceptionในgetเมื่อClientคุณสมบัติเกิดขึ้นเป็นโมฆะ

3) เมื่อClientควรตั้งค่าคุณสมบัติคุณเพียงแค่ส่งคืนClient.Idและปล่อยให้โค้ดโยนNullRefข้อยกเว้นเมื่อClientคุณสมบัติเป็นโมฆะ

ข้อใดถูกต้องที่สุด หรือมีความเป็นไปได้ที่สี่?

มันมีกลิ่นเหมือนว่าคุณควร จำกัด จำนวนสถานะที่Roomคลาสของคุณสามารถเข้าได้

ความจริงที่ว่าคุณกำลังถามเกี่ยวกับสิ่งที่ต้องทำเมื่อClientว่างคือคำใบ้ที่ว่าRoomพื้นที่รัฐมีขนาดใหญ่เกินไป

เพื่อให้ง่ายขึ้นฉันจะไม่อนุญาตให้ClientคุณสมบัติของRoomอินสแตนซ์ใด ๆเป็นโมฆะ นั่นหมายความว่ารหัสภายในRoomสามารถถือว่าไม่มีทางClientเป็นโมฆะ

หากด้วยเหตุผลบางอย่างในอนาคตClientจะnullต่อต้านความอยากสนับสนุนรัฐนั้น การทำเช่นนั้นจะเพิ่มความซับซ้อนในการบำรุงรักษาของคุณ

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

สิ่งนี้อาจเกิดขึ้น (ค่อนข้างเป็นธรรมชาติ) ซึ่งเป็นผลมาจากข้อยกเว้นการอ้างอิง null ที่ไม่สามารถจัดการได้

ข้อควรพิจารณาบางประการ:

a) ทำไมถึงมีผู้ทะเยอทะยานเป็นพิเศษสำหรับ ClientId เมื่อมีผู้ทะเยอทะยานสาธารณะสำหรับอินสแตนซ์ของลูกค้าเอง ฉันไม่เห็นว่าทำไมข้อมูลที่ลูกค้าต้องlongมีการแกะสลักด้วยหินในลายเซ็นของห้อง

ข) Invalid_Client_Idความเห็นเกี่ยวกับการที่สองคุณสามารถแนะนำอย่างต่อเนื่อง

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

ฉันไม่เห็นด้วยกับความคิดเห็นทั้งสาม หากClientไม่สามารถnull, แล้วไม่ได้ทำให้มันเป็นไปได้เพื่อให้เป็นnull !

1. กำหนดค่าของClientในตัวสร้าง
2. โยนArgumentNullExceptionในตัวสร้าง

ดังนั้นรหัสของคุณจะเป็นดังนี้:

public class Room
{
    private Client theClient;

    public Room(Client client) {
        if(client == null) throw new ArgumentNullException();
        this.theClient = client;
    }

    public Client Client { 
        get { return theClient; }
        set 
        {
            if (value == null) 
                throw new ArgumentNullException();
            theClient = value;
        }
    }

    public long ClientId
    {
        get
        {
            return theClient.Id;
        }
    }
}

public class Client 
{
    public long Id { get; set; }
}

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

ตัวเลือกที่สองและสามควรหลีกเลี่ยง - ผู้เรียกไม่ควรตบผู้โทรด้วยข้อยกเว้นที่พวกเขาไม่สามารถควบคุมได้

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

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

ในที่สุดตัวเลือกแรกยังมีกลิ่นรหัส คุณควรให้ลูกค้าจัดการกับคุณสมบัติ ID ของตัวเอง ดูเหมือนว่า overkill จะเขียนรหัสทะเยอทะยานในคลาส container ที่เรียกแค่ getter บนคลาสที่มีอยู่ เพียงแค่ให้ลูกค้าเห็นว่าเป็นคุณสมบัติ (มิฉะนั้นคุณจะต้องทำซ้ำทุกสิ่งที่ลูกค้ามีอยู่แล้ว )

long clientId = room.Client.Id;

หากลูกค้าเป็นโมฆะอย่างน้อยคุณจะต้องรับผิดชอบต่อผู้โทร:

if (room.Client != null){
    long clientId = room.Client.Id;
    /* other code follows... */
}

ถ้าคุณสมบัติ null Client เป็นรัฐสนับสนุนพิจารณาใช้NullObject

แต่ส่วนใหญ่แล้วนี่เป็นสถานะพิเศษดังนั้นคุณควรทำให้เป็นไปไม่ได้ (หรือไม่สะดวกมาก) ในการจบด้วย null Client:

public Client Client { get; private set; }

public Room(Client client)
{
    Client = client;
}

public void SetClient(Client client)
{
    if (client == null) throw new ArgumentNullException();
    Client = client;
}

หากไม่รองรับอย่างไรก็ตามอย่าเสียเวลากับการแก้ปัญหาแบบเบคครึ่ง ในกรณีนี้:

return Client == null ? 0 : Client.Id;

คุณได้ 'แก้ไข' NullReferenceException ที่นี่ แต่มีค่าใช้จ่ายมาก! สิ่งนี้จะบังคับให้ผู้โทรทั้งหมดRoom.ClientIdตรวจสอบ 0:

var aRoom = new Room(aClient);
var clientId = aRoom.ClientId;
if (clientId == 0) RestartRoombookingWizard();
else ContinueRoombooking(clientid);

ข้อผิดพลาดที่แปลกสามารถเกิดขึ้นกับ devs อื่น ๆ (หรือตัวคุณเอง!) ลืมที่จะตรวจสอบค่าตอบแทน "ErrorCode" ในบางช่วงเวลา
เล่นอย่างปลอดภัยและล้มเหลวอย่างรวดเร็ว อนุญาตให้มีการโยน NullReferenceException และ "อย่างสง่างาม" จับที่ใดที่หนึ่งที่สูงกว่าค่าสแต็กการโทรแทนการอนุญาตให้ผู้โทรทำสิ่งต่าง ๆ ได้มากขึ้น ...

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

ในฐานะของ c # 6.0 ซึ่งวางจำหน่ายแล้วคุณควรทำสิ่งนี้

public class Room
{
    public Room(Client client)
    {
        this.Client = client;
    }

    public Client Client { get; }
}

public class Client
{
    public Client(long id)
    {
        this.Id = id;
    }

    public long Id { get; }
}

การเพิ่มคุณสมบัติของClientto Roomเป็นการละเมิด encapsulation และหลักการ DRY ที่ชัดเจน

หากคุณต้องการเข้าถึงIdสิ่งClientที่Roomคุณสามารถทำได้

var clientId = room.Client?.Id;

หมายเหตุการใช้ของNull เงื่อนไข Operator , clientIdจะเป็นlong?ถ้าClientเป็นnull, clientIdจะnullมิฉะนั้นจะมีค่าของclientIdClient.Id