Руководство по именованию неуклюжих предметно-ориентированных объектов?

Я моделирую химическую систему, и у меня возникают проблемы с именованием моих элементов / элементов в перечислении.

Я не уверен, должен ли я использовать:

• атомная формула
• химическое название
• сокращенное химическое название.

Например, серная кислота представляет собой H2SO4, а соляная кислота представляет собой HCl.

С этими двумя я, вероятно, просто использовал бы атомарную формулу, поскольку они достаточно распространены.

Тем не менее, у меня есть другие, такие как гексафторсиликат натрия, который является Na2SiF6.

В этом примере, атомная формула не столь очевидна (для меня) , но химическое название безобразно долго: myEnum.SodiumHexaFluoroSilicate. Я не уверен, как я смогу безопасно придумать сокращенное химическое название, которое будет иметь последовательную схему именования.

Есть несколько проблем, которые я пытаюсь решить, называя элементы enum.
Первый - это удобочитаемость, более длинные имена представляют проблему.
Второе - простота выбора кода для новых сопровождающих, и здесь короткие имена представляют проблему.
Следующая проблема заключается в том, что владельцы бизнеса обычно ссылаются на полное химическое название, но не всегда. «Глотательные» химические вещества обозначаются их формулой.
Последнее беспокойство - убедиться, что оно соответствует. Я не хочу смешанного соглашения об именах, так как невозможно будет вспомнить, какой использовать.

С точки зрения обслуживания, какой из перечисленных выше вариантов имен вы бы предпочли увидеть и почему?

Примечание: все, что ниже строки, является дополнительным | уточняющий материал. Пожалуйста, не увязай в этом. Основной вопрос касается имен неудобных объектов.

Атомный вариант

public myEnum.ChemTypes
{  
   H2SO4,
   HCl,
   Na2SiF6
}

Опция химического названия

public myEnum.ChemTypes
{
   Серная кислота,
   Соляная кислота,
   SodiumHexafluorosilicate  
}

Вот некоторые дополнительные детали из комментариев к этому вопросу:

• Аудитория для кода будет только программисты, а не химики.
• Я использую C #, но я думаю, что этот вопрос более интересен, если игнорировать язык реализации.
• Я начинаю с 10 - 20 соединений и буду иметь не более 100 соединений, поэтому мне не нужно беспокоиться о всех возможных соединениях. К счастью, это фиксированный домен.

• Перечисление используется в качестве ключа для поиска, чтобы упростить общие / общие химические вычисления - это означает, что уравнение одинаково для всех соединений, но вы вводите свойство соединения для завершения уравнения.

  • Например, молярная масса (в г / моль) используется при расчете количества молей из массы (в граммах) соединения. FWIW, Молярная масса == Молярная масса.
  • Другим примером общего расчета является закон идеального газа и его использование удельной газовой постоянной

Пример функции может выглядеть так:

public double GetMolesFromMass (double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (chem); // возвращает грамм / моль
  двойные родинки = масса / молярный вес; // конвертируется в родинки

  возвратные родинки;
}

// Пример вызова:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*или*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);

public double GetSpecificGravity (myEnum.ChemTypes chem, double conc)
{
  // извлекает удельный вес химического соединения на основе концентрации
  double sg = SpecificGravityLookupTableByChem (chem, conc);  
}

Таким образом, перечисление составного имени используется в качестве ключа и для обеспечения согласованности в отношении соединения с соответствующими функциями.

Когда я начал переписывать свой текущий проект из спагетти в разумный код, я столкнулся с той же проблемой. Моя проблемная область - медицинская, и вместо того, чтобы использовать имена типа «ETCO2» и «SPO2», я использовал полные английские имена.

С одной стороны, было очень полезно иметь английские имена, когда я был новичком в проблемной области. С другой стороны, теперь, когда я работал с этими терминами в течение года, я обнаружил, что полные английские имена слишком многословны, и я достаточно знаком с терминами, поэтому я бы предпочел использовать сокращения.

Я бы посоветовал использовать атомарную формулу и добавить комментарий к каждому значению перечисления, в котором указано его полное имя, при условии, что любой, кто просматривает ваш код, будет: а) химиком или б) работать над кодом достаточно долго что они, естественно, знакомятся с формулами.

Кто является аудиторией для кода? Будут ли химики использовать Enums или просто программисты без специальной подготовки в области химии?

Если химики будут использовать код, спросите их. Очень вероятно, что они предпочтут сокращенные символы, поскольку они могут легко распознать их. Если программисты общего знания будут использовать эти идентификаторы от имени химиков, я думаю, что лучше использовать английские версии.

Нет причин не объединять «все вышеперечисленное».

Проблема с полными именами в том, что набирать их будет утомительно, проблема с именами символов - отсутствие смысла.

Итак, создайте константы значений с полным именем. Затем создайте определения, связанные с константой. Затем вы можете легко создавать более новые, более короткие определения, когда вы лучше ознакомитесь со значением аббревиатуры.

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

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

При разработке любого приложения вы должны отделить данные от логики программы. Действительно ли химические соединения являются частью логики программы, а не данными, на которых работает логика программы?

Когда они являются данными, было бы гораздо лучше не рассматривать их как перечисления, а читать их имена и свойства из файла конфигурации и сохранять их в структуре данных. Это также сделало бы обслуживание намного легче. Когда нужно добавить новые соединения или найти ошибку в свойствах одного из них, они могут просто отредактировать файл конфигурации.

Кажется, что это может быть лучше реализовано как класс, который может расширяться и переводиться в зависимости от потребностей разработчиков. Ниже приведен пример 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);