LINQ

Passato e presente

Pietro Libro — Tue, 21 Oct 2008 16:10:12 GMT

Mi trovavo ad analizzare un vecchio codice VB6 per un amico, ed ho trovato una possibile implementazione di un algorimo per la risoluzione del seguente problema: Dato un array di double, trovare il valore minimo, escludendo dei valori, ad esempio, (0).

Soluzione del passato trovata (VB6)

Function TrovaMinimo(dati() As Double, Optional Except As Double)

    Dim i As Integer
    Dim Minimo As Double
    Dim numerodati As Integer
        
    numerodati = UBound(dati)
        
    Minimo = dati(1)
    
    If Except < 0 Then
        For i = 2 To numerodati
            If dati(i) < Minimo Then
                Minimo = dati(i)
            End If
        Next i
    Else
        For i = 2 To numerodati
            If dati(i) < Minimo And dati(i) <> Except Then
                Minimo = dati(i)
            End If
        Next i
    End If
    
    TrovaMinimo = Minimo
    
End Function

Se il valore del parametro Except è minore di zero, viene trovato il minimo considerando tutti i valori nell'array, altrimenti si cerca l'elemento minimo, escludendo il valore di Except

Come potrebbe essere implementata una possibile soluzione del problema, sfruttando le tecnologie attuali:

using System.Linq;
...

double[] data = new Double[] { 28, 25 ,0};
//Ritorna il valore minimo escludendo il valore 0
Console.WriteLine(data.Where(d => d != 0).ToArray().Min().ToString("N"));
//Ritorna il valore minimo
Console.WriteLine(data.Min().ToString("N"));

WPF + LINQ + CollectionViewSource = Rss Reader

Pietro Libro — Wed, 27 Aug 2008 11:30:58 GMT

Questo post è nato con uno scopo diverso da quello dell'implementazione di un Rss Reader, dato che, è sufficiente cercare su internet per trovarne di belli e pronti, ma per enfatizzare alcune proprietà molto interessanti dei controlli WPF, come la possibilità di eseguire il raggruppamento dei dati nei controlli ListBox o ListView. Piccola parentesi: per chi volesse conoscere in dettaglio le specifiche RSS 2.0 le può trovare qui. Iniziamo sviluppando un set di classi come riassunto dal seguente Class Diagram:

Nel resto dell'esempio saranno prese in considerazione solo istanze di tipo Rss e RssItem. Generalmente, senza considerare gli elementi opzionali, la struttura xml di un documento RSS è il seguente:

 1 <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" ...
 2   <channel>
 3     <title>Il blog di Pietro Libro</title>
 4     <link>http://blogs.ugidotnet.org/PietroLibroBlog/Default.aspx</link>
 5     <description />
 6     <language>it-IT</language>
 7     <copyright>Pietro Libro</copyright>
 8     <managingEditor></managingEditor>
 9     <generator>Subtext Version 1.9.5.176</generator>
10     ...
11      <item>
12       <title>Adeona, il software &amp;quot;salva&amp;quot; notebook</title>
13       <category>OT</category>
14       <category>Varie ed eventuali</category>
15       <link>http://blogs.ugidotnet.org/PietroLibroBlog/archive/2008/08/26/93820.aspx</link>
16       <description>...</description>
17       ....
18     </item>

Per leggere un tale documento, utilizziamo un'istanza della classe XDocument, presente nel namespace System.Xml.Linq, contenente metodi che permettono la navigazione dei nodi del documento in maniera molto semplice. Se a questo aggiungiamo la potenza di Linq, veramente c'è poco da dire. Prima di tutto creiamo un'istanza di XDocument e leggiamo il documento passando direttamente l'uri del fornitore del feed RSS:

1 XDocument xDocument = new XDocument();                
2 xDocument = XDocument.Load(blogUri);

Per recuperare tutti gli elementi item contenuti nel documento, utilizziamo Linq. Per far questo utilizziamo il metodo Descendants passando come parametro la stringa "Item":

1 _items =
2     (from item in xDocument.Descendants("item")
3      select new RssItem
4      {
5          Title = item.Element("title").Value,
6          Description =item.Element ("description").Value,
7          Category = item.Element("category") == null ? "Nessuna Categoria" : item.Element("category").Value ,
8          Link = item.Element("link") == null ? "": item.Element("link").Value
9      }).ToList<RssItem>();

_items è una lista tipizzata di oggetti RssItem.

Per presentare i dati recuperati utilizziamo una Window WPF. Il nostro obiettivo è mostrare i dati raggruppati per categoria, ovvero ottenere qualcosa del tipo:

