คำแนะนำในการตั้งชื่อวัตถุเฉพาะโดเมนที่ไม่เหมาะสมหรือไม่

ฉันกำลังสร้างแบบจำลองระบบเคมีและฉันมีปัญหากับการตั้งชื่อองค์ประกอบ / รายการของฉันภายใน Enum

ฉันไม่แน่ใจว่าฉันควรใช้:

• สูตรอะตอม
• ชื่อทางเคมี
• ชื่อทางเคมีแบบย่อ

ตัวอย่างเช่นกรดซัลฟูริกคือ H2SO4 และกรดไฮโดรคลอริกคือ HCl

ด้วยสองอย่างนั้นฉันอาจจะใช้สูตรปรมาณูเนื่องจากมันเป็นเรื่องธรรมดา

อย่างไรก็ตามฉันมีคนอื่น ๆ เช่นโซเดียม hexafluorosilicate ซึ่งก็คือ Na2SiF6

ในตัวอย่างที่สูตรอะตอมไม่เป็นที่เห็นได้ชัด (กับผม) myEnum.SodiumHexaFluoroSilicateแต่ชื่อทางเคมีคือน่ากลัวยาว: ฉันไม่แน่ใจว่าฉันจะสามารถสร้างชื่อทางเคมีอย่างย่อได้อย่างปลอดภัยซึ่งจะมีรูปแบบการตั้งชื่อที่สอดคล้องกันอย่างไร

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

จากมุมมองการบำรุงรักษาตัวเลือกการตั้งชื่อใดที่คุณต้องการดูและเพราะเหตุใด

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

ตัวเลือกอะตอม

สาธารณะ myEnum.ChemTypes
{  
   H2SO4,
   HCl,
   Na2SiF6
}

ตัวเลือกชื่อเคมี

สาธารณะ myEnum.ChemTypes
{
   กรดซัลฟูริก,
   กรดไฮโดรคลอริก,
   SodiumHexafluorosilicate  
}

นี่คือรายละเอียดเพิ่มเติมบางส่วนจากความคิดเห็นในคำถามนี้:

• ผู้ชมสำหรับรหัสนั้นเป็นเพียงโปรแกรมเมอร์ไม่ใช่นักเคมี
• ฉันใช้ C # แต่ฉันคิดว่าคำถามนี้น่าสนใจกว่าเมื่อไม่สนใจภาษาการใช้งาน
• ฉันเริ่มต้นด้วย 10-20 สารประกอบและจะมีมากที่สุด 100 ชนิดดังนั้นผมจึงไม่จำเป็นต้องกังวลเกี่ยวกับทุกสารประกอบที่เป็นไปได้ โชคดีที่มันเป็นโดเมนที่ตายตัว

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

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

ฟังก์ชั่นตัวอย่างอาจมีลักษณะดังนี้:

ประชาชนสอง GetMolesFromMass (สองมวล _ กรัม, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (เคมี); // คืนกรัม / โมล
  โมลคู่ = มวล / โมลาร์น้ำหนัก; // แปลงเป็นโมล

  ไฝกลับ
}

// ตัวอย่างการโทร:
myMoles = GetMolesFromMass (1,000, myEnum.ChemTypes.Na2SiF6);
//*หรือ*
myMoles = GetMolesFromMass (1,000, myEnum.ChemTypes.SodiumHexafluorosilicate);

คู่สาธารณะ GetSpecificGravity (myEnum.ChemTypes chem, double conc)
{
  // ดึงความถ่วงจำเพาะของสารประกอบทางเคมีตามความเข้มข้น
  sg สองครั้ง = SpecificGravityLookupTableByChem (เคมี, เข้มข้น);  
}

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

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

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

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

ใครคือผู้ดูรหัส นักเคมีจะใช้ Enums หรือไม่ก็เป็นโปรแกรมเมอร์โดยไม่ต้องมีการฝึกฝนด้านเคมีเป็นพิเศษ

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

ไม่มีเหตุผลที่จะไม่รวม "ข้างต้นทั้งหมด"

ปัญหาเกี่ยวกับชื่อเต็มคือมันจะน่าเบื่อในการพิมพ์ปัญหากับชื่อสัญลักษณ์ขาดความหมาย

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

const int SodiumHexaFluoroSilicate = 16893859;   
const float Gold = 196.966569;

#define SoduimSilicate SodiumHexaFluoroSilicate 
#define F6Na2Si SodiumHexaFluoroSilicate 
#define au Gold 

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

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

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

public interface IChemical
{
    string AtomicFormula
    {
        get;
    }

    string ChemicalName
    {
        get;
    }

    string AbbreviatedChemicalName
    {
        get;
    }
}

public sealed class Chemical : IChemical
{
    private static readonly IChemical h2so4 = new Chemical("H2SO4", "sulfuric acid", "sulf. acid");

    private static readonly IChemical hcl = new Chemical("HCl", "hydrochloric acid", "hydro. acid");

