Menu

Elenco e dizionario C # - Tutorial con esempi di codice

c list dictionary tutorial with code examples

Prova Il Nostro Strumento Per Eliminare I Problemi

Questa esercitazione spiega l'elenco e il dizionario C # con esempi. Imparerai come inizializzare, popolare e accedere agli elementi nel dizionario e nell'elenco C #:

Nella nostra precedente esercitazione sulle raccolte C #, abbiamo appreso i tipi di raccolte presenti in C # come ArrayList, Hashtable, Stack, SortedList e così via. La cosa comune tra questi tipi di raccolta è che possono archiviare qualsiasi tipo di elemento di dati.

Ciò sembra abbastanza utile per memorizzare diversi tipi di dati all'interno di una singola entità di raccolta, ma lo svantaggio è che durante il recupero dei dati dalla raccolta, è richiesto il datacasting a un tipo di dati applicabile. Senza datacast, il programma genererà un'eccezione di runtime e può ostacolare l'applicazione.

=> Esercitazioni di formazione C # GRATUITE per tutti

Elenco e dizionario C #

Per risolvere questi problemi, C # offre anche classi di raccolta generiche. Una raccolta generica offre prestazioni migliori durante la conservazione e il recupero degli elementi.

Cosa imparerai:

Elenco C #

Abbiamo già imparato a conoscere ArrayList negli articoli precedenti. Fondamentalmente, un List è simile a un ArrayList, l'unica differenza è che l'elenco è generico. L'elenco ha la proprietà univoca di estenderne le dimensioni man mano che cresce, in modo simile all'elenco degli array.

Come inizializzare un elenco?

Possiamo inizializzare un elenco nei seguenti modi:

//using List type for initialization List listInteger = new List(); //using IList type for initialization IList listString = new List();

Se guardi l'esempio sopra puoi vedere che nella prima riga abbiamo usato List per inizializzare un elenco di numeri interi. Ma nella seconda riga, abbiamo usato IList per l'inizializzazione della lista di stringhe. Puoi usare uno qualsiasi di questi per il tuo programma. L'elenco è in realtà l'implementazione dell'interfaccia IList.

Come aggiungere e inserire un elemento all'elenco?

Analogamente a ArrayList, possiamo aggiungere un elemento a List utilizzando il metodo Add (). Il metodo add accetta il valore del tipo di dati come argomento.

Sintassi

ListName.Add(DataType value);

Diamo un'occhiata a un semplice programma per aggiungere dati a un elenco e IList.

Programma:

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List ;(); //Add elements to the list listInteger.Add(1); listInteger.Add(2); listInteger.Add(3); //using IList type for initialization IList listString = new List(); listString.Add('One'); listString.Add('Two'); listString.Add('Three'); Console.ReadLine(); } }

L'elemento può anche essere aggiunto direttamente durante l'inizializzazione dell'elenco. Possiamo aggiungere direttamente il valore alla lista al momento dell'inizializzazione stessa, in modo simile a come abbiamo fatto durante il nostro capitolo Array.

Questo può essere aggiunto inserendo parentesi graffe dopo l'elenco e quindi scrivendo il valore al suo interno separato da virgole. Cambiamo un po 'il programma sopra in modo da poter aggiungere il valore direttamente durante l'inizializzazione.

come testare manualmente sql injection

Quindi, il nostro programma ora avrà il seguente aspetto:

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //using IList type for initialization IList listString = new List(); listString.Add('One'); listString.Add('Two'); listString.Add('Three'); Console.ReadLine(); } }

Nel programma precedente, abbiamo inizializzato i valori dell'elenco di numeri interi all'inizio durante l'inizializzazione. Ci ha permesso di passare il valore direttamente senza scrivere il metodo Add () per ogni valore. Questo è abbastanza utile se abbiamo una quantità quantificabile limitata di dati che dobbiamo inserire in un elenco.

Come accedere all'elenco?

Possiamo accedere ai singoli elementi dall'elenco utilizzando l'indice. L'indice può essere passato tra parentesi quadre dopo il nome dell'elenco.

