Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale.
Traduzione
Originale

Cenni preliminari sull'associazione dati

L'associazione dati Windows Presentation Foundation (WPF) rappresenta per le applicazioni un modo semplice e coerente di presentare e interagire con i dati. È possibile associare gli elementi a numerose origini dati sotto forma di oggetti common language runtime (CLR) e XML. Gli oggetti ContentControlcome ad esempio Button e ItemsControl come ad esempio ListBox e ListView possiedono funzionalità incorporate che consentono un'applicazione di stili flessibile a singoli elementi di dati o a insiemi di elementi di dati. In cima ai dati è possibile generare visualizzazioni di ordinamento, filtraggio e raggruppamento.

La funzionalità dell'associazione dati in WPF presenta molti vantaggi rispetto ai modelli tradizionali, tra cui un'ampia gamma di proprietà che supportano implicitamente l'associazione dati, una rappresentazione dei dati mediante UI flessibile e una netta separazione tra regola business e UI.

In questo argomento vengono innanzitutto trattati i concetti fondamentali dell'associazione dati WPF, per poi analizzare l'utilizzo della classe Binding e altre funzionalità dell'associazione dati.

Nel presente argomento sono contenute le seguenti sezioni.

L'associazione dati è il processo mediante il quale viene stabilita una connessione tra l'UI dell'applicazione e la regola business. Se le impostazioni dell'associazione sono corrette e i dati forniscono le notifiche appropriate, quando il valore dei dati viene modificato, gli elementi associati ai dati riflettono automaticamente le modifiche apportate. Associazione dati significa anche che, se una rappresentazione esterna dei dati in un elemento viene modificata, i dati sottostanti possono essere automaticamente aggiornati per riflettere la modifica. Ad esempio, se l'utente modifica il valore in un elemento TextBox, il valore dei dati sottostanti viene automaticamente aggiornato per riflettere tale modifica.

Un utilizzo tipico dell'associazione dati consiste nell'inserimento dei dati di configurazione locali o del server in moduli o in altri controlli dell'UI. In WPF questo concetto viene ampliato per includere l'associazione di una vasta gamma di proprietà a varie origini dati. In WPF le proprietà di dipendenza degli elementi possono essere associate a oggetti CLR, inclusi oggetti ADO.NET o oggetti associati a servizi Web e proprietà Web, e a dati XML.

Per un esempio di associazione dati, osservare l'UI dell'applicazione seguente disponibile in Demo di associazione dati (la pagina potrebbe essere in inglese):

Schermata dell'esempio Data Binding

Si tratta dell'UI di un'applicazione in cui viene visualizzato un elenco di articoli venduti all'asta. Nell'applicazione vengono illustrate le seguenti funzionalità dell'associazione dati:

  • Il contenuto di ListBox è associato a un insieme di oggetti AuctionItem. Un oggetto AuctionItem possiede diverse proprietà, tra cui Description, StartPrice, StartDate, Category, SpecialFeatures e così via.

  • I dati, ossia gli oggetti AuctionItem, visualizzati in ListBox sono basati su modelli, per cui per ogni articolo vengono visualizzati la descrizione e il prezzo corrente. A tal proposito viene utilizzato DataTemplate. In aggiunta, l'aspetto di ogni articolo dipende dal valore di SpecialFeatures dell'oggetto AuctionItem visualizzato. Se il valore di SpecialFeatures in AuctionItem è Color, l'articolo avrà un bordo blu. Se il valore è Highlight, l'articolo avrà un bordo arancione e una stella. Nella sezione Modelli di dati vengono fornite informazioni sull'applicazione dei modelli di dati.

  • L'utente può raggruppare, filtrare o ordinare i dati utilizzando gli oggetti CheckBox forniti. Nella precedente immagine sono stati selezionati gli oggetti CheckBox "Group by category" e "Sort by category and date". I dati sono raggruppati in base alla categoria del prodotto e i nomi delle categorie sono riportati in ordine alfabetico. Benché non risulti evidente dall'immagine, gli elementi sono anche ordinati in base alla data di inizio all'interno di ogni categoria. A tal proposito viene utilizzata una visualizzazione di insieme. Nella sezione Associazione agli insiemi vengono trattate le visualizzazioni di insieme.

  • Quando l'utente seleziona un articolo, ContentControl visualizza i dettagli dell'articolo selezionato. Si parla in tal caso di scenario Master-Details. Nella sezione Scenario Master-Details vengono fornite informazioni su questo tipo di scenario di associazione.

  • Il tipo della proprietà StartDate è DateTime, il quale restituisce una data che include l'ora fino al millisecondo. In questa applicazione è stato utilizzato un convertitore personalizzato in modo tale da visualizzare una stringa della data più corta. Nella sezione Conversione dei dati vengono fornite informazioni sui convertitori.

Quando l'utente fa clic sul pulsante Add Product, viene visualizzato il seguente modulo:

Pagina Add Product Listing

L'utente può modificare i campi nel modulo, visualizzare in anteprima il prodotto utilizzando i riquadri di anteprima breve e anteprima dettagliata, quindi fare clic su submit per aggiungere il nuovo prodotto. Le funzionalità di raggruppamento, filtraggio e ordinamento esistenti verranno applicate alla nuova voce. In questo caso particolare, l'articolo immesso nell'immagine precedente verrà visualizzato come secondo articolo della categoria Computer.

Nell'immagine non viene illustrata la logica di convalida fornita nell'oggetto TextBox Start Date. Immettendo una data non valida, ovvero una data con formato non valido o una data appartenente al passato, l'utente riceverà una notifica mediante ToolTip e un punto esclamativo rosso verrà visualizzato accanto a TextBox. Nella sezione Convalida dei dati viene illustrato come creare la logica di convalida.

Prima di illustrare le diverse funzionalità dell'associazione dati delineate finora, nella sezione che segue verranno trattati i concetti fondamentali necessari a comprendere l'associazione dati WPF.

Nella presente sezione sono contenute le seguenti sottosezioni.

Indipendentemente dall'elemento associato e dalla natura dell'origine dati, ogni associazione segue sempre il modello illustrato nella figura seguente:

Diagramma di associazione dati di base

Come illustrato nella figura, l'associazione dati funge essenzialmente da ponte tra la destinazione dell'associazione e l'origine dell'associazione. Nella figura vengono illustrati i seguenti concetti fondamentali relativi all'associazione dati WPF:

  • In genere, ogni associazione possiede questi quattro componenti: un oggetto destinazione dell'associazione, una proprietà di destinazione, un'origine dell'associazione e un percorso del valore nell'origine dell'associazione da utilizzare. Se ad esempio si desidera associare il contenuto di un oggetto TextBox alla proprietà Name di un oggetto Employee, l'oggetto destinazione è TextBox, la proprietà di destinazione è Text, il valore da utilizzare è Name e l'oggetto origine è Employee.

  • La proprietà di destinazione deve essere una proprietà di dipendenza. Gran parte delle proprietà degli oggetti UIElement sono proprietà di dipendenza e gran parte delle proprietà di dipendenza, ad eccezione di quelle di sola lettura, supportano l'associazione dati per impostazione predefinita. Solo i tipi DependencyObject possono definire le proprietà di dipendenza e tutti gli oggetti UIElement derivano da DependencyObject.

  • Anche se non specificato nella figura, notare che l'oggetto origine di associazione non è necessariamente costituito da un oggetto CLR personalizzato. L'associazione dati WPF supporta dati nel formato oggetti CLR e XML. Per fornire alcuni esempi, l'origine dell'associazione può essere un oggetto UIElement, qualsiasi oggetto elenco, un oggetto CLR associato a dati ADO.NET o a servizi Web o un XmlNode contenente i dati XML desiderati. Per ulteriori informazioni, vedere Cenni preliminari sulle origini di associazione.

