Spiegazione array

Cos'è un array, in generale?

Un insieme di elementi di un certo tipo

Questi elementi possono essere char, short, int, ecc.

Così avrai array di char, array di short, array di int

Se io dovessi, ad esempio, leggere 5 int da un file, magari li metterei in un array

Quindi dichiarami, in C#, un array di int che ospiti 5 elementi

int variabilediprova; —-> Qui dichiari una variabile

variabilediprova[] —> qui non so cosa fai, perché le quadre vanno dopo il tipo (int[], string[] e non dopo il nome)

Io voglio che tu dichiari un array di nome arraydiprova

Puoi pensare a un array come fosse un tipo

Abbiamo il tipo int? (int variabilediprova)

Un array di int è nient'altro che un tipo int[]

Così come un array di char è un tipo char[]

E così via

int variabilediprova;

Qui int è il tipo, variabilediprova il nome

Ora, io ti dico che un array di int è di tipo int[]

Quindi int[] arraydiprova sarà la dichiarazione

In C# int[] arraydiprova = new int[5];

Così hai dichiarato un array di int di 5 elementi, di nome arraydiprova

ma questi 5 elementi in cosa consistono?

Pensali come cinque stanze prenotate

Tu le prenoti

E poi ci metti dentro quello che vuoi, dopo

Ma prima devi prenotarle

Hotel Array

Ora, in C# troverai tanti "tipi" oltre a quelli del C (char, int, short)

Troverai:

- int[], char[], short[], i tipi che hanno gli array

Poi cose come FileStream, StreamReader, BinaryReader

Tu dichiarerai variabili di tipo FileStream, StreamReader, BinaryReader

Ora, con i tipi del C le dichiarazioni avvengono nel modo in cui ti avevo spiegato qui sopra

I tipi del C sono int, short, char, ecc.

Con tutti gli altri tipi che troverai nel C#(inclusi gli array, tipi int[], ecc.)

Le dichiarazioni avvengono in modo diverso

Avvengono istanziando gli oggetti

Ora, lasciando da parte la teoria, per ora

Avverranno, in pratica, così

tipo + nome = new classe(parametri)

Tipo: int[], char[], FileStream, BinaryReader, ecc.

Nome: quello che vuoi

new: usato per istanziare, è fisso

classe: FileStream, BinaryReader, sono tutte classi

parametri: ognuna di queste classi accetta un certo numero di parametri/overload

Cos'è una classe? Ti farò un esempio visivo

Le classi sono tipi di oggetti, un esempio che ho trovato utile è questo

Una classe contiene:

Costruttori

Proprietà

Metodi

I costruttori cosa sono? Sono le configurazioni che puoi dare, ovvero sono i parametri che puoi mettere nelle parentesi ogni volta

Ad esempio, magari c'è una classe che accetta due tipi di situazione

Prima situazione, le dai come parametro un array

Seconda situazione, le dai come parametri: un array, il numero di elementi dell'array da leggere, e l'elemento nell'array da cui partire

(Ad esempio, le dici leggi 5 elementi a partire dal decimo elemento, o cose così)

Questa classe ha DUE COSTRUTTORI

Il primo prevede un unico parametro

Il secondo prevede tre parametri

Sono due situazioni, configurazioni, che a seconda delle esigenze puoi dare alla classe

Nel primo costruttore tu alla classe dai solo un array

E quindi un solo parametro

Dopo le dai tre cose

Quindi tre parametri

ReadArray(arraydiprova);  Qui dai un solo parametro, l'array

ReadArray(arraydiprova, 2, 20); Qui dai tre parametri. Dai l'array, dici che deve partire dal secondo elemento dell'array, dici che deve leggere 20 elementi

Baldr 36, [11.10.19 15:50]

Nota che tutte queste cose sono arbitrarie

Parlo di leggere, ma potrebbe essere scrivere. Questo è un array, potrebbe essere un file, e così via

Questi erano i Costruttori

FileStream(String, FileMode, FileAccess)

Questo è un esempio reale di costruttore di FileStream