    private static readonly IDictionary<string, IChemical> chemicalsByAtomicFormula = new Dictionary<string, IChemical>();

    private static readonly IDictionary<string, IChemical> chemicalsByChemicalName = new Dictionary<string, IChemical>();

    private static readonly IDictionary<string, IChemical> chemicalsByAbbreviatedChemicalName = new Dictionary<string, IChemical>();

    private readonly string atomicFormula;

    private readonly string chemicalName;

    private readonly string abbreviatedChemicalName;

    static Chemical()
    {
        chemicalsByAtomicFormula.Add(h2so4.AtomicFormula, h2so4);
        chemicalsByChemicalName.Add(h2so4.ChemicalName, h2so4);
        chemicalsByAbbreviatedChemicalName.Add(h2so4.AbbreviatedChemicalName, h2so4);
        chemicalsByAtomicFormula.Add(hcl.AtomicFormula, hcl);
        chemicalsByChemicalName.Add(hcl.ChemicalName, hcl);
        chemicalsByAbbreviatedChemicalName.Add(hcl.AbbreviatedChemicalName, hcl);
    }

    public Chemical(string atomicFormula, string chemicalName, string abbreviatedChemicalName)
    {
        if (string.IsNullOrWhiteSpace(atomicFormula))
        {
            throw new ArgumentException("Atomic formula may not be null or whitespace.", "atomicFormula");
        }

        if (string.IsNullOrWhiteSpace(chemicalName))
        {
            throw new ArgumentException("Chemical name may not be null or whitespace.", "chemicalName");
        }

        if (string.IsNullOrWhiteSpace(abbreviatedChemicalName))
        {
            throw new ArgumentException("Abbreviated chemical name may not be null or whitespace.", "abbreviatedChemicalName");
        }

        this.atomicFormula = atomicFormula;
        this.chemicalName = chemicalName;
        this.abbreviatedChemicalName = abbreviatedChemicalName;
    }

    public static IChemical H2SO4
    {
        get
        {
            return h2so4;
        }
    }

    public static IChemical HCl
    {
        get
        {
            return hcl;
        }
    }

    public string AtomicFormula
    {
        get
        {
            return this.atomicFormula;
        }
    }

    public string ChemicalName
    {
        get
        {
            return this.chemicalName;
        }
    }

    public string AbbreviatedChemicalName
    {
        get
        {
            return this.abbreviatedChemicalName;
        }
    }

    public static void AddChemical(IChemical chemical)
    {
        if (chemical == null)
        {
            throw new ArgumentNullException("chemical", "chemical may not be null");
        }

        if (chemicalsByAtomicFormula.ContainsKey(chemical.AtomicFormula))
        {
            return;
        }

        chemicalsByAtomicFormula.Add(chemical.AtomicFormula, chemical);

        if (chemicalsByChemicalName.ContainsKey(chemical.ChemicalName))
        {
            return;
        }

        chemicalsByChemicalName.Add(chemical.ChemicalName, chemical);

        if (chemicalsByAbbreviatedChemicalName.ContainsKey(chemical.AbbreviatedChemicalName))
        {
            return;
        }

        chemicalsByAbbreviatedChemicalName.Add(chemical.AbbreviatedChemicalName, chemical);
    }

    public static IChemical GetChemicalByAtomicFormula(string atomicFormula)
    {
        if (string.IsNullOrWhiteSpace(atomicFormula))
        {
            throw new ArgumentException("Atomic formula may not be null or whitespace.", "atomicFormula");
        }

        IChemical chemical;

        return chemicalsByAtomicFormula.TryGetValue(atomicFormula, out chemical) ? chemical : null;
    }

    public static IChemical GetChemicalByChemicalName(string chemicalName)
    {
        if (string.IsNullOrWhiteSpace(chemicalName))
        {
            throw new ArgumentException("Chemical name may not be null or whitespace.", "chemicalName");
        }

        IChemical chemical;

        return chemicalsByChemicalName.TryGetValue(chemicalName, out chemical) ? chemical : null;
    }

    public static IChemical GetChemicalByAbbreviatedChemicalName(string abbreviatedChemicalName)
    {
        if (string.IsNullOrWhiteSpace(abbreviatedChemicalName))
        {
            throw new ArgumentException("Abbreviated chemical name may not be null or whitespace.", "abbreviatedChemicalName");
        }

        IChemical chemical;

        return chemicalsByAbbreviatedChemicalName.TryGetValue(abbreviatedChemicalName, out chemical) ? chemical : null;
    }
}

คุณสามารถเพิ่มสารเคมีใหม่ ๆ เช่น:

        Chemical.AddChemical(new Chemical("Na2SiF6", "sodium hexafluorosilicate", "sod. hex.flu.sil."));

และรับบิตอื่น ๆ เช่น:

        Console.WriteLine(Chemical.GetChemicalByChemicalName("sulfuric acid").AtomicFormula);