Come detto in altri argomenti concernenti software development kit (SDK), è importante ricordare che quando si stabilisce un'associazione, si associa una destinazione dell'associazione a un'origine dell'associazione. Ad esempio, nel caso in cui vengano visualizzati dati XML sottostanti in un oggetto ListBox mediante associazione dati, si associa ListBox ai dati XML.

Per stabilire un'associazione si utilizza l'oggetto Binding. Nella parte restante di questo argomento vengono illustrati molti dei concetti associati a Binding, nonché alcune proprietà e modalità di utilizzo dell'oggetto.

Direzione del flusso di dati

Come accennato in precedenza e come si evince dalla freccia nella figura precedente, il flusso di dati di un'associazione può andare dalla destinazione dell'associazione all'origine dell'associazione (ad esempio, il valore di origine viene modificato quando un utente modifica il valore di un oggetto TextBox) e/o dall'origine dell'associazione alla destinazione dell'associazione (ad esempio, il contenuto di TextBox viene aggiornato in seguito alle modifiche apportate nell'origine dell'associazione) se l'origine dell'associazione fornisce le notifiche appropriate.

È possibile fare in modo che l'applicazione consenta agli utenti di modificare i dati e propagarli all'oggetto origine. Oppure è possibile fare in modo che gli utenti non aggiornino i dati di origine. A tal proposito occorre impostare la proprietà Mode dell'oggetto Binding. Nella figura che segue vengono illustrati i diversi tipi di flusso di dati:

Flusso di dati dell'associazione dati
  • L'associazione OneWay fa sì che le modifiche apportate alla proprietà di origine comportino un aggiornamento automatico della proprietà di destinazione. Tuttavia, le modifiche apportate alla proprietà di destinazione non vengono propagate alla proprietà di origine. Questo tipo di associazione è adatto nel caso in cui il controllo associato sia implicitamente di sola lettura. Può accadere ad esempio che si effettui un'associazione a un'origine quale un controllo Stock Ticker oppure che la proprietà di destinazione non possieda un'interfaccia di controllo tramite la quale apportare modifiche, come nel caso di un colore di sfondo con associazione a dati di una tabella. Se non vi è alcuna necessità di controllare le modifiche della proprietà di destinazione, è consigliabile utilizzare la modalità di associazione OneWay, in quanto l'associazione TwoWay implicherebbe operazioni inutili.

  • L'associazione TwoWay fa sì che le modifiche apportate alla proprietà di origine o alla proprietà di destinazione comportino un aggiornamento automatico dell'altra proprietà. Questo tipo di associazione è adatto ai moduli modificabili o ad altri scenari di UI completamente interattiva. La maggior parte delle proprietà utilizza per impostazione predefinita l'associazione OneWay. Tuttavia, alcune proprietà di dipendenza, in genere proprietà di controlli modificabili dall'utente quali ad esempio la proprietà Text di TextBox e la proprietà IsChecked di CheckBox, utilizzano per impostazione predefinita l'associazione TwoWay. Per stabilire a livello di codice se, per impostazione predefinita, una proprietà di dipendenza utilizza l'associazione unidirezionale o bidirezionale, è possibile ottenere i metadati della proprietà utilizzando GetMetadata, quindi controllare il valore booleano della proprietà BindsTwoWayByDefault.

  • OneWayToSource è la modalità di associazione inversa rispetto a OneWay. Con questa modalità, la proprietà di origine viene aggiornata in seguito a una modifica della proprietà di destinazione. Può essere utilizzata, ad esempio, nel caso in cui si debba semplicemente rivalutare il valore di origine dall'UI.

  • Un altro tipo di associazione non illustrato nella figura è l'associazione OneTime, la quale fa sì che la proprietà di origine inizializzi la proprietà di destinazione ma non prevede la propagazione delle successive modifiche. Ciò significa che se il contesto dati subisce una modifica o l'oggetto nel contesto dati viene modificato, la modifica non si riflette nella proprietà di destinazione. Questo tipo di associazione è adatto nel caso in cui i dati utilizzati siano effettivamente statici oppure richiedano l'utilizzo di uno snapshot dello stato corrente. È utile anche nel caso in cui si desideri inizializzare la proprietà di destinazione con un valore derivante da una proprietà di origine senza conoscere in anticipo il contesto dati. Si tratta essenzialmente di una forma più semplice di associazione OneWay, in grado di garantire prestazioni migliori nei casi in cui il valore di origine non viene modificato.

Per rilevare le modifiche apportate all'origine, nel caso delle associazioni OneWay e TwoWay, l'origine deve implementare un meccanismo appropriato di notifica delle modifiche alle proprietà, quale ad esempio INotifyPropertyChanged. Per un esempio di implementazione di INotifyPropertyChanged, vedere Procedura: implementare notifiche di modifiche alle proprietà.

La pagina delle proprietà Mode fornisce ulteriori informazioni sulle modalità di associazione e un esempio in cui viene illustrato come specificare la direzione di un'associazione.

Eventi che generano gli aggiornamenti dell'origine

Le associazioni di tipo TwoWay o OneWayToSource attendono le modifiche apportate alla proprietà di destinazione e le propagano all'origine. Questo processo è noto come aggiornamento dell'origine. Può accadere ad esempio che si modifichi il testo di un oggetto TextBox per modificare il valore di origine sottostante. Come descritto nella sezione precedente, la direzione del flusso di dati è determinata dal valore della proprietà Mode dell'associazione.

Ma il valore di origine viene aggiornato durante la modifica del testo o una volta terminata la modifica, quando si sposta il puntatore del mouse da TextBox? La proprietà UpdateSourceTrigger dell'associazione determina l'evento che genera l'aggiornamento dell'origine. Nella figura che segue, i puntini delle frecce rivolte verso destra illustrano il ruolo della proprietà UpdateSourceTrigger:

Diagramma UpdateSourceTrigger

Se il valore di UpdateSourceTrigger è PropertyChanged, il valore indicato dalla freccia a destra dell'associazione TwoWay o OneWayToSource viene aggiornato non appena si modifica la proprietà di destinazione. Se invece il valore di UpdateSourceTrigger è LostFocus, il valore indicato dalla freccia viene aggiornato con il nuovo valore soltanto quando la proprietà di destinazione perde lo stato attivo.

Analogamente alla proprietà Mode, diverse proprietà di dipendenza possiedono valori di UpdateSourceTrigger predefiniti diversi. Il valore predefinito per la maggior parte delle proprietà di dipendenza è PropertyChanged, mentre il valore predefinito per la proprietà Text è LostFocus. Ciò significa che gli aggiornamenti dell'origine avvengono in genere quando si modifica la proprietà di destinazione. Questo comportamento è appropriato nel caso di oggetti CheckBox e di altri controlli semplici. Nel caso dei campi di testo, tuttavia, l'esecuzione di un aggiornamento a ogni pressione di tasto può comportare un calo di prestazioni nonché negare all'utente la possibilità di tornare indietro e correggere eventuali errori di digitazione prima di confermare il nuovo valore. Per questo motivo il valore predefinito della proprietà Text è LostFocus anziché PropertyChanged.

