WPF Databind Antes De Guardar

Descubrí que la eliminación de los elementos de menú que son ámbito dependía del ámbito de enfoque del menú hace que el cuadro de texto pierda el enfoque correctamente. No creo que esto se aplique a TODOS los elementos del menú, pero ciertamente para una acción de guardar o validar.

<Menu FocusManager.IsFocusScope="False" >

Suponiendo que hay más de un control en la secuencia de tabulación, la siguiente solución parece ser completa y general (solo cortar y pegar)...

Control currentControl = System.Windows.Input.Keyboard.FocusedElement as Control;

if (currentControl != null)
{
    // Force focus away from the current control to update its binding source.
    currentControl.MoveFocus(new TraversalRequest(FocusNavigationDirection.Next));
    currentControl.Focus();
}

Este es un truco FEO, pero también debería funcionar

TextBox focusedTextBox = Keyboard.FocusedElement as TextBox;
if (focusedTextBox != null)
{
    focusedTextBox.GetBindingExpression(TextBox.TextProperty).UpdateSource();
}

Este código comprueba si un cuadro de texto tiene foco... Si se encuentra 1... actualizar la fuente de enlace!

La solución simple es actualizar el código Xaml como se muestra a continuación

    <StackPanel DataContext="{Binding Source={StaticResource MyItemProvider}}"> 
        <Label Content="Enter some text and then File > Save:" /> 
        <TextBox Text="{Binding ValueA, UpdateSourceTrigger=PropertyChanged}" /> 
        <TextBox Text="{Binding ValueB, UpdateSourceTrigger=PropertyChanged}" /> 
    </StackPanel> 

¿Ha intentado configurar UpdateSourceTrigger a PropertyChanged? Alternativamente, puedes llamar al método UpdateSource (), pero eso parece un poco exagerado y frustra el propósito de TwoWay databinding.

Me he encontrado con este problema y la mejor solución que he encontrado fue cambiar el valor enfocable del botón (o cualquier otro componente como MenuItem) a verdadero:

<Button Focusable="True" Command="{Binding CustomSaveCommand}"/>

La razón por la que funciona, es porque obliga al botón a enfocarse antes de que invoque el comando y por lo tanto hace que el cuadro de texto o cualquier otro elemento UIElement para el caso pierda su enfoque y levante el evento de enfoque perdido que invoca el enlace para ser cambiado.

En caso de que esté utilizando bounded comando (como estaba señalando en mi ejemplo), la gran solución de John Smith no encajará muy bien ya que no se puede enlazar StaticExtension en la propiedad acotada (ni DP).

¿Podría establecer el enfoque en otro lugar justo antes de guardar?

Puede hacer esto llamando a focus() en un elemento de la interfaz de usuario.

Puedes enfocarte en cualquier elemento que invoque el "guardar". Si tu disparador es LostFocus entonces tienes que mover el foco a alguna parte. Guardar tiene la ventaja de que no se modifica y tendría sentido para el usuario.

Al investigar esto para responderlo, estoy un poco confundido de que el comportamiento que está viendo está sucediendo, seguramente el acto de hacer clic en el menú Archivo o lo que tiene que desenfocar el cuadro de texto y configurarlo en el menú?

La forma más fácil es poner el foco en algún lugar.
Puedes volver a poner el foco inmediatamente, pero si pones el foco en cualquier lugar activará el evento LostFocus en cualquier tipo de control y hará que actualice su contenido:

IInputElement x = System.Windows.Input.Keyboard.FocusedElement;
DummyField.Focus();
x.Focus();

Otra forma sería obtener el elemento enfocado, obtener el elemento de enlace del elemento enfocado y activar la actualización manualmente. Un ejemplo para TextBox y ComboBox (tendrías que añadir cualquier tipo de control que necesites soportar):

TextBox t = Keyboard.FocusedElement as TextBox;
if ((t != null) && (t.GetBindingExpression(TextBox.TextProperty) != null))
  t.GetBindingExpression(TextBox.TextProperty).UpdateSource();

ComboBox c = Keyboard.FocusedElement as ComboBox;
if ((c != null) && (c.GetBindingExpression(ComboBox.TextProperty) != null))
  c.GetBindingExpression(ComboBox.TextProperty).UpdateSource();

¿Qué piensas de esto? Creo que he descubierto una manera de hacerlo un poco más genérico usando la reflexión. Realmente no me gustó la idea de mantener una lista como algunos de los otros ejemplos.

var currentControl = System.Windows.Input.Keyboard.FocusedElement;
if (currentControl != null)
{
    Type type = currentControl.GetType();
    if (type.GetMethod("MoveFocus") != null && type.GetMethod("Focus") != null)
    {
        try
        {
            type.GetMethod("MoveFocus").Invoke(currentControl, new object[] { new TraversalRequest(FocusNavigationDirection.Next) });
            type.GetMethod("Focus").Invoke(currentControl, null);
        }
        catch (Exception ex)
        {
            throw new Exception("Unable to handle unknown type: " + type.Name, ex);
        }
    }
}

