L'uso di più classi statiche con un massimo di un metodo pubblico è una buona idea

1

Sto scrivendo un software di dettaglio strutturale (CAD) per edifici in cemento in C #. Ho definito come centinaia di static classi ognuna con un public method e se necessario qualche private methods . Ciascuno di questi metodi in queste classi statiche fa parte del lavoro. Sono chiamati da una classe statica di Dio chiamata Building.cs .

Ad esempio, una classe ha questo aspetto:

public static partial class GetMainRebars
{
    public static void GetMainRebars()
    {
    }

    // other possible variables and private methods
}

Il programma sta funzionando molto velocemente rispetto ad altri programmi simili. Ma nel profondo del mio cuore, guardando il codice di cui sopra, sento che qualcosa potrebbe ancora essere sbagliato in questo modello di progettazione. Forse incontrerò problemi in termini di manutenzione o ...? Mi sono insegnato a programmare, quindi potrei aver perso molti principi fondamentali durante il rapido processo di autoapprendimento. Puoi elaborare i contro e i pro del modello sopra?

E una domanda molto rookie pertinente al modello. Diciamo che definisco una variabile statica all'interno di tale classe, rimarrà in memoria durante la vita del programma? Nessuna disposizione e di sorta? Va bene?

Aggiornamento: Quando il programma si avvia sto caricando le variabili richieste nei campi e proprietà rilevanti in Building.cs per esempio listOfBeams, listOfColumns, listOfRebars, listOfConnectivities e così via. Ora che queste variabili sono a posto, ho usato i metodi nelle classi statiche per fare varie operazioni su questi. Diciamo che ottengo la listaOfRebars e listOfColumns in una classe statica e generare alcune variabili per l'output. Poi ottengo listOfRebars e listOfBeams e faccio altre cose.

Update2: Da quello che ho imparato sulla base delle risposte e dei commenti, ho trovato il modello sottostante. Mi stavo chiedendo se sono sulla strada giusta?

Ho una classe statica: Building.cs Quando creo o carico un progetto questa classe contiene tutte le proprietà dell'edificio come lista di colonne, raggi, punti, ecc. Tutti questi sono memorizzati come campi privati. Posso accedervi usando i metodi pubblici della classe come GetColumns o GetPoints ...

Ora ho anche classi non statiche. Contengono 2-3 metodi pubblici. e fare alcune cose su varie parti dell'edificio.

public static class Building
{
    private static List<Column> columns;
    private static List<Beams> beams;
    private static List<Points> points;

    public static List<Column> GetColumns() 
    {
        return Columns;
    }
}

public class ColumnsService()
{
    private List<Columns> columns;
    public GroupColumns(List<Columns> columns)
    {
        this.columns = columns;
    }

    public void Group()
    {
        // group columns
    }
}

var columns = Building.GetColumns();
var columnsService = new ColumnsService(columns);
columnsService.Group();
    
posta Vahid 19.12.2014 - 09:30
fonte

2 risposte

7

L'utilizzo di classi statiche come questa è semplice ed efficiente. Come la maggior parte delle cose che sono semplici ed efficienti, presenta degli svantaggi:

  • il tuo codice sarà difficile da testare in quanto nessun oggetto che usa questi metodi statici non può essere facilmente separato da essi, quindi i test dovranno includerli, mentre di solito avremmo intenzione di usare le implementazioni di stub o di simulazione dei collaboratori dell'oggetto in fase di test.

  • aumenta l'accoppiamento, il che ha l'effetto di rendere difficile la modifica del codice.

  • porta alla necessità di grandi quantità di stato globale, che di per sé porta anche a un test difficile (lo stato globale può rendere i test dipendenti l'uno dall'altro, il che è indesiderabile) e rendere le modifiche più difficili (lo stato globale può portare a interazioni difficili da identificare tra aree apparentemente non correlate del programma)

L'approccio migliore sarebbe cambiare gli oggetti in non-static e usare dependency injection per gestire le dipendenze tra oggetti.

    
risposta data 19.12.2014 - 09:50
fonte
1

Non ho familiarità con C #, ma è mia convinzione che si dovrebbe cercare di limitare i valori e le classi globali come programmazione in generale. Ovviamente a seconda delle circostanze. Cerca sempre di mantenere le tue lezioni ad una responsabilità minima (ma logica). Dovresti fare qualche lettura sull'argomento "accoppiamento basso alta coesione".

Se hai molte classi che interagiscono o dipendono l'una dall'altra, forse potresti implementare un modello di progettazione del mediatore o un modello di osservatore.

Ma potrebbe sembrare che tu non abbia dedicato del tempo a fare qualche progetto del tuo progetto. Possiamo dare una risposta migliore alla tua domanda, se puoi fornirci una spiegazione del dominio o di come gli oggetti si riferiscono / dovrebbero riguardare ciascuno.

    
risposta data 19.12.2014 - 09:55
fonte

Leggi altre domande sui tag