Paolo Possanzini

7° Workshop "Microsoft Office SharePoint Server - Tecnologia e strumenti per lo sviluppo e amministrazione"

Paolo Possanzini — Wed, 29 Oct 2008 17:29:00 GMT

Facciamo un grande in bocca al lupo per i nostri amici di dotnetmarche, che domani in collaborazione con Microsoft e l'università di Camerino, organizzano il 7 workshop su sharepoint. Ancora un grandissimo in bocca al lupo.
Ecco il link alla pagina dell'evento : http://dotnetmarche.org/eventi/Default.aspx?IDevento=23

Windows Azure ... un passo verso il Cloud computing.

Paolo Possanzini — Tue, 28 Oct 2008 10:25:42 GMT

Riporto una notizia che trovo molto importante per lo sviluppo futuro di applicazioni basate sui servizi.
Microsoft in occasione del PDC ha presentato una nuovissima versione di windows : Windows Azure.

Il nuovissimo sistema operativo è studiato per supportare a livello di kernel il Cloud Computing.
Sono già disponibili SDK ed esempi su come l'infrastruttura funzionerà.

La cosa mi intriga parecchio perchè il cloud computing è una cosa che mi affascina da parecchio tempo. Avere a disposizione una infrastruttura in grado di supportarlo permette la creazione di applicazioni sicuramente più interessanti.
Vediamo come evolverà il progetto. Vi riporto il link al sito ufficiale dove è già possibile scaricare dei preview SDK ed esempi.

http://www.microsoft.com/azure/default.mspx

Custom Linq Provider (parte 2)

Paolo Possanzini — Mon, 20 Oct 2008 20:47:40 GMT

Continuiamo a vedere come implementare un provider custom che supporta la sintassi Linq.

Per prima cosa creiamo un oggetto che implementa le interfacce IQueryable e IQueryProvider. Ecco una prima implementazione :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CustomLinqProvider
{
public class myQueryableObject<T> : IQueryable, IQueryable<T>, IQueryProvider
{
private System.Linq.Expressions.Expression _expression = null;

#region IQueryable Members

    public Type ElementType
    {
      get { return typeof(T); }
    }

    public System.Linq.Expressions.Expression Expression
    {
      get { return _expression; }
      internal set { _expression = value; }
    }

    public IQueryProvider Provider
    {
      get { return this; }
    }

#endregion

#region IEnumerable Members

    public System.Collections.IEnumerator GetEnumerator()
    {
      throw new NotImplementedException();
    }

#endregion

#region IEnumerable<T> Members

    IEnumerator<T> IEnumerable<T>.GetEnumerator()
    {
      throw new NotImplementedException();
    }

#endregion

#region IQueryProvider Members

    public IQueryable<TElement> CreateQuery<TElement>(System.Linq.Expressions.Expression expression)
    {
      myQueryableObject<TElement> mq = new myQueryableObject<TElement>();
      mq.Expression = expression;
      return mq;
    }

    public IQueryable CreateQuery(System.Linq.Expressions.Expression expression)
    {
      return CreateQuery<T>(expression);
    }

    public TResult Execute<TResult>(System.Linq.Expressions.Expression expression)
    {
      throw new NotImplementedException();
    }

    public object Execute(System.Linq.Expressions.Expression expression)
    {
      throw new NotImplementedException();
    }

#endregion
}
}

I metodi che per adesso ci interessano sono i due metodi CreateQuery. questi metodi vengono chiamati al termine della creazione della Expression Tree da parte del compilatore. La Expression Tree viene preparata e viene passata come oggetto Expression che può essere interpretato ed utilizzato per eseguire le nostre query.

Come è possibile vedere non viene fatta alcun tipo di elaborazione, semplicemente la expression viene memorizzata all'interno del membro _expression e vine e restituito un oggetto dello stesso tipo che stiamo creando. Questo perchè è molto spesso conveniente implementare IQueryProvider e IQueryable all'interno della stessa classe. Capiremo tra poco il perchè.

