คงที่อ่านได้อย่างเดียวเทียบกับ

ฉันได้อ่านเกี่ยวกับconstและstatic readonlyฟิลด์ เรามีบางคลาสที่มีค่าคงที่เท่านั้น ใช้สำหรับสิ่งต่าง ๆ ในระบบของเรา ดังนั้นฉันสงสัยว่าการสังเกตของฉันถูกต้องหรือไม่:

ค่าคงที่เหล่านี้ควรเป็นค่าstatic readonlyสำหรับทุกสิ่งที่เป็นสาธารณะหรือไม่ และใช้constสำหรับค่าภายใน / การป้องกัน / ส่วนตัวเท่านั้น?

คุณแนะนำเมนูใด? ฉันควรจะไม่ใช้static readonlyฟิลด์ แต่ควรใช้คุณสมบัติหรือไม่

public static readonlyทุ่งนานั้นผิดปกติเล็กน้อย public staticคุณสมบัติ (มีเพียงกget) จะเป็นเรื่องปกติมากขึ้น (อาจได้รับการสนับสนุนจากprivate static readonlyเขตข้อมูล)

constค่าจะถูกเขียนลงในไซต์การโทรโดยตรง นี่คือขอบสองครั้ง:

• มันไม่มีประโยชน์อะไรถ้าค่านั้นมาจากรันไทม์บางทีจากการตั้งค่า
• หากคุณเปลี่ยนค่าของ const คุณจะต้องสร้างไคลเอนต์ทั้งหมดอีกครั้ง
• แต่มันอาจเร็วกว่านี้เนื่องจากจะหลีกเลี่ยงการเรียกเมธอด ...
• ... ซึ่งบางครั้งอาจถูก JIT อินไลน์อยู่แล้ว

หากค่าจะไม่เปลี่ยนแปลงจากนั้น const เป็นเรื่องปกติ - Zeroฯลฯ ทำconst ที่เหมาะสม; p นอกเหนือจากนั้นstaticคุณสมบัติทั่วไป

ฉันจะใช้static readonlyถ้าผู้บริโภคอยู่ในการชุมนุมที่แตกต่างกัน มีconstและผู้บริโภคในสองประกอบที่แตกต่างกันเป็นวิธีที่ดีที่จะยิงตัวเองในการเดินเท้า

มีสิ่งที่เกี่ยวข้องอีกสองสามข้อที่ควรสังเกต:

const int

• จะต้องเริ่มต้น
• การเริ่มต้นต้องมีเวลารวบรวม

int แบบอ่านอย่างเดียว

• สามารถใช้ค่าเริ่มต้นโดยไม่ต้องเริ่มต้น
• การเริ่มต้นสามารถทำได้ในเวลาทำงาน (แก้ไข: ภายในตัวสร้างเท่านั้น)

นี่เป็นเพียงส่วนเสริมของคำตอบอื่น ๆ ฉันจะไม่ทำซ้ำพวกเขา (ตอนนี้สี่ปีต่อมา)

มีสถานการณ์ที่ a constและไม่ใช่สมาชิกมีความหมายที่แตกต่างกัน ตัวอย่างเช่น:

const int y = 42;

static void Main()
{
  short x = 42;
  Console.WriteLine(x.Equals(y));
}

พิมพ์ออกมาTrueในขณะที่:

static readonly int y = 42;

static void Main()
{
  short x = 42;
  Console.WriteLine(x.Equals(y));
}

Falseเขียน

เหตุผลก็คือเมธอดx.Equalsมีสองโอเวอร์โหลดหนึ่งอันที่ใช้ใน a short( System.Int16) และอีกอันที่ใช้object( System.Object) ตอนนี้คำถามคือหนึ่งหรือทั้งสองใช้กับyอาร์กิวเมนต์ของฉัน

