นี่เป็นสถานการณ์ที่ถูกต้องที่จะใช้ค่าคงที่หรือไม่?

ดังนั้นอาจารย์ของฉันก็ให้ความเห็นย้อนกลับในโครงการที่ฉันทำอยู่ เขาเชื่อมต่อสองสามคะแนนสำหรับรหัสนี้:

if (comboVendor.SelectedIndex == 0) {
  createVendor cv = new createVendor();
  cv.ShowDialog();
  loadVendors();
}

สิ่งนี้อยู่ในตัวจัดการ "เปลี่ยนดัชนี" ของ combobox มันถูกใช้เมื่อผู้ใช้ต้องการสร้างผู้ขายรายใหม่ตัวเลือกอันดับแรกของฉัน (ดัชนี 0 ที่ไม่เคยเปลี่ยนแปลง) เปิดกล่องโต้ตอบ "สร้างผู้ขายใหม่" ดังนั้นเนื้อหาของกล่องคำสั่งผสมของฉันจึงดูเป็นแบบนี้:

Create New Vendor...
Existing Vendor
Existing Vendor 2
Existing Vendor 3

ปัญหาของเขากับรหัสบรรทัดแรก:

if (comboVendor.SelectedIndex == 0)

เขาอ้างว่า 0 ควรเป็นค่าคงที่และทำเครื่องหมายให้ฉันจริงเพราะสิ่งนั้น เขาอ้างว่าฉันไม่ควรใช้ตัวอักษรในรหัสของฉันเลย

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

วิธีที่ถูกต้องจริงในการทำสิ่งนี้ใน C # คือการไม่พึ่งพาการสั่งซื้อ ComboItemsเลย

public partial class MyForm : Form
{
    private readonly object VENDOR_NEW = new object();

    public MyForm()
    {
        InitializeComponents();
        comboVendor.Items.Insert(0, VENDOR_NEW);
    }

    private void comboVendor_Format(object sender, ListControlConvertEventArgs e)
    {
        e.Value = (e.ListItem == VENDOR_NEW ? "Create New Vendor" : e.ListItem);
    }

    private void comboVendor_SelectedIndexChanged(object sender, EventArgs e)
    {
        if(comboVendor.SelectedItem == VENDOR_NEW)
        {
            //Special logic for selecting "create new vendor"
        }
        else
        {
            //Usual logic
        }
    }
}

การสั่งซื้อในกล่องคำสั่งผสมอาจมีการเปลี่ยนแปลง จะเกิดอะไรขึ้นถ้าคุณเพิ่มตัวเลือกอื่นเช่น "สร้างผู้ขายพิเศษ ... " ก่อน "สร้างผู้ขายใหม่ ... "

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

การใช้ค่าคงที่ยังอ่านได้ง่ายกว่าตัวอักษร

if (comboVendor.SelectedIndex == NewVendorIndex)

ภาษาที่รวบรวมส่วนใหญ่จะแทนที่ค่าคงที่ในเวลารวบรวมดังนั้นจึงไม่มีการลงโทษประสิทธิภาพ

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

คำตอบที่แท้จริงคือว่าเขาเลือกสิ่งนี้เพื่อสอนบทเรียนให้คุณ

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

ฉันว่าเขาทำงานได้ดีจริง ๆ แล้ว

แน่นอนว่าเขาอาจหลุดพ้นไปเล็กน้อย แต่ฉันมั่นใจว่าคุณจะคิดอีกครั้งก่อนที่จะใช้หมายเลขเวทย์มนตร์

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

ถอดอาจารย์ของคุณออก

[... ]ตัวเลือกอันดับแรกของฉัน (ดัชนี 0 ที่ไม่เคยเปลี่ยนแปลง) เปิดกล่องโต้ตอบ "สร้างผู้ขายใหม่"

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

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

เขาอ้างว่า 0 ควรเป็นค่าคงที่และทำเครื่องหมายให้ฉันจริงเพราะสิ่งนั้น

ฉันเห็นด้วย การใช้ศูนย์ที่นี่คือ "วิเศษ" ลองจินตนาการว่าคุณกำลังอ่านรหัสนี้เป็นครั้งแรก คุณไม่รู้ว่าทำไมศูนย์ถึงพิเศษและตัวอักษรไม่ได้บอกคุณว่าทำไมศูนย์ถึงพิเศษ ถ้าคุณบอกว่าif(comboVendor.SelectedIndex == CreateNewVendorIndex)มันจะชัดเจนยิ่งขึ้นสำหรับผู้อ่านครั้งแรกว่าโค้ดนั้นหมายถึงอะไร

เขาอ้างว่าฉันไม่ควรใช้ตัวอักษรในรหัสของฉันเลย

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

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

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

และมันเป็นสิ่งที่คุณจะต้องปรับแต่ง

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

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

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

ตอนนี้เรามาถึงปมของเรื่อง

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

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

เขาพูดถูก. คุณถูก. คุณผิด.

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

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

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