Vedere la pagina delle proprietà UpdateSourceTrigger per informazioni su come individuare il valore di UpdateSourceTrigger predefinito di una proprietà di dipendenza.

Nella tabella che segue viene fornito uno scenario esemplificativo per ogni valore di UpdateSourceTrigger utilizzando TextBox come esempio:

Valore UpdateSourceTrigger

Aggiornamento del valore di origine

Scenario di esempio per TextBox

LostFocus (impostazione predefinita per TextBox.Text)

Quando il controllo TextBox perde lo stato attivo

Un oggetto TextBox associato alla logica di convalida (vedere la sezione Convalida dei dati)

PropertyChanged

Durante la digitazione in TextBox

Controlli TextBox nella finestra di una chat

Explicit

Quando l'applicazione chiama UpdateSource

Controlli TextBox in un modulo modificabile (aggiorna i valori di origine solo quando l'utente fa clic sul pulsante di invio)

Per un esempio, vedere Procedura: controllare il momento in cui il database di origine viene aggiornato dal testo di TextBox.

Nella presente sezione sono contenute le seguenti sottosezioni.

Per riepilogare alcuni dei concetti illustrati nelle sezioni precedenti, un'associazione viene stabilita utilizzando l'oggetto Binding e ogni associazione è costituita in genere da quattro componenti: la destinazione dell'associazione, la proprietà di destinazione, l'origine dell'associazione e un percorso del valore di origine da utilizzare. In questa sezione viene illustrato come impostare un'associazione.

Si consideri il seguente esempio, nel quale l'oggetto origine dell'associazione è una classe denominata MyData definita nello spazio dei nomi SDKSample. A scopo dimostrativo, la classe MyData possiede una proprietà stringa denominata ColorName il cui valore è impostato su "Red". In questo esempio viene quindi generato un pulsante con uno sfondo rosso.


<DockPanel
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:c="clr-namespace:SDKSample">
  <DockPanel.Resources>
    <c:MyData x:Key="myDataSource"/>
  </DockPanel.Resources>
  <DockPanel.DataContext>
    <Binding Source="{StaticResource myDataSource}"/>
  </DockPanel.DataContext>
  <Button Background="{Binding Path=ColorName}"
          Width="150" Height="30">I am bound to be RED!</Button>
</DockPanel>


Per maggiori dettagli sulla sintassi della dichiarazione di associazione e alcuni esempi di impostazione di un'associazione nel codice, vedere Cenni preliminari sulle dichiarazioni di associazione.

Applicando questo esempio allo schema di base, risulterà una figura analoga alla seguente. Si tratta di un'associazione OneWay in quanto, per impostazione predefinita, la proprietà Background supporta questo tipo di associazione.

Diagramma di associazione dati

Ci si potrebbe chiedere come sia possibile tale associazione, dal momento che la proprietà ColorName è di tipo stringa mentre la proprietà Background è di tipo Brush. In questo caso viene utilizzata la conversione di tipi predefinita, illustrata nella sezione Conversione dei dati.

Specificazione dell'origine dell'associazione

Nell'esempio precedente, l'origine dell'associazione viene specificata impostando la proprietà DataContext nell'elemento DockPanel. Button eredita quindi il valore di DataContext da DockPanel, il quale costituisce l'elemento padre. Come già detto, l'oggetto origine dell'associazione è uno dei quattro componenti necessari di un'associazione. Di conseguenza, se non si specifica l'oggetto origine dell'associazione, questa non viene creata.

Esistono diversi modi per specificare l'oggetto origine dell'associazione. L'utilizzo della proprietà DataContext in un elemento padre è utile in caso di associazione di più proprietà alla stessa origine. In alcuni casi, tuttavia, è preferibile specificare l'origine dell'associazione in singole dichiarazioni di associazione. Nel caso dell'esempio precedente, anziché utilizzare la proprietà DataContext, è possibile specificare l'origine dell'associazione impostando la proprietà Source direttamente nella dichiarazione di associazione del pulsante, come avviene nell'esempio che segue:


<DockPanel.Resources>
  <c:MyData x:Key="myDataSource"/>
</DockPanel.Resources>
<Button Width="150" Height="30"
        Background="{Binding Source={StaticResource myDataSource},
                             Path=ColorName}">I am bound to be RED!</Button>


Oltre a impostare la proprietà DataContext direttamente in un elemento, ereditare il valore di DataContext da un predecessore (si veda il pulsante nel primo esempio) e specificare in modo esplicito l'origine dell'associazione impostando la proprietà Source in Binding (si veda il pulsante nell'ultimo esempio), è anche possibile utilizzare la proprietà ElementName o la proprietà RelativeSource per specificare l'origine dell'associazione. La proprietà ElementName è utile in caso di associazione ad altri elementi nell'applicazione, ad esempio in caso di utilizzo di un dispositivo di scorrimento per regolare la larghezza di un pulsante. La proprietà RelativeSource è utile nel caso di un'associazione specificata in un oggetto ControlTemplate o Style. Per ulteriori informazioni, vedere Procedura: specificare l'origine di associazione.

Specificazione del percorso del valore

Se l'origine dell'associazione è un oggetto, si utilizza la proprietà Path per specificare il valore da utilizzare per l'associazione. In caso di associazione a dati XML, utilizzare la proprietà XPath per specificare il valore. In alcuni casi è possibile utilizzare la proprietà Path anche se i dati sono in formato XML. Ad esempio, per accedere alla proprietà Name di un XmlNode restituito in seguito a una query XPath, è necessario utilizzare la proprietà Path oltre alla proprietà XPath.

Per informazioni sulla sintassi e alcuni esempi, vedere le pagine delle proprietà Path e XPath.

Benché sia stato sottolineato che la proprietà Path del valore da utilizzare è uno dei quattro componenti necessari di un'associazione, negli scenari di associazione a un intero oggetto il valore da utilizzare corrisponde all'oggetto origine dell'associazione. In tali casi è possibile non specificare Path. Si consideri l'esempio seguente:


<ListBox ItemsSource="{Binding}"
         IsSynchronizedWithCurrentItem="true"/>


Nell'esempio viene utilizzata la sintassi di associazione vuota: {Binding}. In questo caso, ListBox eredita DataContext da un elemento DockPanel padre, assente nell'esempio. Quando il percorso non viene specificato, per impostazione predefinita si esegue un'associazione all'intero oggetto. In altre parole, in questo esempio il percorso è stato tralasciato poiché la proprietà ItemsSource viene associata all'intero oggetto. Per informazioni più dettagliate, vedere la sezione Associazione agli insiemi.

Diversamente dall'associazione a un insieme, questo scenario è utile anche in caso di associazione a un intero oggetto anziché a un'unica proprietà di un oggetto. Si consideri ad esempio un oggetto origine di tipo stringa con un'associazione alla stringa stessa. Un altro scenario comune riguarda l'associazione di un elemento a un oggetto con diverse proprietà.

Alcuni scenari richiedono l'applicazione di una logica personalizzata affinché i dati siano significativi per la proprietà di destinazione associata. Tale logica potrebbe essere un convertitore personalizzato, in assenza della conversione di tipi predefinita. Per informazioni sui convertitori, vedere Conversione dei dati.

Binding e BindingExpression

Prima di analizzare altre funzionalità e modalità di utilizzo dell'associazione dati, è opportuno introdurre la classe BindingExpression. Come si è visto nelle sezioni precedenti, la classe Binding è la classe di alto livello per la dichiarazione di un'associazione e fornisce diverse proprietà che consentono di specificare le caratteristiche dell'associazione. Una classe correlata, BindingExpression, è l'oggetto sottostante che gestisce la connessione tra origine e destinazione. Un'associazione contiene tutte le informazioni condivisibili tra diverse espressioni di associazione. BindingExpression è un'espressione di istanza non condivisibile e contiene tutte le informazioni sull'istanza di Binding.

Si consideri l'esempio che segue, nel quale myDataObject è un'istanza della classe MyData, myBinding è l'oggetto Binding di origine e la classe MyData è una classe definita contenente una proprietà stringa denominata MyDataProperty. Nell'esempio viene associato il contenuto di testo di mytext, un'istanza di TextBlock, a MyDataProperty.


//make a new source
  MyData myDataObject = new MyData(DateTime.Now);      
  Binding myBinding = new Binding("MyDataProperty");
  myBinding.Source = myDataObject;
  myText.SetBinding(TextBlock.TextProperty, myBinding);


È possibile utilizzare lo stesso oggetto myBinding per creare altre associazioni. Ad esempio, è possibile utilizzare l'oggetto myBinding per associare il contenuto di testo di una casella di controllo a MyDataProperty. In un simile scenario si avranno due istanze di BindingExpression che condividono l'oggetto myBinding.

Un oggetto BindingExpression può essere ottenuto tramite il valore restituito di una chiamata a GetBindingExpression in un oggetto con associazione a dati. Negli argomenti che seguono vengono illustrate alcune modalità di utilizzo della classe BindingExpression:

Nell'esempio precedente, il pulsante è rosso perché la proprietà Background è associata a una proprietà stringa con valore "Red". Questa associazione funziona grazie alla presenza di un convertitore di tipi nel tipo Brush, il quale converte il valore stringa in un oggetto Brush.

Aggiungendo queste informazioni alla figura della sezione Creazione di un'associazione, si otterrà uno schema analogo al seguente:

Diagramma di associazione dati

Cosa accade però se, anziché avere una proprietà di tipo stringa, l'oggetto origine dell'associazione possiede una proprietà Color di tipo Color? In tal caso, per fare in modo che l'associazione funzioni, occorre innanzitutto convertire il valore della proprietà Color in un valore accettabile dalla proprietà Background. Occorre quindi creare un convertitore personalizzato implementando l'interfaccia IValueConverter, come avviene nell'esempio seguente:


[ValueConversion(typeof(Color), typeof(SolidColorBrush))]
public class ColorBrushConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        Color color = (Color)value;
        return new SolidColorBrush(color);
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return null;
    }
}