Sintassi

dataType Val = list_Name(index);

Ora, diamo un'occhiata a un semplice programma per ottenere i dati dall'elenco che abbiamo creato nel nostro programma precedente.

Programma

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; int val = listInteger(1); Console.WriteLine(val); } }

L'output del programma seguente sarà il valore all'indice 1. L'indice parte da 0, l'output sarà:

Due

Ora, supponiamo di voler ottenere tutti i dati dall'elenco, possiamo farlo utilizzando il ciclo for-each o per un ciclo.

Per ogni ciclo

Possiamo usare per ogni ciclo per ottenere tutti i dati dall'elenco.

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; foreach (var val in listInteger) { Console.WriteLine(val); } } }

Qui abbiamo fatto scorrere l'elenco usando per ogni ciclo dichiarando un valore variabile. Ciò consentirà ogni ciclo attraverso l'elenco finché non ci saranno alcuni dati al suo interno.

Per Loop

Per usare il ciclo for dobbiamo conoscere il numero di elementi presenti all'interno della lista. Il metodo Count () può essere utilizzato per ottenere il conteggio dell'elemento.

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

A volte potremmo anche aver bisogno di inserire un nuovo elemento all'interno dell'elenco. Per farlo dobbiamo usare il metodo Insert () per aggiungere un nuovo metodo ovunque all'interno dell'elenco. Il metodo insert accetta due argomenti, il primo è l'indice in cui si desidera inserire i dati e il secondo è i dati che si desidera inserire.

La sintassi per l'inserimento è:

List_Name.Insert(index, element_to_be_inserted);

Ora, inseriamo un elemento all'interno dell'elenco che abbiamo creato in precedenza. Aggiungeremo una dichiarazione di inserimento al programma sopra e proveremo a vedere come funziona:

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

Se eseguiamo il programma precedente, l'output sarà:

1
Due
3
Valore di elenco dopo aver inserito una nuova val
1
22
Due
3

Dopo il ciclo for, abbiamo aggiunto l'istruzione insert per inserire l'intero 22 all'indice 1 nell'elenco definito in precedenza. Quindi abbiamo scritto un ciclo per ogni per stampare tutti gli elementi ora presenti all'interno della lista (dopo aver inserito i primi dati).

Possiamo chiaramente vedere dall'output che tutti gli elementi della lista sono stati spostati in avanti per far posto al nuovo elemento all'indice 1. L'indice 1 ora ha 22 come elemento e l'elemento precedente all'indice 1 cioè 2 è passato a l'indice successivo e così via.

Come rimuovere un elemento dall'elenco?

A volte, potremmo anche richiedere di rimuovere elementi dall'elenco. Per farlo, C # offre due metodi diversi. Questi due metodi sono Remove () e RemoveAt (). Remove viene utilizzato per rimuovere un determinato elemento dall'elenco e RemoveAt viene utilizzato per rimuovere qualsiasi elemento presente all'indice specificato.

Diamo un'occhiata alla sintassi.

Sintassi

Remove(Element name); RemoveAt(index);

Ora, aggiungiamo l'istruzione Remove al codice precedente e vediamo cosa succede.

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

L'output del programma di cui sopra sarà:

1
Due
3
Rimozione del valore dall'elenco
1
3

Nel programma precedente, abbiamo utilizzato il metodo remove per rimuovere l'elemento 2 dall'elenco. Come puoi vedere nell'output una volta eseguito il metodo Remove, l'elenco non contiene più l'elemento che abbiamo rimosso.

Allo stesso modo, possiamo anche usare il metodo RemoveAt. Sostituiamo il metodo Remove nel programma sopra con il metodo RemoveAt () e passiamo il numero di indice come parametro.

