Si tratta di un modo corretto di utilizzare classi nidificate per tenere traccia dei dati?

0

Ho degli strumenti. Ogni strumento dovrebbe avere un nome (stringa) e una descrizione (stringa).

Ogni strumento può avere alcune configurazioni, che sono tutte queste serie di comandi (stringa [] o Elenco).

Voglio che questa classe sia flessibile, così posso facilmente aggiungere o rimuovere un intero strumento, o aggiungere o rimuovere impostazioni per qualsiasi strumento esistente nella classe.

Alla fine, voglio salvare questa classe nelle proprietà del mio assembly così ogni volta che il programma si avvia può essere caricato. Sto anche pensando di serializzarlo e salvarlo su disco per passare a un'altra copia del software.

Quindi per favore fatemi sapere cosa ne pensate di questo approccio e se pensate che questo possa essere migliorato o anche io dovrei considerare di andare in un altro modo, fatemelo sapere!

namespace MeasurementSuite
{
    /// <summary>
    /// Setups for all instruments
    /// </summary>
    public class Setups
    {
        /// <summary>
        /// An instrument
        /// </summary>
        public class Instrument
        {
            /// <summary>
            /// Name of the instrument
            /// </summary>
            public string Name { get; set; }
            /// <summary>
            /// Info about the instrument
            /// </summary>
            public string Info { get; set; }
            /// <summary>
            /// List of existing setups
            /// </summary>
            public List<Setup> SetupList { get; set; }

            /// <summary>
            /// Adds a setup to the instrument
            /// </summary>
            /// <param name="name"></param>
            /// <param name="commands"></param>
            private void AddSetup(string name, string[] commands)
            {
                this.SetupList.Add(new Setup(name, commands));
            }

            /// <summary>
            /// Removes a setup from the instrument
            /// </summary>
            /// <param name="name">Name of the setup</param>
            public void RemoveSetup(string name)
            {
                foreach (Setup setup in SetupList)
                {
                    if (setup.Name == name)
                    {
                        SetupList.Remove(setup);
                    }
                }
            }        
        }

        /// <summary>
        /// Setup for a instrument
        /// </summary>
        public class Setup
        {
            /// <summary>
            /// Name of the setup
            /// </summary>
            public string Name { get; set; }
            /// <summary>
            /// Command sets for setup
            /// </summary>
            public string[] CommandSet { get; set; }

            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="name">Setup Name</param>
            /// <param name="commands">Setup Command sets</param>
            public Setup(string name, string[] commands)
            {
                this.Name = name;
                this.CommandSet = commands;
            }
        } 
    }
}
    
posta Sean87 03.11.2011 - 11:50
fonte

2 risposte

1

Classi annidate per creare classi private NON è male. In effetti è una buona cosa rendere le classi non visibili al mondo esterno. Ma per questo, dovrebbero essere privati.

Tuttavia, come da codice precedente, queste classi sono pubbliche e diventano visibili per il resto dell'applicazione. Queste cose non hanno un valore speciale se non che la gerarchia delle classi ha davvero connotazioni particolari.

Una cosa del genere va bene solo se vengono seguiti sulla base di un modello ben stabilito dal mondo reale, ma può diventare un disastro se ciò viene fatto per comodità del programmatore.

L'altra differenza non funzionale, ma molto critica, è che la dichiarazione Nested Classes rende il codice molto illeggibile spesso a causa di molte gerarchie. Per aiutarvi dovete dichiarare i metodi lì, ma implementarli separatamente nel file .cpp separatamente.

Dipan.

    
risposta data 03.11.2011 - 15:23
fonte
3

Ecco la dura verità: probabilmente non è il modo giusto per memorizzarlo.

Sul lato positivo: nessuno sa come farlo correttamente finché non ha visto tutti i possibili casi d'uso di quella classe. Sembra ok, ma dovresti vederlo 'in azione' per giudicarlo correttamente.

Per ora basta andare con esso e refactoring se è necessario. Probabilmente il design giusto emergerà se ti attieni ai principi SOLID e cerchi costantemente di migliorarlo. Conserva questa copia come punto di riferimento, quindi torna tra un paio di settimane per vedere quali modifiche hai apportato e se avresti potuto prevederle.

Il più vicino che riuscirai a fare bene è progettare l'intero sistema in anticipo, il che solleva molti altri problemi. Questa classe stessa senza alcun contesto potrebbe essere giusta, ma potrebbe anche essere terribilmente sbagliata.

Questa è la risposta di programmers.stackexchange. Se vuoi maggiori dettagli prova codereview.stackexchange .

    
risposta data 03.11.2011 - 12:09
fonte

Leggi altre domande sui tag