Nella pagina di riferimento relativa a IValueConverter vengono fornite ulteriori informazioni.

Ora il convertitore personalizzato viene utilizzato al posto della conversione predefinita e lo schema appare come segue:

Diagramma di associazione dati

Come già detto, le conversioni predefinite possono essere disponibili o meno a seconda dei convertitori presenti nel tipo a cui si esegue l'associazione. Questo comportamento dipenderà dai convertitori di tipi disponibili nella destinazione. In caso di dubbio, creare un convertitore personalizzato.

Di seguito vengono riportati alcuni scenari tipici in cui può essere opportuno implementare un convertitore di dati:

  • I dati devono essere visualizzati in modo diverso, a seconda delle impostazioni cultura. Ad esempio, è possibile implementare un convertitore di valuta o un convertitore di data/ora nel calendario in base ai valori o agli standard utilizzati in particolari impostazioni cultura.

  • I dati utilizzati non devono necessariamente modificare il valore di testo di una proprietà quanto piuttosto altri valori, ad esempio l'origine di un'immagine oppure il colore o lo stile del testo visualizzato. I convertitori possono essere utilizzati in questo caso per convertire l'associazione di una proprietà considerata poco appropriata, ad esempio l'associazione di un campo di testo alla proprietà Background della cella di una tabella.

  • Più controlli o più proprietà dei controlli sono associati agli stessi dati. In questo caso, l'associazione primaria potrebbe semplicemente visualizzare il testo, mentre le altre associazioni gestiscono problemi di visualizzazione specifici, utilizzando comunque la stessa associazione come informazione di origine.

  • Finora non è stato ancora illustrato MultiBinding, ovvero il caso di una proprietà di destinazione con un insieme di associazioni. Nel caso di MultiBinding si utilizza un oggetto IMultiValueConverter personalizzato per produrre un valore finale partendo dai valori delle associazioni. È possibile ad esempio calcolare il colore dai valori rosso, blu e verde, ovvero valori che possono provenire da oggetti origine dell'associazione identici o differenti. Per esempi e informazioni, vedere la pagina relativa alla classe MultiBinding.

Nella presente sezione sono contenute le seguenti sottosezioni.

Un oggetto origine dell'associazione può essere considerato come un unico oggetto le cui proprietà contengono dati oppure come un insieme di dati di oggetti polimorfici che spesso vengono raggruppati. Un esempio può essere il risultato di una query in un database. Finora è stata illustrata soltanto l'associazione a singoli oggetti, tuttavia l'associazione a un insieme di dati è uno scenario comune. È possibile ad esempio utilizzare un oggetto ItemsControl quale ListBox, ListView o TreeView per visualizzare una raccolta dati, come avviene nell'applicazione illustrata nella sezione Definizione di associazione dati

Anche in questo caso è possibile applicare lo schema di base. In caso di associazione di un oggetto ItemsControl a un insieme, lo schema appare come segue:

Diagramma ItemsControl di associazione dati

Come illustrato in questo schema, l'associazione di ItemsControl a un oggetto insieme richiede l'utilizzo della proprietà ItemsSource. La proprietà ItemsSource può essere considerata il contenuto di ItemsControl. L'associazione dell'esempio è di tipo OneWay, essendo questo il tipo supportato per impostazione predefinita dalla proprietà ItemsSource.

Procedura per l'implementazione degli insiemi

È possibile enumerare in qualsiasi raccolta che implementa l'interfaccia IEnumerable. Tuttavia, per impostare associazioni dinamiche che consentono, all'inserimento o cancellazione o aggiornamento di elementi nella raccolta, l'aggiornamento automatico della UI, la raccolta deve implementare l'interfaccia INotifyCollectionChanged. Questa interfaccia espone un evento che deve essere generato a ogni modifica dell'insieme sottostante.

In WPF viene fornita la classe ObservableCollection<T>, un'implementazione incorporata di un insieme di dati che espone l'interfaccia INotifyCollectionChanged. Per supportare pienamente il trasferimento dei valori dei dati dagli oggetti origine alle destinazioni, ogni oggetto nell'insieme che supporta proprietà associabili deve implementare anche l'interfaccia INotifyPropertyChanged. Per ulteriori informazioni, vedere Cenni preliminari sulle origini di associazione.

Prima di implementare un insieme personalizzato, considerare la possibilità di utilizzare ObservableCollection<T> o una delle classi di insiemi esistenti, ad esempio List<T>, Collection<T> e BindingList<T>. Se si desidera implementare un insieme personalizzato in uno scenario avanzato, è opportuno utilizzare IList, il quale fornisce un insieme non generico di oggetti accessibili singolarmente tramite indice e garantisce prestazioni ottimali.