class Program { staticvoid Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

L'output del programma di cui sopra sarà:

1
Due
3
Rimozione del valore dall'elenco
1
Due

Nel programma sopra, puoi vedere chiaramente che abbiamo rimosso l'elemento presente all'indice 2 invece di rimuovere l'intero 2. Quindi, a seconda del requisito si può usare Remove () o RemoveAt () per rimuovere un certo elemento da un elenco.

migliori app vr per vr box

Dizionario C #

Il dizionario in C # è simile al dizionario che abbiamo in qualsiasi lingua. Anche qui abbiamo una raccolta di parole e il loro significato. Le parole sono note come chiave e il loro significato o definizione può essere definito come valori.

Il dizionario accetta due argomenti, il primo è la chiave e il secondo è il valore. Può essere inizializzato utilizzando una variabile della classe Dictionary o dell'interfaccia IDictionary.

La sintassi per Dictionary è:

Dictionary

Diamo un'occhiata a un semplice programma per inizializzare Dictionary:

Dictionary data = new Dictionary();

Nel programma sopra, puoi vedere chiaramente che abbiamo inizializzato i dati del dizionario sia con chiave che con valore come stringa. Ma puoi usare qualsiasi coppia di tipi di dati per chiavi e valori. Per esempio, se cambiamo la dichiarazione di cui sopra per contenere un diverso tipo di dati, allora anche sarà corretto.

Dictionary data = new Dictionary();

Il tipo di dati all'interno della parentesi angolare è per chiavi e valori. Puoi mantenere qualsiasi tipo di dati come chiave e valore.

Come aggiungere chiavi e valori a un dizionario?

Abbiamo visto come inizializzare un dizionario. Ora aggiungeremo le chiavi e i loro valori al dizionario. Il dizionario è molto utile quando vuoi aggiungere diversi dati e i loro valori in un elenco. Il metodo Add () può essere utilizzato per aggiungere dati al dizionario.

Sintassi

DictionaryVariableName.Add(Key, Value);

Ora includiamo l'istruzione Add nel programma precedente per aggiungere chiavi e valori al dizionario.

Programma

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); } }

Nel programma precedente, abbiamo utilizzato il metodo Add () per aggiungere la chiave e i valori al dizionario. Il primo parametro passato al metodo Add () è la chiave e il secondo parametro è il valore della chiave.

Come accedere a chiavi e valori da un dizionario?

Come discusso nel nostro tutorial sulla lista, possiamo anche accedere agli elementi del dizionario in molti modi diversi. Discuteremo alcuni dei modi importanti in cui possiamo accedervi qui. Discuteremo per ciclo, per ogni ciclo e indice per l'accesso agli elementi di dati.

L'indice può essere utilizzato per accedere a valori specifici dall'elenco.

Il ciclo For può essere utilizzato per accedere o recuperare tutti gli elementi dal dizionario ma richiede la dimensione del dizionario per interrompere il ciclo. Per ogni ciclo è più flessibile, può recuperare tutti i dati presenti dal dizionario senza richiedere la dimensione del dizionario.

Utilizzo dell'indicizzazione

Un elemento dell'indice può essere utilizzato in modo simile a un array per accedere all'elemento, la differenza fondamentale è che invece dell'indice abbiamo bisogno di chiavi per accedere ai valori.

Sintassi

Dictionary_Name(key);

Programma

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); string value = dctn('two'); Console.WriteLine(value); Console.ReadLine(); } }

L'output del programma di cui sopra sarà:

secondo

Utilizzo del ciclo For per l'accesso all'elemento

Il ciclo for può essere utilizzato per accedere a tutti gli elementi del dizionario. Ma deve anche ottenere il conteggio dell'elemento all'interno del dizionario per una serie di iterazioni richieste.