Il costruttore classico, che usasti nelle prime lezioni

Questo costruttore accetta tre parametri

Accetta una stringa, un FileMode, un FileAccess

La stringa è l'indirizzo del file

FileMode è quello che ti fa impostare FileMode.Open, FileMode.Create, per dire se il file lo vuoi aprire o creare

FileAccess per i permessi.

FileAccess.Read, FileAccess.Write

FileStream(String, FileMode, FileAccess, FileShare)

Questo è un altro costruttore, che accetta 4 parametri

Non è importante sapere cosa fa l'ultimo, adesso

Giusto per farti un'idea

I costruttori vengono rappresentati così, con i tipi

Ad esempio, c'è String

Se accettasse un int, avresti

FileStream(String, FileMode, FileAccess, int)

Se accettasse un char

FileStream(String, FileMode, FileAccess, char)

E così via

Il costruttore ti dice:

1. Il numero di parametri accettato

2. Il tipo che ciascun parametro deve avere

3. L'ordine. Importante che siano in ordine

Ora, Proprietà

Cosa più semplice dei costruttori

Le proprietà sono cose legate, nel caso di FileStream, al file (flusso) che FileStream apre

Ad esempio, tu dai a FileStream l'mself di BBS, per dire

Le proprietà sono cose legate a questo file che FileStream ti offre

Se premi la freccetta anche su proprietà, vedrai ad esempio Name e Position

Name ti dà il nome(percorso incluso) dell'mself

Position, ad esempio, ti dà la posizione dello stream, ovvero il punto in cui sei arrivato a leggere/scrivere

Se hai letto i primi 100 byte, Position ti darà l'indirizzo del 101esimo byte
Ora, come si usano?

Con questa sintassi:

nome della variabile.Proprietà

Scriviamo, ad esempio

FileStream fileprova = new FileStream(percorso, FileMode.Open, FileAccess.Create);

Dove FileStream è il tipo

fileprova è il nome della variabile

new è per istanziare, è fisso

FileStream è la classe

Poi ci sono i parametri

fileprova.Proprietà

In questo caso

fileprova.Name

fileprova.Name cosa restituisce? Il nome(più percorso) di fileprova.

Quindi

string quellochevuoi = fileprova.Name;

Con fileprova.Name hai in mano il nome, come ti ho detto

Questo nome, se vuoi usarlo

Lo assegni a una variabile

O magari lo metti come parametro da un'altra parte

Tutto qui
Ad esempio, se volessi scrivere un nuovo FileStream, per aprire lo stesso file

Potresti fare:

FileStream nuovo = new FileStream(quellochevuoi, FileMode.Open, FileAccess.Create);

Ad esempio

Questo sono le proprietà

Poi Position ti darà altro, ad esempio. Le proprietà sono informazioni (proprietà, appunto) che le classi ti danno e che riguardano i file per filestream, altre cose
per altre classi

Ora che stai imparando anche la sintassi, potrai ad esempio navigare quel sito di prima

Per controllare se ci sono cose che ti servono mentre scrivi il codice

Ora, terza cosa

I metodi

Che sono le funzioni del C

I metodi sono le azioni che la classe ti permette di compiere

Vuoi leggere il file? Read

Vuoi scrivere il file? Write

Vuoi chiudere il file? Close

Questi nomi sono semplici con FileStream, ma non sempre è così

In generale ogni classe hai i suoi metodi

I metodi, in un certo senso, funzionano come i costruttori

Ci sono varie (a volte anche una sola) situazione

In ogni situazione accetta un certo numero di parametri, di un certo tipo, in un certo ordine

Come i Costruttori
Facciamo un esempio con Read

Apri Read in quella pagina

Dimmi quante situazioni ci sono, e parlamene (numero di parametri, tipo, ecc.)

Ha tre parametri

Il primo di tipo byte[]

Il secondo di tipo Int32

Il terzo di tipo Int32

Tutto qui

Come vedi, è come con i costruttori di prima

Finiamo il discorso sulle classi e poi ti spiego quelle cose

