Alessandro Del Sole's Blog

{ A programming space about Microsoft® .NET® }
posts - 1908, comments - 2047, trackbacks - 352

My Links

News

Your host

This is me! Questo spazio è dedicato a Microsoft® .NET®, di cui sono molto appassionato :-)

Cookie e Privacy

Disabilita cookie ShinyStat

Microsoft MVP

My MVP Profile

Microsoft Certified Professional

Microsoft Specialist

Xamarin Certified Mobile Developer

Il mio libro su VB 2015!

Pre-ordina il mio libro su VB 2015 Pre-ordina il mio libro "Visual Basic 2015 Unleashed". Clicca sulla copertina per informazioni!

Il mio libro su WPF 4.5.1!

Clicca sulla copertina per informazioni! E' uscito il mio libro "Programmare con WPF 4.5.1". Clicca sulla copertina per informazioni!

These postings are provided 'AS IS' for entertainment purposes only with absolutely no warranty expressed or implied and confer no rights.
If you're not an Italian user, please visit my English blog

Le vostre visite

I'm a VB!

Guarda la mia intervista a Seattle

Follow me on Twitter!

Altri spazi

GitHub
I miei progetti open-source su GitHub

Article Categories

Archives

Post Categories

Image Galleries

Privacy Policy

WPF 4.5: Delay Binding

Con questo post vorrei iniziare una mini-serie dedicate alle novità di Windows Presentation Foundation 4.5, ossia quella che sarà la versione disponibile nella ventura release di .NET Framework. Per eseguire il codice chiaramente è necessario avere installato la Developer Preview di Visual Studio 11.

Vi ricordo che venerdì 17 p.v. terrò una sessione completa sulle novità della piattaforma ai Community Days 2012.

In questo post parliamo del Delay Binding, una feature che all'apparenza può avere scarsa utilità ma che in realtà in alcuni scenari può essere utile. Di cosa si tratta? Sostanzialmente, in un data-binding di tipo Two-Way, è possibile ritardare l'aggiornamento della sorgente dati collegata di un tempo specificato in millisecondi. Questo presuppone che l'UpdateSourceTrigger nel binding sia di tipo PropertyChanged.

La documentazione MSDN in preview fa un esempio calzante, ossia un controllo Slider al cui spostamento il valore collegato non viene aggiornato subito per evitare overhead. Qui invece facciamo un esempio diverso, secondo me più adatto per capire.

Non uso MVVM perchè anche i meno esperti vanno incoraggiati a capire meglio. Ho una banale classe Contact:

Imports System.ComponentModel
 
Public Class Contact
    Implements System.ComponentModel.INotifyPropertyChanged
 
    Private _lastName As String
    Public Property LastName As String
        Get
            Return _lastName
        End Get
        Set(value As String)
            _lastName = value
            RaiseEvent PropertyChanged(MeNew PropertyChangedEventArgs("LastName"))
        End Set
    End Property
 
    Private _firstName As String
    Public Property FirstName As String
        Get
            Return _firstName
        End Get
        Set(value As String)
            _firstName = value
            RaiseEvent PropertyChanged(MeNew PropertyChangedEventArgs("FirstName"))
        End Set
    End Property
 
    Public Event PropertyChanged(sender As Object, e As ComponentModel.PropertyChangedEventArgsImplements ComponentModel.INotifyPropertyChanged.PropertyChanged
End Class

Viene implementata INotifyPropertyChanged per inviare una notifica quando i dati sono modificati. Poi ho una Window così definita:

<Window x:Class="DBWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApplication1"
    Title="DBWindow" Height="300" Width="300">
    <Window.Resources>
        <local:Contact x:Key="DemoContact"/>
    </Window.Resources>
    <Grid DataContext="{Binding Source={StaticResource DemoContact}}">
        <StackPanel DataContext="{Binding}">
            <TextBox Text="{Binding Path=FirstName, Mode=TwoWay, Delay=3000, UpdateSourceTrigger=PropertyChanged}" Width="200" Height="40" FontSize="16"/>
            <TextBox Text="{Binding Path=LastName, Mode=TwoWay, Delay=3000, UpdateSourceTrigger=PropertyChanged}" Width="200" Height="40" FontSize="16"/>
 
            <Button Width="100" Name="Button1" Height="40" Click="Button1_Click" Content="Mostra valori" Margin="0,20,0,0"/>
        </StackPanel>
    </Grid>
</Window>

Nelle risorse dichiaro un'istanza della classe Contact da utilizzare come contesto dati della finestra stessa. Ho due TextBox collegate in binding alle rispettive proprietà della classe citata. Come vedete il binding ha ora una nuova proprietà chiamata Delay, che permette di specificare l'intervallo in millisecondi trascorso il quale la UI invierà le modifiche fatte alla sorgente collegata.

L'evento Click del pulsante è semplice e serve null'altro che a mostrare una stringa contenente il nome e cognome del contatto: 

    Private Sub Button1_Click(sender As Object, e As RoutedEventArgs)
        Dim contactInstance = CType(FindResource("DemoContact"), Contact)
 
        MessageBox.Show(String.Concat(contactINstance.FirstName, " ", contactINstance.LastName))
    End Sub

Per capire come funziona il codice sopra esposto, lanciamo l'applicazione. Inseriamo dei valori e attendiamo tre secondi. Poi facciamo altre modifiche e clicchiamo sul pulsante prima che siano trascorsi i tre secondi specificati. Ci accorgeremo a questo punto che le modifiche fatte non sono state ancora invitate all'oggetto collegato, a causa del delay binding. Trascorso l'intervallo specificato, invece, le modifiche saranno inviate all'oggetto.

Un utilizzo di questo tipo di binding può riguardare oggetti che subiscono continue modifiche (es. testo) e che quindi non necessitano di un update finchè la modifica non si è conclusa.

Alessandro

Print | posted on venerdì 10 febbraio 2012 00:03 | Filed Under [ Windows Presentation Foundation ]

Powered by:
Powered By Subtext Powered By ASP.NET