Orientação para nomear objetos específicos de domínio inábeis?

Estou modelando um sistema químico e estou tendo problemas para nomear meus elementos / itens dentro de uma enumeração.

Não tenho certeza se devo usar:

• a fórmula atômica
• o nome químico
• um nome químico abreviado.

Por exemplo, o ácido sulfúrico é H2SO4 e o ácido clorídrico é HCl.

Com esses dois, eu provavelmente usaria apenas a fórmula atômica, pois eles são razoavelmente comuns.

No entanto, eu tenho outros como hexafluorossilicato de sódio, que é Na2SiF6.

Nesse exemplo, a fórmula atômica não é tão óbvio (para mim), mas o nome químico é terrivelmente longo: myEnum.SodiumHexaFluoroSilicate. Não tenho certeza de como seria capaz de criar com segurança um nome químico abreviado que teria um padrão de nomeação consistente.

Existem alguns problemas que estou tentando resolver nomeando os elementos enum.
A primeira é a legibilidade, com os nomes mais longos apresentando um problema.
A segunda é a facilidade de escolher o código para novos mantenedores, e aqui os nomes mais curtos apresentam um problema.
A próxima questão é que os empresários geralmente se referem ao nome químico completo, mas nem sempre. Os produtos químicos "cheios" são referidos por sua fórmula.
A preocupação final é garantir que seja consistente. Não quero uma convenção de nomes mistos, pois será impossível lembrar qual usar.

Do ponto de vista da manutenção, quais das opções de nomes acima você prefere ver e por quê?

Nota: Tudo aqui abaixo da linha é suplementar | material esclarecedor. Por favor, não se prenda a isso. A principal questão diz respeito a nomear os objetos estranhos.

Opção atômica

public myEnum.ChemTypes
{  
   H2SO4,
   HCl,
   Na2SiF6
}

Opção de nome químico

public myEnum.ChemTypes
{
   Ácido sulfúrico,
   Ácido clorídrico,
   Hexafluorossilicato de sódio  
}

Aqui estão alguns detalhes adicionais dos comentários sobre esta pergunta:

• A audiência do código será apenas programadores, não químicos.
• Estou usando c #, mas acho que essa pergunta é mais interessante ao ignorar a linguagem de implementação.
• Estou começando com 10 - 20 compostos e teria no máximo 100 compostos, então não preciso me preocupar com todos os compostos possíveis. Felizmente, é um domínio fixo.

• O enum é usado como uma chave para pesquisas para facilitar cálculos químicos comuns / genéricos - o que significa que a equação é a mesma para todos os compostos, mas você insere uma propriedade do composto para concluir a equação.

  • Por exemplo, a massa molar (em g / mol) é usada no cálculo do número de moles de uma massa (em gramas) do composto. FWIW, Massa molar == Peso molar.
  • Outro exemplo de cálculo comum é a Lei do Gás Ideal e seu uso da Constante de Gás Específica

Uma função de amostra pode se parecer com:

public double GetMolesFromMass (double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (chem); // retorna gramas / mole
  moles duplos = massa / peso molar; // converte em moles

  moles de retorno;
}

// Exemplo de chamada:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*ou*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);

public double GetSpecificGravity (chem myEnum.ChemTypes, conc. duplo)
{
  // recupera a gravidade específica do composto químico com base na concentração
  double sg = SpecificGravityLookupTableByChem (chem, conc);  
}

Portanto, a enumeração do nome do composto é usada como chave e para fornecer consistência na referência ao composto com as funções relacionadas.

Quando comecei a reescrever meu projeto atual de espaguete em um código razoável, me deparei com o mesmo problema. Meu domínio do problema é médico e, em vez de usar nomes como "ETCO2" e "SPO2" para minhas enumerações, usei os nomes completos em inglês.

Por um lado, era muito útil ter nomes em inglês quando eu era novo no domínio do problema. Por outro lado, agora que estou trabalhando com esses termos há um ano, acho que os nomes completos em inglês são muito detalhados e estou familiarizado o suficiente com os termos que preferiria usar as abreviações.

Meu conselho seria usar a fórmula atômica e incluir um comentário de cada valor de enumeração que dê seu nome completo, na suposição de que quem olha para o seu código será a) um químico ou b) trabalhando no código por tempo suficiente que eles naturalmente se familiarizem com as fórmulas.

Quem é o público para o código? Os químicos estarão usando o Enums, ou apenas programadores sem treinamento específico em domínio em química?

Se os químicos estiverem usando o código, pergunte a eles. Muito provavelmente eles preferirão os símbolos abreviados, pois podem reconhecê-los facilmente. Se os programadores de conhecimento geral usarão esses identificadores em nome dos químicos, acho melhor seguir as versões em inglês.

Não há razão para não combinar "todas as opções acima".

O problema com os nomes completos é que será tedioso digitar, o problema com os nomes dos símbolos é falta de significado.

Portanto, crie constantes dos valores com o nome completo. Em seguida, crie define associado à constante. Você pode facilmente criar definições mais novas e mais curtas à medida que se familiariza com o significado da abreviação.

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

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

Ao projetar qualquer aplicativo, você deve separar os dados da lógica do programa. Os compostos químicos são realmente parte da lógica do programa e não os dados em que a lógica do programa está operando?

Quando são dados, seria muito melhor não tratá-los como enumerações, mas ler seus nomes e propriedades em um arquivo de configuração e armazená-los em uma estrutura de dados. Isso também facilitaria muito a manutenção. Quando é necessário adicionar novos compostos ou encontrar um erro nas propriedades de um, eles podem apenas editar o arquivo de configuração.

Parece que poderia ser melhor implementado como uma classe que pode expandir e traduzir com base nas necessidades dos desenvolvedores. Abaixo está um exemplo de C # que criei para permitir alguns produtos químicos definidos bem conhecidos (como propriedades) e, em seguida, armazenamentos consultáveis ​​(via Adde Getmétodos). Você também pode estender-se facilmente para ter sua massa molar e outras propriedades químicas disponíveis.

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

você pode adicionar novos produtos químicos como:

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

e obtenha os outros bits como tal:

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