Garip alana özgü nesneleri adlandırma konusunda rehberlik?

Kimyasal bir sistemi modelliyorum ve bir numaralandırmadaki öğelerimi / eşyalarımı adlandırırken sorun yaşıyorum.

Kullanmalı mıyım emin değilim:

• atom formülü
• kimyasal isim
• kısaltılmış bir kimyasal isim.

Örneğin, sülfürik asit H2SO4 ve hidroklorik asit HCl'dir.

Bu ikisiyle, muhtemelen oldukça yaygın oldukları için atom formülünü kullanacağım.

Bununla birlikte, Na2SiF6 olan sodyum heksaflorosilikat gibi başkalarım var.

Bu örnekte, atomik formül bariz olarak (bana) değil ama kimyasal isim iğrenç uzun: myEnum.SodiumHexaFluoroSilicate. Tutarlı bir adlandırma modeline sahip olan kısaltılmış bir kimyasal adla nasıl güvenli bir şekilde gelebileceğimden emin değilim.

Numaralandırma öğelerini adlandırarak çözmeye çalıştığım birkaç sorun var.
Birincisi okunabilirliktir, daha uzun isimler sorun yaratır.
İkincisi, yeni koruyucular için kodu toplama kolaylığıdır ve burada daha kısa adlar bir sorun oluşturur.
Bir sonraki konu, işletme sahiplerinin genellikle tam kimyasal isme atıfta bulunmasıdır, ancak her zaman değil. "Ağız dolusu" kimyasallara kendi formülleri ile değinilmektedir.
Son endişe tutarlı olmasını sağlamaktır. Ben yok kullanımı hangi hatırlamak imkansız olacaktır olarak karışık bir adlandırma kuralı wan't.

Bakım açısından, yukarıdaki adlandırma seçeneklerinden hangisini görmeyi tercih edersiniz ve neden?

Not: Çizginin altındaki her şey tamamlayıcıdır | aydınlatıcı malzeme. Lütfen içine düşmeyin. Ana soru, garip nesneleri adlandırmakla ilgilidir.

Atom Seçeneği

kamu myEnum.ChemTypes
{  
   H2SO4,
   HCI,
   Na2SiF6
}

Kimyasal Ad Seçeneği

kamu myEnum.ChemTypes
{
   Sülfürik asit,
   Hidroklorik asit,
   SodiumHexafluorosilicate  
}

İşte bu sorudaki yorumlardan bazı ek detaylar:

• Kodun izleyicisi kimyacılar değil , sadece programcılar olacaktır .
• C # kullanıyorum, ancak uygulama dilini göz ardı ederken bu sorunun daha ilginç olduğunu düşünüyorum.
• Ben 10-20 bileşik ile başlıyorum ve en fazla 100 bileşik olurdu, bu yüzden olası her bileşik hakkında endişelenmenize gerek yok . Neyse ki, sabit bir alan.

• Enum, ortak / genel kimyasal hesaplamaları kolaylaştırmak için aramalar için bir anahtar olarak kullanılır - bu, denklemin tüm bileşikler için aynı olduğu anlamına gelir, ancak denklemi tamamlamak için bileşiğin bir özelliğini eklersiniz.

  • Örneğin, molar kütle (g / mol cinsinden), bileşiğin bir kütlesinden (gram cinsinden) mol sayısı hesaplanırken kullanılır. FWIW, Molar Kütle == Molar Ağırlık.
  • Ortak bir hesaplamanın diğer bir örneği İdeal Gaz Yasası ve Özel Gaz Sabiti'ni kullanmasıdır.

Örnek bir işlev şöyle görünebilir:

genel çift GetMolesFromMass (çift kütle_gramları, myEnum.ChemTypes chem)
{
  çift ​​molarWeight = MolarWeightLookupFunctionByChem (chem); // gram / mol döndürür
  çift ​​mol = kütle / molar Ağırlık; // benlere dönüşür

  dönüş molleri;
}