เมื่อyเป็นค่าคงที่เวลาคอมไพล์ (ตามตัวอักษร) constกรณีมันจะกลายเป็นสิ่งสำคัญที่มีอยู่การแปลงโดยปริยายจาก int เพื่อ shortให้intมีค่าคงที่และหากคอมไพเลอร์ C # ตรวจสอบว่าค่าของมันอยู่ในช่วงของshort( ซึ่ง42ก็คือ) ดูการแปลงนิพจน์ค่าคงที่โดยนัยในข้อกำหนดภาษา C # ดังนั้นจึงต้องคำนึงถึงภาระทั้งสองอย่าง เกินพิกัดEquals(short)เป็นที่ต้องการ (ใด ๆshortเป็นobjectแต่ไม่ทั้งหมดobjectมีshort) ดังนั้นyจะถูกแปลงเป็นshortและใช้งานเกินพิกัด แล้วEqualsเปรียบเทียบสองของค่าที่เหมือนกันและที่ให้shorttrue

เมื่อyไม่ได้เป็นคงไม่มีนัยแปลงจากintการshortที่มีอยู่ นั่นเป็นเพราะโดยทั่วไปแล้วintอาจมีขนาดใหญ่เกินไปที่จะเข้าshortกันได้ (มีการแปลงอย่างชัดเจนแต่ฉันไม่ได้พูดEquals((short)y)ดังนั้นมันจึงไม่เกี่ยวข้องกัน) เราเห็นว่ามีการใช้งานเกินEquals(object)หนึ่งครั้งเท่านั้น ดังนั้นจะบรรจุกล่องไปy objectจากนั้นEqualsจะไปเปรียบเทียบSystem.Int16กับและตั้งแต่ประเภทเวลาทำงานไม่ได้เห็นด้วยที่จะให้ผลผลิตSystem.Int32false

เราสรุปว่าในบางกรณี (หายาก) การเปลี่ยนconstประเภทสมาชิกเป็นstatic readonlyเขตข้อมูล (หรือวิธีอื่นเมื่อเป็นไปได้) สามารถเปลี่ยนพฤติกรรมของโปรแกรม

สิ่งหนึ่งที่ควรทราบคือconstถูก จำกัด ประเภทดั้งเดิม / ค่า (ข้อยกเว้นเป็นสตริง)

อ่านอย่างเดียวแบบคงที่ : ค่าสามารถเปลี่ยนแปลงได้ผ่านตัวstaticสร้างที่รันไทม์ แต่ไม่ผ่านฟังก์ชั่นสมาชิก

อย่างต่อเนื่อง : staticโดยค่าเริ่มต้น ค่าไม่สามารถเปลี่ยนแปลงได้จากทุกที่ (Ctor, ฟังก์ชั่น, รันไทม์และอื่น ๆ ไม่มีที่)

อ่านอย่างเดียว : ค่าสามารถเปลี่ยนแปลงได้ผ่านตัวสร้างที่รันไทม์ แต่ไม่ผ่านฟังก์ชั่นสมาชิก

คุณสามารถดูได้ที่ repo ของฉัน: C # ทรัพย์สินประเภท

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

การอ้างอิง MSDN แบบสั้นและชัดเจนที่นี่

constและreadonlyมีความคล้ายคลึงกัน แต่ไม่เหมือนกันทั้งหมด

constฟิลด์เป็นค่าคงที่รวบรวมเวลาหมายความว่าค่าที่สามารถคำนวณที่รวบรวมเวลา readonlyฟิลด์ช่วยให้สถานการณ์เพิ่มเติมในรหัสบางอย่างจะต้องทำงานในระหว่างการก่อสร้างประเภท หลังจากการก่อสร้างreadonlyจะไม่สามารถเปลี่ยนฟิลด์ได้

ตัวอย่างเช่นconstสมาชิกสามารถใช้เพื่อกำหนดสมาชิกเช่น:

struct Test
{
    public const double Pi = 3.14;
    public const int Zero = 0;
}