ฉันจะได้เปลี่ยนที่มีอย่างต่อเนื่องเพื่อให้ความหมายที่ชัดเจนเช่น0 NewVendorIndexคุณไม่มีทางรู้ว่าคำสั่งซื้อของคุณจะเปลี่ยนไปหรือไม่

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

การฝึกอบรมที่ดีสำหรับโลกธุรกิจ? ค่อนข้างเป็นไปได้

ความจริงแล้วในขณะที่ฉันไม่คิดว่ารหัสของคุณเป็นแนวปฏิบัติที่ดีที่สุดข้อเสนอแนะของเขานั้นค่อนข้างแปลกประหลาด

วิธีปฏิบัติทั่วไปเพิ่มเติมสำหรับ. NET combobox คือการให้รายการ "Select .. " เป็นค่าว่างเปล่าในขณะที่รายการจริงมีค่าที่มีความหมายแล้วทำ:

if (string.IsNullOrEmpty(comboVendor.SelectedValue))

ค่อนข้างมากกว่า

if (comboVendor.SelectedIndex == 0)

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

ประเด็นของเขานั้นดีแม้ว่า นี่อาจเป็นวิธีของเขาที่จะทำให้คุณตระหนักถึงประโยชน์ของค่าคงที่:

1- พวกเขาปกป้องรหัสของคุณในระดับหนึ่งจากการดัดแปลงโดยไม่ได้ตั้งใจ

2-As @DeadMG กล่าวว่าในคำตอบของเขาหากมีการใช้ค่าตัวอักษรเดียวกันในหลาย ๆ ที่มันอาจปรากฏขึ้นด้วยค่าที่แตกต่างกันโดยไม่ได้ตั้งใจ - ดังนั้นค่าคงที่จะคงที่

ค่าคงที่ 3-type อนุรักษ์ดังนั้นคุณไม่จำเป็นต้องใช้อะไรเช่น 0F เพื่อหมายถึงศูนย์

4- เพื่อความสะดวกในการอ่าน COBOL ใช้ ZERO เป็นคำสงวนสำหรับค่าศูนย์ (แต่อนุญาตให้คุณใช้ตัวอักษรเป็นศูนย์) - ดังนั้นการให้ค่าชื่อบางครั้งก็มีประโยชน์เช่น: (ที่มา: ms-Constants

class CalendarCalc
{
    const int months = 12;
    const int weeks = 52; //This is not the best way to initialize weeks see comment
    const int days = 365;

    const double daysPerWeek = (double) days / (double) weeks;
    const double daysPerMonth = (double) days / (double) months;
}

หรือในกรณีของคุณ (ดังแสดงในคำตอบ @Michael Krussel)

คุณจะต้องใส่มันในค่าคงที่ถ้ามันมีความซับซ้อนมาหรือถ้ามันซ้ำบ่อย ๆ อื่น ๆ ตัวอักษรเป็นเรื่องปกติ การใส่ทุกอย่างไว้ในค่าคงที่นั้นเป็นผลรวมที่มากเกินไป

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

ดังนั้นเมื่อคุณสร้างรายการที่คุณเลือกมันจะจบลงด้วย html like

<select>
    <option value='CREATE'>Create New Vendor...</option>
    <option value='1'>Existing Vendor</option>
    <option value='2'>Existing Vendor 2</option>
    <option value='3'>Existing Vendor 3</option>
</select>

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

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

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

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

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

public class Program
{
    public static int Main()
    {
        const int a = 1000;
        const int b = a + a;
        const int c = b + 42;
        const int d = 7928345;
        return (a + b + c + d) / (-a - b - c - d);
    }
}

ส่งผลให้ IL:

.method public hidebysig static 
    int32 Main () cil managed 
{
    .maxstack 1
    .locals init (
        [0] int32 CS$1$0000
    )

    IL_0000: nop
    IL_0001: ldc.i4.m1  // the constant value -1 to be returned.
    IL_0002: stloc.0
    IL_0003: br.s IL_0005

    IL_0005: ldloc.0
    IL_0006: ret
}

ดังนั้นไม่ว่าคุณจะใช้ค่าคงที่ตัวอักษรหรือรหัสกิโลไบต์โดยใช้เลขคณิตคงที่ค่าจะได้รับการปฏิบัติอย่างแท้จริงใน IL

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

public class Program
{
    public static int Main()
    {
        const string a = "a";
        const string b = a + a;
        const string c = "C";
        const string d = "Dee";
        return (a + b + c + d).Length;
    }
}

แต่ลองดู IL:

IL_0000: nop
IL_0001: ldstr "aaaCDee"
IL_0006: callvirt instance int32 [mscorlib]System.String::get_Length()
IL_000b: stloc.0
IL_000c: br.s IL_000e
IL_000e: ldloc.0
IL_000f: ret

Bottom line: ตัวดำเนินการบนนิพจน์คงที่ส่งผลให้เกิดนิพจน์คงที่และคอมไพเลอร์ทำการคำนวณทั้งหมด ไม่ส่งผลกระทบต่อประสิทธิภาพการทำงาน