UpdateSourceTrigger=Explicit - wpf

Question

I'm creating a WPF window with multiple textboxes, when the user presses the OK button I want all the text boxes to be evaluated for being non-blank.
I understand that I have to use TextBoxes with 'UpdateSourceTrigger of 'Explicit', but do I need to call 'UpdateSource()' for each of them ?
e.g.
<TextBox Height="23"
HorizontalAlignment="Left"
Margin="206,108,0,0"
Text="{Binding Path=Definition, UpdateSourceTrigger=Explicit}"
Name="tbDefinitionFolder"
VerticalAlignment="Top"
Width="120" />
<TextBox Height="23"
HorizontalAlignment="Left"
Margin="206,108,0,0"
Text="{Binding Path=Release, UpdateSourceTrigger=Explicit}"
Name="tbReleaseFolder"
VerticalAlignment="Top"
Width="120" />
...
BindingExpression be = tbDefinitionFolder.GetBindingExpression(TextBox.TextProperty);
be.UpdateSource();
BindingExpression be2 = tbReleaseFolder.GetBindingExpression(TextBox.TextProperty);
be2.UpdateSource();

Answer 1

If you use Explicit you need to call UpdateSource.
I am not sure if this is the best approach to what you try to do though, i for one virtually never use Explicit, i rather bind to a copy of an object if i do not want changes to apply right away, or i store a copy and revert everything back if edits are to be cancelled.

Answer 2

An alternative approach can be to set your UpdateSourceTrigger to PropertyChanged.
And then inherit your VM from both INotifyPropertyChanged and IDataErrorInfo. Here's an example...
public class MyViewModel : INotifyPropertyChanged, IDataErrorInfo
{
private string myVar;
public string MyProperty
{
[DebuggerStepThrough]
get { return myVar; }
[DebuggerStepThrough]
set
{
if (value != myVar)
{
myVar = value;
OnPropertyChanged("MyProperty");
}
}
}
private void OnPropertyChanged(string prop)
{
if(PropertyChanged!=null)
{
PropertyChanged(this, new PropertyChangedEventArgs(pro));
}
}
public event PropertyChangedEventHandler PropertyChanged;
public string Error
{
get { return String.Empty; }
}
public string this[string columnName]
{
get
{
if (columnName == "MyProperty")
{
if (String.IsNullOrEmpty(MyProperty))
{
return "Should not be blank";
}
}
return null;
}
}
}
Assume that one of your TextBoxes is bound to 'MyProperty' as declared above. The indexer is implemented in IDataErrorInfo, and gets called when 'MyProperty' changes. In the indexer body, you can perform a check if the value is empty and return an error string. If the error string is non-null, the user gets a nice adorner on the TextBox as a visual cue. So you are in one shot performing validation and delivering the UI experience.
All of this is for free if you use the two interfaces as coded above and use UpdateSourceTrigger=PropertyChanged. The use of UpdateSourceTrigger = Explicit is massive overkill for providing the validation you described.
The Xaml for the TextBox would be...
<TextBox DataContext="{StaticResource Vm}" Text="{Binding MyProperty,
UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True,
NotifyOnSourceUpdated=True, Mode=TwoWay}" Width="200" Height="25"/>

Answer 3

There are some good reasons to use UpdateSourceTrigger=Explicit, instead of other values. Imagine that you have to check if entered value is unique, which will be done by reading database. That can take some time, even 0.3 seconds is unacceptable. When using PropertyChanged, this database checking will be performed every time user presses key, which makes user interface extremely unresponsive. Same thing happens if UpdateSourceTrigger=LostFocus and user will be quickly switching between controls (if you hold Tab, there is lightning fast cycling between controls). So our objective is to validate everything at once at key moment (usually before data is saved). This approach will need minimal code behind, which will push data from view to viewmodel and forces validation. There is no validation code or other application logic inside code behind, so MVVM purists can be relatively calm. I created fully functional example in VB.NET, which is using Caliburn.Micro for MVVM and IoC. You can download it here: https://drive.google.com/file/d/0BzdqT0dfGkO3OW5hcjdBOWNWR2M

Answer 4

I've written some extensions that might make it more comfortable to update sources:
using System.Collections.Generic;
using System.Windows;
using System.Windows.Data;
internal static class EXT_Binding
{
internal static void _UpdateSource(this FrameworkElement element, DependencyProperty dp)
{
BindingExpression be = element.GetBindingExpression(dp: dp);
be?.UpdateSource();
}
internal static void _UpdateSource(this DependencyProperty dp, FrameworkElement element)
{
BindingExpression be = element.GetBindingExpression(dp: dp);
be?.UpdateSource();
}
internal static void _UpdateSources(this FrameworkElement element, List<DependencyProperty> dps)
{
foreach (var dp in dps)
{
BindingExpression be = element.GetBindingExpression(dp: dp);
be?.UpdateSource();
}
}
internal static void _UpdateSources(this FrameworkElement element, params DependencyProperty[] dps)
{
foreach (var dp in dps)
{
BindingExpression be = element.GetBindingExpression(dp: dp);
be?.UpdateSource();
}
}
}
which, for example, can then be used as such
this._UpdateSources(WidthProperty, HeightProperty, LeftProperty, TopProperty);

Answer 5

It would be simpler to just set it to UpdateSourceTrigger=PropertyChanged although it will update the underlying variable each time the value changes (for each letter inputted)