WPF - Actualiser ListView lié à ViewModel

Question

J'écris une application à la minute et j'ai rencontré un problème avec un ListView qui affiche les éléments d'un modèle de vue; il y a une propriété dans ledit modèle de vue "Selected" qui est juste un booléen et, je lie ceci à la propriété "IsSelected" de ListView.

J'ai un bouton pour "Effacer la sélection" qui itère sur chaque élément sélectionné et le définit sur faux; cela fonctionne et la commande est mise à jour et les boutons ne sont plus activés car il n'y a rien où Selected == true.

En images

L'élément est sélectionné; des boutons sont disponibles.

Le bouton "Effacer la sélection" est enfoncé

À ce stade, je ne peux plus cliquer sur le contrôle pour sélectionner l'élément; Je dois contrôler cliquez dessus pour le désélectionner, ce qui remet tout comme désactivé et rien de sélectionné.

Voici le XAML pour le contrôle - je ne sais pas ce que je pourrais faire de mal, mais je suis incapable de trouver une réponse jusqu'à présent.

<ListView ItemsSource="{Binding AssignableItems, UpdateSourceTrigger=PropertyChanged}" Grid.Row="2" SelectionMode="Extended">
    <ListView.ItemContainerStyle>
        <Style TargetType="ListViewItem" BasedOn="{StaticResource lviStyleBase}">
            <Setter Property="IsSelected" Value="{Binding Selected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
        </Style>
    </ListView.ItemContainerStyle>
    <ListView.View>
        <GridView>
            <GridViewColumn Header="Created" DisplayMemberBinding="{Binding ContactCreated}" Width="Auto" />
            <GridViewColumn Header="Contact Name" DisplayMemberBinding="{Binding ContactName}" Width="Auto" />
            <GridViewColumn Header="Company" DisplayMemberBinding="{Binding Company}" Width="Auto" />
        </GridView>
    </ListView.View>
</ListView>

Voici le ViewModel:

namespace CSI.ViewModels
{
    public class AssignViewModel
        : ModelBase
    {
        #region Properties
        private bool viewingFilters;

        public bool Filtering
        {
            get { return viewingFilters; }
            set { if ( SetValue(ref viewingFilters, value) ) Notify(); }
        }

        private bool assigning;

        public bool Assigning
        {
            get { return assigning; }
            set { if ( SetValue(ref assigning, value) ) Notify(); }
        }

        private string viewTitle = "Assign";
        public string ViewTitle
        {
            get => $"{viewTitle}{(Filtered ? " (filtered)" : "")}";
        }

        private AssignFilterValuesModel filters;

        public AssignFilterValuesModel Filters
        {
            get { return filters; }
            set { SetValue(ref filters, value); }
        }

        public bool Filtered
        {
            get
            {
                if ( filters == null ) return false;

                return assignables.Count() != AssignableItems.Count();
            }
        }

        private bool loading;

        public bool Loading
        {
            get { return loading; }
            set { SetValue(ref loading, value); }
        }

        private ObservableCollection<AssignableWorkItemModel> assignables;
        public ObservableCollection<AssignableWorkItemModel> AssignableItems
        {
            get
            {
                if ( assignables == null ) return null;
                if ( Filters == null ) return assignables;

                var retval = assignables.Where(x => 1 == 1);

                if ( Filters.Dealers.Any(x => x.Selected) )
                    retval = retval.Where(x => filters.Dealers.Where(o => o.Selected).Select(o => o.Key).ToList().Contains(x.Dealer));

                if ( Filters.VehicleModels.Any(x => x.Selected) )
                    retval = retval.Where(x => filters.VehicleModels.Where(o => o.Selected).Select(o => o.Key).ToList().Contains(x.VehicleModel));

                return new ObservableCollection<AssignableWorkItemModel>(retval);
            }
            set => SetValue(ref assignables, value);
        }
        private ObservableCollection<AssignableWorkItemModel> selected;
        public ObservableCollection<AssignableWorkItemModel> SelectedItems
        {
            get => selected;
            set => SetValue(ref selected, value);
        }
        #endregion
        #region Commands
        private RelayCommand displayFilterScreen;
        public void Execute_DisplayFilters(object _)
        {
            Filtering = true;
        }
        public bool CanExecute_DisplayFilters(object _) => !Filtering;
        public RelayCommand DisplayFilters
        {
            get => displayFilterScreen ?? (displayFilterScreen = new RelayCommand(Execute_DisplayFilters, CanExecute_DisplayFilters));
        }

        private RelayCommand applyFilters;
        public void Execute_ApplyFilters(object _)
        {
            Filtering = !Filtering;
            Notify(nameof(AssignableItems));
            Notify(nameof(Filtered));
            Notify(nameof(ViewTitle));
        }
        public bool CanExecute_ApplyFilters(object _) => Filtering;
        public RelayCommand ApplyFilters
        {
            get => applyFilters ?? (applyFilters = new RelayCommand(Execute_ApplyFilters, CanExecute_ApplyFilters));
        }

        private RelayCommand doAssign;
        public void Execute_Assign(object _)
        {
            UserSelectWindow us = new UserSelectWindow();
            us.Owner = Application.Current.MainWindow;

            ViewModelServer.UserSelectVM.Prompt = "Select the user you wish to assign these items to";
        }
        public bool CanExecute_Assign(object _) => !Filtering && (bool)AssignableItems?.Any(x => x.Selected);
        public RelayCommand Assign
        {
            get => doAssign ?? (doAssign = new RelayCommand(Execute_Assign, CanExecute_Assign));
        }

        private RelayCommand clrSelection;
        public void Execute_ClearSelection(object _)
        {
            AssignableItems?.Where(x => x.Selected).ToList().ForEach(x => x.Selected = false);
        }
        public bool CanExecute_ClearSelection(object _) => (bool)AssignableItems?.Any(x => x.Selected);
        public RelayCommand ClearSelection
        {
            get => clrSelection ?? (clrSelection = new RelayCommand(Execute_ClearSelection, CanExecute_ClearSelection));
        }
        #endregion
        #region Constructors
        
        #endregion
    }
}

Answer 1

La solution consistait à ajouter une liaison pour SelectedIndex et à définir la valeur sur -1 lors de l'appel de ClearSelection; Astuce d' ici