เนื่องจากค่าเช่น 3.14 และ 0 เป็นค่าคงที่เวลาคอมไพล์ อย่างไรก็ตามพิจารณากรณีที่คุณกำหนดประเภทและต้องการให้อินสแตนซ์ pre-fab บางอย่างของมัน ตัวอย่างเช่นคุณอาจต้องการกำหนดคลาสสีและให้ "ค่าคงที่" สำหรับสีทั่วไปเช่นสีดำสีขาว ฯลฯ คุณไม่สามารถทำสิ่งนี้กับสมาชิก const เนื่องจากด้านขวามือไม่ใช่ค่าคงที่เวลาคอมไพล์ หนึ่งสามารถทำได้กับสมาชิกคงที่ปกติ:

public class Color
{
    public static Color Black = new Color(0, 0, 0);
    public static Color White = new Color(255, 255, 255);
    public static Color Red   = new Color(255, 0, 0);
    public static Color Green = new Color(0, 255, 0);
    public static Color Blue  = new Color(0, 0, 255);
    private byte red, green, blue;

    public Color(byte r, byte g, byte b) => (red, green, blue) = (r, g, b);
}

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

เพียงแค่แนะนำreadonlyคำสำคัญในการประกาศเราจะรักษาความยืดหยุ่นในการเริ่มต้นในขณะที่ป้องกันไม่ให้ลูกค้ารหัสจากการล้อเล่น

public class Color
{
    public static readonly Color Black = new Color(0, 0, 0);
    public static readonly Color White = new Color(255, 255, 255);
    public static readonly Color Red   = new Color(255, 0, 0);
    public static readonly Color Green = new Color(0, 255, 0);
    public static readonly Color Blue  = new Color(0, 0, 255);
    private byte red, green, blue;

    public Color(byte r, byte g, byte b) => (red, green, blue) = (r, g, b);
}

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

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

public class A
{
    public static const C = 0;
}

และนักพัฒนาซอฟต์แวร์คนอื่นเขียนโค้ดที่ใช้ A:

public class B
{
    static void Main() => Console.WriteLine(A.C);
}

ตอนนี้โค้ดที่สร้างขึ้นสามารถขึ้นอยู่กับความจริงที่ว่า AC เป็นค่าคงที่เวลารวบรวมได้หรือไม่? คือสามารถใช้ AC แทนค่า 0 ได้หรือไม่? หากคุณพูดว่า "ใช่" นี่หมายความว่าผู้พัฒนา A ไม่สามารถเปลี่ยนวิธีการเริ่มต้น AC ได้ - สิ่งนี้จะอยู่ในมือของผู้พัฒนา A โดยไม่ได้รับอนุญาต

หากคุณพูดว่า "ไม่" สำหรับคำถามนี้การเพิ่มประสิทธิภาพที่สำคัญจะพลาดไป บางทีผู้เขียน A อาจเป็นบวกว่า AC จะเป็นศูนย์เสมอ การใช้ทั้ง const และอ่านอย่างเดียวทำให้นักพัฒนา A สามารถระบุเจตนาได้ สิ่งนี้ทำให้เกิดพฤติกรรมการกำหนดเวอร์ชันที่ดีขึ้นและประสิทธิภาพที่ดีขึ้น

การตั้งค่าของฉันคือการใช้constทุกครั้งที่ทำได้ซึ่งดังที่ได้กล่าวไว้ข้างต้นจะ จำกัด เฉพาะการแสดงออกที่แท้จริงหรือสิ่งที่ไม่ต้องการการประเมินผล

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

Const: Const คืออะไรนอกจาก "ค่าคงที่" ซึ่งเป็นตัวแปรที่ค่าคงที่ แต่ในเวลารวบรวม และจำเป็นต้องกำหนดค่าให้กับมัน โดยค่าเริ่มต้น const คงที่และเราไม่สามารถเปลี่ยนค่าของตัวแปร const ได้ตลอดโปรแกรมทั้งหมด