Aggiungiamo il ciclo for al programma precedente per recuperare tutti i valori dal dizionario.

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); for(int i =0; i

L'output del programma di cui sopra sarà:

L'elemento chiave: uno e il suo valore è: primo
L'elemento in chiave: due e il suo valore è: secondo
L'elemento chiave: tre e il suo valore è: terzo

Nel programma sopra, abbiamo utilizzato il metodo ElementAt () per ottenere la chiave in un dato indice, quindi abbiamo utilizzato la stessa chiave per recuperare i dati del valore della chiave. Il ciclo for itera attraverso tutti i dati all'interno del dizionario. La proprietà Count è stata utilizzata per ottenere la dimensione del dizionario per l'iterazione.

etl test intervista domande e risposte pdf

Utilizzo di For-Each Loop

Simile al ciclo for, possiamo anche usare il ciclo for.

Diamo un'occhiata al programma sopra con il ciclo for-each.

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); foreach (KeyValuePair item in dctn) { Console.WriteLine('The Key is :'+ item.Key+' - The value is: '+ item.Value); } Console.ReadLine(); } }

L'output del programma di cui sopra sarà:

La chiave è: uno - Il valore è: primo
La chiave è: due - Il valore è: secondo
La chiave è: tre - Il valore è: terzo

Il programma precedente utilizza KeyValuePair per dichiarare la variabile, quindi iteriamo su ciascuna delle coppie chiave-valore nel dizionario e la stampiamo sulla console.

Come convalidare la presenza di dati in un dizionario?

A volte dobbiamo verificare se una determinata chiave o valore esiste o meno nel dizionario. Possiamo convalidarlo utilizzando due metodi, ovvero ContainsValue () e ContainsKey (), per verificare la chiave o il valore esistente all'interno del dizionario.

Il metodo Contains viene utilizzato per verificare se il valore specificato è presente o meno nel dizionario. Il metodo ContainsKey viene utilizzato per verificare se una determinata chiave esiste o meno nel dizionario.

Sintassi

Dictionary_Name.ContainsValue(Value); Dictionary_Name.ContainsKey(Key);

Scriviamo un semplice programma per convalidare utilizzando il metodo Contains e ContainsKey.

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); bool key = dctn.ContainsKey('one'); bool val = dctn.ContainsValue('four'); Console.WriteLine('The key one is available : ' + key); Console.WriteLine('The value four is available : ' + val); Console.ReadLine(); } }

L'output del programma di cui sopra sarà:

Quello chiave è disponibile: vero
È disponibile il valore quattro: False

Nel programma sopra, abbiamo prima utilizzato il metodo ContainsKey per convalidare se la chiave data è presente all'interno del dizionario. Poiché la chiave è presente nel dizionario, il metodo restituisce true. Quindi usiamo ContainsValue per determinare se il valore specificato è presente o meno. Poiché il valore 'quattro' non è presente nel dizionario, restituirà false.

Come rimuovere un elemento da un dizionario?

Potrebbe esserci un momento in cui dovremo rimuovere una determinata coppia chiave-valore dal dizionario per soddisfare una determinata logica di programmazione. Il metodo Remove può essere utilizzato per rimuovere qualsiasi coppia dal dizionario in base alla chiave.

Sintassi

Remove(key);

Programma

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); //removing key two dctn.Remove('two'); //validating if the key is present or not bool key = dctn.ContainsKey('two'); Console.WriteLine('The key two is available : ' + key); Console.ReadLine(); } }

L'output del programma di cui sopra sarà:

La chiave due è disponibile: False

Nel programma precedente, abbiamo prima aggiunto una coppia chiave-valore al dizionario. Quindi abbiamo rimosso una chiave dal dizionario e abbiamo utilizzato il metodo ContainsKey () per verificare se la coppia chiave-valore non è più presente nel dizionario.

Conclusione

L'elenco memorizza gli elementi del tipo di dati specifico e cresce man mano che vengono aggiunti elementi. Può anche memorizzare più elementi duplicati. Possiamo accedere facilmente agli elementi all'interno dell'elenco utilizzando index o loop. L'elenco è molto utile per memorizzare una grande quantità di dati.

Un dizionario viene utilizzato per memorizzare le coppie chiave-valore. Qui le chiavi devono essere uniche. I valori dal dizionario possono essere recuperati utilizzando un ciclo o un indice. Possiamo anche convalidare chiavi o valori utilizzando il metodo Contains.

=> Guarda la serie completa di formazione C # qui

Lettura consigliata

^