Devo usare Enum, static Class, Dictionary o Struct per rappresentare questi "float etichettati" in C#?

Question

Ho una struttura di dati costante che rappresenta l'altezza relativa di ogni vertebra umana, normalizzata in relazione all'altezza totale della colonna vertebrale. Questo deriva da studi antropometrici, ecc

ho implementato in Python come una tupla di tuple, ciascuna contenente una (stringa) Nome e (doppio) Valore, in questo modo:

vertebral_heights = (
("C7", 0.0000000), 
("T1", 0.0391914), 
("T2", 0.0785479), 
("T3", 0.1183993), 
("T4", 0.1590759), 
("T5", 0.2009076), 
("T6", 0.2442244), 
("T7", 0.2893564), 
("T8", 0.3366337), 
("T9", 0.3863861), 
("T10", 0.4389439), 
("T11", 0.4946370), 
("T12", 0.5537954), 
("L1", 0.6167492), 
("L2", 0.6838284), 
("L3", 0.7553630), 
("L4", 0.8316832), 
("L5", 0.9131188), 
("S1", 1.0000000)) 

mio il primo pensiero è stato quello di creare un dizionario, ma che avrebbe avuto bisogno di una classe come contenitore. Poi mi è venuta in mente l'idea di un Enum, ma ho letto "le enumerazioni sono per inti", e ho il doppio. Poi ci sono Class and Struct, ma a questo punto sono completamente confuso, e credo che la mia attuale comprensione delle migliori pratiche di fare questa roba in C# non sia ancora abbastanza.

La mia destinazione d'uso è avere una "mappa" tra il modello dell'applicazione (la parte numerica degli elementi) e il modello utente (la parte relativa agli elementi denominata, relativa al dominio).

Qualche suggerimento?

Answer 1

in realtà dipende da come vuoi accedere ai valori.

Costanti

Se si intende utilizzare sempre i nomi delle variabili, ad esempio:

double x = C7; 

allora si può solo utilizzare una classe piena di costanti in questo modo:

public class VertebralHeights 
{ 
    public const double C7 = 0.0000000d; 
} 

Dizionario

Tuttavia, se si desidera accedere in modo dinamico, ad esempio:

string id = "C7"; 
double x = VertebralHeights[id]; 

allora si sarà meglio con un Dictionary quale è possibile definire in questo modo:

Dictionary<string, double> VertebralHeights = new Dictionary<string, double>() 
{ 
    { "C7", 0.0000000d }, 
    { "T1", 0.0391914d} 
} 

---

Avere entrambi i modi insieme.

Se si desidera sia l'accesso dinamico fortemente digitato al valore che è possibile estendere uno dei metodi sopra ...

Per costanti (metodo 1) aggiungere una funzione che prende una stringa:

public double GetValue(string s) 
{ 
    switch(s) 
    { 
     case "C7": return C7; 
     case "T7": return T7; 
     //...and so on... 
     default: return 0;//or an alternate default 
    } 
} 

(nota: si potrebbe fare questo con la riflessione, invece, che sarebbe più facile con un elenco enorme, ma isn' t davvero la pena la performance migliore colpito qui)

Per la Dizionario approccio (metodo 2), si potrebbe aggiungere una collezione di getter:

public double C7 { get { return VertebralHeights["C7"]; } } 

Answer 2

Dipende da come si utilizzano tali mapping. Se sono necessarie ricerche per nome (string), allora Dictionary è la scelta giusta. Ma se hai bisogno solo di quei numeri per avere nomi amichevoli, andrei per costanti in una classe (forse statico).

E 'anche facile enumerare entrambe le chiavi e valori in un dizionario:

var dict = new Dictionary<string, double>(); 

foreach (var key in dict.Keys) 
{ 

} 

foreach (var value in dict.Values) 
{ 

} 

Answer 3

Si potrebbe creare una classe:

public static class VertebralHeights 
{ 
    public const double C7 = 0.0000000; 
    public const double T1 = 0.0391914; 
    //... 
} 

Accesso: double c7 = VertebralHeights.C7;

Answer 4

Ecco il mio prendere su questo - lavoro con una classe Singleton che è un dizionario:

public class Vertebrae : Dictionary<string, double> 
{ 
    private Vertebrae() : base() { } 


    private static Vertebrae _heights = new Vertebrae() { 
     { "C7", 0.0 }, 
     { "T1", 0.0391914 }, 
     { "T2", 0.0785479 }, 
    }; 

    public static Vertebrae Heights { get { return _heights; } } 

    public static double C7 { get { return Heights["C7"]; } } 
    public static double T1 { get { return Heights["T1"]; } } 
    public static double T2 { get { return Heights["T2"]; } } 

    public static IEnumerable<double> All 
    { 
     get 
     { 
      return new List<double>() { C7, T1, T2 }; 
     } 
    } 
} 

Per accedere le vertebre per nome della stringa, si fa:

double c7 = Vertebrae.Heights["C7"]; 

Per accedere le vertebre dalla simbolica nome, si fa:

double c7 = Vertebrae.C7; 

Per enumerare le vertebre si fa:

foreach (double v in Vertebrae.All) { /* ... */ } 

Per l'enumeratore si potrebbe avere un unico elenco statico inizializzato come nel enumeratore, ma non ero sicuro che sarebbe ottenere inizializzato prima, l'elenco statico o il dizionario statica ...

Answer 5

enumerarli , trovali per stringa e ordinali per ordine, è necessario memorizzare tre pezzi di dati. Il modo in cui accedi a loro cambia il modo migliore per memorizzarli.

1. List di tuple contenenti nome e valore.
   • Questo ha il vantaggio principale di ordinare.
   • Per ottenere un oggetto specifico per nome, è necessario una query linq per recuperarlo.
2. Dictionary con chiave di nome, e il valore di tuple ordine e valore
   • Questo ha il vantaggio principale di trovare oggetti rapidamente per nome
   • Al fine di ottenere tutti gli elementi in un ordine specifico contenente voi Avrei bisogno di una query di linq per ordinarli.
   • Se si desidera eseguire il loop su tutti gli elementi senza un ordine specifico, Dictionary lo consentirà.
3. Mantiene un dizionario e un elenco di valori. - Un po 'disordinato, potrebbe essere un eccesso di ottimizzazione.
4. Creare una raccolta personalizzata che erediti da una delle implementazioni precedenti e ha fornito la funzionalità mancante che nasconde l'implementazione effettiva. Linq non è così lento da essere preoccupante con una breve lista.

Answer 6

È possibile utilizzare una classe semplice in una raccolta generica. Quindi LINQ semplifica la mappatura dei valori tra loro.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace ConsoleApplication1 
{ 

    class Vertebra { 
     public string name { get; set; } 
     public double height { get; set; } 
    } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      List<Vertebra> Vertebrae = new List<Vertebra>() { 
       new Vertebra() {name = "C7", height = 0.0000000}, 
       new Vertebra() {name = "T1", height = 0.0391914} 
       //etc 
      }; 

      //find height by name: 
      double H = Vertebrae.Single(v => v.name == "C7").height; 

      //find name by height: 
      string N = Vertebrae.Single(v => v.height == 0.0391914).name; 

     } 
    } 

} 

