Annuler la sélection combobox dans WPF avec MVVM

cela peut être réalisé de manière générique et compacte en utilisant le comportement Générique de Blend .

le comportement définit une propriété de dépendance appelée SelectedItem , et vous devez mettre votre reliure dans cette propriété, au lieu de la propriété SelectedItem de ComboBox. Le comportement est en charge de transmettre les changements dans la propriété de dépendance au ComboBox (ou plus généralement, au sélecteur), et lorsque le sélecteur SelectedItem change, il tente de le céder à sa propre propriété SelectedItem . Si la tâche échoue (probablement parce que le setter VM proeprty lié a rejeté la tâche), le comportement met à jour le sélecteur SelectedItem avec la valeur courante de sa propriété SelectedItem .

pour toutes sortes de raisons, vous pouvez rencontrer des cas où la liste des éléments dans le sélecteur est effacée, et l'élément sélectionné devient null (voir cette question ). Vous n'avez généralement pas vous voulez que votre propriété VM devienne nulle dans ce cas. Pour cela, j'ai ajouté la propriété de dépendance IgnoreNullSelection, ce qui est vrai par défaut. Cela devrait résoudre un tel problème.

c'est la classe CancellableSelectionBehavior :

using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Interactivity;

namespace MySampleApp
{
    internal class CancellableSelectionBehavior : Behavior<Selector>
    {
        protected override void OnAttached()
        {
            base.OnAttached();
            AssociatedObject.SelectionChanged += OnSelectionChanged;
        }

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

        public static readonly DependencyProperty SelectedItemProperty =
            DependencyProperty.Register("SelectedItem", typeof(object), typeof(CancellableSelectionBehavior),
                new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSelectedItemChanged));

        public object SelectedItem
        {
            get { return GetValue(SelectedItemProperty); }
            set { SetValue(SelectedItemProperty, value); }
        }

        public static readonly DependencyProperty IgnoreNullSelectionProperty =
            DependencyProperty.Register("IgnoreNullSelection", typeof(bool), typeof(CancellableSelectionBehavior), new PropertyMetadata(true));

        /// <summary>
        /// Determines whether null selection (which usually occurs since the combobox is rebuilt or its list is refreshed) should be ignored.
        /// True by default.
        /// </summary>
        public bool IgnoreNullSelection
        {
            get { return (bool)GetValue(IgnoreNullSelectionProperty); }
            set { SetValue(IgnoreNullSelectionProperty, value); }
        }

        /// <summary>
        /// Called when the SelectedItem dependency property is changed.
        /// Updates the associated selector's SelectedItem with the new value.
        /// </summary>
        private static void OnSelectedItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var behavior = (CancellableSelectionBehavior)d;

            // OnSelectedItemChanged can be raised before AssociatedObject is assigned
            if (behavior.AssociatedObject == null)
            {
                System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
                {
                    var selector = behavior.AssociatedObject;
                    selector.SelectedValue = e.NewValue;
                }));
            }
            else
            {
                var selector = behavior.AssociatedObject;
                selector.SelectedValue = e.NewValue;
            }
        }

        /// <summary>
        /// Called when the associated selector's selection is changed.
        /// Tries to assign it to the <see cref="SelectedItem"/> property.
        /// If it fails, updates the selector's with  <see cref="SelectedItem"/> property's current value.
        /// </summary>
        private void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (IgnoreNullSelection && (e.AddedItems == null || e.AddedItems.Count == 0)) return;
            SelectedItem = AssociatedObject.SelectedItem;
            if (SelectedItem != AssociatedObject.SelectedItem)
            {
                AssociatedObject.SelectedItem = SelectedItem;
            }
        }
    }
}

C'est la façon de L'utiliser dans XAML:

<Window x:Class="MySampleApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="My Smaple App" Height="350" Width="525"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:local="clr-namespace:MySampleApp"
        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
        mc:Ignorable="d"
        d:DataContext="{d:DesignInstance local:MainWindowViewModel}">
    <StackPanel>
        <ComboBox ItemsSource="{Binding Options}">
            <i:Interaction.Behaviors>
                <local:CancellableSelectionBehavior SelectedItem="{Binding Selected}" />
            </i:Interaction.Behaviors>
        </ComboBox>
    </StackPanel>
</Window>

et ceci est un échantillon de la propriété VM:

private string _selected;

public string Selected
{
    get { return _selected; }
    set
    {
        if (IsValidForSelection(value))
        {
            _selected = value;
        }
    }
}

