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:

• 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 interfaccia utente 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'interfaccia utente.

• 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 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.

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:

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:

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

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.

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.

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.

Dim data1 As New MyData(DateTime.Now)
Dim binding1 As New Binding("MyDataProperty")
binding1.Source = data1
Me.myText.SetBinding(TextBlock.TextProperty, binding1)

//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:

• Procedura: ottenere l'oggetto di associazione da una proprietà di destinazione associata

• Procedura: controllare il momento in cui il database di origine viene aggiornato dal testo di TextBox

È possibile eseguire enumerazioni in qualsiasi insieme che implementa l'interfaccia IEnumerable. Tuttavia, per impostare associazioni dinamiche in modo tale che l'interfaccia utente venga automaticamente aggiornata in seguito a operazioni di inserimento o eliminazione nell'insieme, è necessario che questo implementi 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<(Of <(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 un esempio, vedere Esempio di associazione a un insieme. Per ulteriori informazioni, vedere Cenni preliminari sulle origini di associazione.

Prima di implementare un insieme personalizzato, considerare la possibilità di utilizzare ObservableCollection<(Of <(T>)>) o una delle classi di insiemi esistenti, ad esempio List<(Of <(T>)>), Collection<(Of <(T>)>) e BindingList<(Of <(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.

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
• Procedura per la creazione di una visualizzazione
• Ordinamento
• Filtraggio
• Raggruppamento
• Puntatori dell'elemento corrente
• Scenario di associazione Master-Details

Definizione di visualizzazione di insieme

Procedura per la creazione di una visualizzazione

<Window.Resources>


...


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


...


</Window.Resources>

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


...


</ListBox>

Ordinamento

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

listingDataView.Filter += new FilterEventHandler(ShowOnlyBargainsFilter);

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;
        }
    }
}

Raggruppamento

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

Puntatori dell'elemento corrente

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

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

Scenario di associazione Master-Details

<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"/>

Il modello di associazione dati WPF consente di associare ValidationRules all'oggetto Binding. Di seguito viene illustrato il codice XAML relativo all'oggetto TextBox "Start Price" contenuto in Add Product Listing, secondo l'esempio riportato nella sezione Definizione di associazione dati :

<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>

La proprietà ValidationRules utilizza un insieme di oggetti ValidationRule. ExceptionValidationRule è un oggetto ValidationRule incorporato che verifica la presenza di eccezioni generate durante l'aggiornamento della proprietà di origine dell'associazione. In questo particolare esempio, la proprietà di origine dell'associazione è StartPrice (di tipo integer), mentre la proprietà di destinazione è TextBox..::.Text. Quando l'utente immette un valore che non può essere convertito in un valore integer, viene generata un'eccezione e l'associazione viene contrassegnata come non valida.

È 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.

Se l'utente immette un valore non valido, è possibile fornire un feedback relativo all'errore nell'interfaccia utente 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 TextBox StartDateEntryForm 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:

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'interfaccia utente dell'oggetto TextBox StartPriceEntryForm appare come segue:

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.

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 per 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 il cui valore di ValidationStep sia impostato su UpdatedValue per Binding, nel qual caso chiama il metodo Validate su ciascun oggetto ValidationRule con ValidationStep impostato su UpdatedValue fino a che non viene rilevato un errore per uno di essi o finché non restituiscono tutti esito positivo.

6. Il motore di associazione controlla se sono stati definiti oggetti ValidationRule personalizzati il cui valore di ValidationStep sia impostato su CommittedValue per Binding, nel qual caso chiama il metodo Validate su ciascun oggetto ValidationRule con ValidationStep impostato 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 seguente in cui si verifica il processo di convalida il motore di associazione rimuove l’oggetto ValidationError subito 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 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.