La sintassi dei metodi è la stessa delle proprietà

nome variabile.Metodo(parametri);

Ad esempio

fileprova.Read(arraydiprova, 0, 100);

In realtà i metodi sono un misto tra costruttori e proprietà🤔

In termini di sintassi

Ricorda che qui parliamo di SINTASSI, cioè di come si scrive

 Funzioni e procedure

Dopo le funzioni, parlava di procedure

Una delle ultime cose che resta da capire è cosa sono questi metodi

Ora, ricordi cos'è una funzione?

Una funzione è un pezzo di codice che ha un certo compito

int Media()

calcolo della media aritmetica

Ad esempio

Un blocco di codice, chiuso tra parentesi graffe, che ha un certo compito

Il main, ad esempio

Lo apri con il suo nome

int main()

programma

E chiudi quello che vuoi scrivere tra parentesi graffe

Il main è una funzione

Le funzioni sono questo

Una funzione ha anche un return

Ovvero restituisce un valore

int Media() è di tipo int

Restituirà un valore di tipo int

char Prova() è di tipo char

Restituirà un valore di tipo char

E così via

Ora, cos'è una procedura?

Una funzione che non restituisce nulla

Ovvero, una funzione di tipo void

void proceduraprova()

Una procedura puoi considerarla alla stregua di una funzione di tipo void

Ora, tutto questo per dire

Che i metodi sono nient'altro che funzioni

Un altro punto che devi comprendere è che le funzioni accettano parametri, in generale

Questi parametri vanno tra le parentesi

int Media(a, b);

int Media (int a, int b)

Qui, ad esempio, dai come parametri alla funzione due valori di tipo int

Questi valori è come se fossero dichiarati

Potrai usarli a piacimento nella funzione

int Media (int a, int b)

a = 20;

b = 30;

Ora, qual è la logica che sta dietro questi parametri? A cosa servono?

A -passare- valori dalla funzione "chiamante" alla funzione che ti interessa

La cosa che devi ricordare è questa

Se io scrivo

int main()

int a = 24;

int Media()