Answer 7

Fatelo come enume e scrivete il codice idraulico della scatola nera in avanti. Non ve ne pentirete! Ecco quello che vorrei fare:

Scrivi un attributo personalizzato in modo che è possibile associare il doppio valore ad ogni enum:

[AttributeUsage(AttributeTargets.Field, Inherited = false, AllowMultiple = false)] 
internal sealed class VertebralHeightAsDoubleAttribute : Attribute 
{ 
    public double HeightValue { get; private set; } 

    public VertebralHeightAsDoubleAttribute(double heightValue_) 
    { 
    HeightValue = heightValue_; 
    } 
} 

Alcuni metodi di estensione per rendere la vita più facile:

public static class VHAttribExtensions 
{ 
    public static string ToNameString(this VertebralHeight target) 
    { 
    return Enum.GetName(typeof(VertebralHeight), target); 
    } 

    public static double ToHeightValue(this VertebralHeight target) 
    { 
    var fi = target.GetType().GetField(target.ToString()); 
    var attributes = (VertebralHeightAsDoubleAttribute[])fi.GetCustomAttributes(
     typeof(VertebralHeightAsDoubleAttribute), false); 
    return attributes.Length > 0 ? attributes[0].HeightValue : double.NaN; 
    } 
} 

Definisci la tua enum utilizzando l'attributo personalizzato:

public enum VertebralHeight 
{ 
    [VertebralHeightAsDouble(0.0000000)] 
    C7, 
    [VertebralHeightAsDouble(0.0391914)] 
    T1, 
    [VertebralHeightAsDouble(0.0785479)] 
    T2, 
    [VertebralHeightAsDouble(0.1183993)] 
    T3, 
    [VertebralHeightAsDouble(0.1590759)] 
    T4, 
    [VertebralHeightAsDouble(0.2009076)] 
    T5, 
    [VertebralHeightAsDouble(0.2442244)] 
    T6, 
    [VertebralHeightAsDouble(0.2893564)] 
    T7, 
    [VertebralHeightAsDouble(0.3366337)] 
    T8, 
    [VertebralHeightAsDouble(0.3863861)] 
    T9, 
    [VertebralHeightAsDouble(0.4389439)] 
    T10, 
    [VertebralHeightAsDouble(0.4946370)] 
    T11, 
    [VertebralHeightAsDouble(0.5537954)] 
    T12, 
    [VertebralHeightAsDouble(0.6167492)] 
    L1, 
    [VertebralHeightAsDouble(0.6838284)] 
    L2, 
    [VertebralHeightAsDouble(0.7553630)] 
    L3, 
    [VertebralHeightAsDouble(0.8316832)] 
    L4, 
    [VertebralHeightAsDouble(0.9131188)] 
    L5, 
    [VertebralHeightAsDouble(1.0000000)] 
    S1 
} 

prova esso:

static void Main(string[] args) 
{ 
    var list = Enum.GetValues(typeof(VertebralHeight)).OfType<VertebralHeight>(); 
    foreach (var vh in list) 
    { 
    Console.WriteLine("{0} : {1}", vh.ToNameString(), vh.ToHeightValue()); 
    } 
    Console.ReadLine(); 
}