Sélectionner plusieurs éléments dans une grille de données dans un projet WPF MVVM

Ce que je voudrais faire est de créer Behaviors à l'aide de System.Windows.Interactivity. Vous devez le référencer manuellement dans votre projet.

Donné un contrôle qui permet de ne pas exposer SelectedItems par exemple, (ListBox, DataGrid)

Vous pouvez créer un comportement de classe à quelque chose comme ceci

public class ListBoxSelectedItemsBehavior : Behavior<ListBox>
{
    protected override void OnAttached()
    {
        AssociatedObject.SelectionChanged += AssociatedObjectSelectionChanged;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.SelectionChanged -= AssociatedObjectSelectionChanged;
    }

    void AssociatedObjectSelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        var array = new object[AssociatedObject.SelectedItems.Count];
        AssociatedObject.SelectedItems.CopyTo(array, 0);
        SelectedItems = array;
    }

    public static readonly DependencyProperty SelectedItemsProperty =
        DependencyProperty.Register("SelectedItems", typeof(IEnumerable), typeof(ListBoxSelectedItemsBehavior), 
        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

    public IEnumerable SelectedItems
    {
        get { return (IEnumerable)GetValue(SelectedItemsProperty); }
        set { SetValue(SelectedItemsProperty, value); }
    }
}

Et sur votre XAML je voudrais faire le Binding comme ça où i est xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity" et behaviors est l'espace de noms de votre Behavior classe

<ListBox>
 <i:Interaction.Behaviors>
    <behaviors:ListBoxSelectedItemsBehavior SelectedItems="{Binding SelectedItems, Mode=OneWayToSource}" />
 </i:Interaction.Behaviors>

En supposant que votre DataContext pour la ListBox a la SelectedItems propriété dans le ViewModel alors il sera automatiquement mise à jour le SelectedItems. Vous avez encapsulé la event vous abonnant à partir de la View c'est à dire,

<ListBox SelectionChanged="ListBox_SelectionChanged"/>

Vous pouvez modifier la Behavior classe pour être de type DataGrid si vous le souhaitez.

Avec la valeur par défaut DataGrid de WPF, il n'est pas possible d'utiliser une Liaison, comme il est possible avec le SelectedItem-Propriété, la cause de la SelectedItems-Propriété n'est pas une DependencyProperty.

D'une façon à ce que vous voulez faire est de vous inscrire à la SelectionChanged-Cas de la grille de données pour mettre à jour la propriété du ViewModel, qui stocke les éléments sélectionnés.

La propriété SelectedItems de la grille de données est de type IList si vous avez besoin de jeter les éléments dans la liste pour votre type spécifique.

C#

public MyViewModel {
  get{
    return this.DataContext as MyViewModel;
  }
}

private void DataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e) {
  //... Get SelectedItems from DataGrid.
  var grid = sender as DataGrid;
  var selected = grid.SelectedItems;

  List<MyObject> selectedObjects = selected.OfType<MyObject>().ToList();

  MyViewModel.SelectedMyObjects = selectedObjects;
}

XAML

<Window x:Class="WpfApplication1.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="350" Width="525">
    <Grid>
    <DataGrid
        SelectionChanged="DataGrid_SelectionChanged"
        />
    </Grid>
</Window>

Vous pouvez maka un génériques réutilisables classe de base. De cette façon, vous pouvez sélectionner des lignes à la fois à partir du code et de l'INTERFACE utilisateur.

C'est ma classe d'exemple je veux être sélectionnable

public class MyClass
{
    public string MyString {get; set;}   
}

Génériques de la classe de base pour sélectionnable classes. INotifyPropertyChanged permet de l'INTERFACE utilisateur mise à jour lorsque vous définissez IsSelected.

public class SelectableItem<T> : System.ComponentModel.INotifyPropertyChanged
{
    public SelectableItem(T item)
    {
        Item = item;
    }

    public T Item { get; set; }

    bool _isSelected;

    public bool IsSelected {
        get {
            return _isSelected;
        }
        set {
            if (value == _isSelected)
            {
                return;
            }

            _isSelected = value;

            if (PropertyChanged != null)
            { 
                PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs("IsSelected"));
            }
        }
    }

    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
}

Créer sélectionnable classe

public class MySelectableItem: SelectableItem<MyClass>
{
    public MySelectableItem(MyClass item)
       :base(item)
    {
    }
}

Créer une propriété de se lier à

ObservableCollection<MySelectableItem> MyObservableCollection ...

Ensemble propety

MyObservableCollection = myItems.Select(x => new MySelectableItem(x));

Lier à datagrid et ajouter un style à la DataGridRow qui se lie à la IsSelected propety sur le MySelectedItem

<DataGrid  
    ItemsSource="{Binding MyObservableCollection}"
    SelectionMode="Extended">
    <DataGrid.Resources>
        <Style TargetType="DataGridRow">
            <Setter Property="IsSelected" Value="{Binding IsSelected}" />
        </Style>
    </DataGrid.Resources>
</DataGrid>

Pour obtenir des lignes sélectionnées/articles

var selectedItems = MyObservableCollection.Where(x=>x.IsSelected).Select(y=>y.Item);

Pour sélectionner les lignes ou les éléments

MyObservableCollection[0].IsSelected = true;

Edit--->
Il semble que cela ne fonctionne pas lorsque EnableRowVirtualization est vrai

Le projet, je travaille sur les utilisations MVVM Light et j'ai trouvé ce blog
post être la solution la plus simple. Je le répète, la solution ici:

Modèle De Vue:

using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
...

public class SomeVm : ViewModelBase {

    public SomeVm() {
        SelectItemsCommand = new RelayCommand<IList>((items) => {
            Selected.Clear();
            foreach (var item in items) Selected.Add((SomeClass)item);
        });

        ViewCommand = new RelayCommand(() => {
            foreach (var selected in Selected) {
                //todo do something with selected items
            }
        });
    }

    public List<SomeClass> Selected { get; set; }
    public RelayCommand<IList> SelectionChangedCommand { get; set; }
    public RelayCommand ViewCommand { get; set; }
}

XAML:

<Window
    ...
    xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
    xmlns:command="http://www.galasoft.ch/mvvmlight"
    ...
    <DataGrid
        Name="SomeGrid"
        ...
        <i:Interaction.Triggers>
            <i:EventTrigger EventName="SelectionChanged">
                <command:EventToCommand
                    Command="{Binding SelectionChangedCommand}"
                    CommandParameter="{Binding SelectedItems, ElementName=SomeGrid}" />
            </i:EventTrigger>
        </i:Interaction.Triggers>
        ...
        <DataGrid.ContextMenu>
            <ContextMenu>
                <MenuItem Header="View" Command="{Binding ViewCommand}" />
            </ContextMenu>
        </DataGrid.ContextMenu>
        ...