Comment soutenir ListBox SelectedItems liaison avec MVVM dans un navigables application

Essayez de créer un IsSelected de propriété sur chacun de vos éléments de données et de liaison ListBoxItem.IsSelected à la propriété

<Style TargetType="{x:Type ListBoxItem}">
    <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}" />
</Style>

Je ne pouvais pas obtenir de Rachel solution fonctionne, comment je le voulais, mais j'ai trouvé Sandesh de l' réponse de créer un personnalisé propriété de dépendance fonctionne parfaitement pour moi. J'ai juste eu à écrire du code similaire pour une ListBox:

public class ListBoxCustom : ListBox
{
    public ListBoxCustom()
    {
        SelectionChanged += ListBoxCustom_SelectionChanged;
    }

    void ListBoxCustom_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        SelectedItemsList = SelectedItems;
    }

    public IList SelectedItemsList
    {
        get { return (IList)GetValue(SelectedItemsListProperty); }
        set { SetValue(SelectedItemsListProperty, value); }
    }

    public static readonly DependencyProperty SelectedItemsListProperty =
       DependencyProperty.Register("SelectedItemsList", typeof(IList), typeof(ListBoxCustom), new PropertyMetadata(null));

}

Dans mon Modèle de Vue je viens de référence de la propriété pour obtenir ma liste sélectionnée.

Pas satisfait avec les réponses que j'essayais d'en trouver un par moi-même...
Eh bien il s'avère à être plus comme un hack alors une solution, mais pour moi, ce qui fonctionne parfaitement. Cette Solution utilise MultiBindings d'une manière spéciale.
D'abord, il peut ressembler à une tonne de Code, mais vous pouvez la réutiliser avec très peu d'effort.

J'ai d'abord mis en œuvre une "IMultiValueConverter'

public class SelectedItemsMerger : IMultiValueConverter
{
    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
    {
        SelectedItemsContainer sic = values[1] as SelectedItemsContainer;

        if (sic != null)
            sic.SelectedItems = values[0];

        return values[0];
    }

    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
    {
        return new[] { value };
    }
}

Et un SelectedItems Conteneurs/Emballage:

public class SelectedItemsContainer
{
    ///Nothing special here...
    public object SelectedItems { get; set; }
}

Maintenant nous allons créer la Liaison de notre zone de liste.SelectedItem (Au Singulier). Remarque: Vous devez créer une Ressource statique pour le "Converter". Cela peut être fait une fois par l'application et être réutilisées pour toutes les listes qui ont besoin du convertisseur.

<ListBox.SelectedItem>
 <MultiBinding Converter="{StaticResource SelectedItemsMerger}">
  <Binding Mode="OneWay" RelativeSource="{RelativeSource Self}" Path="SelectedItems"/>
  <Binding Path="SelectionContainer"/>
 </MultiBinding>
</ListBox.SelectedItem>

Dans le ViewModel j'ai créé le Récipient où je peux lier. Il est important d'initialiser avec new() afin de le remplir avec les valeurs.

    SelectedItemsContainer selectionContainer = new SelectedItemsContainer();
    public SelectedItemsContainer SelectionContainer
    {
        get { return this.selectionContainer; }
        set
        {
            if (this.selectionContainer != value)
            {
                this.selectionContainer = value;
                this.OnPropertyChanged("SelectionContainer");
            }
        }
    }

Et c'est tout. Peut-être que quelqu'un voit quelques améliorations?
Qu'en pensez-Vous?

C'était une question importante pour moi, certaines des réponses que j'ai vu étaient trop hackish, ou à la réinitialisation de l' SelectedItems valeur de la propriété de la rupture de tout code associé à des propriétés OnCollectionChanged événement. Mais j'ai réussi à obtenir une solution réalisable par la modification de la collecte directement et en bonus, il prend même en charge SelectedValuePath pour les collections d'objets.

public class MultipleSelectionListBox : ListBox
{
internal bool processSelectionChanges = false;
public static readonly DependencyProperty BindableSelectedItemsProperty =
DependencyProperty.Register("BindableSelectedItems",
typeof(object), typeof(MultipleSelectionListBox),
new FrameworkPropertyMetadata(default(ICollection<object>),
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnBindableSelectedItemsChanged));
public dynamic BindableSelectedItems
{
get => GetValue(BindableSelectedItemsProperty);
set => SetValue(BindableSelectedItemsProperty, value);
}
protected override void OnSelectionChanged(SelectionChangedEventArgs e)
{
base.OnSelectionChanged(e);
if (BindableSelectedItems == null || !this.IsInitialized) return; //Handle pre initilized calls
if (e.AddedItems.Count > 0)
if (!string.IsNullOrWhiteSpace(SelectedValuePath))
{
foreach (var item in e.AddedItems)
if (!BindableSelectedItems.Contains((dynamic)item.GetType().GetProperty(SelectedValuePath).GetValue(item, null)))
BindableSelectedItems.Add((dynamic)item.GetType().GetProperty(SelectedValuePath).GetValue(item, null));
}
else
{
foreach (var item in e.AddedItems)
if (!BindableSelectedItems.Contains((dynamic)item))
BindableSelectedItems.Add((dynamic)item);
}
if (e.RemovedItems.Count > 0)
if (!string.IsNullOrWhiteSpace(SelectedValuePath))
{
foreach (var item in e.RemovedItems)
if (BindableSelectedItems.Contains((dynamic)item.GetType().GetProperty(SelectedValuePath).GetValue(item, null)))
BindableSelectedItems.Remove((dynamic)item.GetType().GetProperty(SelectedValuePath).GetValue(item, null));
}
else
{
foreach (var item in e.RemovedItems)
if (BindableSelectedItems.Contains((dynamic)item))
BindableSelectedItems.Remove((dynamic)item);
}
}
private static void OnBindableSelectedItemsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (d is MultipleSelectionListBox listBox)
{
List<dynamic> newSelection = new List<dynamic>();
if (!string.IsNullOrWhiteSpace(listBox.SelectedValuePath))
foreach (var item in listBox.BindableSelectedItems)
{
foreach (var lbItem in listBox.Items)
{
var lbItemValue = lbItem.GetType().GetProperty(listBox.SelectedValuePath).GetValue(lbItem, null);
if ((dynamic)lbItemValue == (dynamic)item)
newSelection.Add(lbItem);
}
}
else
newSelection = listBox.BindableSelectedItems as List<dynamic>;
listBox.SetSelectedItems(newSelection);
}
}
}

Liaison fonctionne exactement comme vous l'aurait attendu MS à l'avoir fait eux-mêmes:

<uc:MultipleSelectionListBox 
ItemsSource="{Binding Items}" 
SelectionMode="Extended" 
SelectedValuePath="id" 
BindableSelectedItems="{Binding mySelection}"
/>

Il n'a pas été testé, mais a passé le premier coup d'œil les inspections. J'ai essayé de rester réutilisables, en utilisant les types de dynamiques sur les collections.

S'avère la liaison d'une case à cocher à la propriété IsSelected et de mettre le textblock et case sein d'une pile de panneau fait le tour!