แบบคงที่ ReadOnly:ค่าตัวแปรชนิดคงที่อ่านได้อย่างเดียวสามารถกำหนดได้ที่รันไทม์หรือกำหนดในเวลารวบรวมและการเปลี่ยนแปลงที่รันไทม์ แต่ค่าของตัวแปรนี้สามารถเปลี่ยนแปลงได้ในตัวสร้างสแตติกเท่านั้น และไม่สามารถเปลี่ยนแปลงได้อีก มันสามารถเปลี่ยนได้เพียงครั้งเดียวที่รันไทม์

อ้างอิง: c-sharpcorner

ฟิลด์สแตติกแบบอ่านอย่างเดียวจะมีประโยชน์เมื่อเปิดเผยให้แอสเซมบลีอื่นค่าที่อาจเปลี่ยนแปลงในรุ่นที่ใหม่กว่า

ตัวอย่างเช่นสมมติว่าแอสเซมบลีXเปิดเผยค่าคงที่ดังนี้:

public const decimal ProgramVersion = 2.3;

หากแอสเซมบลีYอ้างอิงXและใช้ค่าคงที่นี้ค่า 2.3 จะถูกอบเข้าสู่แอสเซมบลีYเมื่อคอมไพล์ ซึ่งหมายความว่าหากXมีการคอมไพล์ในภายหลังด้วยการตั้งค่าคงที่เป็น 2.4 Yจะยังคงใช้ค่าเดิม 2.3 จนกระทั่งYคอมไพล์ใหม่ ฟิลด์อ่านอย่างเดียวแบบคงที่จะหลีกเลี่ยงปัญหานี้

อีกวิธีหนึ่งในการดูสิ่งนี้คือค่าใด ๆ ที่อาจเปลี่ยนแปลงในอนาคตนั้นไม่คงที่ตามคำจำกัดความดังนั้นจึงไม่ควรแสดงเป็นค่าเดียว

const:

1. ควรให้มูลค่าเมื่อมีการประกาศ
2. รวบรวมเวลาคงที่

อ่านเท่านั้น:

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

Const : ค่าตัวแปร const ต้องกำหนดพร้อมกับการประกาศและหลังจากนั้นจะไม่เปลี่ยนแปลง const คงที่โดยปริยายดังนั้นโดยไม่ต้องสร้างอินสแตนซ์ของคลาสเราสามารถเข้าถึงได้นี่มีค่า ณ เวลารวบรวม

อ่านเท่านั้น : ค่าตัวแปรอ่านได้เดียวที่เราสามารถกำหนดได้ในขณะที่ประกาศเช่นเดียวกับการใช้ตัวสร้างที่รันไทม์ ตัวแปรแบบอ่านอย่างเดียวไม่สามารถเข้าถึงได้โดยไม่มีอินสแตนซ์ของคลาส

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

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

https://www.stum.de/2009/01/14/const-strings-a-very-convenient-way-to-shoot-yourself-in-the-foot/

มีความแตกต่างเล็กน้อยระหว่างฟิลด์ const และสแตติกแบบอ่านอย่างเดียวใน C # .Net

const ต้องเริ่มต้นด้วยค่าในเวลารวบรวม

const เป็นค่าคงที่เริ่มต้นและจะต้องเริ่มต้นด้วยค่าคงที่ซึ่งไม่สามารถแก้ไขได้ในภายหลัง มันไม่สามารถใช้กับประเภทข้อมูลทั้งหมด สำหรับอดีต DateTime มันไม่สามารถใช้กับประเภทข้อมูล DateTime

public const DateTime dt = DateTime.Today;  //throws compilation error
public const string Name = string.Empty;    //throws compilation error
public static readonly string Name = string.Empty; //No error, legal

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

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

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

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

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

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

ความแตกต่างที่สำคัญอีกอย่างหนึ่งก็คือค่าคงที่อยู่ในคลาสในขณะที่ตัวแปรอ่านอย่างเดียวเป็นของอินสแตนซ์!

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

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

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

ความแตกต่างระหว่างการประกาศอีกconstและคงอ่านได้อย่างเดียวอยู่ในจัดสรรหน่วยความจำ

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

ในทางกลับกันฟิลด์const "เป็นของอินสแตนซ์ของประเภท

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