Quelle est la meilleure structure de données pour implémenter cela? [Propriétés imbriquées en C#]

Question

J'essaie de comprendre comment stocker et organiser efficacement les données suivantes dans une structure de données en C#. Les données sont des paramètres qui ont chacun un nom de paramètre (chaîne), une étiquette (chaîne) et éventuellement d'autres éléments.

Par exemple, les données en C++:

//Analog Inputs 
#define PROBETEMPERATURE "P33352" 
#define PROBETEMPERATURE2 "P33353" 
... 
//Digital Inputs 
#define RACKTEMPERATURE1 "P33384" 
#define RACKTEMPERATURE2 "P33385" 
... 

//Analog Input Labels 
#define LBLPROBETEMPERATURE  "Probe Temperature" 
#define LBLPROBETEMPERATURE2 "Probe Temperature 2" 
... 
//Digital Input Labels 
#define LBLRACKTEMPERATURE1  "Rack Temperature 1" 
#define LBLRACKTEMPERATURE1  "Rack Temperature 2" 
... 

est-il un moyen de structurer efficacement ce en utilisant les propriétés imbriquées, en utilisant simplement const « s, ou une meilleure façon? Par exemple la mise en œuvre serait:

AnalogInput.PROBETEMPERATURE.Paramater; 
AnalogInput.PROBETEMPERATURE.Label; 

DigitalInput.RACKTEMPERATURE1.Paramater; 
DigitalInput.RACKTEMPERATURE1.Label; 

J'essaye d'éviter de créer des objets statiques pour chacun car ils sont nombreux.

Merci.

Answer 1

quelque chose comme ça pourrait aider (ne sais pas s'il est le meilleur, mais je l'aurais utilisé)

déclare classe des deux types et de les utiliser comme

public class AnalogInput 
{ 
    public string Label { get; set; } 
    public string Parameter { get; set; } 
} 

public class DigitalInput 
{ 
    public string Label { get; set; } 
    public string Parameter { get; set; } 
} 

Vous pouvez les consommer comme

créer une instance

DigitalInput digiIn = new DigitalInput(); 
digiIn.Label = "This is digital Input"; 
digiIn.Parameter = "This is digital Parameter" 

si vous voulez avoir de nombreuses valeurs de entrées numériques ou entrée analogique, vous voudrez peut-être déclarer List<DigitalInput> digiData = new List<DigitalInput>();

puis ajoutez digiIn à comme

digiData.Add(digiIn); 

même peut être fait pour analogique

laissez-moi vous montrer comment

List <DigitalInput> digiData = new List<DigitalInput>(); 
    for(int x =0;x<10;x++) 
    { 
     DigitalInput digiIn = new DigitalInput(); 
     digiIn.Label = "This is digital Input No "+ x.ToString(); 
     digiIn.Parameter = "This is digital Parameter No "+ x.ToString(); 
     digiData.Add(digiIn); 
    } 

et pour montrer les valeurs que vous pouvez faire

foreach (DigitalInput dataToDisplay in digiData) 
{ 
MessageBox.Show("Label is :" + dataToDisplay.Label +" and Parameter is " + dataToDisplay.Parameter); 
} 

Answer 2

si vous avez utilisé #defines en C++, alors probablement ENUM devrait être votre choix

Vous pouvez utiliser la méthode GetName de classe Enum http://msdn.microsoft.com/en-us/library/system.enum.getname.aspx

Voir aussi le dernier exemple ici http://msdn.microsoft.com/en-us/library/cc138362.aspx

Nom de chaque valeur enum peut avoir '_' dans l'espace ("Probe_Temperature" au lieu de "Probe Temperature"), puis simplement string.replace ou peut-être essayer d'écrire la méthode d'extension, ce qui vous donnera une étiquette correcte

Edit: oups, désolé, je vous échoué en utilisant des chaînes comme params (« P33352 »), ENUM est un entier, donc ce probablement pas la solution pour vous

Answer 3

Je suppose que tout est un extrait de ce que vous devez faire et que les températures de sonde/rack ne sont pas statiques mais sont dans une base de données ou quelque chose. Voici une structure qui fera ce que vous voulez:

List<TemperatureInfo> infos = new List<TemperatureInfo>() 
{ 
    new TemperatureInfo("Probe") 
    { 
    new Temperature("P33352", "Temperature 1"), 
    new Temperature("P33353", "Temperature 2"), 
    }, 
    new TemperatureInfo("Rack") 
    { 
    new Temperature("P33384", "Temperature 1"), 
    new Temperature("P33385", "Temperature 2"), 
    } 
}; 

public class TemperatureInfo : List<Temperature> 
{ 
    public string Name { get; set; } 

    public TemperatureInfo(string name) 
    { 
    this.Name = name; 
    } 
} 

public class Temperature 
{ 
    public string ID { get; set; } 
    public string Label { get; set; } 

    public Temperature(string id, string label) 
    { 
    this.ID = id; 
    this.Label = label; 
    } 
} 

PS: Je souhaite que mon code SO soit correctement formaté. :(

Answer 4

Perhas quelque chose comme ça

public class Input 
{ 
    public InputType InputType { get; set; } 
    public Temperature ProbeTemperature { get; set; } 
    public Temperature RackTemperature { get; set; } 
} 

public class Temperature 
{ 
    public string Parameter { get; set; } 
    public string Label { get; set; } 
} 

public enum InputType 
{ 
    Digital, 
    Analog 
} 

Utilisez ensuite comme ceci:?

List<Input> inputs = new List<Input>(); 

Input x = new Input() { InputType = InputType.Digital }; 
x.RackTemperature = new Temperature { Parameter = "P", Label = "L" }; 
x.ProbeTemperature = new Temperature { Parameter = "P', Label = "L" }; 

inputs.Add(x); 

Answer 5

Je suppose que vous pouvez aller pour une classe de paramètres générique qui a des variables d'instance comme paramètre et étiquette ensuite. Vous pouvez étendre cette classe pour chaque paramètre et ajouter d'autres paramètres

public class Settings 
{ 
    public readonly string Parameter; 
    public readonly string Label; 

    public Settings(string parameter, string label) 
    { 
     Parameter = parameter; 
     Label = label; 
    } 
} 

public class ProbeTemperature : Settings 
{ 

.. 

} 

Je pense que toutes les autres réponses sont également bonnes. Vous devez probablement être plus précis sur ce que vous voulez exactement accomplir.