solution très simple pour .NET 4.5.1+:

<ComboBox SelectedItem="{Binding SelectedItem, Delay=10}" ItemsSource="{Binding Items}"  />

Ça marche pour moi, dans la plupart des cas. Vous pouvez faire reculer la sélection dans combobox, juste le feu NotifyPropertyChanged sans assignation de valeur.

j'ai trouvé une réponse beaucoup plus simple à cette question par l'utilisateur shaun sur un autre fil: https://stackoverflow.com/a/6445871/2340705

le problème de base est que la propriété changed event est avalée. Certains auraient appelé ce un bug. Pour contourner cette utilisation BeginInvoke du répartiteur pour forcer la propriété changed event à être remis dans la file d'attente end of UI event. Cela ne nécessite aucun changement au xaml, aucune classe de comportement supplémentaire, et un une seule ligne de code changée pour le modèle de vue.

le problème est qu'une fois que WPF met à jour la valeur avec la propriété setter, il ignore toute autre notification de changement de propriété de l'intérieur de cet appel: il suppose qu'ils se produiront comme une partie normale du setter et sont sans conséquence, même si vous avez réellement mis à jour la propriété retour à la valeur originale.

la façon dont j'ai contourné ce problème était de permettre au champ d'être mis à jour, mais aussi de faire la queue sur une action du répartiteur pour" annuler " le changement. Action il faudrait revenir à l'ancienne valeur et lancer une notification de changement de propriété pour que WPF réalise que ce n'est pas vraiment la nouvelle valeur qu'il pensait qu'elle était.

de toute évidence, l'action" Annuler " doit être mise en place afin qu'elle ne déclenche aucune logique commerciale dans votre programme.

j'ai eu le même problème, causes par UI thread et la façon dont biding fonctionne. Vérifier le lien suivant: SelectedItem on ComboBox

la structure de l'échantillon utilise le code derrière mais le MVVM est exactement le même.

je préfère le code de" splintor " à "AngelWPF". Leurs approches sont assez similaires. J'ai mis en œuvre le comportement ci-joint, Annulableselectionbehavior, et il fonctionne comme annoncé. Peut-être que c'était juste que le code dans l'exemple de splintor était plus facile à brancher dans mon application. Le code dans le comportement ci-joint D'AngelWPF avait des références à un type de KeyValuePair qui aurait exigé plus de modification de code.

dans ma demande, j'avais ComboBox où les éléments affichés dans un DataGrid sont basés sur l'élément sélectionné dans le ComboBox. Si l'Utilisateur a fait des changements à la DataGrid, puis a sélectionné un nouvel élément dans le ComboBox, je voudrais demander à l'utilisateur de sauvegarder les changements avec les boutons Oui|Non|annuler comme options. S'ils ont appuyé sur Cancel, je voulais ignorer leur nouvelle sélection dans le ComboBox et garder l'ancienne sélection. Ça a marché comme un champion!

pour ceux qui effraient au moment où ils voient des références à Mélange et du Système.Windows.Interactivité, vous ne devez pas avoir Microsoft Expression Blend installé. Vous pouvez télécharger le SDK Blend pour .NET 4 (ou Silverlight).

Blend SDK for .NET 4

Blend SDK for Silverlight 4

Oh, oui, dans mon XAML, j'utilise ce que ma déclaration d'espace de noms pour se Fondre dans cet exemple:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

voici le flux général que j'utilise (ne nécessite aucun comportement ou modifications XAML):

1. j'ai juste laissé le changement passer à travers le modèle de vue et de garder la trace de ce qui est passé avant. (Si votre logique commerciale exige que l'élément sélectionné ne soit pas dans un état invalide, je suggère de le déplacer du côté du modèle). Cette approche est également conviviale pour les listes de diffusion qui sont rendues en utilisant des boutons Radio Comme faire la sortie SelectedItem setter dès que possible n'empêchera pas les boutons radio d'être mis en évidence lorsqu'une boîte de message s'affiche.
2. j'appelle immédiatement l'événement OnPropertyChanged indépendamment de la valeur transmise.