Per raggiungere il goal, invece di utilizzare la proprietà ItemSource esposta dal controllo ListBox, utilizziamo un'istanza di oggetto di tipo CollectionViewSource la quale altro non è una che un Proxy della classe CollectionView. Quest'ultima permette di eseguire operazioni di raggruppamento, ordinamento, navigazione e ricerca su di una collezione di dati. Definiamo un'istanza di tipo CollectionViewSource nella collezione Window.Resources della nostra Window WPF:

1 <CollectionViewSource x:Key="cvs">
2     <CollectionViewSource.GroupDescriptions>
3         <PropertyGroupDescription PropertyName="Category"/>
4     </CollectionViewSource.GroupDescriptions>
5 </CollectionViewSource>

Così facendo, aggiungiamo alla collezione GroupDescriptions un oggetto di tipo GroupDescription che descrive il criterio in base al quale i dati devono essere raggruppati nella vista, nello specifico in base al valore della proprietà Category.

Tramite codice XAML, andiamo a descrivere come devono essere visualizzati i nostri Gruppi:

 1 <Style x:Key="CustomGroupStyle" TargetType="{x:Type GroupItem}">
 2     <Setter Property="Margin" Value="0,0,0,5"/>
 3     <Setter Property="Template">
 4         <Setter.Value>
 5             <ControlTemplate TargetType="{x:Type GroupItem}">
 6                 <Expander IsExpanded="False" BorderBrush="#FFA4B97F" BorderThickness="0,0,0,1">
 7                     <Expander.Header>
 8                         <DockPanel>
 9                             <TextBlock FontWeight="Bold" Text="{Binding Path=Name}"/>
10                             <TextBlock FontWeight="Bold" Text="{Binding Path=ItemCount, 
11                                     Converter={StaticResource CustomConverter},
12                                     ConverterParameter=' - Numero di post ({0}) '}"/>
13                         </DockPanel>
14                     </Expander.Header>
15                     <Expander.Content>
16                         <ItemsPresenter />
17                     </Expander.Content>
18                 </Expander>
19             </ControlTemplate>
20         </Setter.Value>
21     </Setter>
22 </Style>

E gli elementi in essi contenuti:

1 <DataTemplate x:Key="ItemTemplate">
2     <StackPanel>
3         <TextBlock Text="{Binding Path=Title}"></TextBlock>
4         <TextBlock>
5     <Hyperlink NavigateUri="{Binding Path=Link}" Click="Hyperlink_Click">Visualizza</Hyperlink>
6         </TextBlock>
7     </StackPanel>
8 </DataTemplate>

Non resta che definire il controllo ListBox:

1 <ListBox Name="lstBox" ItemTemplate="{StaticResource ItemTemplate}" Margin="12,41,12,12">
2     <ListBox.GroupStyle>
3         <GroupStyle ContainerStyle="{StaticResource CustomGroupStyle}"/>
4     </ListBox.GroupStyle>
5 </ListBox>

Utilizzando un controllo Button per recuperare il contenuto del documento RSS, scriviamo il seguente codice C#:

1 LinqRss.Rss rss = new LinqRss.Rss();
2 if (rss.Load("http://blogs.ugidotnet.org/PietroLibroBlog/Rss.aspx"))
3 {
4     CollectionViewSource collectionViewSource = this.FindResource("cvs") as CollectionViewSource ;
5     collectionViewSource.Source = rss.Items;
6     lstBox.ItemsSource = collectionViewSource.View;
7 }

In sintesi, recuperata l'istanza di CollectionViewSource contenuta nelle risorse della nostra Window WPF, impostiamo la proprietà Source dell'oggetto CollectionViewSource utilizzando la collezione Items esposta dall'istanza Rss. Non resta che impostare la proprietà ItemSource del controllo ListBox con la proprietà View esposta da CollectionViewSource. Osservazione: i GroupItem sono costituiti da controlli Expander. Nell'ItemTemplate è presente anche un HyperLink che permette la navigazione verso il post d'interesse.

Codice C# e XAML

Technorati Tag: CollectionViewSource

Linq: ThenBy e ThenByDescending

Pietro Libro — Fri, 16 May 2008 06:49:57 GMT

Se abbiamo la necessità di ordinare una query Linq per più campi possiamo utilizzare gli operatori ThenBy e ThenByDescending. Considerando le classi del post precedente, se volessimo ordinare la query:

1 var query1 = esamiSostenuti
2     .OrderBy(es => es.ID_Studente)
3     .Select(es => new { es.ID_Studente, es.Voto });

non solo per il campo ID_Studente, ma anche per il campo Voto, possiamo scrivere:

1 //Ordinamento Ascendente
2 var query2 = esamiSostenuti
3     .OrderBy(es => es.ID_Studente)
4     .ThenBy(es => es.Voto)                        
5     .Select(es => new { es.ID_Studente, es.Voto });

