Des conseils pour nommer des objets spécifiques à un domaine maladroit?

Je modélise un système chimique et j'ai des problèmes pour nommer mes éléments / éléments dans une énumération.

Je ne sais pas si je dois utiliser:

• la formule atomique
• le nom chimique
• un nom chimique abrégé.

Par exemple, l'acide sulfurique est H2SO4 et l'acide chlorhydrique est HCl.

Avec ces deux, j'utiliserais probablement juste la formule atomique car elles sont raisonnablement courantes.

Cependant, j'en ai d'autres comme l'hexafluorosilicate de sodium qui est Na2SiF6.

Dans cet exemple, la formule atomique est pas aussi évidente (pour moi) mais le nom chimique est affreusement longue: myEnum.SodiumHexaFluoroSilicate. Je ne sais pas comment je pourrais trouver en toute sécurité un nom chimique abrégé qui aurait un modèle de dénomination cohérent.

Il y a quelques problèmes que j'essaie de résoudre en nommant les éléments enum.
Le premier est la lisibilité, les noms plus longs présentant un problème.
La seconde est la facilité à récupérer le code pour les nouveaux responsables, et ici les noms plus courts posent un problème.
Le problème suivant est que les propriétaires d'entreprise se réfèrent généralement au nom chimique complet, mais pas toujours. Les produits chimiques "en bouchée" sont désignés par leur formule.
La dernière préoccupation est de s'assurer qu'elle est cohérente. Je ne veux pas d' une convention de dénomination mixte car il sera impossible de se rappeler laquelle utiliser.

Du point de vue de la maintenance, laquelle des options de dénomination ci-dessus préféreriez-vous voir et pourquoi?

Remarque: tout ce qui se trouve en dessous de la ligne est supplémentaire | matériel de clarification. Veuillez ne pas vous enliser. La principale question concerne la dénomination des objets maladroits.

Option atomique

myEnum.ChemTypes public
{  
   H2SO4,
   HCl,
   Na2SiF6
}

Option de nom chimique

myEnum.ChemTypes public
{
   Acide sulfurique,
   Acide hydrochlorique,
   SodiumHexafluorosilicate  
}

Voici quelques détails supplémentaires des commentaires sur cette question:

• Le public du code sera uniquement des programmeurs, pas des chimistes.
• J'utilise C #, mais je pense que cette question est plus intéressante lorsque l'on ignore le langage d'implémentation.
• Je commence avec 10 à 20 composés et j'aurais au plus 100 composés, donc je n'ai pas besoin de m'inquiéter pour chaque composé possible. Heureusement, c'est un domaine fixe.

• L'énumération est utilisée comme clé pour les recherches afin de faciliter les calculs chimiques communs / génériques - ce qui signifie que l'équation est la même pour tous les composés, mais vous insérez une propriété du composé pour compléter l'équation.

  • Par exemple, la masse molaire (en g / mol) est utilisée lors du calcul du nombre de moles à partir d'une masse (en grammes) du composé. FWIW, Masse Molaire == Poids Molaire.
  • Un autre exemple de calcul commun est la loi du gaz idéal et son utilisation de la constante de gaz spécifique

Un exemple de fonction pourrait ressembler à ceci:

public double GetMolesFromMass (double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (chem); // renvoie des grammes / mole
  double mole = masse / poids molaire; // convertit en taupes

  taupes de retour;
}

// Exemple d'appel:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*ou*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);

public double GetSpecificGravity (myEnum.ChemTypes chem, double conc)
{
  // récupère la gravité spécifique du composé chimique en fonction de la concentration
  double sg = SpecificGravityLookupTableByChem (chem, conc);  
}

Ainsi, l'énumération du nom du composé est utilisée comme clé et pour assurer la cohérence du référencement du composé avec les fonctions associées.

Quand j'ai commencé à réécrire mon projet actuel de spaghetti en code raisonnable, j'étais confronté au même problème. Mon domaine de problème est médical, et plutôt que d'utiliser des noms comme "ETCO2" et "SPO2" pour mes énumérations, j'ai utilisé les noms anglais complets.

D'une part, il était très utile d'avoir des noms anglais lorsque j'étais nouveau dans le domaine problématique. D'un autre côté, maintenant que je travaille avec ces termes depuis un an, je trouve que les noms anglais complets sont beaucoup trop verbeux et je connais assez bien les termes que je préférerais de loin utiliser les abréviations.

Mon conseil serait d'utiliser la formule atomique et d'inclure un commentaire par chaque valeur d'énumération qui donne son nom complet, en supposant que toute personne qui regarde votre code sera soit a) un chimiste, soit b) travaillant sur le code assez longtemps qu'ils se familiarisent naturellement avec les formules.

Quel est le public visé par le code? Les chimistes utiliseront-ils les Enums, ou simplement des programmeurs sans formation spécifique en chimie?

Si les chimistes utiliseront le code, demandez-leur. Très probablement, ils préféreront les symboles abrégés, car ils peuvent facilement les reconnaître. Si les programmeurs de connaissances générales utiliseront ces identifiants au nom des chimistes, je pense qu'il vaut mieux aller avec les versions de type anglais.

Aucune raison de ne pas combiner "tout ce qui précède".

Le problème avec les noms complets est qu'il sera fastidieux de taper, le problème avec les noms de symboles est le manque de sens.

Donc, créez des constantes des valeurs avec le nom complet. Créez ensuite des définitions associées à la constante. Vous pouvez ensuite facilement créer de nouvelles définitions plus courtes à mesure que vous vous familiarisez avec la signification de l'abréviation.

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

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

Lorsque vous concevez une application, vous devez séparer les données de la logique du programme. Les composés chimiques font-ils vraiment partie de la logique du programme et pas plutôt les données sur lesquelles la logique du programme fonctionne?

Quand ce sont des données, il serait préférable de ne pas les traiter comme des énumérations mais plutôt de lire leurs noms et propriétés à partir d'un fichier de configuration et de les stocker dans une structure de données. Cela faciliterait également la maintenance. Quand on a besoin d'ajouter de nouveaux composés, ou trouve une erreur dans les propriétés de l'un, il suffit de modifier le fichier de configuration.

Cela semble pouvoir être mieux implémenté en tant que classe pouvant s'étendre et traduire en fonction des besoins des développeurs. Vous trouverez ci-dessous un exemple de C # que j'ai créé pour permettre quelques produits chimiques définis bien connus (en tant que propriétés), puis des magasins interrogeables (via Addet Getméthodes). Vous pouvez également vous étendre assez facilement pour avoir votre masse molaire et d'autres propriétés chimiques disponibles.

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

vous pouvez ajouter de nouveaux produits chimiques comme ceux-ci:

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

et obtenez les autres bits en tant que tels:

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