Guida nella denominazione di oggetti specifici di dominio scomodi?


12

Sto modellando un sistema chimico e ho problemi con la denominazione dei miei elementi / oggetti all'interno di un enum.

Non sono sicuro se dovrei usare:

  • la formula atomica
  • il nome chimico
  • un nome chimico abbreviato.

Ad esempio, l'acido solforico è H2SO4 e l'acido cloridrico è HCl.

Con quei due, probabilmente userei semplicemente la formula atomica poiché sono ragionevolmente comuni.

Tuttavia, ne ho altri come esafluorosilicato di sodio, che è Na2SiF6.

In questo esempio, la formula atomica non è così evidente (per me), ma il nome chimico è terribilmente lunga: myEnum.SodiumHexaFluoroSilicate. Non sono sicuro di come riuscire a trovare un nome chimico abbreviato che abbia un modello di denominazione coerente.

Ci sono alcuni problemi che sto cercando di affrontare attraverso la denominazione degli elementi enum.
La prima è la leggibilità, con i nomi più lunghi che presentano un problema.
Il secondo è la facilità nel raccogliere il codice per i nuovi manutentori, e qui i nomi più brevi presentano un problema.
Il prossimo problema è che gli imprenditori di solito fanno riferimento al nome chimico completo, ma non sempre. I prodotti chimici "bocconi" sono indicati dalla loro formula.
L'ultima preoccupazione è assicurarsi che sia coerente. Io non wan't una convenzione di denominazione mista in quanto sarà impossibile ricordare quale utilizzare.

Da un punto di vista della manutenzione, quale delle opzioni di denominazione sopra preferiresti vedere e perché?


Nota: tutto qui sotto la riga è supplementare | materiale chiarificatore. Per favore, non impantanarti. La domanda principale riguarda la denominazione degli oggetti scomodi.

Opzione atomica

public myEnum.ChemTypes
{  
   H2SO4,
   HCl,
   Na2SiF6
}

Opzione nome chimico

public myEnum.ChemTypes
{
   Acido solforico,
   Acido cloridrico,
   SodiumHexafluorosilicate  
}

Ecco alcuni dettagli aggiuntivi dai commenti su questa domanda:

  • Il pubblico per il codice sarà solo programmatore, non chimico.
  • Sto usando C #, ma penso che questa domanda sia più interessante quando si ignora il linguaggio di implementazione.
  • Sto iniziando con 10-20 composti e avrei al massimo 100 composti, quindi non devo preoccuparmi di ogni possibile composto. Fortunatamente, è un dominio fisso.
  • L'enum è usato come chiave per le ricerche per facilitare calcoli chimici comuni / generici - il che significa che l'equazione è la stessa per tutti i composti ma si inserisce una proprietà del composto per completare l'equazione.

Una funzione di esempio potrebbe apparire come:

GetMolesFromMass doppio pubblico (double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem (chem); // restituisce grammi / mole
  doppie moli = massa / molare Peso; // converte in moli

  talpe di ritorno;
}

// Chiamata di esempio:
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.Na2SiF6);
//*o*
myMoles = GetMolesFromMass (1000, myEnum.ChemTypes.SodiumHexafluorosilicate);
pubblico doppio GetSpecificGravity (myEnum.ChemTypes chem, double conc)
{
  // recupera il peso specifico del composto chimico in base alla concentrazione
  double sg = SpecificGravityLookupTableByChem (chem, conc);  
}

Quindi l'enum del nome composto viene usato come chiave e per fornire coerenza nel riferimento al composto con le relative funzioni.


7
perché devono essere enumerati? ci sono infinite quantità di possibili composti, quindi non sarai mai in grado di impostarli tutti
maniaco del cricchetto

3
Come programmatore, non chimico, trovo che Na2SiF6 e esafluorosilicato di sodio siano ugualmente oscuri. Il primo è più breve da digitare ed è molto probabile che passi strane regole di codifica non più di 40 caratteri per identificatore.
mouviciel,

5
Come programmatore, penso personalmente che il sodio stia rotolando le dita più velocemente di Na2 - le parole tendono a scorrere più facilmente per me durante la digitazione (odio la notazione ungherese per questo motivo).
Drake Clarris,

5
Non dovrebbero essere valori enumerati, dovrebbero essere istanze Substancecon qualsiasi proprietà di cui abbiano bisogno.
AakashM,

2
@ GlenH7: basta leggere la tua domanda su "meta". Penso che il vero problema qui per alcune persone qui sia "perché i nomi chimici devono essere nel codice"? Avere quei nomi solo come una qualche forma di dati eviterebbe di ingombrare il tuo codice con nomi molto lunghi e potresti scegliere i nomi proprio come preferisce l'utente del tuo sistema, indipendentemente da ciò che uno sviluppatore potrebbe pensare su di essi. Ciò delegherebbe la responsabilità di denominazione all'utente ed eviterebbe completamente il tuo problema.
Doc Brown,

Risposte:


9