3. j'ai mis n'importe quelle logique d'annulation dans un handler et j'ai appelé cela en utilisant SynchronizationContext.Post() (BTW: SynchronizationContext.Post fonctionne également pour les applications Windows Store. Donc si vous avez partagé le code de ViewModel, cette approche fonctionnerait quand même).

   public class ViewModel : INotifyPropertyChanged
   {
       public event PropertyChangedEventHandler PropertyChanged;
   
       public List<string> Items { get; set; }
   
       private string _selectedItem;
       private string _previouslySelectedItem;
       public string SelectedItem
       {
           get
           {
               return _selectedItem;
           }
           set
           {
               _previouslySelectedItem = _selectedItem;
               _selectedItem = value;
               if (PropertyChanged != null)
               {
                   PropertyChanged(this, new PropertyChangedEventArgs("SelectedItem"));
               }
               SynchronizationContext.Current.Post(selectionChanged, null);
           }
       }
   
       private void selectionChanged(object state)
       {
           if (SelectedItem != Items[0])
           {
               MessageBox.Show("Cannot select that");
               SelectedItem = Items[0];
           }
       }
   
       public ViewModel()
       {
           Items = new List<string>();
           for (int i = 0; i < 10; ++i)
           {
               Items.Add(string.Format("Item {0}", i));
           }
       }
   }
   

Je l'ai fait d'une manière similaire à ce que splintor a ci-dessus.

Votre point de vue:

<ComboBox  
ItemsSource="{Binding CompetitorBrands}" 
DisplayMemberPath="Value" 
SelectedValuePath="Key" 
SelectedValue="{Binding Path=CompMfgBrandID, 
Mode=TwoWay,
UpdateSourceTrigger=Explicit}" //to indicate that you will call UpdateSource() manually to get the property "CompMfgBrandID" udpated 
SelectionChanged="ComboBox_SelectionChanged"  //To fire the event from the code behind the view
Text="{Binding CompMFGText}"/>

ci-dessous est le code pour le gestionnaire D'événements" ComboBox_SelectionChanged " à partir du fichier de code derrière la vue. Par exemple, si vous affichez est mavue.xaml, le nom de fichier de code de ce gestionnaire d'événements devrait être myview.XAML.cs

private int previousSelection = 0; //Give it a default selection value

private bool promptUser true; //to be replaced with your own property which will indicates whether you want to show the messagebox or not.

private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ComboBox comboBox = (ComboBox) sender;
            BindingExpression be = comboBox.GetBindingExpression(ComboBox.SelectedValueProperty);

            if (comboBox.SelectedValue != null && comboBox.SelectedIndex != previousSelection)
            {
                if (promptUser) //if you want to show the messagebox..
                {
                    string msg = "Click Yes to leave previous selection, click No to stay with your selection.";
                    if (MessageBox.Show(msg, "Confirm", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes) //User want to go with the newest selection
                    {

                        be.UpdateSource(); //Update the property,so your ViewModel will continue to do something
                        previousSelection = (int)comboBox.SelectedIndex;  
                    }
                    else //User have clicked No to cancel the selection
                    {
                        comboBox.SelectedIndex = previousSelection; //roll back the combobox's selection to previous one
                    }
                }
                else //if don't want to show the messagebox, then you just have to update the property as normal.
                {
                    be.UpdateSource();
                    previousSelection = (int)comboBox.SelectedIndex;
                }
            }
        }

