ทำความเข้าใจกับ setters ส่วนตัว

ฉันไม่เข้าใจความจำเป็นของการมีตัวตั้งค่าส่วนตัวซึ่งเริ่มต้นด้วย C # 2

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

สิ่งนี้สำหรับฉันคือการใช้ "การห่อหุ้ม" มีข้อโต้แย้งบางประการที่อ้างว่าตัวตั้งค่าส่วนตัวจะอนุญาตให้คุณใช้การห่อหุ้ม

ฉันไม่ได้ใช้การห่อหุ้มโดยใช้วิธีการตั้งค่าสาธารณะหรือไม่? ทำไมเราถึงต้องการตัวตั้งค่าส่วนตัว?

อะไรคือความแตกต่างระหว่างคลาสที่ไม่เปลี่ยนรูปและคลาสที่มีตัวตั้งค่าส่วนตัว?

อย่างมีเหตุผล

การมีตัวตั้งค่าส่วนตัวเป็นเพราะคุณสามารถใช้คุณสมบัติอัตโนมัติ:

public int MyProperty { get; set; }

คุณจะทำอย่างไรถ้าต้องการให้อ่านอย่างเดียว

public int MyProperty { get; }

โอ้ยย !! ฉันไม่สามารถเข้าถึงได้จากชั้นเรียนของฉันเอง ฉันควรสร้างมันให้เหมือนคุณสมบัติทั่วไป:

private int myProperty;
public int MyProperty { get { return myProperty; } }

อืม ... แต่ฉันทำคุณสมบัติ "Auto Property" หาย ...

public int MyProperty { get; private set; }

AHHH .. ดีกว่า !!

ตัวตั้งค่าส่วนตัวมีประโยชน์หากคุณมีคุณสมบัติอ่านอย่างเดียวและไม่ต้องการประกาศตัวแปรสำรองอย่างชัดเจน

ดังนั้น:

public int MyProperty
{
    get; private set;
}

เหมือนกับ:

private int myProperty;
public int MyProperty
{
    get { return myProperty; }
}

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

เพื่อตอบคำถามสุดท้ายของคุณ MSDN ได้กล่าวไว้กับผู้ตั้งค่าส่วนตัว:

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

จากหน้า MSDN ในคุณสมบัติ Auto Implemented

มันค่อนข้างง่าย ตัวตั้งค่าส่วนตัวอนุญาตให้คุณสร้างคุณสมบัติสาธารณะหรือที่มีการป้องกันแบบอ่านอย่างเดียว

แค่นั้นแหละ. นั่นเป็นเหตุผลเดียว

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

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

ด้วยการแนะนำC # 6.0และไวยากรณ์สำหรับAuto-Property Initializers ตัวตั้งค่าส่วนตัวไม่จำเป็นอีกต่อไปสำหรับคุณสมบัติที่ตั้งค่าเมื่อเริ่มต้นไม่ว่าจะเป็นแบบอินไลน์หรือภายในตัวสร้าง

ตอนนี้ไวยากรณ์ใหม่เหล่านี้รวบรวม:

คุณสมบัติเริ่มต้นแบบอินไลน์

public class MyClass1 {
  public string MyProperty { get; } = "Aloha!"
}

ตัวสร้างเริ่มต้นคุณสมบัติ

public class MyClass2 {
  public string MyProperty { get; }

  public MyClass2(string myProperty) {
    MyProperty = myProperty;
  }
}

ฉันไม่เข้าใจความจำเป็นของการมีตัวตั้งค่าส่วนตัวซึ่งเริ่มต้นด้วย C # 2

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

public class Item
{
  public string item_code;
  public int qty;

  public Item(string i, int q)
  {
    this.item_code = i;
    this.qty = q;
  }
}

public class Invoice
{
  public List Items { get; private set; }

  public Invoice()
  {
    this.Items = new List();
  }
}

public class TestInvoice
{
  public void Test()
  {
    Invoice inv = new Invoice();
    inv.Items.Add(new Item("apple", 10));

    List my_items = new List();
    my_items.Add(new Item("apple", 10));

    inv.Items = my_items;   // compilation error here.
  }
}

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

ในกรณีนี้คุณสามารถสร้างวิธีการคำนวณของคุณได้

private void Calculate(int value)
{
 //...
}

หรือคุณสามารถทำได้โดยใช้

public int MyProperty {get; private set;}

ในกรณีเหล่านี้ฉันขอแนะนำให้ใช้ในภายหลังเนื่องจากคุณสมบัติ refactor แต่ละองค์ประกอบของสมาชิกยังคงอยู่

นอกจากนั้นหากยังบอกว่าคุณแมปคุณสมบัติด้วยตัวแปร ในกรณีนี้ภายในโค้ดของคุณคุณต้องการเขียนดังนี้:

public int myprop;
public int MyProperty {get { return myprop;}}

... ...

