A propriedade UpdateSourceTrigger

No artigo anterior, vimos como as alterações em um TextBox não eram enviadas imediatamente de volta à origem. Em vez disso, a fonte foi atualizada somente depois que o foco foi perdido no TextBox. Esse comportamento é controlado por uma propriedade do binding chamada UpdateSourceTrigger. O valor padrão é o "Default", que basicamente significa que a origem é atualizada com base na propriedade a qual você se vincula. A partir da escrita, todas as propriedades, exceto a propriedade Text, são atualizadas assim que a propriedade é alterada (PropertyChanged), enquanto a propriedade Text é atualizada quando o foco no elemento de destino é perdido (LostFocus).

O padrão é, obviamente, o valor padrão do UpdateSourceTrigger. As outras opções são PropertyChanged, LostFocus e Explicit. Os dois primeiros já foram descritos, enquanto o último simplesmente significa que a atualização tem que ser enviada manualmente para ocorrer, usando uma chamada para UpdateSource no Binding.

Para ver como todas essas opções funcionam, atualizei o exemplo do capítulo anterior para mostrar todas elas:

<Window x:Class="WpfTutorialSamples.DataBinding.DataContextSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="DataContextSample" Height="130" Width="310">
	<StackPanel Margin="15">
		<WrapPanel>
			<TextBlock Text="Window title:  " />
			<TextBox Name="txtWindowTitle" Text="{Binding Title, UpdateSourceTrigger=Explicit}" Width="150" />
			<Button Name="btnUpdateSource" Click="btnUpdateSource_Click" Margin="5,0" Padding="5,0">*</Button>
		</WrapPanel>
		<WrapPanel Margin="0,10,0,0">
			<TextBlock Text="Window dimensions: " />
			<TextBox Text="{Binding Width, UpdateSourceTrigger=LostFocus}" Width="50" />
			<TextBlock Text=" x " />
			<TextBox Text="{Binding Height, UpdateSourceTrigger=PropertyChanged}" Width="50" />
		</WrapPanel>
	</StackPanel>
</Window>

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;

namespace WpfTutorialSamples.DataBinding
{
	public partial class DataContextSample : Window
	{
		public DataContextSample()
		{
			InitializeComponent();
			this.DataContext = this;
		}

		private void btnUpdateSource_Click(object sender, RoutedEventArgs e)
		{
			BindingExpression binding = txtWindowTitle.GetBindingExpression(TextBox.TextProperty);
			binding.UpdateSource();
		}
	}
}

Como você pode ver, cada uma das três caixas de texto agora usa um UpdateSourceTrigger diferente.

O primeiro é definido como Explicit, o que basicamente significa que a fonte não será atualizada a menos que você faça isso manualmente. Por esse motivo, adicionei um botão ao lado do TextBox, que atualizará o valor de origem sob demanda. No Code-behind, você encontrará o manipulador Click, no qual usamos algumas linhas de código para ter o vínculo do controle de destino e, em seguida, chamar o método UpdateSource().

O segundo TextBox usa o valor LostFocus, que na verdade é o padrão para um binding de texto. Isso significa que o valor da fonte será atualizado sempre que o controle de destino perder o foco.

O terceiro e último TextBox usa o valor PropertyChanged, o que significa que o valor de origem será atualizado sempre que a propriedade associada for alterada, o que acontece nesse caso assim que o texto for alterado.

Tente executar o exemplo na máquina e veja como as três caixas de texto agem completamente diferente: O primeiro valor não é atualizado antes de você clicar no botão, o segundo valor não é atualizado até você deixar o TextBox, enquanto o terceiro valor é atualizado automaticamente em cada tecla digitada, mudança de texto, etc.

Resumo

A propriedade UpdateSourceTrigger de uma ligação controla como e quando um valor alterado é enviado de volta à origem. No entanto, como o WPF é muito bom em controlar isso para você, o valor padrão deve ser suficiente para a maioria dos casos, onde você obterá o melhor mix de uma interface do usuário atualizada constantemente e um bom desempenho.

Para as situações em que você precisa de mais controle sobre o processo, essa propriedade definitivamente ajudará. Apenas certifique-se de não atualizar o valor de origem com mais frequência do que realmente precisa. Se você quiser o controle total, poderá usar o valor Explicit e, em seguida, fazer as atualizações manualmente, mas isso tira um pouco da graça de trabalhar com data binding.