// Örnek Çağrı:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*veya*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);

kamu çift GetSpecificGravity (myEnum.ChemTypes chem, çift konsantrasyon)
{
  // konsantrasyona göre kimyasal bileşiğin özgül ağırlığını alır
  double sg = SpecificGravityLookupTableByChem (chem, kons.);  
}

Dolayısıyla bileşik adının sıralaması bir anahtar olarak kullanılır ve bileşiğin ilgili işlevlere referansta bulunmasında tutarlılık sağlamak için kullanılır.

Mevcut projemi spagetti'den makul bir koda yeniden yazmaya başladığımda, aynı sorunla karşılaştım. Sorun alanım tıbbi ve numaralandırmalar için "ETCO2" ve "SPO2" gibi isimler kullanmak yerine tam İngilizce isimler kullandım.

Bir yandan, sorunlu etki alanında yeniyken İngilizce adlara sahip olmak çok yararlı oldu. Öte yandan, bir yıldır bu terimlerle çalıştığım için, tam İngilizce isimlerinin çok ayrıntılı olduğunu ve kısaltmaları kullanmayı tercih ettiğim terimleri yeterince tanıdım.

Tavsiyem atom formülünü kullanmak ve kodunuza bakan herkesin a) bir kimyager veya b) kod üzerinde yeterince uzun süre çalışacağı varsayımına göre, her bir enum değerine tam adını veren bir yorum eklemek olacaktır. doğal olarak formüllere aşina olurlar.

Kodun izleyicileri kim? Kimyagerler Numaralandırmaları mı, yoksa sadece kimyada belirli bir alan eğitimi olmayan programcıları mı kullanacaklar?

Kimyagerler kodu kullanacaklarsa, onlara sorun. Büyük olasılıkla kısaltılmış sembolleri tercih edeceklerdir, çünkü onları kolayca tanıyabilirler. Eğer genel bilgi programcıları kimyagerler adına bu tanımlayıcıları kullanacaklarsa, bence İngilizceye benzer versiyonlarla gitmek daha iyidir.

"Yukarıdakilerin hepsini" birleştirmemek için hiçbir neden yok.

Tam adlarla ilgili sorun, yazmanın sıkıcı olacağı, sembol adlarıyla ilgili sorun anlam eksikliğidir.

Böylece, tam adla değerlerin sabitlerini oluşturun. Sonra sabit ile ilişkili tanımlar oluşturun. Daha sonra kısaltmanın anlamını daha iyi tanıdıkça daha yeni, daha kısa tanımları kolayca oluşturabilirsiniz.

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

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

Herhangi bir uygulama tasarlarken, verileri program mantığından ayırmanız gerekir. Kimyasal bileşikler program mantığının üzerinde çalıştığı verileri değil, gerçekten program mantığının bir parçası mı?

Veri olduklarında, bunları numaralandırma olarak işlememek yerine adlarını ve özelliklerini bir yapılandırma dosyasından okumak ve bir veri yapısında saklamak çok daha iyi olur. Bu aynı zamanda bakımı çok daha kolaylaştıracaktır. Birinin yeni bileşikler eklemesi gerektiğinde veya bir bileşenin özelliklerinde bir hata bulduğunda, yapılandırma dosyasını düzenleyebilirler.

Bu, geliştiricilerin ihtiyaçlarına göre genişleyebilen ve tercüme edebilecek bir sınıf olarak daha iyi uygulanabilir gibi görünüyor. Aşağıda, birkaç iyi tanımlanmış kimyasalın (özellik olarak) ve daha sonra sorgulanabilir mağazaların ( Addve Getyöntemleri ile) izin vermek için geldiğim bazı örnek C # . Ayrıca molar kütlenizi ve diğer kimyasal özellikleri elde etmek için kolayca genişletebilirsiniz.

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

bunun gibi yeni kimyasallar ekleyebilirsiniz:

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

ve diğer bitleri şu şekilde alın:

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