Visualizzazioni di insiemi

Una volta associato ItemsControl a un insieme di dati, è possibile ordinare, filtrare o raggruppare tali dati. A tale scopo si utilizzano le visualizzazioni di insiemi, ovvero classi che implementano l'interfaccia ICollectionView.

Nella presente sezione sono contenute le seguenti sottosezioni.

Definizione di visualizzazione di insieme

Una visualizzazione di insieme rappresenta il livello superiore di un insieme di origine di associazione che consente di spostarsi e visualizzare l'insieme di origine in base a query di ordinamento, filtro e raggruppamento, il tutto senza modificare l'insieme di origine sottostante. Una visualizzazione di insieme mantiene inoltre un puntatore all'elemento corrente nell'insieme. Se l'insieme di origine implementa l'interfaccia INotifyCollectionChanged, le modifiche generate dall'evento CollectionChanged vengono propagate alle visualizzazioni.

Poiché le visualizzazioni non modificano gli insiemi di origine sottostanti, ogni insieme di origine può disporre di più visualizzazioni associate. Si consideri ad esempio un insieme di oggetti Task. Grazie alle visualizzazioni è possibile visualizzare gli stessi dati in modi diversi. Ad esempio, è possibile visualizzare le attività ordinate in base alla priorità nella parte sinistra della pagina e, contemporaneamente nella parte destra, le stesse attività raggruppate in base all'area.

Procedura per la creazione di una visualizzazione

Per creare e utilizzare una visualizzazione, è possibile creare direttamente un'istanza dell'oggetto visualizzazione e utilizzare tale istanza come origine dell'associazione. Ad esempio, considerare l'applicazione Demo di associazione dati illustrata nella sezione Definizione di associazione dati. L'applicazione viene implementata in modo tale che ListBox venga associato a una visualizzazione dell'insieme di dati anziché direttamente all'insieme in questione. L'esempio seguente è stato estratto dall'applicazione Demo di associazione dati (la pagina potrebbe essere in inglese). La classe CollectionViewSource è il proxy Extensible Application Markup Language (XAML) di una classe che eredita da CollectionView. In questo particolare esempio, l'oggetto Source della visualizzazione è associato all'insieme AuctionItems, di tipo ObservableCollection<T>, dell'oggetto applicazione corrente.


<Window.Resources>


...


<CollectionViewSource 
      Source="{Binding Source={x:Static Application.Current}, Path=AuctionItems}"   
      x:Key="listingDataView" />


...


</Window.Resources>


La risorsa listingDataView funge quindi da origine dell'associazione per gli elementi nell'applicazione, quale ad esempio ListBox:


<ListBox Name="Master" Grid.Row="2" Grid.ColumnSpan="3" Margin="8"
    ItemsSource="{Binding Source={StaticResource listingDataView}}">


...


</ListBox>


Per creare un'altra visualizzazione per lo stesso insieme, è possibile creare una nuova istanza di CollectionViewSource e attribuirle un nome x:Key diverso.

Nella tabella seguente vengono illustrati i tipi di dati della visualizzazione creati come visualizzazione di insieme predefinita o in base a CollectionViewSource a seconda del tipo di insieme di origine.

Tipo di insieme di origine

Tipo di visualizzazione di insieme

Note

IEnumerable

Tipo interno basato su CollectionView

Impossibile raggruppare gli elementi.

IList

ListCollectionView

Più veloce.

IBindingList

BindingListCollectionView

Utilizzo di una visualizzazione predefinita

Specificare una visualizzazione di insieme come origine di associazione rappresenta un modo per creare e utilizzare una visualizzazione di insieme. WPF crea inoltre una visualizzazione di insieme predefinita per ogni insieme utilizzato come origine di associazione. Se si esegue l'associazione direttamente a un insieme, WPF esegue l'associazione alla relativa visualizzazione predefinita. Questa visualizzazione predefinita è condivisa da tutte le associazioni allo stesso insieme, pertanto una modifica apportata a una visualizzazione predefinita da un controllo associato o dal codice, ad esempio l'ordinamento o una modifica al puntatore dell'elemento corrente illustrati più avanti, viene riflessa in tutte le altre associazioni allo stesso insieme.

Per ottenere la visualizzazione predefinita, utilizzare il metodo GetDefaultView. Per un esempio, vedere Procedura: ottenere la visualizzazione predefinita di una raccolta dati.

Visualizzazioni di insieme con ADO.NET DataTable

Per migliorare le prestazioni, le visualizzazioni di insieme per gli oggetti ADO.NET DataTable o DataView delegano l'ordinamento e il filtraggio all'oggetto DataView. In tal modo, l'ordinamento e il filtraggio vengono condivisi in tutte le visualizzazioni di insieme dell'origine dati. Per consentire a ogni visualizzazione di insieme di ordinare e filtrare in modo indipendente, inizializzare ogni visualizzazione di insieme con il relativo oggetto DataView personalizzato.

Ordinamento

Come detto in precedenza, le visualizzazioni possono applicare un ordinamento a un insieme. I dati presenti nell'insieme sottostante possono avere o non avere un ordine intrinseco. La visualizzazione dell'insieme consente di imporre un ordine o di modificare l'ordine predefinito in base a criteri di confronto forniti dall'utente. Trattandosi di una visualizzazione dei dati basata su client, uno scenario comune prevede che l'utente possa ordinare le colonne di dati tabulari in base al valore al quale corrisponde la colonna. Grazie alle visualizzazioni, è possibile applicare questo ordinamento gestito dall'utente senza apportare alcuna modifica all'insieme sottostante né ripetere la query per il contenuto dell'insieme. Per un esempio, vedere Procedura: ordinare una colonna GridView quando si fa clic su un'intestazione.

Nell'esempio seguente viene illustrata la logica di ordinamento dell'oggetto CheckBox "Sort by category and date" dell'UI dell'applicazione inclusa nella sezione Definizione di associazione dati:


private void AddSorting(object sender, RoutedEventArgs args)
{
    // This sorts the items first by Category and within each Category,
    // by StartDate. Notice that because Category is an enumeration,
    // the order of the items is the same as in the enumeration declaration
    listingDataView.SortDescriptions.Add(
        new SortDescription("Category", ListSortDirection.Ascending));
    listingDataView.SortDescriptions.Add(
        new SortDescription("StartDate", ListSortDirection.Ascending));
}


Filtraggio

Le visualizzazioni possono anche applicare un filtro a un insieme. In altre parole, anche se un insieme può includere un elemento, una particolare visualizzazione è progettata per visualizzare solo un determinato sottoinsieme di un insieme completo. I dati possono essere filtrati in base a una condizione. Ad esempio, come accade per l'applicazione nella sezione Definizione di associazione dati, l'oggetto CheckBox "Show only bargains" contiene una logica che prevede l'esclusione degli articoli con un costo pari o superiore a $ 25. Il codice seguente viene eseguito per impostare ShowOnlyBargainsFilter come gestore dell'evento Filter quando si seleziona l'oggetto CheckBox in questione:


listingDataView.Filter += new FilterEventHandler(ShowOnlyBargainsFilter);


L'implementazione del gestore eventi ShowOnlyBargainsFilter è la seguente:


private void ShowOnlyBargainsFilter(object sender, FilterEventArgs e)
{
    AuctionItem product = e.Item as AuctionItem;
    if (product != null)
    {
        // Filter out products with price 25 or above
        if (product.CurrentPrice < 25)
        {
            e.Accepted = true;
        }
        else
        {
            e.Accepted = false;
        }
    }
}


Se si utilizza direttamente una delle classi CollectionView anziché CollectionViewSource, occorre utilizzare la proprietà Filter per specificare un callback. Per un esempio, vedere Procedura: filtrare i dati in una visualizzazione.

Raggruppamento

A eccezione della classe interna che visualizza un insieme IEnumerable, tutte le visualizzazioni di insieme supportano la funzionalità di raggruppamento, che consente all'utente di suddividere l'insieme contenuto in una data visualizzazione in gruppi logici. Se l'utente fornisce un elenco di gruppi, questi saranno espliciti; se invece i gruppi vengono generati in modo dinamico in base ai dati, si avranno gruppi impliciti.

Nell'esempio che segue viene illustrata la logica dell'oggetto CheckBox "Group by category":


// This groups the items in the view by the property "Category"
PropertyGroupDescription groupDescription = new PropertyGroupDescription();
groupDescription.PropertyName = "Category";
listingDataView.GroupDescriptions.Add(groupDescription);


Per un altro esempio di raggruppamento, vedere Procedura: raggruppare gli elementi di un controllo ListView che implementa una GridView.

Puntatori dell'elemento corrente

Le visualizzazioni supportano anche la nozione di elemento corrente. In una visualizzazione di insieme è possibile spostarsi da un oggetto all'altro. Durante lo spostamento viene spostato un puntatore dell'elemento che consente di recuperare l'oggetto presente in un particolare percorso nell'insieme. Per un esempio, vedere Procedura: navigare tra gli oggetti nella visualizzazione di una raccolta dati.

Poiché WPF esegue l'associazione a un insieme solo tramite una visualizzazione, che può essere sia una visualizzazione specificata dall'utente che la visualizzazione predefinita dell'insieme, tutte le associazioni agli insiemi contengono un puntatore dell'elemento corrente. Quando si esegue l'associazione a una visualizzazione, il carattere barra ("/") in un valore Path definisce l'elemento corrente della visualizzazione. Nell'esempio seguente il contesto dati è una visualizzazione di insieme. La prima riga viene associata all'insieme. La seconda riga viene associata all'elemento corrente dell'insieme. La terza riga viene associata alla proprietà Description dell'elemento corrente nell'insieme.

<Button Content="{Binding }" />
<Button Content="{Binding Path=/}" />
<Button Content="{Binding Path=/Description}" /> 

La barra e la sintassi della proprietà possono inoltre essere sovrapposte per scorrere una gerarchia di insiemi. Nell'esempio seguente viene eseguita l'associazione all'elemento corrente di un insieme denominato Offices, che è una proprietà dell'elemento corrente dell'insieme di origine.

<Button Content="{Binding /Offices/}" />

Il puntatore dell'elemento corrente può essere influenzato da un'operazione di ordinamento o filtraggio applicata all'insieme. L'ordinamento mantiene il puntatore dell'elemento corrente sull'ultimo elemento selezionato, ma la visualizzazione di insieme viene ristrutturata in base a tale elemento. Se in precedenza l'elemento selezionato si trovava all'inizio dell'elenco, ora è possibile che si trovi in posizione centrale. Il filtraggio mantiene l'elemento selezionato se la selezione rimane nella visualizzazione dopo il filtraggio. In caso contrario, il puntatore dell'elemento corrente viene impostato sul primo elemento della visualizzazione di insieme filtrata.

Scenario di associazione Master-Details

La nozione di elemento corrente è utile non solo per lo spostamento sugli elementi in un insieme, bensì anche per lo scenario di associazione Master-Details. Si consideri nuovamente l'UI della sezione Definizione di associazione dati. In tale applicazione, la selezione all'interno di ListBox determina il contenuto visualizzato in ContentControl. In altre parole, quando si seleziona un elemento di ListBox, ContentControl visualizza i dettagli dell'elemento selezionato.

Per implementare lo scenario Master-Details, occorre semplicemente avere due o più controlli associati alla stessa visualizzazione. Nell'esempio seguente estratto da Demo di associazione dati viene illustrato il markup degli oggetti ListBox e ContentControl visualizzati nell'UI dell'applicazione illustrata nella sezione Definizione di associazione dati:


<ListBox Name="Master" Grid.Row="2" Grid.ColumnSpan="3" Margin="8"
    ItemsSource="{Binding Source={StaticResource listingDataView}}">


...


</ListBox>


...


<ContentControl Name="Detail" Grid.Row="3" Grid.ColumnSpan="3" 
        Content="{Binding Source={StaticResource listingDataView}}" 
        ContentTemplate="{StaticResource detailsProductListingTemplate}" 
        Margin="9,0,0,0"/>


Entrambi i controlli sono associati alla stessa origine, ovvero la risorsa statica listingDataView. Vedere in proposito la definizione di questa risorsa nella sezione Procedura per la creazione di una visualizzazione. Tutto ciò è possibile in quanto, associando un oggetto Singleton (ContentControl in questo caso) a una visualizzazione di insieme, tale oggetto viene automaticamente associato all'oggetto CurrentItem della visualizzazione. Gli oggetti CollectionViewSource sincronizzano automaticamente validità e selezione. Se l'elenco non è associato a un oggetto CollectionViewSource come avviene in questo esempio, sarà necessario impostare la proprietà IsSynchronizedWithCurrentItem su true per fare in modo che la procedura funzioni.

Per altri esempi, vedere Procedura: eseguire l'associazione di un insieme e visualizzare informazioni in base alla selezione effettuata e Procedura: utilizzare il modello Master-Details con dati gerarchici.

Come si può notare, nell'esempio precedente viene utilizzato un modello. I dati non verrebbero infatti visualizzati come desiderato senza l'utilizzo dei modelli, per la precisione quello utilizzato in modo esplicito da ContentControl e quello utilizzato in modo implicito da ListBox. Nella sezione che segue vengono illustrati i modelli di dati.

Senza l'utilizzo di modelli di dati, l'UI dell'applicazione illustrata nella sezione Definizione di associazione dati avrebbe un aspetto simile al seguente:

Data Binding Demo senza Data Templates

