Annuler zone de liste déroulante de sélection en WPF avec MVVM

Pour atteindre ce sous MVVM....

1] Ont un comportement attaché à un qui gère la SelectionChanged cas de la zone de liste déroulante. Cet événement est déclenché avec certains des événements les arguments qui ont Handled drapeau. Mais la valeur true est inutile pour SelectedValue de liaison. La liaison des mises à jour de la source, indépendamment de savoir si l'événement a été géré.

2] Donc nous allons configurer le ComboBox.SelectedValue liaison à TwoWay et Explicit.

3] Uniquement lorsque votre vérifier est satisfait et messagebox dit Yes est lorsque nous effectuons BindingExpression.UpdateSource(). Sinon, nous appelons simplement la BindingExpression.UpdateTarget() pour revenir à l'ancien de sélection.

---

Dans mon exemple ci-dessous, j'ai une liste de KeyValuePair<int, int> lié au contexte de données de la fenêtre. Le ComboBox.SelectedValue est lié à une simple écriture MyKey propriété de la Window.

XAML ...

    <ComboBox ItemsSource="{Binding}"
              DisplayMemberPath="Value"
              SelectedValuePath="Key"
              SelectedValue="{Binding MyKey,
                                      ElementName=MyDGSampleWindow,
                                      Mode=TwoWay,
                                      UpdateSourceTrigger=Explicit}"
              local:MyAttachedBehavior.ConfirmationValueBinding="True">
    </ComboBox>

Où MyDGSampleWindow est le x:Nom de la Window.

Code Derrière ...

public partial class Window1 : Window
{
    private List<KeyValuePair<int, int>> list1;

    public int MyKey
    {
        get; set;
    }

    public Window1()
    {
        InitializeComponent();

        list1 = new List<KeyValuePair<int, int>>();
        var random = new Random();
        for (int i = 0; i < 50; i++)
        {
            list1.Add(new KeyValuePair<int, int>(i, random.Next(300)));
        }

        this.DataContext = list1;
    }
 }

Et la comportement attaché à

public static class MyAttachedBehavior
{
public static readonly DependencyProperty
ConfirmationValueBindingProperty
= DependencyProperty.RegisterAttached(
"ConfirmationValueBinding",
typeof(bool),
typeof(MyAttachedBehavior),
new PropertyMetadata(
false,
OnConfirmationValueBindingChanged));
public static bool GetConfirmationValueBinding
(DependencyObject depObj)
{
return (bool) depObj.GetValue(
ConfirmationValueBindingProperty);
}
public static void SetConfirmationValueBinding
(DependencyObject depObj,
bool value)
{
depObj.SetValue(
ConfirmationValueBindingProperty,
value);
}
private static void OnConfirmationValueBindingChanged
(DependencyObject depObj,
DependencyPropertyChangedEventArgs e)
{
var comboBox = depObj as ComboBox;
if (comboBox != null && (bool)e.NewValue)
{
comboBox.Tag = false;
comboBox.SelectionChanged -= ComboBox_SelectionChanged;
comboBox.SelectionChanged += ComboBox_SelectionChanged;
}
}
private static void ComboBox_SelectionChanged(
object sender, SelectionChangedEventArgs e)
{
var comboBox = sender as ComboBox;
if (comboBox != null && !(bool)comboBox.Tag)
{
var bndExp
= comboBox.GetBindingExpression(
Selector.SelectedValueProperty);
var currentItem
= (KeyValuePair<int, int>) comboBox.SelectedItem;
if (currentItem.Key >= 1 && currentItem.Key <= 4
&& bndExp != null)
{
var dr
= MessageBox.Show(
"Want to select a Key of between 1 and 4?",
"Please Confirm.",
MessageBoxButton.YesNo,
MessageBoxImage.Warning);
if (dr == MessageBoxResult.Yes)
{
bndExp.UpdateSource();
}
else
{
comboBox.Tag = true;
bndExp.UpdateTarget();
comboBox.Tag = false;
}
}
}
}
}

Dans le comportement je utiliser ComboBox.Tag propriété de stocker temporairement un drapeau qui saute le revérifier quand on revenir à l'ancienne valeur sélectionnée.

Laissez-moi savoir si cela aide.

Solution très simple pour .NET 4.5.1+:

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

Il travaille pour moi dans la plupart des cas.
Vous pouvez reprendre la sélection dans la zone de liste déroulante, il suffit de le lancer NotifyPropertyChanged sans affectation de la valeur.

Le problème est qu'une fois WPF mises à jour de la valeur du bien setter, il ignore toute autre propriété a changé de notifications à partir de l'intérieur de cet appel: il suppose qu'elles se produisent comme une partie normale de l'incubateur et sont sans conséquence, même si vous avez vraiment mis à jour la propriété à la valeur d'origine.

La façon dont je suis arrivé c'était pour permettre le champ à mettre à jour, mais aussi de la file d'attente d'une action sur le Répartiteur de "défaire" le changement. L'action se définir à l'ancienne valeur et l'incendie d'une notification de modification de propriété pour obtenir WPF pour réaliser que ce n'est pas vraiment la nouvelle valeur de ce qu'il en est.

Évidemment le "undo" action devrait être mis en place afin de ne pas le feu à toute la logique métier dans votre programme.

Je préfère "splintor du" code de l'échantillon sur "AngelWPF de l'". Leurs approches sont assez similaires, quoique. J'ai mis en œuvre le comportement attaché, CancellableSelectionBehavior, et il fonctionne comme annoncé. Peut-être qu'il était juste que le code de splintor l'exemple était plus facile à brancher dans mon application. Le code de la AngelWPF du comportement attaché a des références à un KeyValuePair Type qui aurait appelé pour plus de code altération.

Dans mon application, j'ai une zone de liste déroulante où les éléments sont affichés dans une grille de données sont basées sur l'élément sélectionné dans la liste déroulante. Si l'utilisateur a apporté des modifications à la grille de données, puis sélectionné un nouvel élément dans la zone de liste déroulante, je voudrais inviter l'utilisateur à enregistrer les modifications avec Oui|NON|Annuler les boutons d'options. Si ils ont appuyé sur Annuler, je voulais ignorer leur nouvelle sélection dans la liste déroulante et garder l'ancienne sélection. Cela a fonctionné comme un champion!

Pour ceux qui effraient le moment ils de voir des références à Mélange et du Système.De Windows.L'interactivité, vous n'avez pas Microsoft Expression Blend installé. Vous pouvez télécharger le Blend SDK pour .NET 4 (ou Silverlight).

Blend SDK pour .NET 4

Blend SDK pour Silverlight 4

Oh ouais, 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"

Je n'ai, d'une manière similaire à ce qui 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 du gestionnaire d'événement "ComboBox_SelectionChanged" à partir du fichier de code behind de la vue. Par exemple, si vous affichez est mavue.xaml, le code de nom de fichier pour ce gestionnaire d'événement doit être mavue.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 voudrais pour terminer splintor réponse parce que je suis tombé sur un problème avec le retard de l'initialisation dans OnSelectedItemChanged:

Quand OnSelectedItemChanged est soulevée devant AssociatedObject est affecté, à l'aide de la System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke peut avoir des effets secondaires indésirables, tels que de l'initialisation de l'newValue avec la valeur par défaut de la zone de liste déroulante de sélection.

Donc, même si votre ViewModel est jusqu'à ce jour, le comportement sera le déclencheur d'un changement à partir de ce Dernier est SelectedItem valeur actuelle de la sélection par défaut de la zone de liste déroulante stockées 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;
}
}
}
}