Orientamento nel nominare oggetti specifici del dominio scomodi?

12

Sto modellando un sistema chimico e ho problemi con la denominazione dei miei elementi / elementi 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 questi due, probabilmente userò la formula atomica perché sono ragionevolmente comuni.

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

In questo esempio, la formula atomica non è così ovvia (per me), ma il nome chimico è orribilmente lungo: myEnum.SodiumHexaFluoroSilicate . Non sono sicuro di come sarei in grado di trovare un nome chimico abbreviato che avrebbe un modello di denominazione coerente.

Ci sono alcuni problemi che sto cercando di affrontare nominando gli elementi enumerati.
Il primo è la leggibilità, con i nomi più lunghi che presentano un problema.
Il secondo è la facilità di scegliere il codice per i nuovi manutentori, e qui i nomi più brevi presentano un problema.
Il prossimo numero è che i titolari di aziende di solito si riferiscono al nome completo della sostanza chimica, ma non sempre. I prodotti chimici "a bocca aperta" si riferiscono alla loro formula.
L'ultima preoccupazione è assicurarsi che sia coerente. I non non richiede una convenzione di denominazione mista in quanto sarà impossibile ricordare quale usare.

Dal punto di vista della manutenzione, quale delle opzioni di denominazione in alto vorresti vedere e perché?

Nota: tutto qui sotto la linea è supplementare | materiale di chiarimento. 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
{
   SulfuricAcid,
   HydrochloricAcid,
   SodiumHexafluorosilicate  
}

Ecco alcuni dettagli aggiuntivi dei commenti su questa domanda:

  • Il pubblico per il codice sarà solo programmatore, non chimici.
  • 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 avrò al massimo 100 composti, quindi non devo preoccuparmi del possibile composto ogni . 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 essere simile a:

public double GetMolesFromMass(double mass_grams, myEnum.ChemTypes chem)
{
  double molarWeight = MolarWeightLookupFunctionByChem(chem); //returns grams / mole
  double moles = mass / molarWeight;  //converts to moles

  return moles;
}

//Sample Call:
myMoles = GetMolesFromMass(1000, myEnum.ChemTypes.Na2SiF6);
//*or*
myMoles = GetMolesFromMass(1000, myEnum.ChemTypes.SodiumHexafluorosilicate);
public double GetSpecificGravity(myEnum.ChemTypes chem, double conc)
{
  //retrieves specific gravity of chemical compound based upon concentration
  double sg = SpecificGravityLookupTableByChem(chem, conc);  
}

Quindi l'enum del nome composto viene usato come chiave e per fornire coerenza nel riferire il composto con le funzioni correlate.

    
posta GlenH7 19.12.2012 - 17:01
fonte

5 risposte

9

Quando ho iniziato a riscrivere il mio attuale progetto da spaghetti in un codice ragionevole, mi sono trovato ad affrontare lo stesso problema. Il mio dominio del problema è medico, e invece di usare nomi come "ETCO2" e "SPO2" per le mie enumerazioni ho usato i nomi inglesi completi.

Da un lato, era molto utile avere nomi in inglese 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 siano fin troppo prolissi e io conosco abbastanza bene i termini che preferirei usare le abbreviazioni.

Il mio consiglio sarebbe di usare la formula atomica e includere un commento per ogni valore enum che dà il suo nome completo, partendo dal presupposto che chiunque guarda il tuo codice sarà a) un chimico o b) che lavora sul codice abbastanza a lungo da familiarizzarsi con le formule.

    
risposta data 19.12.2012 - 17:46
fonte
5

Chi è il pubblico per il codice? I chimici useranno l'Enum o solo programmatori senza un dominio specifico in chimica?

Se i chimici useranno il codice, chiediglielo. Molto probabilmente preferiranno i simboli abbreviati, in quanto possono riconoscerli facilmente. Se i programmatori di conoscenza generale useranno questi identificatori per conto dei chimici, penso che sia meglio andare con le versioni di tipo inglese.

    
risposta data 19.12.2012 - 17:16
fonte
4

Non c'è motivo per non combinare "tutto quanto sopra".

Il problema con i nomi completi è che sarà noioso da 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 facilmente creare definizioni più nuove 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 
    
risposta data 19.12.2012 - 17:57
fonte
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 i dati su cui la logica del programma sta operando?

Quando sono dati, sarebbe molto meglio non trattarli come enumerazioni, ma piuttosto leggere i loro nomi e proprietà da un file di configurazione e memorizzarli in una struttura dati. Ciò renderebbe anche la manutenzione molto più semplice. Quando è necessario aggiungere nuovi composti o trovare un errore nelle proprietà di uno, possono semplicemente modificare il file di configurazione.

    
risposta data 19.12.2012 - 17:53
fonte
3

Sembra che potrebbe essere meglio implementato come una classe in grado di espandersi e tradurre in base alle esigenze degli sviluppatori. Di seguito è riportato un esempio di C # che ho trovato per consentire alcuni noti prodotti chimici definiti (come proprietà) e quindi archivi interrogabili (tramite metodi Add e Get ). Puoi anche estendere abbastanza facilmente per avere la 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 nuove sostanze chimiche come queste:

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

e ottieni gli altri bit in questo modo:

        Console.WriteLine(Chemical.GetChemicalByChemicalName("sulfuric acid").AtomicFormula);
    
risposta data 19.12.2012 - 18:49
fonte

Leggi altre domande sui tag