Come illustrato nell'esempio incluso nella sezione precedente, sia il controllo ListBox che ContentControl vengono associati all'intero oggetto Collection (o più specificatamente alla vista sull'oggetto Collection) di AuctionItem. Senza istruzioni specifiche per la visualizzazione dell'insieme di dati, l'oggetto ListBox determinerebbe la visualizzazione di una rappresentazione di stringa di ogni oggetto nell'insieme sottostante e l'oggetto ContentControl determinerebbe la visualizzazione di una rappresentazione di stringa dell'oggetto al quale è associato.

Per risolvere il problema, nell'applicazione vengono definiti oggetti DataTemplate. Come illustrato nell'esempio incluso nella sezione precedente, ContentControl utilizza in modo esplicito l'oggetto DataTemplatedetailsProductListingTemplate. Il controllo ListBox utilizza in modo implicito il seguente oggetto DataTemplate durante la visualizzazione degli oggetti AuctionItem nell'insieme:


<DataTemplate DataType="{x:Type src:AuctionItem}">
    <Border BorderThickness="1" BorderBrush="Gray"
            Padding="7" Name="border" Margin="3" Width="500">
        <Grid>
          <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition/>
            <RowDefinition/>
            <RowDefinition/>
          </Grid.RowDefinitions>
          <Grid.ColumnDefinitions>
            <ColumnDefinition Width="20"/>
            <ColumnDefinition Width="86"/>
            <ColumnDefinition Width="*"/>
          </Grid.ColumnDefinitions>

            <Polygon Grid.Row="0" Grid.Column="0" Grid.RowSpan="4"
                     Fill="Yellow" Stroke="Black" StrokeThickness="1"
                     StrokeLineJoin="Round" Width="20" Height="20"
                     Stretch="Fill"
                     Points="9,2 11,7 17,7 12,10 14,15 9,12 4,15 6,10 1,7 7,7"
                     Visibility="Hidden" Name="star"/>

            <TextBlock Grid.Row="0" Grid.Column="1" Margin="0,0,8,0"
                       Name="descriptionTitle"
                       Style="{StaticResource smallTitleStyle}">Description:</TextBlock>
            <TextBlock Name="DescriptionDTDataType" Grid.Row="0" Grid.Column="2" 
                Text="{Binding Path=Description}" 
                Style="{StaticResource textStyleTextBlock}"/>

            <TextBlock Grid.Row="1" Grid.Column="1" Margin="0,0,8,0"
                       Name="currentPriceTitle"
                       Style="{StaticResource smallTitleStyle}">Current Price:</TextBlock>
            <StackPanel Grid.Row="1" Grid.Column="2" Orientation="Horizontal">
                <TextBlock Text="$" Style="{StaticResource textStyleTextBlock}"/>
                <TextBlock Name="CurrentPriceDTDataType" 
                    Text="{Binding Path=CurrentPrice}" 
                    Style="{StaticResource textStyleTextBlock}"/>
            </StackPanel>
        </Grid>
    </Border>
    <DataTemplate.Triggers>
        <DataTrigger Binding="{Binding Path=SpecialFeatures}">
            <DataTrigger.Value>
                <src:SpecialFeatures>Color</src:SpecialFeatures>
            </DataTrigger.Value>
          <DataTrigger.Setters>
            <Setter Property="BorderBrush" Value="DodgerBlue" TargetName="border" />
            <Setter Property="Foreground" Value="Navy" TargetName="descriptionTitle" />
            <Setter Property="Foreground" Value="Navy" TargetName="currentPriceTitle" />
            <Setter Property="BorderThickness" Value="3" TargetName="border" />
            <Setter Property="Padding" Value="5" TargetName="border" />
          </DataTrigger.Setters>
        </DataTrigger>
        <DataTrigger Binding="{Binding Path=SpecialFeatures}">
            <DataTrigger.Value>
                <src:SpecialFeatures>Highlight</src:SpecialFeatures>
            </DataTrigger.Value>
            <Setter Property="BorderBrush" Value="Orange" TargetName="border" />
            <Setter Property="Foreground" Value="Navy" TargetName="descriptionTitle" />
            <Setter Property="Foreground" Value="Navy" TargetName="currentPriceTitle" />
            <Setter Property="Visibility" Value="Visible" TargetName="star" />
            <Setter Property="BorderThickness" Value="3" TargetName="border" />
            <Setter Property="Padding" Value="5" TargetName="border" />
        </DataTrigger>
    </DataTemplate.Triggers>
</DataTemplate>


Grazie all'utilizzo di questi due oggetti DataTemplate, l'interfaccia utente risultante sarà quella illustrata nella sezione Definizione di associazione dati. Come si evince dalla schermata, oltre a consentire di posizionare i dati all'interno dei controlli, gli oggetti DataTemplate permettono di conferire ai dati un aspetto visivo gradevole. Ad esempio, nel precedente DataTemplate vengono utilizzati oggetti DataTrigger che consentono di visualizzare gli oggetti AuctionItem per i quali SpecialFeatures è impostato su HighLight con un bordo arancione e una stella.

Per ulteriori informazioni sui modelli di dati, vedere Cenni preliminari sui modelli di dati.

Nella presente sezione sono contenute le seguenti sottosezioni.

Gran parte delle applicazioni che accettano input dell'utente devono avere una logica di convalida per garantire che l'utente immetta le informazioni previste. I controlli di convalida possono basarsi sul tipo, l'intervallo, il formato o altri requisiti specifici dell'applicazione. In questa sezione viene illustrato il funzionamento della convalida dei dati in WPF.

Associazione di regole di convalida a un'associazione

Il modello di associazione dati WPF consente di associare ValidationRules all'oggetto Binding. Nell'esempio seguente viene ad esempio associato un oggetto TextBox a una proprietà denominata StartPrice e viene aggiunto un oggetto ExceptionValidationRule alla proprietà Binding.ValidationRules.


<TextBox Name="StartPriceEntryForm" Grid.Row="2" Grid.Column="1"
    Style="{StaticResource textStyleTextBox}" Margin="8,5,0,5">
  <TextBox.Text>
    <Binding Path="StartPrice" UpdateSourceTrigger="PropertyChanged">
      <Binding.ValidationRules>
        <ExceptionValidationRule />
      </Binding.ValidationRules>
    </Binding>
  </TextBox.Text>
</TextBox>


Un oggetto ValidationRule controlla se il valore di una proprietà è valido. In WPF sono disponibili i due tipi di oggetti ValidationRule incorporati seguenti:

È anche possibile creare una regola di convalida personalizzata mediante derivazione dalla classe ValidationRule e implementazione del metodo Validate. Di seguito viene illustrata la regola utilizzata dall'oggetto TextBox "Start Date" contenuto in Add Product Listing, secondo l'esempio riportato nella sezione Definizione di associazione dati:


class FutureDateRule : ValidationRule
{
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        DateTime date;
        try
        {
            date = DateTime.Parse(value.ToString());
        }
        catch (FormatException)
        {
            return new ValidationResult(false, "Value is not a valid date.");
        }
        if (DateTime.Now.Date > date)
        {
            return new ValidationResult(false, "Please enter a date in the future.");
        }
        else
        {
            return ValidationResult.ValidResult;
        }
    }
}


L'oggetto TextBox StartDateEntryForm utilizza FutureDateRule, come illustrato nell'esempio che segue:


<TextBox Name="StartDateEntryForm" Grid.Row="3" Grid.Column="1" 
    Validation.ErrorTemplate="{StaticResource validationTemplate}" 
    Style="{StaticResource textStyleTextBox}" Margin="8,5,0,5">
    <TextBox.Text>
        <Binding Path="StartDate" UpdateSourceTrigger="PropertyChanged" 
            Converter="{StaticResource dateConverter}" >
            <Binding.ValidationRules>
                <src:FutureDateRule />
            </Binding.ValidationRules>
        </Binding>
    </TextBox.Text>
</TextBox>


Poiché il valore di UpdateSourceTrigger è PropertyChanged, il motore di associazione aggiorna il valore di origine a ogni pressione di tasto, il che significa che controlla anche ogni regola nell'insieme ValidationRules a ogni pressione di tasto. L'argomento verrà ulteriormente trattato nella sezione Processo di convalida.

Visualizzazione di un feedback