{
int b = a;

Media NON VEDE a Perché è in un altro blocco E quindi dà errore, in questo caso particolare

In generale, le variabili sono visibili SOLO ALL'INTERNO DEI BLOCCHI in cui sono dichiarate. Scrivo in maiuscolo perché è un concetto chiave

Ricorda anche che tra parentesi va scritto anche il tipo

int media(int a), ad esempio

Le funzioni, per essere usate

Vanno CHIAMATE

Ci si mette nel main (o in un'altra funzione) e si chiama la funzione

In questo modo, il programma SALTA a quella funzione, la svolge, e torna da dove era stata chiamata

int main()

chiamata;

int Media()

...
}

Parte il programma, si legge il main

Chiamo la funzione (la sintassi te la dico tra poco)

Il programma cosa fa?

Mi svolge int Media()

E poi torna indietro, e prosegue nel main

Ora, una funzione va chiamata, come ho detto

La chiami, lei fa il suo lavoro, e torna nel main

Come si chiama una funzione?

Con il suo nome

int main

int a = 100;

int media = Media(a);

Cosa ho fatto?

Perché la funzione è il valore di una variabile?

Perché ho messo a tra parentesi?

Una funzione si chiama scrivendone il nome. Questo è quello che devi ricordare

Nello scrivere il nome, devi tenere conto di due cose

Parametri

Tipo della funzione

Infatti è durante la chiamata che si assegnano i parametri che vuoi passare alla funzione (a non sarebbe visibile, altrimenti)

Si passano parametri mettendoli tra le parentesi, separati da virgole, scrivendo il loro nome(a) SENZA il tipo, a differenza di quello che avviene all'inizio della
funzione

Come si "usano" le classi?

1. A ogni classe sarà associato un tipo dello stesso nome, dove per tipo si intendono cose come char, int, ecc. Quindi ad esempio alla classe FileStream è
associato il tipo FileStream

2. Ogni classe si "usa" istanziando un oggetto, ovvero dichiarando una variabile (che sarà di tipo FileStream, StreamWriter, e così via per tutte le classi)

Questa dichiarazione avviene seguendo una precisa sintassi

tipo + nome = new classe(parametri);

Dove tipo è il tipo della variabile (uguale a quello della classe). nome è il nome arbitrario che tu assegni a questa variabile, new è fisso, classe è appunto il nome
della classe

In parametri inserirai i parametri, secondo il costruttore che utilizzi

Se volessi creare un file in C:/prova con permessi di scrittura

Come sarebbe la dichiarazione?

FileStream prova = new FileStream("C:\", FileMode.Create, FileAccess.Write)

Ricorda che le virgolette devono essere precisamente queste ""

E non queste ' '

"" —-> Stringhe

' ' —-> Caratteri singoli

Dove i caratteri singoli NON SONO stringhe con un solo carattere, attenzione

Sono variabili di tipo char

Quindi forse sarebbe meglio dividere unicamente per variabile

"" —-> string

' ' —-> char

La differenza è totale, e stavo proprio per spiegare

"Ora, prima di passare al prossimo mini-esercizio, una breve spiegazione su FileMode e FileAccess" stavo per scrivere😂

FileMode e FileAccess sono un nuovo piccolo elemento. Come ti dice anche la pagina, sono ***costanti***

Funzionano solo in quel modo

Le troverai sempre come costante.qualcosa

Mai in modo diverso

Ad esempio, costante FileMode, troverai sempre FileMode.xxxx

Queste costanti non fanno altro che "specificare", termine tecnico

Dopo il punto specificano appunto delle costanti, che sono in pratica delle indicazioni

Tu non dovrai usare le costanti, bensì i nomi accanto (che sono pseudonimi)

Stessa cosa per FileAccess

I particolari valori li ottieni appunto guardando nella pagina, o con l'autocompletamento

Quelle costanti sono quelle effettivamente date al sistema

FileMode e FileAccess sono entrambe costanti

Ora un esercizio sui metodi

Anzi, prima un'altra cosa

Gli array

In C#, gli array si dichiarano in modo particolare

In pratica, per farti capire, nella sintassi(e solo nella sintassi)

Devi considerare gli array come fossero classi

Una cosa chiaramente fondamentale da ricordare

E' l'utilizzo delle parentesi quadre

Che è la caratteristica degli array

Queste classi, inoltre, hanno il nome del tipo di elementi che contiene l'array(int, ad esempio) più parentesi quadre

Per farti capire...

string[] prova = new string[5];

Dimmi semplicemente cosa ho dichiarato

Come le altre classi, anche se ripeto, NON sono classi, gli array restituiscono tipi appositi. Il tipo string[], il tipo char[], ecc.

Quindi la prima cosa da fare è scrivere il tipo (string[], ecc.) e il nome, e ok

Il new ci va, come con le classi

Poi devi ripetere il tipo (string, int, ecc.) e aprire le parentesi quadre

L'array accetta, nelle parentesi quadre, la lunghezza

Cioè il numero di elementi che dovrà contenere

Niente di più

Tra il tipo dell'array, string[], e il tipo dei singoli elementi contenuti nell'array, string
Un array di stringhe è un oggetto di tipo string[]

Che al suo interno contiene elementi di tipo string

prova è di tipo string[]

Ma prova[0], il primo elemento, è di tipo string

prova[0] è il primo elemento

prova[1] il secondo

Sono gli elementi singoli

Nella dichiarazione scrivi la lunghezza

Ma dopo Ad esempio

string prova2 = prova[0];

Qui prova2 è posta uguale a prova[0]

PROVA, non string

Dove prova[0] è il primo elemento dell'array prova

Così come prova[1] è il secondo

prova[2] il terzo, e così via

Nella dichiarazione, string[] prova = new string[5], 5 è la lunghezza, cioè il numero di elementi che assegni all'array

Ora, i tipi

Nel C# vari tipi assumono nuove denominazioni

char —-> sbyte

unsigned char —-> byte

short —-> Int16

unsigned short —> UInt16

int —> Int32

unsigned int —-> UInt32

long —-> Int64

unsigned long —-> UInt64

Ora, cosa cambia tra signed e unsigned?

signed ha un bit di riferimento

Perché l'unsigned, non avendo il flag, accetta solo numeri positivi

Più che accetta

da dove nascono questi numeri negativi?

Dal flag

Il flag è il segno

In pratica, ogni numero può essere rappresentato in binario, così

01011000

Ogni 0 o 1 è un bit

I signed cosa fanno? Prendo l'ultimo bit e lo usano per rappresentare il segno

0 —-> +

1 —-> -

perché associano 1 al segno negativo?

Pura convenzione

11111110 —> 127

11111111 —-> -127

Questo grazie all'ultimo bit

Che NON fa parte del numero

1111111 questo è il numero, 7 bit

Poi l'ottavo è sempre il flag

Così avviene in tutti i tipi

Un unsigned non potrà rappresentare numeri negativi, quindi scegli tu in base alle circostanze

Una nota Per i puntatori, usa gli unsigned

Avere un bit usato come flag può essere dannoso

Quindi ti do questo consiglio

Poi per il resto, quando hai numeri solo positivi, puoi scegliere

Sapendo che l'unsigned ti dà accesso a valori più alti

Ok, ora l'ultima cosa

L'esercizio sui metodi

Spiegami esattamente cosa fa questo metodo

E scrivici una linea di codice

Read(Byte[], Int32, Int32)

Byte[]  Quando questo metodo finisce, esso contiene l'array di byte specificato, con i byte tra offset e (offset + count - 1) rimpiazzati dai byte letti dalla
sorgente corrente

Int32[]  Nel secondo parametro decidiamo dove puntare l'array, ovvero se metto 2, partirà dal secondo byte dell'array, ad esempio

Int32[]  Si decide il numero massimo di bytes da leggere

offset è il secondo parametro, come avrai visto

count il terzo

Il fatto è che offset viene effettivamente riempito

Puoi anche provare a fare un conto con le dita

Se offset è 2

E count è 5

2, 3, 4, 5 e 6

Eh, esatto

Qui offset è 2

count è 5

offset + count - 1 = 6

offset = 10, count = 5 ——> 10, 11, 12, 13, 14

offset = 28, count = 5 —-> 28, 29, 30, 31, 32

E così via

Il punto era quel -1, è solo aritmetica

Se tu includi il numero da cui parti

Che sia 2, 10, 28

Ti fermi un numero prima della somma

Questi byte dell'array che abbiamo appena visto

Sono rimpiazzati, da cosa?

dai byte letti dalla sorgente

Quindi magari abbiamo un array vuoto, da riempire

E lo riempiamo mettendoci i byte letti da questa sorgente

Ecco, l'unica cosa è capire cos'è questa sorgente

Quale potrà mai essere la sorgente di un metodo di FileStream?

una sorgente potrebbe essere un file appena creato

O anche aperto

Si tratta del file di FileStream

FileStream gestisce un file

Questo file è la sorgente dei metodi

Quindi, ricapitolando

Noi stiamo leggendo dei byte dal file

Questi byte letti dovranno essere messi da qualche parte, se vogliamo usarli o conservarli

Dove li mette Read?

La risposta è nel primo parametro

Quindi Read legge dei byte dal file

E li mette in un array di byte da noi specificato

Devi impararlo bene

Perché tutti i file, i pezzi di file, ec.

Li leggerai così

Nell'array, mettiamo i byte nell'array, lo fa Read quindi qua —-> []

Baldr 36, [20.10.19 21:53]

Ora, l'unica cosa che manca è un'introduzione alla classe openfiledialog

Baldr 36, [20.10.19 21:55]

Quanti costruttori ha?

Alessandro Solinas, [20.10.19 21:56]

uno

Baldr 36, [20.10.19 21:56]

Esatto

Baldr 36, [20.10.19 21:56]

Questo costruttore quanti parametri ha?

Alessandro Solinas, [20.10.19 21:56]

nessuno

Baldr 36, [20.10.19 21:56]

Esatto
Baldr 36, [20.10.19 21:56]

Quindi già qui partiamo in discesa

Baldr 36, [20.10.19 21:56]

Fammi al volo una dichiarazione

Baldr 36, [20.10.19 21:57]

Di solito come nome della variabile si sceglie openfile

Baldr 36, [20.10.19 21:57]

Ma ovviamente è arbitrario

Baldr 36, [20.10.19 21:59]

Quando vuoi "usare" una classe

Baldr 36, [20.10.19 21:59]

Dichiari una variabile associata a quella classe

Baldr 36, [20.10.19 21:59]

Come abbiamo fatto in questi giorni

Baldr 36, [20.10.19 22:00]

Quando volevi usare FileStream cosa facevi?

Baldr 36, [20.10.19 22:00]

Dichiaravi una variabile FileStream di nome test

Alessandro Solinas, [20.10.19 22:00]

tipo + nome = new costrutto

Baldr 36, [20.10.19 22:00]

Eh, quando usi le classi si fa così

Baldr 36, [20.10.19 22:01]

Fammi una dichiarazione con openfiledialog come classe

Alessandro Solinas, [20.10.19 22:01]

OpenFileDialog openfile = new OpenFileDialog()

Baldr 36, [20.10.19 22:04]

OpenFileDialog ha diverse proprietà

Baldr 36, [20.10.19 22:04]

Dove per proprietà intendo il componente delle classi, insieme a costruttori e metodi

Baldr 36, [20.10.19 22:07]

Ma io te ne insegnerò due

Baldr 36, [20.10.19 22:07]

Che in parte già conosci

Baldr 36, [20.10.19 22:07]

Filter e Multiselect

Baldr 36, [20.10.19 22:08]

Filter viene utilizzata per restringere il campo dei file accettati

Baldr 36, [20.10.19 22:09]

La sintassi è questa

Baldr 36, [20.10.19 22:18]

nomevariabile.Filter = "descrizione a piacere|condizione";

Baldr 36, [20.10.19 22:18]

La sbarra verticale serve, perché la condizione va dopo

Baldr 36, [20.10.19 22:10]

Dove nomevariabile è il nome della variabile openfiledialog

Baldr 36, [20.10.19 22:11]

La descrizione a piacere è quella che metti tu, appunto. Ad esempio, nel mini-tool che ho fatto per gli rbin, avevo messo "KH3D archive"

Baldr 36, [20.10.19 22:11]

Tra parentesi, la condizione è quella che restringe effettivamente il campo

Baldr 36, [20.10.19 22:12]

Si usa generalmente per le estensioni, ma può essere usata in qualsiasi modo sfruttando caratteri come *

Baldr 36, [20.10.19 22:12]

* si chiama wildcard, e indica un valore/stringa qualsiasi

Baldr 36, [20.10.19 22:12]

*.txt significa che prima del punto può esserci qualsiasi cosa

Baldr 36, [20.10.19 22:13]

Poi il .txt esplicito impone appunto che l'estensione sia txt

Baldr 36, [20.10.19 22:13]

Le sbarre verticali | sono messe per separare, e sono facoltative

Baldr 36, [20.10.19 22:14]

Potresti raccogliere tutto senza utilizzarle, perché fra parentesi puoi mettere più condizioni, separandole con una virgola (*.bin, *txt)

Baldr 36, [20.10.19 22:14]

Ma per motivi estetici e pratici, a volte è meglio avere una divisione

Baldr 36, [20.10.19 22:15]

Il tutto dev'essere inserito in virgolette ""

Baldr 36, [20.10.19 22:16]

openfile.Filter = "KH3D audio (*.bcsar)";

Baldr 36, [20.10.19 22:19]

In pratica ogni sbarra crea un'opzione

Baldr 36, [20.10.19 22:19]

Come quando nei programmi clicchi e vedi una lista di descrizioni di file accettati

Baldr 36, [20.10.19 22:20]

Mpeg video file(*.mp4)

Baldr 36, [20.10.19 22:20]

Audio-Video Interleave(*avi)

Baldr 36, [20.10.19 22:20]

Ad esempio

Baldr 36, [20.10.19 22:20]

Quindi da una parte c'è la tua descrizione a piacere

Baldr 36, [20.10.19 22:20]

Dall'altro lato della sbarra la condizione effettiva

Baldr 36, [20.10.19 22:21]

Che restringe i file visualizzati

Baldr 36, [20.10.19 22:21]

openfile.Filter = "KH3D audio|*.bcsar";

Baldr 36, [20.10.19 22:21]

La seconda proprietà è molto più semplice

Baldr 36, [20.10.19 22:22]

Multiselect regola la selezione multipla, come si intuisce

Baldr 36, [20.10.19 22:22]

Si tratta di un valore di tipo bool, cioè assume soltanto i valori true o false

Baldr 36, [20.10.19 22:22]

false significa che non è permessa la selezione multipla di file

Baldr 36, [20.10.19 22:23]

true invece significa che è permessa

Baldr 36, [20.10.19 22:23]

Di default, Multiselect è false.

Baldr 36, [20.10.19 22:24]

Quindi se non si vuole attivare la selezione multipla, non si deve fare nulla

Baldr 36, [20.10.19 22:24]

Se la si vuole attivare, Multiselect dev'essere posta true

Baldr 36, [20.10.19 22:24]

Ricordando che si tratta sempre di una proprietà, scriviamo

Baldr 36, [20.10.19 22:24]

openfile.Multiselect = true;

Baldr 36, [20.10.19 22:25]

E questo abilita la selezione multipla, che di default non è abilitata

Baldr 36, [20.10.19 22:25]

Poi un'altra cosa semplice è il metodo che devi imparare

Baldr 36, [20.10.19 22:25]

Si tratta di ShowDialog

Baldr 36, [20.10.19 22:26]

ShowDialog ha un'unica configurazione

Baldr 36, [20.10.19 22:26]

In questa configurazione, non accetta/richiede alcun parametro

Baldr 36, [20.10.19 22:27]

ShowDialog è essenziale, perché è necessaria appunto ad aprire la finestra di dialogo

Baldr 36, [20.10.19 22:28]

Va quindi usato sempre, questo metodo

Baldr 36, [20.10.19 22:28]

Che ha solita sintassi

Baldr 36, [20.10.19 22:28]

nomevariabile.ShowDialog(parametri);

Baldr 36, [20.10.19 22:28]

Che in questo caso diventa

Baldr 36, [20.10.19 22:28]

openfile.ShowDialog();

Baldr 36, [20.10.19 22:29]

Ora, guardando quella pagina vedrai che ritorna una cosa

Baldr 36, [20.10.19 22:29]

DialogResult

Baldr 36, [20.10.19 22:31]

Abbiamo parlato della differenza tra funzioni di tipo void, e funzioni di qualsiasi altro tipo

Baldr 36, [20.10.19 22:31]

Abbiamo detto che una funzione di tipo void può essere chiamata da sola, mentre una di qualsiasi altro tipo dev'essere posta uguale a qualcosa

Baldr 36, [20.10.19 22:32]

Il discorso lo facevamo con i numeri

Baldr 36, [20.10.19 22:32]

int a = 100;

Baldr 36, [20.10.19 22:32]

140;

Baldr 36, [20.10.19 22:32]

Il 140 rappresentava la nostra funzione di tipo int

Baldr 36, [20.10.19 22:32]

Che messa così non va bene

Baldr 36, [20.10.19 22:32]

Ora, dissi anche un'altra cosa

Baldr 36, [20.10.19 22:33]

Nel C#, i metodi delle classi si comportano in modo peculiare

Baldr 36, [20.10.19 22:33]

Si comportano sia da void, che non

Baldr 36, [20.10.19 22:33]

La maggior parte delle volte, puoi usarle come void

Baldr 36, [20.10.19 22:34]

FileStream.Read ieri, e lo stesso ShowDialog adesso

Baldr 36, [20.10.19 22:34]

Le abbiamo usate come void, perché non le abbiamo poste uguali a nessun valore

Baldr 36, [20.10.19 22:34]

Ma entrambe, come quasi tutti metodi

Baldr 36, [20.10.19 22:34]

Ritornano valori, e possono essere usate anche come non-void

Baldr 36, [20.10.19 22:35]

In questo caso, ShowDialog ritorna un oggetto di tipo DialogResult, che è una costante

Baldr 36, [20.10.19 22:36]

Ritornerà DialogResult.OK se l'utente preme ok

Baldr 36, [20.10.19 22:36]

Ritornerà DialogResult.Cancel se l'utente preme cancel

Baldr 36, [20.10.19 22:36]

Ora, se l'utente preme ok

Baldr 36, [20.10.19 22:37]

Noi facciamo partire il programma

Baldr 36, [20.10.19 22:37]

Ma se l'utente preme cancel

Baldr 36, [20.10.19 22:37]

Noi il programma non vogliamo farlo partire

Baldr 36, [20.10.19 22:37]

Cioè non vogliamo eseguire tutto lo stesso

Baldr 36, [20.10.19 22:37]

Quindi cosa facciamo? Poniamo un controllo

Baldr 36, [20.10.19 22:38]

Possiamo sapere cosa ha premuto l'utente (Ok o Cancel) grazie al fatto che ShowDialog ritorna DialogResult in quel modo

Baldr 36, [20.10.19 22:38]

Ora, detto ciò

Baldr 36, [20.10.19 22:39]

E sapendo bene come ci si comporta quando si gestisce una funzione/metodo come non void

Baldr 36, [20.10.19 22:39]

Questo controllo (che ti anticipo, è un if) come lo scriveresti?

Baldr 36, [20.10.19 23:21]

OpenFileDialog openfile = new OpenFileDialog();

openfile.Filter = "BCSAR files (*.bcsar)|All files (*.*)";

openfile.ShowDialog();

if (openfile.ShowDialog() == DialogResult.OK)

codice

Baldr 36, [20.10.19 23:21]

Comunque basta questo

Baldr 36, [20.10.19 23:21]

Se preme ok, entra nell'if

Baldr 36, [20.10.19 23:21]

Dove c'è tutto il programma

Baldr 36, [20.10.19 23:22]

Altrimenti non ci entra, e semplicemente il codice (e quindi il programma) finisce

Baldr 36, [20.10.19 23:22]

Ah, un'altra cosa

Baldr 36, [20.10.19 23:23]

Non serve ripetere openfile.ShowDialog();

Baldr 36, [20.10.19 23:23]

OpenFileDialog openfile = new OpenFileDialog();

openfile.Filter = "BCSAR files (*.bcsar)|All files (*.*)";

if (openfile.ShowDialog() == DialogResult.OK)

{
 codice

Baldr 36, [20.10.19 23:23]

Questo perché nelle condizioni

Baldr 36, [20.10.19 23:23]

Si valutano i membri

Baldr 36, [20.10.19 23:24]

Il programma, per controllare che siano uguali

Baldr 36, [20.10.19 23:24]

Deve eseguire openfile.ShowDialog()

Baldr 36, [20.10.19 23:25]

Il programma arriva all'if

Baldr 36, [20.10.19 23:25]

E prima di controllare la verità della condizione

Baldr 36, [20.10.19 23:26]

Deve valutare entrambi i membri

Baldr 36, [20.10.19 23:26]

Cioè, deve stabilire quanto valgono

Baldr 36, [20.10.19 23:26]

DialogResult.OK è una costante, lo sa già (come fosse un numero)

Baldr 36, [20.10.19 23:26]

openfile.ShowDialog() lo deve svolgere

Baldr 36, [20.10.19 23:26]

E se svolgi openfile.ShowDialog() , significa che apri la finestra di selezione

Baldr 36, [20.10.19 23:27]

Premi Ok o Cancel, e a questo punto il programma ha il suo valore

Baldr 36, [20.10.19 23:27]

Per questo non serve ripeterlo