Quando ho iniziato a riscrivere il mio progetto attuale da spaghetti in codice ragionevole, ho dovuto affrontare lo stesso problema. Il mio dominio problematico è medico, e piuttosto che usare nomi come "ETCO2" e "SPO2" per i miei enum ho usato i nomi inglesi completi.

Da un lato, era molto utile avere nomi inglesi quando ero nuovo nel dominio del problema. D'altra parte, ora che lavoro con questi termini da un anno, trovo che i nomi inglesi completi sono fin troppo dettagliati e ho abbastanza familiarità con i termini che preferirei di gran lunga usare le abbreviazioni.

Il mio consiglio sarebbe di usare la formula atomica e includere un commento per ogni valore enum che dia il suo nome completo, partendo dal presupposto che chiunque guardi il tuo codice sarà o) un chimico, oppure b) lavorerà sul codice abbastanza a lungo che acquisiscono familiarità con le formule.


1
+1: Inoltre, si potrebbe sempre cercare "ETCO2" o "Na2SiF6" e finirlo.
Steven Evers,

5

Chi è il pubblico per il codice? I chimici useranno gli Enum, o solo i programmatori senza una specifica formazione di dominio in chimica?

Se i chimici useranno il codice, chiediglielo. Molto probabilmente preferiranno i simboli abbreviati, poiché possono prontamente riconoscerli. Se i programmatori di conoscenza generale useranno questi identificatori per conto dei chimici, penso che sia meglio scegliere versioni simili a quelle inglesi.


saranno solo programmatori, non chimici

1
oppure aggiungi la traduzione nella documentazione di ciascun enum
ratchet maniaco del

4

Nessun motivo per non combinare "tutto quanto sopra".

Il problema con i nomi completi è che sarà noioso digitare, il problema con i nomi dei simboli è la mancanza di significato.

Quindi, crea costanti dei valori con il nome completo. Quindi creare le definizioni associate alla costante. Puoi quindi facilmente creare definizioni più recenti e più brevi man mano che acquisisci familiarità con il significato dell'abbreviazione.

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

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

Ho usato alcuni esempi di codice C corrotto ... Penso che dovrebbe tradursi in C # abbastanza facilmente.
Daniel,

Non sono così preoccupato per una particolare implementazione, motivo per cui non ho specificato C # nella mia domanda. E mi è piaciuto il tuo suggerimento da un punto di vista C. Il tag Descrizione C # di System.ComponentModel è un modo elegante per aggiungere il descrittore. Ero più interessato alla risposta più ampia alla domanda su una particolare implementazione.

3

Quando si progetta un'applicazione, è necessario separare i dati dalla logica del programma. I composti chimici fanno davvero parte della logica del programma e non piuttosto i dati su cui sta funzionando la logica del programma?

Quando sono dati, sarebbe molto meglio non trattarli come enum ma piuttosto leggere i loro nomi e proprietà da un file di configurazione e archiviarli in una struttura di dati. Ciò renderebbe anche la manutenzione molto più semplice. Quando uno ha bisogno di aggiungere nuovi composti o trova un errore nelle proprietà di uno, può semplicemente modificare il file di configurazione.


1
+1 @ GlenH7 sarebbe di aiuto se tu potessi spiegare perché specifici composti chimici fanno parte del codice, specialmente dopo che hai detto che "l'equazione è la stessa per tutti i composti".
Caleb,

1
@ GlenH7: Ancora nessuna ragione per cui i prodotti chimici non sono solo dati. Numerosi poster ti dicono di non usare un enum. Certamente no.
Kevin Cline,

1
@kevincline & caleb (e tutti gli altri in realtà), ho creato una meta domanda chiedendo aiuto su come strutturare questa domanda e l'aspetto enumico di essa. Gradirei il tuo feedback.

3
Bene, quando qualcuno viene da te con un coltello bloccato in testa e ti chiede di guardare la scheggia nella sua mano, è difficile concentrarsi su quello.
Philipp,

1
@Caleb - Domanda aggiornata per chiarire meglio l'uso dell'enum.

3

Sembra che potrebbe essere implementato meglio come una classe che può espandersi e tradurre in base alle esigenze degli sviluppatori. Di seguito è riportato un esempio di C # che ho escogitato per consentire alcuni noti prodotti chimici definiti (come proprietà) e quindi negozi interrogabili (tramite Adde Getmetodi). Puoi anche estenderti abbastanza facilmente per avere la tua massa molare e altre proprietà chimiche disponibili.

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

puoi aggiungere nuovi prodotti chimici come questi:

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

e ottieni gli altri bit come tali:

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

Grazie per la risposta, e ho aggiornato la mia domanda per essere un po 'più chiaro in ciò che sto prendendo di mira. Non sono così preoccupato di ottenere il nome del composto chimico come lo sono con l'accesso alle sue proprietà da varie tabelle e simili. Ho una meta domanda aperta sull'opportunità o meno di aggiungere nella discussione enum o di suddividerla in una
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.