Se l'utente immette un valore non valido, è possibile fornire un feedback relativo all'errore nell'UI dell'applicazione. Un modo per fornire tale feedback consiste nell'impostare la proprietà associata Validation.ErrorTemplate su un oggetto ControlTemplate personalizzato. Come illustrato nella sottosezione precedente, l'oggetto TextBox StartDateEntryForm utilizza un oggetto ErrorTemplate definito validationTemplate. Nell'esempio seguente viene illustrata la definizione di validationTemplate:


<ControlTemplate x:Key="validationTemplate">
  <DockPanel>
    <TextBlock Foreground="Red" FontSize="20">!</TextBlock>
    <AdornedElementPlaceholder/>
  </DockPanel>
</ControlTemplate>


L'elemento AdornedElementPlaceholder specifica il punto in cui deve essere posizionato il controllo decorato.

In aggiunta, è anche possibile utilizzare un oggetto ToolTip per visualizzare il messaggio di errore. Gli oggetti TextBoxStartDateEntryForm e StartPriceEntryForm utilizzano entrambi lo stile textStyleTextBox, il quale crea un oggetto ToolTip in cui viene visualizzato il messaggio di errore. Nell'esempio seguente viene illustrata la definizione di textStyleTextBox. Il valore della proprietà associata Validation.HasError è true quando una o più associazioni nelle proprietà dell'elemento associato sono in errore.


<Style x:Key="textStyleTextBox" TargetType="TextBox">
  <Setter Property="Foreground" Value="#333333" />
  <Setter Property="MaxLength" Value="40" />
  <Setter Property="Width" Value="392" />
  <Style.Triggers>
    <Trigger Property="Validation.HasError" Value="true">
      <Setter Property="ToolTip"
        Value="{Binding RelativeSource={RelativeSource Self},
                        Path=(Validation.Errors)[0].ErrorContent}"/>
    </Trigger>
  </Style.Triggers>
</Style>


Utilizzando ErrorTemplate personalizzato e ToolTip, in caso di errore di convalida l'oggetto TextBox StartDateEntryForm appare come segue:

Errore di convalida dell'associazione dati

Se Binding possiede regole di convalida associate ma non viene specificato alcun oggetto ErrorTemplate nel controllo associato, verrà utilizzato un oggetto ErrorTemplate predefinito per avvisare gli utenti in caso di errore di convalida. L'oggetto ErrorTemplate predefinito è un modello di controllo che definisce un bordo rosso nel livello dello strumento decorativo visuale. Utilizzando ErrorTemplate predefinito e ToolTip, in caso di errore di convalida l'UI dell'oggetto TextBox StartPriceEntryForm appare come segue:

Errore di convalida dell'associazione dati

Per un esempio di come fornire una logica di convalida per tutti i controlli in una finestra di dialogo, vedere la sezione Finestre di dialogo personalizzate contenuta in Cenni preliminari sulle finestre di dialogo.

Processo di convalida

La convalida avviene solitamente quando si trasferisce un valore di destinazione alla proprietà di origine dell'associazione. Ciò si verifica con associazioni TwoWay e OneWayToSource. Come già detto, gli eventi che generano un aggiornamento dell'origine dipendono dal valore della proprietà UpdateSourceTrigger, come descritto nella sezione Eventi che generano gli aggiornamenti dell'origine.

Gli elementi seguenti descrivono il processo di convalida. Si noti che se in un qualsiasi momento del processo si verifica un errore di convalida o di altro tipo, il processo viene interrotto.

  1. Successivamente controlla se siano stati definiti oggetti ValidationRule personalizzati con ValidationStep impostato su RawProposedValue per tale oggetto Binding, nel qual caso chiama il metodo Validate su ciascun oggetto ValidationRule fino a che non viene rilevato un errore per uno di essi o finché non restituiscono tutti esito positivo.

  2. Il motore di associazione chiama quindi il convertitore, se presente.

  3. Se il convertitore riesce, il motore di associazione controlla se sono stati definiti oggetti ValidationRule personalizzati il cui valore di ValidationStep sia impostato su ConvertedProposedValue per Binding, nel qual caso chiama il metodo Validate su ciascun oggetto ValidationRule con ValidationStep impostato su ConvertedProposedValue fino a che non viene rilevato un errore per uno di essi o finché non restituiscono tutti esito positivo.

  4. Il motore di associazione imposta la proprietà di origine.

  5. Il motore di associazione controlla se sono stati definiti oggetti ValidationRule personalizzati la cui proprietà ValidationStep sia impostata su UpdatedValue per l'oggetto Binding in questione, nel qual caso chiama il metodo Validate su ciascun oggetto ValidationRule con la proprietà ValidationStep impostata su UpdatedValue fino a che non viene rilevato un errore per uno di essi o finché non restituiscono tutti esito positivo. Se un oggetto DataErrorValidationRule è associato a un'associazione e la relativa proprietà ValidationStep è impostata sul valore predefinito, vale a dire UpdatedValue, DataErrorValidationRule viene controllato a questo punto. Si tratta inoltre del momento in cui vengono controllate le associazioni la cui proprietà ValidatesOnDataErrors è impostata su true.

  6. Il motore di associazione controlla se sono stati definiti oggetti ValidationRule personalizzati la cui proprietà ValidationStep sia impostata su CommittedValue per l'oggetto Binding in questione, nel qual caso chiama il metodo Validate su ciascun oggetto ValidationRule con la proprietà ValidationStep impostata su CommittedValue fino a che non viene rilevato un errore per uno di essi o finché non restituiscono tutti esito positivo.

Se in un qualsiasi momento del processo l’oggetto ValidationRule restituisce esito negativo, il motore di associazione crea un oggetto ValidationError e lo aggiunge all’insieme Validation.Errors dell’elemento associato. Prima che il motore di associazione venga eseguito sugli oggetti ValidationRule in un determinato passaggio, esso rimuove qualsiasi oggetto ValidationError aggiunto alla proprietà associata Validation.Errors dell’elemento associato durante quel passaggio. Ad esempio, se un oggetto ValidationRule il cui ValidationStep è impostato su UpdatedValue ha avuto esito negativo, la volta successiva in cui si verifica il processo di convalida, il motore di associazione rimuove l'oggetto ValidationError immediatamente prima di chiamare ValidationRule con ValidationStep impostato su UpdatedValue.

Se la proprietà Validation.Errors non è vuota, la proprietà associata Validation.HasError dell'elemento viene impostata su true. Se, inoltre, la proprietà NotifyOnValidationError dell'oggetto Binding è impostata su true, il motore di associazione genera l'evento associato Validation.Error sull'elemento.

Il trasferimento di un valore valido in una delle due direzioni (dalla destinazione all'origine o viceversa) comporta la cancellazione della proprietà associata Validation.Errors.

Se all’associazione è associato un oggetto ExceptionValidationRule o se la proprietà ValidatesOnExceptions è impostata su true e viene generata un’eccezione quando il motore di associazione imposta l’origine, il motore di associazione controlla se è presente un oggetto UpdateSourceExceptionFilter. È possibile utilizzare il callback UpdateSourceExceptionFilter per fornire un gestore personalizzato per la gestione delle eccezioni. Se un UpdateSourceExceptionFilter non viene specificato sull'oggetto Binding, il modulo di associazione crea un ValidationError con l'eccezione e lo aggiunge all'insieme Validation.Errors dell'elemento associato.

È possibile impostare la proprietà associata PresentationTraceSources.TraceLevel in un oggetto correlato all'associazione per ricevere informazioni sullo stato di una particolare associazione.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft