Dati comuni e il metodo Record

[petrusic]

E' un argomìento che avevo già intrapreso e poi sospeso . In quella serie di post DragoRosso mi aveva anche suggerito un esempio dal quale ricavare il concetto da applicare nel mio programma.
Allora ho capito molto poco ed ho abbandonato l'idea. Ora, in funzione anche di alcune difficolta costruttive nel passaggio di datai complessi fra form diversi, ho cercato di realiuzzare una soluzione "fai da te", ma, arrivato quasi al completamento dell'impianto logico occorrente, mi sono accorto che è molto vicino al metodo Record consigliatomi in quel tempo dal paziente DragoRosso.

Ho pensato perciò di rivedere l'argomento e di provare ad appoggiarmi allo schema già esistente e sicuramente funzionante.

Mi servirebbe però un qualche spunto.
Supponiamo, per es., che al momento in cui debba richiamare la funzione TDatiCoumni.InserisciDati, io abbia bisogno di  inserire una variabile String che chiamo varSTri1.
Ho capito che posso inserirla dentro un array da predichiarare con una lunghezza di X elementi, dove X è, appunto, il numero dei suoi elementi.

Poi però mi trovo a dovere inserire un array bidimensionale. Potrei allora scrivere nella funzione TDatiCoumni.InserisciDati un'istruzione del tipo

Codice: [Seleziona]

SetLength(fDati[1], 3)

?

Se, si, ora mi troverei con una variabile String alla riga 0 di fDati e una variabile array di 3 colonne alla riga 1 di fDati.

Inoltre, mi troverei nella necessità di tenere memoria della posizione delle suddette due distinte variabili all'interno del record fDati, oppure, potrei identificare mnemonicamente le due variabili?

Mi dispiace fare certe domande, ma non mi è assolutamente chiaro:

[DragoRosso]

Scusa ma non ho capito nulla.
Riassumi di cosa necessiti semplicemente. Non misciare necessità e proposte ... se nò non si capisce nulla.
Grazie.

[petrusic]

Riassumi di cosa necessiti semplicemente. Non misciare necessità e proposte ... se nò non si capisce nulla.

Non è facile. Sto tentando di addentrarmi nel metodo Record, assolutamente sconosciuto.
Azzero quanto detto nel post d'apertura e ricomincio

L'esempio a cui mi sono potuto affidare per capire il meccanismo contiene, nella sezione interface, la dichiarazione di un Record

Codice: [Seleziona]

interface

type
   TDatiCoumni = record
     private
       fDati: TArray<TArray<string>>;
       fNumRow, fNumCol: integer;
     public
       property NumRow: integer read fNumRow;
       property NumCol: integer read fNumCol;
       property Dati: TArray<TArray<string>> read fDati;
       function InserisciDati(Valore: string; Riga, Colonna: integer): boolean;
       procedure Init(NumeroRighe: integer; NumeroColonne: integer);
   end;

var DatiComuni: TDatiCoumni;

e qui cominciano  le prime perplessità, perchè vedo dichiarato un array in maniera insolita rispetto a quanto incontrato ed utilizzato fino a questo momento:

Codice: [Seleziona]

 fDati: TArray<TArray<string>>;

Non conosco il significato dei simboli "< e >>".
Devo pertanto impostare la mia prima domanda: Si tratta sempre di una array dinamico del tipo array of array in formato String?

[DragoRosso]