Abbiamo detto che i metodi CreateQuery vengono invocati appena la creazione della expression tree è completata, tuttavia non viene eseguita nessuna elaborazione. Il motivo di questa tardata esecuzione è che ancora non sappiamo come applicare l'Expression Tree; in modo particolare non sappiamo se dobbiamo attenderci un risultato singolo oppure una lista di elementi e il metodo che viene invocato per l'esecuzione della query potrebbe essere differente.

Facciamo un esempio. Nella query

var result = from rr in myQueryObject<tabella1>()
select rr;

abbiamo definito che intendiamo ottenere tutti i campi della tabella 1 senza nessun filtro. Tuttavia l'esecuzione potrebbe essere eseguita in uno dei seguenti metodi:

rr.ToArray();
rr.Count();
rr.FirstOrDefault();

Ognuno di questi metodi applica la query eseguendo operazioni differenti:
La prima restituisce un risultato multiplo, la seconda esegue un raggruppamento su tutti i record per restituirci il numero di elementi all'interno della tabella, il terzo restituisce il primo elemento completo.

Vediamo quindi come viene invocata l'esecuzione della query.
La prima grande differenza tra i metodi che invocano la query è il tipo di risultato che andiamo ad ottenere.

Se il risultato è un elenco di elementi, allora verranno invocati i metodi GetEnumerator() della nostra classe.
Se invece il risultato è un elemento singolo, allora la query verrà arricchita con l'informazione della chiamata all'ultimo metodo e verrà invocato il metodo Execute().

Tornando al nostro esempio, nel caso di ToArray() verà invocato il GetEnumerator, nel caso di Count() o di FirstOrDefault(), verrà aggiunto all'Expression Tree l'informazione della chiamata all'ultimo metodo e verrà effettivamente invocato il metodo Execute.

Quindi per implementare il nostro parser, dovremo implementare sia i metodi Execute che i metodi GetEnumerator di cui abbiamo già gli stub pronti perchè abbiamo implementato le interfaccie.

E comodo avere implementate entrambe le interfaccie all'interno della stessa classe, poichè il metodo GetEnumerator viene fornito dalla interfaccia IQueryable, mentre il metodo Execute viene fornito dalla interfaccia IQueryProvider.

E' venuto il momento di capire l'Expression Tree e piegarla alla nostra volontà. L'Expression Tree è la rappresentazione a livello linguaggio delle operazioni che devono essere eseguite per ottenere un certo set di dati.
Quello che vogliamo fare per prima cosa è capire come "leggere" l'expression tree, per poi interpretarla ed eseguire operazioni Custom.

Scriviamo questa Query:

myQueryableObject<int> test = new myQueryableObject<int>();
var result = from i in test
select i;

e vediamo come viene interpretata eseguendo result.Expression.ToString();