je pense que le problème est que le ComboBox définit l'élément sélectionné à la suite de l'action de l'utilisateur après avoir défini la valeur de propriété liée. Ainsi, L'élément Combobox change peu importe ce que vous faites dans le modèle de vue. J'ai trouvé une approche différente où vous n'avez pas à plier le modèle MVVM. Voici mon exemple (désolé qu'il soit copié de mon projet et ne corresponde pas exactement aux exemples ci-dessus):

public ObservableCollection<StyleModelBase> Styles { get; }

public StyleModelBase SelectedStyle {
  get { return selectedStyle; }
  set {
    if (value is CustomStyleModel) {
      var buffer = SelectedStyle;
      var items = Styles.ToList();
      if (openFileDialog.ShowDialog() == true) {
        value.FileName = openFileDialog.FileName;
      }
      else {
        Styles.Clear();
        items.ForEach(x => Styles.Add(x));
        SelectedStyle = buffer;
        return;
      }
    }
    selectedStyle = value;
    OnPropertyChanged(() => SelectedStyle);
  }
}

la différence est que je nettoie complètement les articles collectionner et ensuite remplir avec les articles stockés auparavant. Cela force le Combobox à se mettre à jour car j'utilise la classe Generic ObservableCollection. Puis j'ai remis l'article sélectionné à l'article sélectionné qui avait été mis précédemment. Cela n'est pas recommandé pour beaucoup d'articles parce que le nettoyage et le remplissage du combobox est un peu coûteux.

je voudrais compléter réponse de splintor parce que je suis tombé sur un problème avec l'initialisation retardée dans OnSelectedItemChanged :

quand OnSelectedItemChanged est soulevé avant AssociatedObject est assigné, en utilisant le System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke peut avoir des effets secondaires indésirables, tels que d'essayer d'initialiser la nouvelle valeur avec la valeur par défaut de la sélection combobox.

donc même si votre modèle de vue est à jour, le comportement va déclencher un changement de la valeur actuelle SelectedItem de ViewModel vers la sélection par défaut du ComboBox stocké dans e.NewValue . Si votre code déclenche une Boîte de Dialogue, l'utilisateur sera averti d'un changement bien qu'il n'y est aucune. Je ne peux pas expliquer pourquoi cela arrive, probablement un problème de synchronisation.

Voici mon fix

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Interactivity;

namespace MyApp
{
    internal class CancellableSelectionBehaviour : Behavior<Selector>
    {
        protected override void OnAttached()
        {
            base.OnAttached();

            if (MustPerfomInitialChange)
            {
                OnSelectedItemChanged(this, InitialChangeEvent);
                MustPerfomInitialChange = false;
            }

            AssociatedObject.SelectionChanged += OnSelectionChanged;
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();

            AssociatedObject.SelectionChanged -= OnSelectionChanged;
        }

        public static readonly DependencyProperty SelectedItemProperty =
            DependencyProperty.Register("SelectedItem", typeof(object), typeof(CancellableSelectionBehaviour),
                new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSelectedItemChanged));

        public object SelectedItem
        {
            get { return GetValue(SelectedItemProperty); }
            set { SetValue(SelectedItemProperty, value); }
        }

        public static readonly DependencyProperty IgnoreNullSelectionProperty =
            DependencyProperty.Register("IgnoreNullSelection", typeof(bool), typeof(CancellableSelectionBehaviour), new PropertyMetadata(true));

        /// <summary>
        /// Determines whether null selection (which usually occurs since the combobox is rebuilt or its list is refreshed) should be ignored.
        /// True by default.
        /// </summary>
        public bool IgnoreNullSelection
        {
            get { return (bool)GetValue(IgnoreNullSelectionProperty); }
            set { SetValue(IgnoreNullSelectionProperty, value); }
        }

        /// <summary>
        /// OnSelectedItemChanged can be raised before AssociatedObject is assigned so we must delay the initial change. 
        /// Using System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke has unwanted side effects.
        /// So we use this bool to know if OnSelectedItemChanged must be called afterwards, in OnAttached
        /// </summary>
        private bool MustPerfomInitialChange { get; set; }

        /// <summary>
        /// OnSelectedItemChanged can be raised before AssociatedObject is assigned so we must delay the initial change. 
        /// Using System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke has unwanted side effects.
        /// So we use this DependencyPropertyChangedEventArgs to save the argument needed to call OnSelectedItemChanged.
        /// </summary>
        private DependencyPropertyChangedEventArgs InitialChangeEvent { get; set; }

        /// <summary>
        /// Called when the SelectedItem dependency property is changed.
        /// Updates the associated selector's SelectedItem with the new value.
        /// </summary>
        private static void OnSelectedItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var behavior = (CancellableSelectionBehaviour)d;

            // OnSelectedItemChanged can be raised before AssociatedObject is assigned so we must delay the initial change.
            if (behavior.AssociatedObject == null)
            {
                behavior.InitialChangeEvent = e;
                behavior.MustPerfomInitialChange = true;               
            }
            else
            {
                var selector = behavior.AssociatedObject;
                selector.SelectedValue = e.NewValue;               
            }
        }

        /// <summary>
        /// Called when the associated selector's selection is changed.
        /// Tries to assign it to the <see cref="SelectedItem"/> property.
        /// If it fails, updates the selector's with  <see cref="SelectedItem"/> property's current value.
        /// </summary>
        private void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (IgnoreNullSelection && (e.AddedItems == null || e.AddedItems.Count == 0)) return;
            SelectedItem = AssociatedObject.SelectedItem;
            if (SelectedItem != AssociatedObject.SelectedItem)
            {
                AssociatedObject.SelectedItem = SelectedItem;
            }
        }
    }
}