如何在MVVM模式下将WPF TextBox内容存储到Model层？

Great question—let’s break this down step by step to make sure your implementation stays true to MVVM principles. First, a quick recap of core roles to keep us aligned:

• Model: Holds your app’s raw data and business logic (this is your TextStore). It should never know about the View or ViewModel.
• ViewModel: Acts as the bridge between View and Model. It exposes bindable properties for the View, and handles syncing changes between the two layers.
• View: Displays data from the ViewModel and passes user input back to it (your TextBoxes fall here).

Here’s how to implement this correctly:

1. Define Your Model (TextStore) #

Start with a simple Model class to hold your text data. It doesn’t need INotifyPropertyChanged for your demo (unless you later add business logic that needs to notify the ViewModel of changes):

public class TextStore
{
    // The Model's core data property
    public string Text { get; set; }
}

2. Update Your ViewModel (TextContent) #

Your ViewModel should hold a reference to the Model instance. In the Text property’s setter, follow this order to stay compliant: update the Model first, sync the ViewModel’s backing field, then notify the View of changes.

public class TextContent : INotifyPropertyChanged
{
    // Reference to your Model instance
    private readonly TextStore _textStore;
    private string _text;

    // Inject the Model via constructor (clean MVVM practice)
    public TextContent(TextStore textStore)
    {
        _textStore = textStore;
        // Initialize ViewModel property from Model on startup
        _text = _textStore.Text;
    }

    public string Text
    {
        get => _text;
        set
        {
            if (_text == value) return; // Skip redundant updates

            // 1. Update the Model first (ViewModel mediates all Model changes)
            _textStore.Text = value;

            // 2. Sync the ViewModel's backing field
            _text = value;

            // 3. Notify the View to refresh the UI
            OnPropertyChanged(nameof(Text));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

3. Wire Up the Layers #

When initializing your View, pass a Model instance to the ViewModel (this is dependency injection, a standard MVVM practice):

// In your View's code-behind or app startup
var textStore = new TextStore();
var viewModel = new TextContent(textStore);
DataContext = viewModel;

Key MVVM Compliance Checks #

• No Direct View-Model Interaction: The View never touches the Model directly—all changes flow through the ViewModel.
• Single Source of Truth: The Model holds the canonical version of your data; the ViewModel mirrors it for the View to bind to.
• Separation of Concerns: If you later add validation (e.g., restricting text length), add that logic in the ViewModel’s setter or the Model (if it’s business-focused), not the View.

For your extra test TextBoxes, you can add additional bindable properties to the ViewModel and repeat the same pattern—update the Model first, then sync and notify.

内容的提问来源于stack exchange，提问作者M_K