value( CustomLinqProvider.myQueryableObject`1[System.Int32] ).Select( i => i )

quello che vediamo è la visualizzazione testuale dell'expression tree. come possiamo vedere ogni operazione viene esplicitata in modo del tutto simile alla chiamata a metodi.
Quello che accade in realtà, è che ogni sezione della nostra espressione viene rappresentata attraverso un nodo della expression tree.

Ogni nodo è composto da un oggetto che eredita dalla classe expression. L'oggetto specializza la classe base in modo da rappresentare in modo più fedele possibile il significato del nodo stesso.
Vediamo quali sono gli oggetti che ereditano da Expression.

BinaryExpression
ConditionalExpression
ConstantExpression
InvocationExpression
LambdaExpression
ListInitExpression
MemberExpression
MemberInitExpression
MethodCallExpression
NewArrayExpression
NewExpression
ParameterExpression
TypeBinaryExpression
UnaryExpression

Ognuno di questi oggetti rappresenta un particolare tipo di nodo all'interno della nostra espressione. Ogni classe può tuttavia rappresentare più di un tipo di nodo.
I tipi possibili di nodo sono rappresentati da un Enum.

public enum ExpressionType
{
    Add,
    AddChecked,
    And,
    AndAlso,
    ArrayLength,
    ArrayIndex,
    Call,
    Coalesce,
    Conditional,
    Constant,
    Convert,
    ConvertChecked,
    Divide,
    Equal,
    ExclusiveOr,
    GreaterThan,
    GreaterThanOrEqual,
    Invoke,
    Lambda,
    LeftShift,
    LessThan,
    LessThanOrEqual,
    ListInit,
    MemberAccess,
    MemberInit,
    Modulo,
    Multiply,
    MultiplyChecked,
    Negate,
    UnaryPlus,
    NegateChecked,
    New,
    NewArrayInit,
    NewArrayBounds,
    Not,
    NotEqual,
    Or,
    OrElse,
    Parameter,
    Power,
    Quote,
    RightShift,
    Subtract,
    SubtractChecked,
    TypeAs,
    TypeIs
}

Per interpretare in modo corretto quindi un Expression Tree è sufficiente navigare l'albero e interpretare ogni tipo di nodo. Nel prossimo post vedremo con scrivere in modo corretto un parser per interpretare l'expression tree.
Vi consiglio di dare un'occhiata ai link che vi riporto.

Link utili :

http://msdn.microsoft.com/en-us/library/bb882521.aspx
http://msdn.microsoft.com/en-us/library/bb882536.aspx
http://msdn.microsoft.com/en-us/library/bb397951.aspx

070-432 : MS SQL Server 2008, Implementation and Maintenance -> Passed.

Paolo Possanzini — Thu, 09 Oct 2008 05:13:16 GMT

Passato l'esame per l'implementazione e la manutenzione dei DB in SQL Server 2008 .. :D

Custom Linq Provider (parte 1)

Paolo Possanzini — Fri, 03 Oct 2008 11:25:00 GMT

Diciamo che il rientro dalle ferie è stato più duro del previsto. In questo tempo però ho avuto modo di approfondire alcuni argomenti piuttosto interessanti legati alla programmazione con il framework 3.5 in modo particolare con Linq.

Facendo una veloce ricerca su google possiamo accorgerci che le implementazioni custom di linq stanno crescendo in modo piuttosto veloce. Da quelle per fare le query su Amazon a quelle per cercare documenti in Sharepoint a tutto quello che vi può venire in mente. Questo è possibile perchè la sintassi introdotta con il framework 3.5 e che abbiamo visto utilizzare in LinqtoSql o in LinqtoXml non è legata alla implementazione di alcune librerie di accesso ai dati di Microsoft, ma è un nuovo tipo di sintassi introdotta a livello di linguaggio e supportata da 2 interfaccie che sono presenti nelle librerie base del framework 3.5. Quindi è sufficiente reimplementare le interfaccie di base per rendere i nostri oggetti pienamente compatibili con la sintassi Linq.

L'obiettivo di questo articolo è di comprendere come Linq viene interpretato a livello di compilatore e come viene utilizzato per effettuare ricerche sui dati. Arriveremo anche customizzare il comportamento di Linq per effettuare query su fonti dati non tradizionali. In TeamDev abbiamo seguito questo approccio per estendere le funzionalità del nostro layer di accesso ai dati al fine di sfruttare le interessantissime caratteristiche della sintassi Linq.

Le interfaccie di base

Abbiamo detto che linq si appoggia a due interfaccie :

IEnumerable (presente da tempo nella libreria mscorlib)
IQueryable (introdotta con il framework 3.5 nella libreria System.Core)

queste interfaccie vengono riconosciute dal compilatore e rendono possibile l'utilizzo della sintassi Linq. Comprendere come il compilatore utilizza le interfaccie, aiuta a comprendere come Linq funziona e come possiamo customizzarne il comportamento.

public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

IEnumerable è presente dalla prima implementazione del framework a supporto della sintassi foreach. Possiamo infatti utilizzare il foreach solo sugli oggetti che implementano IEnumerable.
Siccome Linq utilizza IEnumerable per effettuare le query che coinvolgono collection e liste, questo ci lascia intuire che tutti i foreach possono essere trasformati in query Linq.

public interface IQueryable : IEnumerable
{
    Type ElementType { get; }
    Expression Expression { get; }
    IQueryProvider Provider { get; }
}

IQueryable è stata introdotta con la versione 3.5 del framework e si trova in System.Core. L'implementazione di IQueryable permette di customizzare il comportamento della query linq per adattarla ad una sorgente dati particolare.
Mentre le query su oggetti IEnumerable vengono eseguite in memoria , le query su IQueryable possono essere trasformate in query custom su oggetti di ogni tipo.

Tutto questo è possibile grazie alla classe Expression e alla interfaccia IQueryProvider esposte attraverso IQueryable

Come vengono utilizzate le interfaccie

Quando utilizzata con IQueryable, la query linq viene trasformata dal compilatore in un oggetto di tipo Expression (detto anche ExpressionTree , perchè ha una struttra ad albero).
L'oggetto Expression viene passato ad un provider che provvede ad interpretarlo e restituirà un risultato coerente con la query effettuata.

Quando utilizzata con IEnumerable, la query linq viene immediatamente eseguita attraverso degli extension methods che estendono le funzionalità della interfaccia IEnumerable.

E facile intuire quindi che per customizzare il comportamento delle query Linq dobbiamo implementare una delle suddette interfaccie.
Agendo con Reflector ci accorgiamo anche che il modo più corretto per intervenire è utilizzare IQueryable piuttosto che IEnumerable, questo perchè IEnumerable ha lo scopo di effettuare operazioni in memoria, cosa che probabilmente vorremo continuare a fare.

IQueryable invece è pensata per agire fuori dal contesto dell'applicazione e quindi è l'interfaccia che meglio si presta alla realizzazione di provider custom per l'accesso ai dati.

Nel prossimo post vedremo come è strutturata la classe Expression e come creare un parser per tradurre le Expression Tree in tutto ciò che vogliamo.

Book Review: Beginning Web Development, Silverlight, and ASP.NET Ajax

Paolo Possanzini — Fri, 22 Aug 2008 09:57:00 GMT

Il libro “Beginning Web Development, Silverlight, and ASP.NET Ajax”, scritto da Laurance Moroney, è una introduzione alla programmazione Web, adatto in modo particolare per chi inizia ad affacciarsi a questo mondo. E’ diviso in 3 parti principali di cui la prima, dopo un capitolo di storia sul mondo web, introduce ai principi dello sviluppo ASP.Net 2.0. Guida passo-passo il principiante a creare la prima applicazione Web, spiegando anche il funzionamento di base di Visual Studio e affrontando progressivamente gli argomenti fondamentali come WebForms, DataBing, WebServices.

Nella seconda parte viene fatta una carrellata delle nuove tecnologie introdotte con la versione 3.0 di Microsoft .Net Framework: Windows Communication Foundation, Windows Presentation Foundation, Windows Workflow Foundation.
Nell’ultima parte viene ripreso l’argomento Web, dove viene illustrata l’evoluzione che ha portato ad Ajax per affrontare infine Silverlight.

Il libro è decisamente introduttivo e getta le basi per ulteriori approfondimenti. Di facile lettura è pienamente comprensibile anche da un programmatore inesperto. Non approfondisce troppo nessun argomento lasciando al lettore la giusta dose di curiosità per ulteriori letture. Una cosa molto importante da sottolineare è la visione di insieme che si ottiene dalla lettura di questo libro dove tutte le tecnologie affrontate trovano il loro giusto posto.

[OT] TS: MS .NET Framework 3.5, ADO .NET Application Development --> Passed

Paolo Possanzini — Wed, 23 Jul 2008 20:31:00 GMT

Anche io mi sto dilettando con gli esami in Beta. E proprio questa sera ho saputo di aver passato il 70-561 : TS: MS .NET Framework 3.5, ADO .NET Application Development

Uno snippet per le DependencyProperty su WPF

Paolo Possanzini — Tue, 27 May 2008 07:59:00 GMT

Mi capita molto spesso di creare DependencyProperty per i miei oggetti da utilizzare con WPF.
Nello snippet base devo sostituire continuamente UIPropertyMetadata con FrameworkElementMetadata, quindi ho deciso di farmi uno snippet gia modificato.

Ve lo allego.
Potete richiamarlo con propdpf

Per installarlo è sufficiente copiare il file nella cartella
C:\Program Files\Microsoft Visual Studio 9.0\VC#\Snippets\1033\NetFX30\

WPF - VS 2008 {Community} Launch - Il Codice della demo

Paolo Possanzini — Mon, 12 May 2008 00:24:00 GMT

In allegato a questo Post trovate il codice della demo della sessione su WPF utilizzata durante l'evento dell'8 Aprile.

WPF: Costruiamo un RSS Reader passo 4 (ListView)

Paolo Possanzini — Sun, 11 May 2008 21:24:00 GMT

Riprendiamo la nostra serie di articoli per la costruzione dell'RSS Reader in WPF. Questa è la volta della definizione della ListView.

Iniziamo a creare 2 wrapper che nascondono gli oggetti COM a WPF.
Incorriamo in questo modo in meno problematiche di Binding.

Ecco i due Wrapper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Feeds.Interop;
using System.Collections;

namespace WpfRssReader
{
public class myFeed
{
private IFeed _currentFeed;

    public string Copyright
    {
      get { return _currentFeed.Copyright; }
    }

    public string Description
    {
      get { return _currentFeed.Description; }
    }

    public string Image
    {
      get { return _currentFeed.Image; }
    }

    public myFeedItem[] Items
    {
      get
      {
        List<myFeedItem> _items = new List<myFeedItem>();
        foreach (IFeedItem item in (IEnumerable)_currentFeed.Items)
        {
          _items.Add(new myFeedItem() { CurrentFeedItem = item });
        }
        return _items.ToArray();
      }
    }

    public DateTime PubDate
    {
      get { return _currentFeed.PubDate; }
    }

    public string Title
    {
      get { return _currentFeed.Title; }
    }

    public string Url
    {
      get { return _currentFeed.Url; }
    }

    public IFeed CurrentFeed
    {
      get { return _currentFeed; }
      set
      {
        _currentFeed = value;
      }
    }

}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Feeds.Interop;

namespace WpfRssReader
{
public class myFeedItem : IFeedItem
{
private IFeedItem _currentFeedItem;

    public IFeedItem CurrentFeedItem
    {
      get { return _currentFeedItem; }
      set { _currentFeedItem = value; }
    }

    public string Author
    {
      get { return _currentFeedItem.Author; }
    }

    public string Comments
    {
      get { return _currentFeedItem.Comments; }
    }

    public string Description
    {
      get { return _currentFeedItem.Description; }
    }

    public string DownloadUrl
    {
      get { return _currentFeedItem.DownloadUrl; }
    }

    public object Enclosure
    {
      get { return _currentFeedItem.Enclosure; }
    }

    public string Guid
    {
      get { return _currentFeedItem.Guid; }
    }

    public bool IsRead
    {
      get
      {
        return _currentFeedItem.IsRead;
      }
      set
      {
        _currentFeedItem.IsRead = value;
      }
    }

    public DateTime LastDownloadTime
    {
      get { return _currentFeedItem.LastDownloadTime; }
    }

    public string Link
    {
      get { return _currentFeedItem.Link; }
    }

    public int LocalId
    {
      get { return _currentFeedItem.LocalId; }
    }

    public DateTime Modified
    {
      get { return _currentFeedItem.Modified; }
    }

    public object Parent
    {
      get { return _currentFeedItem.Parent; }
    }

    public DateTime PubDate
    {
      get { return _currentFeedItem.PubDate; }
    }

    public string Title
    {
      get { return _currentFeedItem.Title; }
    }

    public void Delete()
    {
      _currentFeedItem.Delete();
    }

    public string Xml(FEEDS_XML_INCLUDE_FLAGS includeFlags)
    {
      return _currentFeedItem.Xml(includeFlags);
    }

}
}

Una volta preparate le classi dobbiamo apportare una piccolissima correzione al codice che inserisce il feed all'interno del TAG degli oggetti della TreeView in modo da utilizzare le nuove classi al posto degli oggetti COM che ci restituisce il FeedFolder.

[code language="c#"]

foreach (IFeed feed in ((IFeedsEnum)feedfolder.Feeds))
{
    TreeViewItem tvi = new TreeViewItem()
    {
      Header = feed.Name,
      Tag = new myFeed() { CurrentFeed = feed }                                        // <<<-------- Riga modificata.
    };

// Esegue il download asincrono degli items presenti nel feed
ThreadPool.QueueUserWorkItem(delegate

[/code]

A questo punto facciamo una piccola modifica anche allo xaml ed inseriamo il DataTemplate per la visualizzazione dei feed.

[code language="XML"]

[/code]

Aggiungiamo in fine un elemento Frame che ci permetterà di visualizzazre il contenuto HTML dei posts.

[code language="XML"]

[/code]

In allegato a questo post trovate il progetto completo con le parti sviluppate fino a questo punto.

Nei post futuri vedremo compe personalizzare il layout di quest'applicazione con Blend e come applicare alcuni Effetti che WPF ci permette di realizzare.
Buon divertimento.

WPF: Costruiamo un RSS Reader passo 3 (TreeView)

Paolo Possanzini — Wed, 23 Apr 2008 12:47:12 GMT

Inseriamo la TreeView che conterrà la struttura ad albero dei feed sottoscritti.

[code language="XML"]

[/code]

Inseriamo un oggetto di ObjectDataProvider per preparare il Binding.
Utilizziamo il metodo GetFeedSubTree dell'oggetto di tipo FeedHelper per popolare la TreeView

[code language="XML"]

<Window.Resources>
<ObjectDataProvider x:Key="FeedTreeDS" ObjectType="{x:Type rssreader:FeedHelper}" MethodName="GetFeedSubTree" />
</Window.Resources>

[/code]

A questo punto andiamo ad inserire il binding all'interno dell'oggetto TreeView

[code language="XML"]

[/code]

Inseriamo subito anche un'altro Grid che con i controlli necessari a sottoscrivere i feeds, per adesso inseriamo solo due textbox, una per il nome che vogliamo dare al feed ed una per l'uri
Posizioniamo questo nuovo Grid nella prima cella in alto a sinistra.

[code language="XML"]

<Grid Margin="0,0,0,0">
        <Rectangle Fill="#FFFFFFFF" Stroke="#FF000000" RadiusX="4" RadiusY="4" Margin="0,0,0,0"/>
        <TextBox Text="<url>" TextWrapping="Wrap" Margin="8,36,8,0" VerticalAlignment="Top" Name="txtUrl" />
        <TextBox Height="24" Text="<nome>" TextWrapping="Wrap" Margin="8,8,8,0" VerticalAlignment="Top" Name="txtNome" />
        <Button d:LayoutOverrides="Height" x:Name="btnSubscribe" Height="28" Content="Sottoscrivi" Click="btnSubscribe_Click" HorizontalAlignment="Right" Margin="0,0,8,8" VerticalAlignment="Bottom" Width="76"/>
    </Grid>

[/code]

Scriviamo il codice necessario a gestire l'evento Click del bottone che abbiamo inserito.
Il metodo dovrà controllare qual'è il folder selezionato nella Treeview ed inserire la sottoscrizione all'interno di quel folder.
Poi dovrà invocare il metodo FeedHelper.SubscribeFeed

[code language="C#"]

private void btnSubscribe_Click(object sender, RoutedEventArgs e)
{
TreeViewItem tvi = tvFeedsFolders.SelectedItem as TreeViewItem;
if (tvi != null)
{
IFeedFolder folder = null;

    folder = tvi.Tag as IFeedFolder;
    if (folder == null)
    {
      IFeed feed = tvi.Tag as IFeed;
      if (feed != null)
      {
        folder = feed.Parent as IFeedFolder;
      }
    }

if (folder == null)
folder = new FeedsManagerClass().RootFolder as IFeedFolder;

FeedHelper.SubscribeFeed(folder, txtUrl.Text, txtNome.Text);
}
}

[/code]

Ecco il risultato del lavoro svolto fino a questo momento

WPF: Costruiamo un RSS Reader passo 2 (L'interfaccia utente)

Paolo Possanzini — Mon, 21 Apr 2008 07:30:24 GMT

Come secondo passo iniziano a creare l'interfaccia utente.

Creiamo un nuovo Windows Forms e lo chiamiamo MainForm.xaml. Ci spostiamo sul file App.xaml e impostiamo StartupUri a MainForm.xaml.
Vediamo come creare la nostra UI. La mia idea iniziale è quella di creare un menù in alto e dividere il resto della UI in due colonne. Quella di sinistra come colonna di controllo, il resto come area di lettura dei feeds.

[code language="XML"]

[/code]

Ho già inserito nella struttura, lo spazio dei nomi dell'applicazione e l'ho chiamata "rssreader".
Dividiamo inoltre il form in due righe, una ad altezza fissa e una ad altezza variabile attraverso i due tag RowDefinition . Inserisco due oggetti per dare al form un leggero stile "Heros".

Inseriamo all'interno del form un nuovo Grid che utilizzeremo come area per il posizionamento dei controlli.
Dividiamo il Grid in righe e colonne. Dimensioniamo le colonne con un rapporto 1 a 3 utilizzando la notazione "*" e creiamo 3 righe.
Una ad altezza fissa e due riproporzionabili.

[code language="XML" ]

[/code]

Questo è il risultato del lavoro fino a questo momento.

WPF: Costruiamo un RSS Reader passo 1 (utilizzare Microsoft.Feeds.dll)

Paolo Possanzini — Sat, 19 Apr 2008 20:44:00 GMT

Questo vuole essere il primo di una serie di articoli dedicati alla scrittura di applicazioni complete, dalla A alla Z sviluppate con il Framework 3.5, ponendo particolare attenzione al layer di presentazione attraverso WPF. Come primo esercizio creiamo un RSS reader.

Microsoft ci mette a disposizione una libreria COM per la lettura dei Feed. La utilizzeremo in questo progetto.

Iniziamo.

Creiamo la nostra applicazione con VS2008 e scegliamo WPF Application come tipo di progetto.
Per prima cosa aggiungiamo la reference alla Microsoft.Feeds.dll che possiamo trovare tra i componenti COM.

Creiamo una classe che ci permetta di gestire in modo agevole i feeds. Chiameremo questa classe FeedHelper

[code language="C#"]

public static class FeedHelper
{

    /// <summary>
    /// Get The subtree for RootFolder folder
    /// </summary>
    /// <param name="feedfolder"></param>
    /// <returns></returns>
    [Description("Get The subtree for each folder")]
    public static TreeViewItem[] GetFeedSubTree()
    {
      return GetFeedSubTree((IFeedFolder)(new FeedsManagerClass().RootFolder));
    }

    /// <summary>
    /// Get The subtree for each folder
    /// </summary>
    /// <param name="feedfolder"></param>
    /// <returns></returns>
    [Description("Get The subtree for each folder")]
    public static TreeViewItem[] GetFeedSubTree(IFeedFolder feedfolder)
    {
      try
      {

        // Creiamo una lista di nodi per questo folder
        List<TreeViewItem> result = new List<TreeViewItem>();
        foreach (IFeedFolder folder in ((IFeedsEnum)feedfolder.Subfolders))
        {
          TreeViewItem tvi = new TreeViewItem()
          {
            Header = folder.Name,
            Tag = folder,
            ItemsSource = GetFeedSubTree(folder)
          };
          result.Add(tvi);
        }

        // Creiamo i nodi anche per i feed gia scaricati.
        if (feedfolder.Feeds != null)
        {
          foreach (IFeed feed in ((IFeedsEnum)feedfolder.Feeds))
          {
            TreeViewItem tvi = new TreeViewItem()
            {
              Header = feed.Name,
              Tag = feed
            };

            // Esegue il download asincrono degli items presenti nel feed
            ThreadPool.QueueUserWorkItem(delegate
            {
              try
              {
                feed.Download();
              }
              catch (Exception ex)
              {
                Debug.WriteLine(ex.Message);
              }
            }, null);
            result.Add(tvi);
          }
        }

        return result.ToArray();
      }
      catch (Exception ex)
      {
        Debug.WriteLine(ex.Message);
      }
      return null;
    }

    /// <summary>
    /// Create a Feed in a foder
    /// </summary>
    /// <param name="folder"></param>
    /// <param name="uri"></param>
    /// <param name="name"></param>
    public static void SubscribeFeed(IFeedFolder folder, string uri, string name)
    {
      folder.CreateFeed(name, uri);
    }
}

[/code]

Estenderemo questa classe se necessario in seguito. Per adesso ci basta porre attenzione sui due overloads GetFeedSubTree In questi due metodi viene creato in modo ricorsivo l'albero che descrive i feed sottoscritti eseguendo anche il download dei feed da ogni sottoscrizione. Da notare che non abbiamo bisogno di creare una struttura di storage dei feeds sottoscritti e scaricati. La libreria Microsoft.Feeds si occuperà di tutto per conto nostro.

WPF Performance Tuning

Paolo Possanzini — Thu, 17 Apr 2008 10:11:21 GMT

Ho trovato un link utile a chi si diletta nello sviluppo di applicazioni WPF.
Sono riportati tutti gli oggetti WPF che inficiano in qualche modo le performance della nostra applicazione.

Sono riportati anche suggerimenti per migliorare le performances.

http://blogs.msdn.com/wpfsdk/archive/2007/01/15/maximizing-wpf-3d-performance-on-tier-2-hardware.aspx

Vi riporto inoltre il link ai tools di profiling delle performances.

http://msdn2.microsoft.com/en-us/library/aa969767.aspx

Un link per migliorare le nostre animazioni

http://msdn2.microsoft.com/en-us/library/bb613592.aspx

Un link che ci spiega come funziona il Tier della struttura grafica.

http://msdn2.microsoft.com/en-us/library/ms742196.aspx

Ed infine un link per risolvere i problemi dovuti all'interazione con la scheda grafica

http://msdn2.microsoft.com/en-us/library/aa970912.aspx

C# ReaderWriterLock

Paolo Possanzini — Mon, 14 Apr 2008 17:30:53 GMT

In .Net quando dobbiamo creare applicazioni multithread siamo soliti utilizzare l'istruzione lock per sincronizzare l'accesso alle risorse condivise.
Questo potrebbe non essere l'approccio più corretto se si eseguono molte letture e poche scritture perchè costringiamo i vari thread ad accedere alla risorsa anche in lettura uno alla volta.

La classe ReaderWriterLock ci aiuta a inserire i lock solo quando necessari e permette accessi multipli in lettura e accessi singoli in scrittura.
Vi rimando ad MSDN per una trattazione dell'argomento più dettagliata.

http://msdn2.microsoft.com/en-us/library/system.threading.readerwriterlock.aspx

http://msdn2.microsoft.com/en-us/magazine/cc163846.aspx