Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C# / VB.NET - c# - indicizzatori per sortedlist di sortedlist di list di classe utente
Forum - C# / VB.NET - c# - indicizzatori per sortedlist di sortedlist di list di classe utente

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
kenton (Normal User)
Newbie


Messaggi: 7
Iscritto: 31/10/2016

Segnala al moderatore
Postato alle 14:41
Sabato, 04/02/2017
Ciao,
nel creare la seguente struttura per i dati ho degli errori.
E' una 'sortedlist' di una 'sortedlist' di una 'list' di una classe 'attivita' da me definita.

Per rendere agevole lettura e scrittura voglio mettere degli indicizzatori
in modo da accedere come fosse una matrice con le parentesi quadre,
agli oggetti interni.

Esempio:
Codice sorgente - presumibilmente C# / VB.NET

  1. var matrice = new matrAttivita();
  2. //inserire così
  3. matrice["1A"]["John"] = {"math","3cat",30,""};
  4. //leggere così
  5. string materia = matrice["1A"]["John"][0].materia;
  6. //e leggere anche così
  7. string materia = matrice[0][0][0].materia;
  8. //(override sui tipi?)



(so che mancano ancora tutti i controlli ai metodi per verificare l'esistenza o meno degli oggetti in lettura e scrittura)

Ho questo errore (in 4 punti, rige 36 40 59 63):
Errore    CS0029    Non è possibile convertire in modo implicito il tipo
'System.Collections.Generic.SortedList<string, Estrazione_Excel01.listAttivita>'
in
'System.Collections.Generic.SortedList<string, System.Collections.Generic.SortedList<string, Estrazione_Excel01.listAttivita>>'


Cosa non ho capito ?


Codice sorgente - presumibilmente C#

  1. public class matrAttivita
  2.     {
  3.         private SortedList<string, SortedList<string, listAttivita>> _Inner = new SortedList<string, SortedList<string, listAttivita>>();
  4.  
  5.         public void Add(string corso, string insegnante, string materia, string ufc, ushort ore, string aulaLabo)
  6.         {
  7.             if(!_Inner.ContainsKey(corso))
  8.                 _Inner.Add(corso, null);
  9.             if (!_Inner[corso].ContainsKey(insegnante))
  10.                 _Inner[corso].Add(insegnante, null);
  11.             var last = _Inner[corso][insegnante].listAtt.Last();
  12.             foreach (Attivita att in _Inner[corso][insegnante].listAtt)
  13.             {
  14.                
  15.                 if (att.materia == materia)
  16.                 {
  17.                     //errore materia già presente
  18.                     break;
  19.                 }
  20.                 else
  21.                 {
  22.                     if (att.Equals(last))
  23.                         _Inner[corso][insegnante].Add(materia, ufc, ore, aulaLabo);
  24.                 }
  25.             }
  26.  
  27.  
  28.  
  29.  
  30.         }
  31.  
  32.         public SortedList<string, SortedList<string, listAttivita>> this[int i]
  33.         {
  34.             get
  35.             {
  36.                 return _Inner.Values[i]; //<- errore
  37.             }
  38.             set
  39.             {
  40.                 _Inner.Values[i] = value; //<- errore
  41.             }
  42.         }
  43.  
  44.     }
  45.  
  46.     public class vectAttivita
  47.     {
  48.         public SortedList<string, listAttivita> _Inner = new SortedList<string, listAttivita>();
  49.  
  50.         public void Add(string key)
  51.         {
  52.             _Inner.Add(key, null);
  53.         }
  54.  
  55.         public SortedList<string, listAttivita> this[int i]
  56.         {
  57.             get
  58.             {
  59.                 return _Inner.Values[i]; //<- errore
  60.             }
  61.             set
  62.             {
  63.                 _Inner.Values[i] = value; //<- errore
  64.             }
  65.         }
  66.  
  67.     }
  68.  
  69.    
  70.     public class listAttivita
  71.     {
  72.         public void Add(string materia, string ufc, ushort ore, string aulaLabo)
  73.         {
  74.             listAtt.Add(new Attivita(materia, ufc, ore, aulaLabo));
  75.         }
  76.         public void Add(Attivita att)
  77.         {
  78.             listAtt.Add(att);
  79.         }
  80.         public List<Attivita> this[int i]
  81.         {
  82.             get
  83.             {
  84.                 return listAtt;
  85.             }
  86.             set
  87.             {
  88.                 listAtt = value;
  89.             }
  90.         }
  91.     }
  92.  
  93.     public class Attivita
  94.     {
  95.         public string materia;
  96.         public string ufc;
  97.         public ushort ore;
  98.         public string aulaLab;
  99.         public Attivita(string materia, string ufc, ushort ore, string aulaLabo)
  100.         {
  101.             this.materia = materia;
  102.             this.ufc = ufc;
  103.             this.ore = ore;
  104.             this.aulaLab = aulaLabo;
  105.         }
  106.  
  107.  
  108.     }


Ultima modifica effettuata da kenton il 04/02/2017 alle 19:08
PM Quote
Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 17:59
Sabato, 04/02/2017
Non saprei :(

PM Quote
Avatar
kenton (Normal User)
Newbie


Messaggi: 7
Iscritto: 31/10/2016

Segnala al moderatore
Postato alle 19:13
Sabato, 04/02/2017
Ok ho capito da solo ...
restituivo un livello di troppo nella dichiarazione degli indicizzatori ...
che stupidata, ero fermo qui da giorni ...
pfffff

Questo è il codice corretto,
righe 32 e 55
se può interessare ...

Codice sorgente - presumibilmente C#

  1. public class matrAttivita
  2.     {
  3.         private SortedList<string, SortedList<string, listAttivita>> _Inner = new SortedList<string, SortedList<string, listAttivita>>();
  4.  
  5.         public void Add(string corso, string insegnante, string materia, string ufc, ushort ore, string aulaLabo)
  6.         {
  7.             if(!_Inner.ContainsKey(corso))
  8.                 _Inner.Add(corso, null);
  9.             if (!_Inner[corso].ContainsKey(insegnante))
  10.                 _Inner[corso].Add(insegnante, null);
  11.             var last = _Inner[corso][insegnante].listAtt.Last();
  12.             foreach (Attivita att in _Inner[corso][insegnante].listAtt)
  13.             {
  14.                
  15.                 if (att.materia == materia)
  16.                 {
  17.                     //errore materia già presente
  18.                     break;
  19.                 }
  20.                 else
  21.                 {
  22.                     if (att.Equals(last))
  23.                         _Inner[corso][insegnante].Add(materia, ufc, ore, aulaLabo);
  24.                 }
  25.             }
  26.  
  27.  
  28.  
  29.  
  30.         }
  31.  
  32.         public SortedList<string, listAttivita> this[int i]
  33.         {
  34.             get
  35.             {
  36.                 return _Inner.Values[i];
  37.             }
  38.             set
  39.             {
  40.                 _Inner.Values[i] = value;
  41.             }
  42.         }
  43.  
  44.     }
  45.  
  46.     public class vectAttivita
  47.     {
  48.         public SortedList<string, listAttivita> _Inner = new SortedList<string, listAttivita>();
  49.  
  50.         public void Add(string key)
  51.         {
  52.             _Inner.Add(key, null);
  53.         }
  54.  
  55.         public listAttivita this[int i]
  56.         {
  57.             get
  58.             {
  59.                 return _Inner.Values[i];
  60.             }
  61.             set
  62.             {
  63.                 _Inner.Values[i] = value;
  64.             }
  65.         }
  66.  
  67.     }
  68.  
  69.    
  70.     public class listAttivita
  71.     {
  72.         public void Add(string materia, string ufc, ushort ore, string aulaLabo)
  73.         {
  74.             listAtt.Add(new Attivita(materia, ufc, ore, aulaLabo));
  75.         }
  76.         public void Add(Attivita att)
  77.         {
  78.             listAtt.Add(att);
  79.         }
  80.         public List<Attivita> this[int i]
  81.         {
  82.             get
  83.             {
  84.                 return listAtt;
  85.             }
  86.             set
  87.             {
  88.                 listAtt = value;
  89.             }
  90.         }
  91.     }
  92.  
  93.     public class Attivita
  94.     {
  95.         public string materia;
  96.         public string ufc;
  97.         public ushort ore;
  98.         public string aulaLab;
  99.         public Attivita(string materia, string ufc, ushort ore, string aulaLabo)
  100.         {
  101.             this.materia = materia;
  102.             this.ufc = ufc;
  103.             this.ore = ore;
  104.             this.aulaLab = aulaLabo;
  105.         }
  106.  
  107.  
  108.     }


Ultima modifica effettuata da kenton il 04/02/2017 alle 19:14
PM Quote
Avatar
Poggi Marco (Member)
Guru


Messaggi: 950
Iscritto: 05/01/2010

Segnala al moderatore
Postato alle 19:31
Sabato, 04/02/2017
Ciao !

Ho letto il tuo programma, e sinceramente, non ho capito completamente la sua funzionalità generale.
In ogni caso, la classe  listAttivita andrebbe definita meglio:
Codice sorgente - presumibilmente C#

  1. public class listAttivita
  2.          {
  3.  
  4.         private List<Attivita> listAtt = null; // Aggiunta del campo listAtt
  5.  
  6.         // Aggiunta di almeno un costruttore
  7.         public listAttivita()
  8.         {
  9.             listAtt = new List<Attivita>(10);
  10.         }
  11.  
  12.         public void Add(string materia, string ufc, ushort ore, string aulaLabo)
  13.         {
  14.             listAtt.Add(new Attivita(materia, ufc, ore, aulaLabo));
  15.         }
  16.         public void Add(Attivita att)
  17.         {
  18.             listAtt.Add(att);
  19.         }
  20.  
  21.         // Indicizzazione,
  22.         // Ho modificato alcune cose per renderlo "funzinante"
  23.         // In pratica, listAtt, per l' esterno si comporta come un vettore. Non so se nel tuo caso sia funzionale.
  24.         public Attivita this[int i]
  25.         {
  26.             get
  27.             {
  28.                 // Aggiungere controlli sull' indice.
  29.                 // Lanciare un'eccezione se i sfora gli elementi caricati
  30.                 return listAtt[i];
  31.             }
  32.             set
  33.             {
  34.                //  Aggiungere controlli sull' indice.
  35.                // Lanciare un'eccezione se i sfora gli elementi caricati o aumentare la capacità della lista.
  36.                 listAtt[i] = value;
  37.             }
  38.         }
  39.     }



Nulla va più veloce della luce, quindi rilassati.
PM Quote
Avatar
kenton (Normal User)
Newbie


Messaggi: 7
Iscritto: 31/10/2016

Segnala al moderatore
Postato alle 20:00
Sabato, 04/02/2017
Grazie Marco,

hai ragione listAttivita era proprio senza tutto ...
comunque è per memorizzare le ore di lezione (attivita) di una scuola

Quindi al primo livello ci sono le classi
al secondo livello gli insegnanti
al terzo la lista di materie di quella coppia classe-insegnante
e infine al quarto i dati di quella materia (attivita)

Se può interessare ho trovato questa guida c# molto dettagliata:
http://www.antoniopelleriti.it/ABCsharp%20guida%20alla%20p ...

Ho corretto gli indicizzatori leggendo lì.

Ultima modifica effettuata da kenton il 04/02/2017 alle 20:03
PM Quote
Avatar
kenton (Normal User)
Newbie


Messaggi: 7
Iscritto: 31/10/2016

Segnala al moderatore
Postato alle 9:12
Domenica, 05/02/2017
Che differenza c'è tra dichiarare il costruttore
Codice sorgente - presumibilmente C# / VB.NET

  1. private List<Attivita> listAtt = null;
  2. public listAttivita()
  3.     {
  4.         listAtt = new List<Attivita>(10);
  5.     }


oppure dichiarare il campo così:
Codice sorgente - presumibilmente C# / VB.NET

  1. public List<Attivita> listAtt = new List<Attivita>();



e perché nel costruttore c'è (10) tra parentesi ?

Ultima modifica effettuata da kenton il 05/02/2017 alle 9:14
PM Quote
Avatar
Poggi Marco (Member)
Guru


Messaggi: 950
Iscritto: 05/01/2010

Segnala al moderatore
Postato alle 10:07
Domenica, 05/02/2017
La dichiarazione
Codice sorgente - presumibilmente C# / VB.NET

  1. private List<Attivita> listAtt = null;

nomina listAtt come campo privato; impedisce l'utilizzo diretto della variabile all'esterno della classe.
Mentre
Codice sorgente - presumibilmente C# / VB.NET

  1. listAtt = new List<Attivita>(10);

inizializza listAtt di tipo List < Attiva > con la capacità iniziale di 10 elementi. ( https://msdn.microsoft.com/it-it/library/dw8e0z9z(v=vs.110) ... )


Nulla va più veloce della luce, quindi rilassati.
PM Quote
Avatar
kenton (Normal User)
Newbie


Messaggi: 7
Iscritto: 31/10/2016

Segnala al moderatore
Postato alle 11:11
Domenica, 05/02/2017
Ma perché dichiarare 10 elementi se tanto cresce da sola e di default occupa 0 poi 4 dopo il primo inserimento e poi cresce di valori pari nei successivi ...

Io pensavo di dichiarare
listAtt = new List<Attivita>();

Ultima modifica effettuata da kenton il 05/02/2017 alle 11:12
PM Quote
Avatar
Thejuster (Member)
Guru^2


Messaggi: 1703
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 12:40
Domenica, 05/02/2017
Esattamente quoto Kenton.

Credo che sia un inutile spreco dichiarare una lista vuota con la capacità iniziale di 10 elementi vuoti.
Ovviamente se la lista non è inizializzata si ha sicuramente un Crash.

ma per come la vedo io, e molto più comodo inizializzare una lista vuota che una lista con 10 elementi vuoti.


PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo