Proprietà di classe readonly

Originariamente inviato da _alka_

....
Per contro, allora si potrebbe dire lo stesso del metodo di aggiornare la lunghezza a fronte del cambiamento dei dati correlati: ogni volta che se ne cambia uno (es. Ini o Fin) il valore della proprietà viene ricalcolato.
.........

IMHO,
la lunghezza dipende solo dal punto iniziale e da quello finale ;
se se ne cambia uno molto probabilmente è un'altra asta;

come detto @Sebastiano ha tutti gli elementi per decidere e può fare le sue prove
con entrambi i metodi essendo tutto incapsulato nella classe linea

Originariamente inviato da sspintux

la lunghezza dipende solo dal punto iniziale e da quello finale

Sì, esattamente, però io sottolineavo altre questioni puramente architetturali.

Nella tua soluzione, è ipotizzabile che il campo venga calcolato sempre due volte: le proprietà che definiscono i punti iniziale e finale sono separate, ed entrambe vanno ad aggiornare il calcolo chiamando l'apposito metodo, quindi la lunghezza viene calcolata sull'assegnazione del primo valore e poi di nuovo sul secondo, ripetendo l'operazione due volte quando ne basterebbe una (oltre alle tempistiche di chiamate dei metodi, che comunque possiamo trascurare ma ci sono).

Inoltre, il campo utilizzato per memorizzare il valore del calcolo aggiornato occupa inutilmente memoria nell'oggetto per un dato relativamente semplice che può essere calcolato "on the fly".

A seconda dell'uso che si fa dell'API, la proprietà che contiene il valore della lunghezza potrebbe anche non essere mai letta, a seconda delle informazioni che interessano allo sviluppatore che fa uso del modello a oggetti, quindi calcolarlo a priori è una operazione che si può evitare per ottimizzare le performance, mentre calcolarlo al volo significa eseguire alla peggio quel calcolo che avremmo già eseguito in anticipo, e per due volte.

Nella modellazione OOP si consiglia (quando è possibile) di ridurre al massimo i "side effect" (effetti collaterali) nel codice delle classi, ovvero la gamma di informazioni che deve essere mantenuta "allineata" quando se ne modifica un'altra.

E' una questione di "clean coding" e di adesione alla massima semplicità possibile, come da principio KISS.

Ciao!

Originariamente inviato da _alka_

Sì, esattamente, però io sottolineavo altre questioni puramente architetturali.

Nella tua soluzione, è ipotizzabile che il campo venga calcolato sempre due volte
...

è presente un costruttore Line che accetta in input sia il punto iniziale che quello finale
come sembra logico fare quando si definisce una nuova linea
e che quindi permette di calcolare la lunghezza una sola volta
e di non ricalcolarla più se la linea resta sempre la stessa.

IMHO , l'architettura va adatta all'esigenza senza baci e senza ma.

Poi, se la lunghezza di una linea gli serve una sola volta entrambe le soluzioni si equivalgono
se invece deve essere acceduta più volte è inutile starla a ricalcolare ogni volta
perchè potrebbe essere troppo penalizzante in caso di molte linee;

... che dici lasciamo scegliere Sebastiano che sa che deve farci con queste benedette linee ?

Grazie ragazzi,
in effetti è un modellatore e le linee possono arrivare a 2000 - 3000.
Adesso il calcolo è massivo.

  public static void CalcoloLunghezzaAste()
        {
            foreach (var TutteAste in Globale.Aste)
            {
                Double Xini;
                Double Yini;
                Double Zini;
                Double Xfin;
                Double Yfin;
                Double Zfin;

                Xini = Globale.Nodi[TutteAste.Value.ini].X;
                Yini = Globale.Nodi[TutteAste.Value.ini].Y;
                Zini = Globale.Nodi[TutteAste.Value.ini].Z;
                Xfin = Globale.Nodi[TutteAste.Value.fin].X;
                Yfin = Globale.Nodi[TutteAste.Value.fin].Y;
                Zfin = Globale.Nodi[TutteAste.Value.fin].Z;
                TutteAste.Value.Lunghezza = Math.Sqrt(Math.Pow((Xini - Xfin), 2) + Math.Pow((Yini - Yfin), 2) + Math.Pow((Zini - Zfin), 2));
            }

        }

Ma in certe situazioni veloci ho necessità di conoscere la lunghezza di una sola e non posso appesantire il ricalcolo (cosa che succede adesso).

Preferisco la strada dell'avere il valore disponibile.
i vari scenari sono tutti interessanti e validi.

Grazie
Sebastiano Floridia

Ciao a tutti!!!

Alla fine ho chiuso la procedura così:

private string _ini="";
        public string ini
        {
            get { return _ini; }
            set
            {
                _ini = value;
            }
        }

        private string _fin = "";
        public string fin
        {
            get { return _fin; }
            set
            {
                 _fin = value;
            }
        }

        public double Lunghezza
        {
            get
            {
                double Xini;
                double Yini;
                double Xfin;
                double Yfin;
                Xini = Globale.Nodi[_ini].X;
                Yini = Globale.Nodi[_ini].Y;
                Xfin = Globale.Nodi[_fin].X;
                Yfin = Globale.Nodi[_fin].Y;
                return Math.Sqrt(Math.Pow((Xini - Xfin), 2) + Math.Pow((Yini - Yfin), 2));
            }
        }

non entra in tutte le innumerevoli modifiche di ini e fin che l'utente può fare ma solo a richiesta.


Per la cronaca ho semplificato con una linea, ma sono pannelli murari.
praticamente ogni oggetto è un muro di un palazzo o una trave in acciaio.

P.S:: La tempesta di cervelli è una risorsa incredibile di conoscenza.



Grazie tante
Sebastiano Floridia

Originariamente inviato da SebastianoFloridia

Ciao a tutti!!!

Alla fine ho chiuso la procedura così:

....
                return Math.Sqrt(Math.Pow((Xini - Xfin), 2) + Math.Pow((Yini - Yfin), 2));
            }
        }

P.S:: La tempesta di cervelli è una risorsa incredibile di conoscenza.

OK,
hai scelto la soluzione che hai ritenuto più adatta alla tua esigenza;

ma ti suggerirei ancora una volta di sostituire quel Math.Pow((Xini - Xfin), 2)
con una moltiplicazione per se stesso che è equivalente all'elevamento al quadrato