¿Ves algún problema con eso?

Dado que noté que este problema sigue siendo un dolor en el culo para resolver de una manera muy genérica, probé varias soluciones.

Finalmente uno que funcionó para mí: Siempre que sea necesario que los cambios en la interfaz de usuario se validen y actualicen a sus fuentes (Comprobar si hay cambios al cerrar una ventana, realizar operaciones de guardado, ...), llamo a una función de validación que hace varias cosas: - asegúrese de que un elemento enfocado (como cuadro de texto, combobox,...) pierde su enfoque que activará el valor predeterminado comportamiento de updatesource - validar cualquier control dentro del árbol del DependencyObject que se le da a la función de validación - volver a poner el foco en el elemento enfocado original

La función en sí devuelve true si todo está en orden (la validación es exitosa) -> su acción original (cerrando con opcional pidiendo confirmación, guardando, ... puede continuar. De lo contrario, la función devolverá false y su acción no podrá continuar porque hay errores de validación en uno o más elementos (con la ayuda de un ErrorTemplate genérico en los elementos).

El código (la funcionalidad de validación se basa en el artículo Detectando Errores de Validación de WPF):

public static class Validator
{
    private static Dictionary<String, List<DependencyProperty>> gdicCachedDependencyProperties = new Dictionary<String, List<DependencyProperty>>();

    public static Boolean IsValid(DependencyObject Parent)
    {
        // Move focus and reset it to update bindings which or otherwise not processed until losefocus
        IInputElement lfocusedElement = Keyboard.FocusedElement;
        if (lfocusedElement != null && lfocusedElement is UIElement)
        {
            // Move to previous AND to next InputElement (if your next InputElement is a menu, focus will not be lost -> therefor move in both directions)
            (lfocusedElement as UIElement).MoveFocus(new TraversalRequest(FocusNavigationDirection.Previous));
            (lfocusedElement as UIElement).MoveFocus(new TraversalRequest(FocusNavigationDirection.Next));
            Keyboard.ClearFocus();
        }

        if (Parent as UIElement == null || (Parent as UIElement).Visibility != Visibility.Visible)
            return true;

        // Validate all the bindings on the parent 
        Boolean lblnIsValid = true;
        foreach (DependencyProperty aDependencyProperty in GetAllDependencyProperties(Parent))
        {
            if (BindingOperations.IsDataBound(Parent, aDependencyProperty))
            {
                // Get the binding expression base. This way all kinds of bindings (MultiBinding, PropertyBinding, ...) can be updated
                BindingExpressionBase lbindingExpressionBase = BindingOperations.GetBindingExpressionBase(Parent, aDependencyProperty);
                if (lbindingExpressionBase != null)
                {
                    lbindingExpressionBase.ValidateWithoutUpdate();
                    if (lbindingExpressionBase.HasError)
                        lblnIsValid = false;
                }
            }
        }

        if (Parent is Visual || Parent is Visual3D)
        {
            // Fetch the visual children (in case of templated content, the LogicalTreeHelper will return no childs)
            Int32 lintVisualChildCount = VisualTreeHelper.GetChildrenCount(Parent);
            for (Int32 lintVisualChildIndex = 0; lintVisualChildIndex < lintVisualChildCount; lintVisualChildIndex++)
                if (!IsValid(VisualTreeHelper.GetChild(Parent, lintVisualChildIndex)))
                    lblnIsValid = false;
        }

        if (lfocusedElement != null)
            lfocusedElement.Focus();

        return lblnIsValid;
    }

    public static List<DependencyProperty> GetAllDependencyProperties(DependencyObject DependencyObject)
    {
        Type ltype = DependencyObject.GetType();
        if (gdicCachedDependencyProperties.ContainsKey(ltype.FullName))
            return gdicCachedDependencyProperties[ltype.FullName];

        List<DependencyProperty> llstDependencyProperties = new List<DependencyProperty>();
        List<FieldInfo> llstFieldInfos = ltype.GetFields(BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Static).Where(Field => Field.FieldType == typeof(DependencyProperty)).ToList();
        foreach (FieldInfo aFieldInfo in llstFieldInfos)
            llstDependencyProperties.Add(aFieldInfo.GetValue(null) as DependencyProperty);
        gdicCachedDependencyProperties.Add(ltype.FullName, llstDependencyProperties);

        return llstDependencyProperties;
    }
}

Estoy usando BindingGroup.

XAML:

<R:RibbonWindow Closing="RibbonWindow_Closing" ...>

    <FrameworkElement.BindingGroup>
        <BindingGroup />
    </FrameworkElement.BindingGroup>

    ...
</R:RibbonWindow>

C #

private void RibbonWindow_Closing(object sender, CancelEventArgs e) {
    e.Cancel = !NeedSave();
}

bool NeedSave() {
    BindingGroup.CommitEdit();

    // Insert your business code to check modifications.

    // return true; if Saved/DontSave/NotChanged
    // return false; if Cancel
}

Debería funcionar.