WPF：如何在 XAML 中填充我的 ViewModel 而不是背后的代码

Question

So i have this ViewModel class :

public class ViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        private ObservableCollection<Person> _persons;

        public ObservableCollection<Person> Porsons
        {
            get { return _persons; }
            set
            {
                _persons = value;
                NotifyPropertyChanged();
            }
        }

        private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

And then create this ViewModel class and populate its Person list:

ViewModel viewModel;
ObservableCollection<Person> persons

public MainWindow()
{
    InitializeComponent();
    viewModel = new ViewModel();
    viewModel.Porsons= persons;
}

And then my ListView :

<ListView ItemSource={Binding Persons}/>

So instead of binding this Persons list into my ViewModel class and then do this ItemSource can i do it in pure XAML or this is the right way ?

Answer 1

Instead of creating a ViewModel property on your view it is recommended to use it's DataContext (this link also shows how to set it using XAML) . Also don't populate the view model in the view since most of the time the data resides in the model and the view should not know anything about any models (when following MVVM).

Please read the link above and visit the links you meet. Also read this article about MVVM . This gives you some basic knowledge to make it easier to understand how to use the WPF framework.

There are many variations of view model creation in XAML. For example alternatively you can create it in the App.Xaml to make it globally accessible via the StaticResource markup extension and assign it to the individual controls's DataContext via a Style or use an ObjectDataProvider .

This example uses XAML Property Element declaration to create a ViewModel instance directly in the target view. This instance is locally accessible only.

ViewModel.cs:

namespace Example
{
  public class ViewModel : INotifyPropertyChanged
  {       
    public ViewModel()
    {
      this.Persons = new ObservableCollection<Person>();
    }

    private ObservableCollection<Person> _persons;
    public ObservableCollection<Person> Persons
    {
      get => _persons;
      set
      {
        _persons = value;
        NotifyPropertyChanged();
      }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
    {
      PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}

View.xaml:

<Window x:Class="Example.MainWindow"
        ...
        xmlns:local="clr-namespace:Example">

  <Window.DataContext>
    <local:ViewModel />
  </Window.DataContext>

  <Grid>
    <ListView ItemSource={Binding Persons}/>
  </Grid>
</Window>

Answer 2

Yes, you can. But no, you most certainly do not want to.

To answer your question, let's say your Person class looks like this:

public class Person
{
    public string Name { get; set; }
}

You can easily declare a list in XAML and bind it to a ListView (say) like this:

<ListView DisplayMemberPath="Name">
    <ListView.ItemsSource>
        <x:Array Type="{x:Type vm:Person}">
            <vm:Person Name="Tom" />
            <vm:Person Name="Dick" />
            <vm:Person Name="Harry" />
        </x:Array>
    </ListView.ItemsSource>
</ListView>

The result of which is this:

Just because you can do this, though, doesn't mean you should. The whole point of MVVM is to separate your view layer from your view model layer. You should be able to run your entire application from a test build without creating a single view object at all. In asking this question what you are apparently trying to do is declare a data structure in your view layer, which is totally the wrong place to put it. Your view layer should be as "dumb" as possible, with only the weakest possible bindings to your view model layer where the actual logic is going on.