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

12

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.


la source
7
pourquoi doivent-ils être des énumérations? il y a une quantité infinie de composés possibles, donc vous ne pourrez jamais les régler tous
ratchet freak
3
En tant que programmeur et non chimiste, je trouve que le Na2SiF6 et l'hexafluorosilicate de sodium sont également obscurs. Le premier est plus court à taper et est plus susceptible de passer des règles de codage étranges ne dépassant pas 40 caractères par identifiant.
mouviciel
5
En tant que programmeur, je pense personnellement que Sodium va rouler plus vite que Na2 - les mots ont tendance à couler plus facilement pour moi lors de la frappe (je déteste la notation hongroise pour cette raison).
Drake Clarris
5
Ils ne devraient pas être des valeurs énumérées, ils devraient être des instances de Substancetoutes les propriétés dont ils ont besoin.
AakashM
2
@ GlenH7: lisez simplement votre question sur "meta". Je pense que le vrai problème ici pour certaines personnes est "pourquoi les noms chimiques doivent-ils être dans le code"? Avoir ces noms uniquement sous forme de données éviterait d'encombrer votre code avec des noms très longs, et vous pourriez choisir les noms comme le préfère l'utilisateur de votre système, indépendamment de ce qu'un développeur pourrait en penser. Cela déléguerait la responsabilité de la dénomination à l'utilisateur et éviterait complètement votre problème.
Doc Brown

Réponses:

9

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.

Fourmi
la source
1
+1: En outre, on peut toujours rechercher "ETCO2" ou "Na2SiF6" et en finir avec cela.
Steven Evers
5

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.

Robert Harvey
la source
ce ne seront que des programmeurs, pas des chimistes
1
ou ajoutez la traduction dans la documentation de chaque énumération
ratchet freak
4

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 
Daniel
la source
J'ai utilisé un exemple de code C borked ... Je pense qu'il devrait se traduire assez facilement en C #.
Daniel
Je ne suis pas aussi inquiet pour une implémentation particulière, c'est pourquoi je n'ai pas spécifié C # dans ma question. Et j'ai aimé votre suggestion d'un point de vue C. La balise C # Description de System.ComponentModel est un moyen élégant d'ajouter le descripteur. J'étais plus intéressé par la réponse plus large à la question concernant une mise en œuvre particulière.
3

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.

Philipp
la source
1
+1 @ GlenH7, cela pourrait aider si vous pouviez expliquer pourquoi des composés chimiques spécifiques font partie du code, surtout après avoir dit que "l'équation est la même pour tous les composés".
Caleb
1
@ GlenH7: Toujours aucune raison pour laquelle les produits chimiques ne sont pas seulement des données. Plusieurs affiches vous disent utilement de ne pas utiliser une énumération. Je ne le ferais certainement pas.
kevin cline
1
@kevincline & caleb (et tout le monde en fait), j'ai créé une méta-question demandant de l'aide sur la façon de structurer cette question et son aspect énuméré. J'apprécierais vos commentaires.
3
Eh bien, quand quelqu'un vient à vous avec un couteau coincé dans la tête et qu'il vous demande de regarder l'éclat dans sa main, il est difficile de se concentrer sur cela.
Philipp
1
@Caleb - Question mise à jour pour mieux clarifier l'utilisation de l'énumération.
3

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);
Jesse C. Slicer
la source
Merci pour la réponse, et j'ai mis à jour ma question pour être un peu plus clair sur ce que je cible. Je ne suis pas aussi inquiet d'obtenir le nom du composé chimique que d'accéder à ses propriétés à partir de diverses tables et autres. J'ai une méta-question ouverte sur l'opportunité d'ajouter ou non la discussion enum ou de la diviser en un Q. séparé