在 WPF/MVVM 应用程序中设置编辑 state

Question

Using the MVVM pattern in a WPF application, I want to handle the 'Editing State' of a record .
Every time the user starts editing a record, that window should switch to the 'editing' mode, easily represented in code by a boolean property named IsEditing .
This allows for activating/deactivating UI buttons etc. etc.

I've understood that such a property should go into the ViewModel.
But how to make sure that as soon as the user starts editing one of the fields, IsEditing is set to true?
The only way I've found is to explicitly assign IsEditing into the wrappers of the model's fields. Is there a better, smarter way to do this, maybe in a centralized way? The cons that I see in my approach is the verbosity and the possiblity of forgetting to do so for a field.
Maybe there's an entirely different approach that handles such an issue right from the beginning?

My model (Entity Framework Core, though should be irrelevant):

public class City
{
    public string Id { get; set; }
    public string Name { get; set; }
}

The associated ViewModel (I included only the relevant code):

public class CityVM : INotifyPropertyChanged
{

    private bool _isEditing;
    public bool IsEditing
    {
        get { return _isEditing; }
        set
        {
            if (value!=_isEditing)
            {
                _isEditing = value;
                NotifyPropertyChanged(); 

            }
        }
    }

    public string Name
    {
        get { return _model.Name; }
        set
        {

            if (value!=_model.Name) 
            {
                _model.Name = value;
                NotifyPropertyChanged();
                IsEditing = true;
            }
        }
    }

}

Answer 1

I understood your problem and already had the same problem. My solution was based in Triggers firing commmands for GotFocus and LostFocus updating the boolean, I know that is not the best option but was the only one I had.

I'll prepare one snipped and update my reply.

Edit: I found a better way to do it.

Creating a behavior and attaching it to your textbox, is a cleaner solution. It wont let your code dirty as my first suggestion. :)

public static class EditingStateBehavior
{
    #region IsEditing

    public static bool GetIsEditing(DependencyObject obj) => (bool)obj.GetValue(IsEditingProperty);

    public static void SetIsEditing(DependencyObject obj, bool value) => obj.SetValue(IsEditingProperty, value);

    public static readonly DependencyProperty IsEditingProperty =
       DependencyProperty.Register(
       "IsEditing",
       typeof(bool),
       typeof(EditingStateBehavior));

    #endregion IsEditing

    #region Enabling

    public static bool GetIsEditingEnabled(DependencyObject obj) => (bool)obj.GetValue(IsEditingEnabledProperty);

    public static void SetIsEditingEnabled(DependencyObject obj, bool value) => obj.SetValue(IsEditingEnabledProperty, value);

    public static readonly DependencyProperty IsEditingEnabledProperty =
        DependencyProperty.Register(
        "IsEditingEnabled",
        typeof(bool),
        typeof(TextBox),
        new PropertyMetadata(OnIsEditingEnabledChanged));

    private static void OnIsEditingEnabledChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        TextBox textBox = sender as TextBox;
        if (textBox is null) return;

        textBox.GotFocus += (x, p) => UpdateStatus(x as FrameworkElement, true);
        textBox.LostFocus += (x, p) => UpdateStatus(x as FrameworkElement, false);

        //Also, you cam implement something to handle if you don't want to receive notifications anymore....
    }

    private static void UpdateStatus(FrameworkElement frameworkElement, bool value) => frameworkElement.SetValue(IsEditingProperty, value);

    #endregion Enabling
}

and in your text box:

 <TextBox
        Grid.Row="1"
        Margin="3" Grid.ColumnSpan="1"
        VerticalContentAlignment="Center"
        local:EditingStateBehavior.IsEditing="{Binding IsEditing, Mode=TwoWay}"
        local:EditingStateBehavior.IsEditingEnabled="True"
        Text="{Binding SomeText}" />

Do not forget to put the Mode:TwoWay

The 'IsEditingEnabled' has to exists due the necessity of get the textbox reference to hook the events, so when the window is loading the 'OnIsEditingEnabledChanged' will be fired giving you the right control to "monitor". Of course, if you want to implement a control to stop to monitor the editing state or change the event you'll change there.

I did a small project to test it, fell free to take a look.

https://github.com/mateusavelar/EditingStatePoc-WPF