在同级用户控件之间绑定属性

Question

I have the below problem: I have two different user controls inside a parent user control. These are trainList , wich holds a list of train objects and trainView , wich is an user control that shows details of the selected train in the list.

My wish is to share a variable of trainList with trainView . What I have now is:

Parent user control:

<UserControl>
    <UserControl>
        <customControls:trainList x:Name="trainList"></customControls:trainList>
    </UserControl>

    <UserControl>
        <customControls:trainView x:Name="trainView"></customControls:trainView>
    </UserControl>

    <TextBlock DataContext="{Binding ElementName=trainList, Path=SelectedTrain}" Text="{ Binding SelectedTrain.Id }">Test text</TextBlock>
</UserControl>

TrainList class:

public partial class TrainList : UserControl
    {
        public TrainList()
        {
            this.InitializeComponent();
            this.DataContext = this;
        }

        public Train SelectedTrain { get; set; }

        public void SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            Debug.Print(this.SelectedTrain.Id);
        }
    }

Note: The Train class implements INotifyPropertyChanged .

If I got this to work, I'd apply the binding to the trainView user control (not sure if this would work) instead to the text block.

    <UserControl>
        <customControls:trainView x:Name="trainView" DataContext="{Binding ElementName=trainList, Path=SelectedTrain}"></customControls:trainView>
    </UserControl>

And then, I would access that variable someway from the code-behind of trainView .

(And after this, I would like to share a different variable from trainView with its parent user control, but maybe that's another question).

My current question is: could this be done this way or would I need to follow another strategy?

Answer 1

Take this simple view model, with a base class that implements the INotifyPropertyChanged interface, and a Train, TrainViewModel and MainViewModel class.

public class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

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

    protected void SetValue<T>(
        ref T storage, T value, [CallerMemberName] string propertyName = null)
    {
        if (!Equals(storage, value))
        {
            storage = value;
            OnPropertyChanged(propertyName);
        }
    }
}

public class Train : ViewModelBase
{
    private string name;
    public string Name
    {
        get { return name; }
        set { SetValue(ref name, value); }
    }

    private string details;
    public string Details
    {
        get { return details; }
        set { SetValue(ref details, value); }
    }

    // more properties
}

public class TrainViewModel : ViewModelBase
{
    public ObservableCollection<Train> Trains { get; }
        = new ObservableCollection<Train>();

    private Train selectedTrain;
    public Train SelectedTrain
    {
        get { return selectedTrain; }
        set { SetValue(ref selectedTrain, value); }
    }
}

public class MainViewModel
{
    public TrainViewModel TrainViewModel { get; } = new TrainViewModel();
}

which may be initialized in the MainWindow's constructor like this:

public MainWindow()
{
    InitializeComponent();

    var vm = new MainViewModel();
    DataContext = vm;

    vm.TrainViewModel.Trains.Add(new Train
    {
        Name = "Train 1",
        Details = "Details of Train 1"
    });

    vm.TrainViewModel.Trains.Add(new Train
    {
        Name = "Train 2",
        Details = "Details of Train 2"
    });
}

The TrainDetails controls would look like this, of course with more elements for more properties of the Train class:

<UserControl ...>
    <StackPanel>
        <TextBlock Text="{Binding Name}"/>
        <TextBlock Text="{Binding Details}"/>
    </StackPanel>
</UserControl>

and the parent UserControl like this, where I directly use a ListBox instead of a TrainList control:

<UserControl ...>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition/>
            <ColumnDefinition/>
        </Grid.ColumnDefinitions>
        <ListBox ItemsSource="{Binding Trains}"
                 SelectedItem="{Binding SelectedTrain}"
                 DisplayMemberPath="Name"/>
        <local:TrainDetailsControl Grid.Column="1" DataContext="{Binding SelectedTrain}"/>
    </Grid>
</UserControl>

It would be instantiated in the MainWindow like this:

<Grid>
    <local:TrainControl DataContext="{Binding TrainViewModel}"/>
</Grid>

Note that in this simple example the elements in the UserControls' XAML bind directly to a view model instance that is passed via their DataContext. This means that the UserControl know the view model (or at least their properties). A more general approach is to declare dependency properties in the UserControl class, that are bound to view model properties. The UserControl would then be independent of any particular view model.