Mentre per eseguire l'ordinamento in modo discendente scriviamo:

1 //Ordinamento Discendente
2 var query3 = esamiSostenuti
3     .OrderBy(es => es.ID_Studente)
4     .ThenByDescending(es => es.Voto)
5     .Select(es => new { es.ID_Studente, es.Voto });

Technorati Tag: Linq,ThenBy,ThenByDescending

Linq: Operatore Group By

Pietro Libro — Fri, 09 May 2008 06:28:38 GMT

Supponiamo di avere tre classi rappresentanti una ipotetica basi di dati "Università" (molto semplice). Una classe rappresentante lo studente, un classe rappresentante un esame sostenuto dallo studente ed una classe rappresentante l'associazione tra studenti ed esami sostenuti. Utilizzando un ClassDiagram avremmo qualcosa di simile a:

Supponiamo ora, di voler recuperare, una volta popolate le collezione di oggetti opportune, quali esami siano stati sostenuti dagli studenti e con quale votazione, utilizzando LINQ e l'operatore di Group By.

Possiamo scrivere del codice del tipo:

 1 var queryEsamiSostenutiDaStudenti =
 2     from s in studenti
 3     join es in esamiSostenuti on s.ID_Studente equals es.ID_Studente
 4     join esa in esami on es.ID_Esame equals esa.ID_Esame
 5     select new { s.Cognome, s.Matricola, esa.Nome, esa.Descrizione, es.Voto, es.Lode };
 6 //Esegue il GroupBy per cognome
 7 var groupEsamiPerStudente =
 8     from eSost in queryEsamiSostenutiDaStudenti
 9     orderby eSost.Cognome ascending
10     group eSost by eSost.Cognome;
11 //Visualizza il risultato ottenuto
12 foreach (var groupEsamiStudente in groupEsamiPerStudente)
13 {
14     Console.WriteLine("----------------------------------------------------------");
15     Console.WriteLine("Lo studente {0} ha sostenuto i seguenti esami con profitto", groupEsamiStudente.Key);
16     foreach (var item in groupEsamiStudente)
17     {
18         Console.WriteLine("\t{0}, {1} {2} {3}", new object[]{
19             item.Nome , item.Descrizione , 
20             item.Voto,item.Lode ? "Con lode" : "Senza lode"}
21             );
22     }
23     Console.WriteLine("----------------------------------------------------------");
24 }
25

Utilizzando due cicli foreach riusciamo da ottenere un effetto del tipo:

Codice esempio

Technorati Tag: LINQ,Group By

LINQ: ToList e ToArray

Pietro Libro — Sat, 12 Apr 2008 12:14:17 GMT

Se nella nostra applicazione abbiamo la necessità di leggere molte volte gli stessi dati, può essere conveniente (se questi non cambiano frequentemente nel tempo), l'utilizzo di ToList (o ToArray ) per convertire il risultato di una query linq in un oggetto List o Array da utilizzare come cache dei dati. Supponiamo di avere mappato una tabella Corsi con la seguente entità:

 1 [Table(Name="Corso")]
 2     public class Corso
 3     {
 4 
 5         [Column(IsPrimaryKey=true)]
 6         public int cod_Corso;
 7         [Column]
 8         public string nome_Corso;
 9         [Column]
10         public string descrizione_Corso;
11         [Column]
12         public string livello;
13         [Column]        
14         public string tipo;
15         [Column]
16         public string categoria;
17         [Column]
18         public bool web;
19 
20         [Association(OtherKey = "Fk_Cod_Corso")]
21         public EntitySet<Prenotazione> Prenotazioni;
22 
23     }

Se utilizzassimo la query seguente (molto semplice)

1 var query =from c in _corsoTable orderby c.nome_Corso ascending select c;

per estrapolare tutti i corsi contenuti nel database, per visualizzarli, sarebbe sufficiente eseguire un semplice ciclo foreach (il quale richiamerebbe il corrispondente GetEnumerator). Se dovessimo eseguire quesa operazione molte volte durante il ciclo di vita della nostra applicazione, ogni volta che il foreach viene eseguito, viene interrogato il database sottostante, e questa operazione comporta ovviamente un certo tempo per essere portata a termine. Sulla mia macchina (portatile con processore Intel T7700 @2.4Ghz con 4GB di Ram e Windows Vista Ultimate), ho provato ad eseguire il seguente codice:

 1 
 2 List<double> tempi = new List<double> (20);
 3 
 4 _corsoTable = db.GetTable<Corso>();
 5 
 6 IEnumerable<Corso> query =
 7     from c in _corsoTable
 8     orderby c.nome_Corso ascending
 9     select c;
