Bimbingan dalam penamaan objek khusus domain canggung?

Saya memodelkan sistem kimia, dan saya mengalami masalah dengan penamaan elemen / item saya dalam enum.

Saya tidak yakin apakah saya harus menggunakan:

• rumus atom
• nama kimianya
• nama kimia yang disingkat.

Sebagai contoh, asam sulfat adalah H2SO4 dan asam klorida adalah HCl.

Dengan keduanya, saya mungkin hanya akan menggunakan rumus atom karena keduanya cukup umum.

Namun, saya punya yang lain seperti sodium hexafluorosilicate yang Na2SiF6.

Dalam contoh itu, rumus atom tidak jelas (untuk saya), tapi nama kimia amat sangat panjang: myEnum.SodiumHexaFluoroSilicate. Saya tidak yakin bagaimana saya dapat dengan aman menghasilkan nama kimia yang disingkat yang akan memiliki pola penamaan yang konsisten.

Ada beberapa masalah yang saya coba atasi melalui penamaan elemen enum.
Yang pertama adalah keterbacaan, dengan nama yang lebih panjang menghadirkan masalah.
Yang kedua adalah kemudahan mengambil kode untuk pengelola baru, dan di sini nama yang lebih pendek menyajikan masalah.
Masalah berikutnya adalah bahwa pemilik bisnis biasanya merujuk pada nama kimia lengkap, tetapi tidak selalu. Bahan kimia "seteguk" dirujuk dengan formula mereka.
Perhatian terakhir adalah memastikan itu konsisten. Saya tidak ingin mengadakan konvensi penamaan campuran karena tidak mungkin untuk mengingat mana yang akan digunakan.

Dari sudut pandang pemeliharaan, manakah dari opsi penamaan di atas yang akan Anda pilih dan mengapa?

Catatan: Semua yang ada di sini di bawah ini adalah tambahan | materi klarifikasi. Tolong jangan terjebak di dalamnya. Pertanyaan utama tentang penamaan objek canggung.

Opsi Atom

myEnum.ChemTypes publik
{  
   H2SO4,
   HCl,
   Na2SiF6
}

Opsi Nama Kimia

myEnum.ChemTypes publik
{
   Asam belerang,
   Asam hidroklorik,
   SodiumHexafluorosilicate  
}

Berikut adalah beberapa detail tambahan dari komentar pada pertanyaan ini:

• Pemirsa untuk kode hanya akan menjadi programmer, bukan ahli kimia.
• Saya menggunakan C #, tapi saya pikir pertanyaan ini lebih menarik ketika mengabaikan bahasa implementasi.
• Saya mulai dengan 10 - 20 senyawa dan memiliki paling banyak 100 senyawa, jadi saya tidak perlu khawatir tentang setiap senyawa yang mungkin. Untungnya, ini adalah domain tetap.

• Enum digunakan sebagai kunci untuk pencarian untuk memfasilitasi perhitungan kimia umum / umum - yang berarti bahwa persamaan adalah sama untuk semua senyawa tetapi Anda memasukkan properti senyawa untuk menyelesaikan persamaan.

  • Misalnya, massa molar (dalam g / mol) digunakan saat menghitung jumlah mol dari massa (dalam gram) senyawa. FWIW, Massa Molar == Berat Molar.
  • Contoh lain dari perhitungan umum adalah Hukum Gas Ideal dan penggunaannya atas Constant Gas Spesifik

Fungsi sampel mungkin terlihat seperti:

GetMolesFromMass ganda publik (double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (chem); // mengembalikan gram / mol
  double moles = massa / molarBerat; // mengonversi menjadi mol

  mengembalikan tahi lalat;
}

// Panggilan Sampel:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*atau*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);

double publik GetSpecificGravity (myEnum.ChemTypes chem, double conc)
{
  // mengambil gravitasi spesifik senyawa kimia berdasarkan konsentrasi
  double sg = SpecificGravityLookupTableByChem (chem, conc);  
}

Jadi enum dari nama majemuk digunakan sebagai kunci dan untuk memberikan konsistensi dalam merujuk senyawa dengan fungsi terkait.

Ketika saya mulai menulis ulang proyek saya saat ini dari spageti menjadi kode yang masuk akal, saya dihadapkan dengan masalah yang sama. Domain masalah saya adalah medis, dan daripada menggunakan nama-nama seperti "ETCO2" dan "SPO2" untuk enum saya, saya menggunakan nama-nama Inggris penuh.

Di satu sisi, itu sangat berguna untuk memiliki nama bahasa Inggris ketika saya baru di domain masalah. Di sisi lain, sekarang saya telah bekerja dengan istilah-istilah ini selama setahun saya menemukan bahwa nama-nama Inggris penuh terlalu verbose dan saya cukup akrab dengan istilah yang saya lebih suka menggunakan singkatan.

Saran saya adalah menggunakan rumus atom dan memasukkan komentar oleh setiap nilai enum yang memberikan nama lengkapnya, dengan asumsi bahwa siapa pun yang melihat kode Anda akan a) seorang ahli kimia, atau b) mengerjakan kode cukup lama bahwa mereka secara alami menjadi terbiasa dengan formula.

Siapa audiens untuk kode? Akankah ahli kimia menggunakan Enums, atau hanya programmer tanpa pelatihan domain khusus dalam kimia?

Jika ahli kimia akan menggunakan kode, tanyakan pada mereka. Sangat mungkin mereka akan lebih suka simbol yang disingkat, karena mereka dapat dengan mudah mengenalinya. Jika pemrogram pengetahuan umum akan menggunakan pengidentifikasi ini atas nama ahli kimia, saya pikir lebih baik menggunakan versi yang mirip bahasa Inggris.

Tidak ada alasan untuk tidak menggabungkan "semua yang di atas."

Masalah dengan nama lengkap adalah itu akan membosankan untuk mengetik, masalah dengan nama simbol adalah kurangnya makna.

Jadi, buat konstanta nilai dengan nama lengkap. Kemudian buat definisi terkait dengan konstanta. Anda dapat dengan mudah membuat definisi yang lebih baru dan lebih pendek saat Anda menjadi lebih akrab dengan makna singkatan.

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

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

Saat Anda merancang aplikasi apa pun, Anda harus memisahkan data dari logika program. Apakah senyawa kimia benar-benar bagian dari logika program dan bukan data yang digunakan logika program?

Ketika mereka adalah data, akan jauh lebih baik untuk tidak memperlakukan mereka sebagai enum tetapi membaca nama dan properti mereka dari file konfigurasi dan menyimpannya dalam struktur data. Itu juga akan membuat perawatan jauh lebih mudah. Ketika seseorang perlu menambahkan senyawa baru, atau menemukan kesalahan dalam properti salah satunya, mereka hanya dapat mengedit file konfigurasi.

Ini sepertinya bisa lebih baik diimplementasikan sebagai kelas yang dapat memperluas dan menerjemahkan berdasarkan kebutuhan pengembang. Di bawah ini adalah beberapa sampel C # yang saya buat untuk memungkinkan beberapa bahan kimia terdefinisi yang terkenal (sebagai properti) dan kemudian toko yang dapat diminta (melalui Adddan Getmetode). Anda juga dapat memperpanjang dengan mudah agar massa molar Anda dan sifat kimia lainnya tersedia.

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;
    }
}

Anda dapat menambahkan bahan kimia baru seperti:

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

dan dapatkan bit lainnya seperti itu:

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