¿Orientación para nombrar objetos incómodos específicos del dominio?

Estoy modelando un sistema químico y tengo problemas para nombrar mis elementos / elementos dentro de una enumeración.

No estoy seguro de si debo usar:

• la fórmula atómica
• el nombre químico
• Un nombre químico abreviado.

Por ejemplo, el ácido sulfúrico es H2SO4 y el ácido clorhídrico es HCl.

Con esos dos, probablemente usaría la fórmula atómica ya que son razonablemente comunes.

Sin embargo, tengo otros como el hexafluorosilicato de sodio que es Na2SiF6.

En ese ejemplo, la fórmula atómica no es tan obvia (para mí) pero el nombre químico es terriblemente largo: myEnum.SodiumHexaFluoroSilicate. No estoy seguro de cómo sería capaz de encontrar un nombre químico abreviado que tenga un patrón de denominación consistente.

Hay algunos problemas que estoy tratando de resolver nombrando los elementos de enumeración.
El primero es la legibilidad, con los nombres más largos que presentan un problema.
El segundo es la facilidad de elegir el código para los nuevos mantenedores, y aquí los nombres más cortos presentan un problema.
El siguiente problema es que los dueños de negocios generalmente se refieren al nombre químico completo, pero no siempre. Los productos químicos "bocados" se refieren a su fórmula.
La última preocupación es asegurarse de que sea consistente. No quiero una convención de nomenclatura mixta, ya que será imposible recordar cuál usar.

Desde el punto de vista del mantenimiento, ¿cuál de las opciones de nombres anteriores preferiría ver y por qué?

Nota: Todo aquí debajo de la línea es complementario | material clarificador Por favor, no te atasques en él. La pregunta principal se refiere a nombrar los objetos incómodos.

Opción atómica

public myEnum.ChemTypes
{  
   H2SO4,
   HCl
   Na2SiF6
}

Opción de nombre químico

public myEnum.ChemTypes
{
   Ácido sulfúrico,
   Ácido clorhídrico,
   Sodio Hexafluorosilicato  
}

Aquí hay algunos detalles adicionales de los comentarios sobre esta pregunta:

• La audiencia para el código será solo programadores, no químicos.
• Estoy usando C #, pero creo que esta pregunta es más interesante al ignorar el lenguaje de implementación.
• Estoy comenzando con 10-20 compuestos y tendría como máximo 100 compuestos, así que no necesito preocuparme por todos los compuestos posibles. Afortunadamente, es un dominio fijo.

• La enumeración se usa como clave para las búsquedas para facilitar los cálculos químicos comunes / genéricos, lo que significa que la ecuación es la misma para todos los compuestos, pero inserta una propiedad del compuesto para completar la ecuación.

  • Por ejemplo, la masa molar (en g / mol) se usa al calcular el número de moles de una masa (en gramos) del compuesto. FWIW, masa molar == peso molar.
  • Otro ejemplo de un cálculo común es la Ley del Gas Ideal y su uso de la constante de gas específica.

Una función de muestra podría verse así:

public double GetMolesFromMass (double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (chem); // devuelve gramos / mol
  moles dobles = masa / peso molar; // se convierte en moles

  devolver lunares;
}

// Llamada de muestra:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*o*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);

GetSpecificGravity doble pública (myEnum.ChemTypes chem, double conc)
{
  // recupera la gravedad específica del compuesto químico basado en la concentración
  sg doble = SpecificGravityLookupTableByChem (chem, conc);  
}

Por lo tanto, la enumeración del nombre compuesto se usa como clave y para proporcionar coherencia al hacer referencia al compuesto con las funciones relacionadas.

Cuando comencé a reescribir mi proyecto actual de spaghetti en un código razonable, me encontré con el mismo problema. Mi dominio del problema es médico, y en lugar de usar nombres como "ETCO2" y "SPO2" para mis enumeraciones, utilicé los nombres completos en inglés.

Por un lado, fue muy útil tener nombres en inglés cuando era nuevo en el dominio del problema. Por otro lado, ahora que he estado trabajando con estos términos durante un año, encuentro que los nombres completos en inglés son demasiado detallados y estoy lo suficientemente familiarizado con los términos que preferiría usar las abreviaturas.

Mi consejo sería utilizar la fórmula atómica e incluir un comentario por cada valor de enumeración que dé su nombre completo, suponiendo que cualquiera que vea su código sea a) un químico o b) trabajando en el código el tiempo suficiente. que, naturalmente, se familiarizan con las fórmulas.

¿Quién es la audiencia para el código? ¿Los químicos usarán Enums o solo programadores sin capacitación específica en química?

Si los químicos usarán el código, pregúntales. Es muy probable que prefieran los símbolos abreviados, ya que pueden reconocerlos fácilmente. Si los programadores de conocimiento general utilizarán estos identificadores en nombre de los químicos, creo que es mejor ir con versiones similares al inglés.

No hay razón para no combinar "todo lo anterior".

El problema con los nombres completos es que será tedioso escribir, el problema con los nombres de los símbolos es la falta de significado.

Entonces, cree constantes de los valores con el nombre completo. Luego crea definiciones asociadas con la constante. Puede crear fácilmente definiciones más nuevas y más cortas a medida que se familiarice con el significado de la abreviatura.

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

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

Cuando diseñe cualquier aplicación, debe separar los datos de la lógica del programa. ¿Son los compuestos químicos realmente parte de la lógica del programa y no los datos en los que opera la lógica del programa?

Cuando son datos, sería mucho mejor no tratarlos como enumeraciones, sino leer sus nombres y propiedades de un archivo de configuración y almacenarlos en una estructura de datos. Eso también facilitaría mucho el mantenimiento. Cuando uno necesita agregar nuevos compuestos, o encuentra un error en las propiedades de uno, simplemente puede editar el archivo de configuración.

Parece que podría implementarse mejor como una clase que puede expandirse y traducirse según las necesidades de los desarrolladores. A continuación se parte de la muestra C # me ocurrió para permitir unos pocos productos químicos bien conocidos definidas (como propiedades) y luego almacena consultables (vía Addy Getmétodos). También puede extenderse fácilmente para tener disponibles su masa molar y otras propiedades químicas.

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

puedes agregar nuevos químicos como tales:

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

y obtener los otros bits como tales:

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