Quella scrittura indica una definizione di dati "generica" (vedi https://www.freepascal.org/docs-html/ref/refch8.html purtroppo in inglese).

Consente di avere una gestione diversa rispetto alla classica definizione con una serie di ausili a livello di compilazione, helper e di RTL ... una gestione decisamente migliore in alcuni contesti (ad esempio la definizione di TArray è simile a quella di un aray dinamico, ma consente più elasticità nel suo uso).

Inoltre tali definizioni (come TArray) sono sempre più presenti nei parametri di moltissime funzioni.

Concettualmente, comunque questa è simile (in questo caso identica nell'uso) a:

Codice: [Seleziona]

 fDati: array of array of string;

La differenza rispetto ad questa classica definizione è che usarla come proprietà avrei dovuta creare un tipo nuovo perchè non viene accettato il tipo "array of array".

Invece così posso scrivere direttamente:

Codice: [Seleziona]

property Dati: TArray<TArray<string>> read fDati;

Per la definizione e le spiegazioni sui "generici", ti rimando al link delle righe precedenti. Puoi tradurlo direttamente in linea con un qualsiasi browser.

[DragoRosso]

Si tratta sempre di una array dinamico del tipo array of array in formato String?

Per rispondere coinciso e diretto: si è un array dinamico che contiene valori di tipo "string".

E puoi, come ti ho già indicato in un altro topic, dimensionare ogni singola riga (esempio, riga 0 di 10 colonne, riga 1 di 5 colonne e riga 2 di 7 colonne, etc ...).

[petrusic]

Quella scrittura indica una definizione di dati "generica"

Benissimo ho letto l'argomento che mi hai linkato. Ho cominciato a capire qualcosa. Nel mio caso

Codice: [Seleziona]

 property Dati: TArray<TArray<string>> read fDati;

capisco che è la proprietà che si occuperà del caricamento dei dati dal record fDati.

Al momento della dichiarazione, il record fDati è indefinito. I riferimenti agli elementi interni si concreteranno, a partire dal momento di quella che viene chiamata specializzazione, cioè, all'interno della procedura .init?


Rirendo la procedura .init dall'esempio ricevuto da te qualche mese fa:

Codice: [Seleziona]

. . .
implementation

{TDatiCoumni}

procedure TDatiCoumni.Init(NumeroRighe: integer; NumeroColonne: integer);
begin
  SetLength(fDati, NumeroColonne, NumeroRighe);
  fNumRow := Length(fDati);
  fNumCol := Length(fDati[0]);
end; 

Tuttavia potrebbe essere ancora prematuro conoscere l'esatto numero righe e colonne di fDati, perchè potrebbe essere, in un primo momento,  per Es. NumeroRighe[2], ma potrebbe modificarsi, più avanti in NumeroRighe[5].
Potrò allora aggiungere altre righe senza perdere il contenuto raggiunto ad un  dato momento?

Come vedi, ancora non mi è chiaro il meccanismo logico di utilizzo di una struttura di tipo record.

[DragoRosso]

Per adesso le domande le hai poste sugli array, non abbiamo ancora toccato i record.
"fDati" si comporta come un array dinamico, quindi potrai in un qualsiasi momento ridimennsionarlo come un array dinamico per singola riga con la stessa modalità che ti ho già indicato in un altro post:

Codice: [Seleziona]

SetLength(fDati[4], 2);

In questo esempio la riga 4 di fDati viebe ridimensionata con 2 colonne.

Fai attenzione che fDati deve avere già abbastanza righe (in questo caso cinque, dalla 0 alla 4 almeno) altrimenti prima deve essere espanso come numero di righe e poi puoi espandere le colonne rispettive.

Teoricamente i dati presenti vengono mantenuti e i dati espansi vengono messi a 0 (o a '' nel caso delle stringhe), ti consiglio comunque di fare qualche prova banale per prendere mano con gli array.

Per ciò che riguarda i tipi ricordati che i tipi (personalizzati, record, classi, oggetti, etc ...) hanno un comportamento "autonomo": essi possono essere usati quasi ovunque insieme ad altri tipi e mantengono la propria autonomia di funzionamento.

Un array dinamico all'interno di un record, di una classe o di un altro tipo si comporterà sempre allo stesso modo.

L'unica differenza che puoi avere è l'accessibilità (o meglio la visibilità):
- se il tipo viene usato in un contesto "strict private" allora viene visto solo all'interno del contesto (quindi classe, record, etc...) ;
- se il tipo viene usato in un contesto "private" allora viene visto solo all'interno della UNIT dove è dichiarato;
- se il tipo viene usato in un contesto "public" allora viene visto globalmente;

[petrusic]

Per adesso le domande le hai poste sugli array, non abbiamo ancora toccato i record.
. . .

Hai ragione. In realtà sono molto confuso.
Nei giorni passati ho cercato di capire come ricorrere al metodo record, perchè mi sembrerebbe più pratico nell'inserimento e nella lettura dei dati al suo interno. Se non ho capito male potrei inserire i dati nuovi inserendo anche il nome del campo, però non capisco come mettere insieme campi tring, Integer, ..., array semplici, array complessi.

Una soluzione comodo mi sembra che sia quella di organizzare una Tcollection per ogni insieme di dati, uno per i campi string,Integer, . . ., uno per gli array semplici, un per gli array complessi, ma non ho capito com procedere per la lora dichiarazione ed il loro impiego.

Avevo cominciato a scrivere qualcosa dentro una unit (DatiComuni). Provo a girarti in allegato quello che ho ho abbozzato, non tanto per verificare il codice in se stesso, tanto per capire dove sbaglio nella logica costruttiva del progettino.
 

[DragoRosso]

Avevo cominciato a scrivere qualcosa dentro una unit (DatiComuni). Provo a girarti in allegato quello che ho ho abbozzato, non tanto per verificare il codice in se stesso, tanto per capire dove sbaglio nella logica costruttiva del progettino.
 

Ok, ripartiamo.

Giustamente parli di logica: quale è il tuo scopo ?
Lo riassumo per ciò che ho capito:"
- da un tuo oggetto, ad esempio una "StringGrid" vuoi trasferire i dati (tutti, alucni, etc ..) da un'altra parte. Fino a qui non ci sarebbero problemi, puoi effettuare uno scambio diretto. L'inghippo nasce quando il trasferimento deve avvenire tra due oggetti che non sono istanziati contemporaneamente e quindi serve un recipiente intermedio che presservi i dati nel frattempo.

Se fino a qui ci siamo, allora possiamo cercare di capire quale è il metodo o i metodi che si possono usare (tralasciamo per adesso metodi complessi che non fanno al caso nostro).

Guarda caso, ho accennato ad una STringGrid (che poi è l'oggetto su ci mi pare tu stia lavorando e che usi per la visualizzazione dei tuoi dati).

La StringGrid è semplicemente un array di stringhe a due dimensioni (riga / cella) con l'aggiunta di alcuni metodi e funzioni per specializzaris in un determinato scopo (visualizzazione, modifica, accesso ai dati).

Quindi io non mi farei tanti problemi sui tipi da passare, rendili tutti come stringa così hai risolto uno dei dilemmi: interi, stringhe, float, etc ... diventano tutti stringhe.

Se è così intanto incomicnciamo a parlare di array o collection di stringhe.

Se così non fosse, dovrai comuqnue strutturare qualcosa, perchè per adesso array e collection sono "composti" solo da oggetti omogenei.

Puoi crearti strutture più complesse appunto con record e classi che ti consentono di creare un oggetto unico con tutto ciò che serve, ottimizzato per l'accesso secondo le tue necessità. Ma per costruire oggetti di questo tipo è necessario pensarci e provare e riprovare, ci vuole tempo e molto studio.

Nell'esempio che hai postato, hai creato qualche metodo per trasferire dei dati ma il succo della questione non è creare il codice ... è capire cosa devi fare:
- la struttura è variabile ?
- puoi pensare ad una struttura unica che contenga tutte le specifiche esigenze ?
- come descrivere la struttura (limiti, elementi di accesso) ?
- devi prevedere ogni tipologia di trasferimento che ti serve (per elemento, riga, colonna, parziale, totale).
- ovviamente deve esserci un accesso in lettura e uno in scrittura.

In tutto questo tieni presente che il codice si può "autoadattare", ad esempio in fase di scrittura la struttura si può ampliare o restringere, e mentre in scrittura devi fornire più elementi (ad esempio la lunghezza che deve essere esplicit o rilevabile) in lettura generalmente non serve: esempio la riga 5 sà quanto elementi ha e quindi la sua lettura non implica alcun passaggio di "il numero di elementi da leggere" a meno che non si debba leggere un numero specifico di elelemnti.

Prima di buttare giù il codice, prenditi il tempo per scrivere su un blocco note (anche uno digitale và bene) ciò che ti ho scritto sopra e ciò che ti necessita, tipo lista della spesa e poi espandi ogni singolo elemento.
Dopo puoi incominciare a scrivere codice e anche a richiederci aiuto.
Se non hai chiare le ideee su cosa devi fare o non riesci ad esplicitarle (in questo caso sono io che non riesco a comprendere a pieneo cosa ti necessita) non riusciamo a darti un aiuto concreto.

[petrusic]

. . .
La StringGrid è semplicemente un array di stringhe a due dimensioni (riga / cella) con l'aggiunta di alcuni metodi e funzioni per specializzaris in un determinato scopo (visualizzazione, modifica, accesso ai dati).

Quindi io non mi farei tanti problemi sui tipi da passare, rendili tutti come stringa così hai risolto uno dei dilemmi: interi, stringhe, float, etc ... diventano tutti stringhe.
. . .

La mia StringGrid non è più completa di tutte le celle, ma contiene solamente le celle mostrate nel Form. ed i dati alo loro interno sono il duplicato delle corrispondenti celle presenti in un array, vero depositario di tutti i valori legati a ciascuna riga.

Già detta modifica è costata del tempo. Ora sono impantanato, come, hai capito benissimo tu perchè sono di fronte ad un metodo, per me, completamente nuovo e tutto da scoprire. Devo inoltre essere più grato a chi, come te, sta cercando di aiutarmi a capire, con i mezzi oggi disponibili.

Io avevo pensato, a modo mio, come organizzare una struttura, diciamo, universale,tramite un array unico, formato da tante righe a lunghezza variabile. Ciascuna riga avrebbe dovuto contenere :
la col.0, riportante il nome della variabile d'origine;
le colonne successive, riportanti i dati veri e propri.

Mi sembrava una buona idea, ma poi ho letto del metodo record e l'ho pensato più pratico e veloce. Sicuramente molto bello e veloce, immagino, ma tutto da imparare.

Quindi, se tu credi che mi convenga pensare ad una struttura di tipo TCollection, posso tentare di realizzarla, se, invece, credi che, per fare più presto, mi convenga mettere in pratica l'array a cui avevo cominciato a lavorare, ritorno sui mie passi e riprendo da dove ho interrotto. Se infine stai immaginando un altro tipo di struttura, dimmi pure, cercherò di capirne il meccanismo, per attuare quella.
 

[DragoRosso]

La struttura che hai pensato può ampliarsi a runtime in maniera indefinita oppure è definita e per ampliarla devi mettere mano al codice ?
Se è quest'ultima la definizione allora usa i record.
Se invece cresce a runtime senza un limite allora usa la TCollection.
Ci sono anche altri elementi che puoi usare, come i TDictionary.

Solo che non ho capito cosa devi passare e soprattutto quanto "roba".

Ripeto che se non riesco a comprendere cosa vuoi passare non riesco ad aiutarti più di tanto.

Anche ciò che hai pensato di universale potrebbe andare bene.

NOTA: non ci sarò da per un paio di settimane, quindi non potrò supportarti. Confido che gli altri membri intervengano con la loro esperienza.

[petrusic]

La struttura che hai pensato può ampliarsi a runtime in maniera indefinita oppure è definita e per ampliarla devi mettere mano al codice ?

Ho cominciato a scrivere qualcosa. Con le mie conoscenze, ho dichiarato nella Interface un array semplice dinamico, ma è ancora allo stato embrionale, perchè non ho ancora capito a quale metodo rivolgermi.

Ci sono anche altri elementi che puoi usare, come i TDictionary.

Li sconosco del tutto. Cerceherò di capire come poterli impiegare.

Grazie!