10 
11 List <Corso > lstCorso = query.ToList<Corso>();            
12 DateTime startTime;
13 
14 for (int i = 0; i < 20; i++)
15 {
16     startTime = DateTime.Now;
17     for (int index = 0; index < 100; index++)
18     {
19         Console.WriteLine("Ciclo {0}---------------------------------------------------------", index);
20         EseguiForEach(lstCorso  );
21         Console.WriteLine("Fine ciclo {0}-----------------------------------------------------", index);
22     }
23     tempi.Add(DateTime.Now.Subtract(startTime).TotalSeconds);
24 }
25 
26 Console.WriteLine ("Media:{0}",tempi.Average());

Ripetendo quest'ultimo diverse volte, commentando o meno la riga 11, a secondo se passavo al metodo EseguiForEach, la lista lstCorso o l'oggetto IEnumerable query. Ho ottenuto i seguenti risultati:

# Iterazioni Ciclo esterno	#Iterazioni Ciclo Interno	Query (media in sec.)	lstCorso (media in sec.)
1	10	1,176	0,5590
3	10	0,7601	0,548
5	10	0,7170	0,5770
10	10	0,6714	0,5356
20	10	0,6408	0,5630
1	100	6,527	5,343

Quello che più mi ha sorpreso è il risultato della prima riga. Il tempo medio si riferisce ad un intera esecuzione del ciclo più interno. Penso che per avere dei test più accurati bisognerebbe "azzerare" la memoria prima di ogni esecuzione (magari con un bel riavvio), e prendere in considerazione una tabella composta da un numero maggiore di dati (la tabella presa in esame contiene circa 4000 righe).

In ogni caso è evidente, che quando si ha la necessità di eseguire molte operazioni di lettura sui dati ( e questi non cambiano frequentemente nel tempo) l'utilizzo di una cache di dati può migliorare notevolmente le prestazioni della nostra applicazione.

Technorati Tag: LINQ,ToList,ToArray

LINQ: Piccoli esperimenti

Pietro Libro — Tue, 24 Jul 2007 09:43:00 GMT

Trovato il tempo per installare la beta 1 di Visual Studio "Orcas" mi sono concesso 5 minuti per effettuare qualche (piccolo)esperimento con "LINQ" (per fortuna per WPF e WCF ho utilizzato le estensioni di VS2005
e non ho aspettato così tanto :-) ),ecco il codice

        Dim lPersone As New Persone

        Dim arrNomi() As String = New String() { _
            "Pietro", "Giovanni", "Paolo", "Bottoni", "Alessandro", "Nicola", "Filippo", _
            "Maria", "Stefano", "Luigi", "Pierluigi"}

        'Trova tutti i nomi che iniziano per Pi ed ordina il risultato in modo crescente
        Dim nomi As IEnumerable = From s As String In arrNomi Where s.StartsWith("Pi") Order By s Ascending

        'Visualizzo il risultato in un ListBox
        For Each nome As String In nomi
            lstStrings.Items.Add(nome)
        Next

        'Utilizzo degli "Inizializzatori di oggetto"
        lPersone.Add(New Persona With {.Nome = "Pietro", .Cognome = "Libro"})
        lPersone.Add(New Persona With {.Nome = "Eleonora", .Cognome = "x"})
        lPersone.Add(New Persona With {.Nome = "Pinco", .Cognome = "Pallino"})
        lPersone.Add(New Persona With {.Nome = "Tizio", .Cognome = "Caio"})
        lPersone.Add(New Persona With {.Nome = "Paolo", .Cognome = "Lino"})
        lPersone.Add(New Persona With {.Nome = "Paolo", .Cognome = "Dell'Angelo"})

        'Trova tutte le persone nella lista lPersone che hanno il nome che inizia
        'per P ed il cognome che inizia per L e ordina il risultato per Cognome
        Dim persone1 As IEnumerable(Of Persona) = From per As Persona In lPersone _
                                                    Where per.Nome.StartsWith("P") And per.Cognome.StartsWith("L") _
                                                    Order By per.Cognome

        'Trova tutte le persone nella lista lPersone che hanno il cognome che inizia
        'per P o il cognome che inizia per L e restituisci un IEnumerable contenente
        'stringhe valorizzate conme Nome Cognome
        Dim persone2 As IEnumerable = From per As Persona In lPersone _
                                                    Where per.Nome.StartsWith("P") And per.Cognome.StartsWith("L") _
                                                    Select new = per.Nome & " " & per.Cognome
        'Visualizzo il risultato in un ListBox
        For Each p In persone2
            lstPersone.Items.Add(p.ToString)
        Next