this.myprop = 30;

... ...
if(this.MyProperty > 5)
   this.myprop = 40;

โค้ดด้านบนดูน่ากลัวเนื่องจากโปรแกรมเมอร์ต้องใช้ความระมัดระวังในการใช้ MyProperty for Get และ myprop for Set

Rether เพื่อความสม่ำเสมอคุณสามารถใช้ตัวตั้งค่าส่วนตัวซึ่งทำให้ Propoerty อ่านอย่างเดียวภายนอกในขณะที่คุณสามารถใช้ตัวตั้งค่าภายในรหัสของคุณได้

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

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

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

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

ในอีกกรณีหนึ่งในภาษาอื่นจะมีเมธอด getter และ setter บางอย่างเช่นint getId()เพื่อรับค่าและvoid setId(int val)อัปเดต

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

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

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

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

สำหรับคำถามสุดท้ายของคุณการไม่เปลี่ยนรูปหมายความว่าคลาสนั้นไม่มีตัวตั้งค่าสาธารณะที่ได้รับการป้องกันหรือภายในและไม่มีวิธีสาธารณะที่ได้รับการป้องกันหรือภายในที่เปลี่ยนแปลงฟิลด์ มีองศานี้ใน C # มีสามองศาที่เป็นไปได้:

1. ฟิลด์อินสแตนซ์ของคลาสทั้งหมดเป็นreadonlyดังนั้นแม้แต่รหัสส่วนตัวก็ไม่สามารถแก้ไขได้ รับประกันว่าจะไม่เปลี่ยนรูป (สิ่งใดก็ตามที่พยายามเปลี่ยนแปลงจะไม่รวบรวม) และการเพิ่มประสิทธิภาพอาจทำได้ที่ด้านหลังของสิ่งนี้

2. ชั้นเรียนไม่สามารถเปลี่ยนรูปได้จากภายนอกเนื่องจากไม่มีสมาชิกสาธารณะเปลี่ยนแปลงอะไร แต่ไม่รับประกันว่าreadonlyจะไม่เปลี่ยนจากภายใน

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

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

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

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

ตัวตั้งค่าส่วนตัวเข้ามาใช้บ่อยขึ้นโดยใช้ชวเลขคุณสมบัติที่ติดตั้งใน C # 3 ใน C # 2 ตัวเซ็ตมักจะถูกละไว้และข้อมูลส่วนตัวจะเข้าถึงได้โดยตรงเมื่อตั้งค่า

คุณสมบัตินี้:

public int Size { get; private set; }

เหมือนกับ:

private int _size;
public int Size {
  get { return _size; }
  private set { _size = value; }
}

ยกเว้นชื่อของตัวแปรสำรองถูกสร้างขึ้นภายในโดยคอมไพเลอร์ดังนั้นคุณจึงไม่สามารถเข้าถึงได้โดยตรง

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

ฉันไม่เข้าใจความจำเป็นของการมีตัวตั้งค่าส่วนตัวซึ่งเริ่มต้นด้วย C # 2

ใช้กรณีตัวอย่าง:

ฉันมีตัวอย่างของแอปพลิเคชันอ็อบเจ็กต์'UserInfo'ที่มีคุณสมบัติSessionTokenIDV1ที่ฉันไม่ต้องการเปิดเผยต่อผู้บริโภคในคลาสของฉัน

ฉันยังต้องการความสามารถในการตั้งค่านั้นจากชั้นเรียนของฉัน

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

public class UserInfo
{
   public String SessionTokenIDV1 { get; set; }

}


public class Example
{
  // Private vars
  private UserInfo _userInfo = new UserInfo();

  public string SessionValidV1
  {
    get { return ((_userInfo.SessionTokenIDV1 != null) && (_userInfo.SessionTokenIDV1.Length > 0)) ? "set" : "unset"; }
    private set { _userInfo.SessionTokenIDV1 = value; }
  }
}

แก้ไข: แก้ไขแท็กรหัสแก้ไข: ตัวอย่างมีข้อผิดพลาดที่ได้รับการแก้ไข

เครดิตhttps://www.dotnetperls.com/property

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

public class MyClass
{
    public MyClass()
    {
        // Set the private property.
        this.Name = "Sample Name from Inside";
    }
     public MyClass(string name)
    {
        // Set the private property.
        this.Name = name;
    }
    string _name;
    public string Name
    {
        get
        {
            return this._name;
        }
        private set
        {
            // Can only be called in this class.
            this._name = value;
        }
    }
}

class Program
{
    static void Main()
    {
        MyClass mc = new MyClass();
        Console.WriteLine(mc.name);

        MyClass mc2 = new MyClass("Sample Name from Outside");
        Console.WriteLine(mc2.name);
    }
}

โปรดดูภาพหน้าจอด้านล่างเมื่อฉันพยายามตั้งค่าจากนอกชั้นเรียน