WPF Combobox réinitialise l'élément sélectionné lorsque l'élément-source change

hmm, je ne sais pas s'il s'agit d'une "belle" façon, mais si vous pouvez accéder à l'élément sélectionné avant que le rechargement ne se produise, vous pouvez l'enregistrer (ou sa clé ou quelque chose), et la sélectionner de manière programmative après La recharge est terminée.

maquette rapide: p> xxx pré>

mais je suppose que vous voulez dire une autre manière que ce manuel fonctionne?
J'espère que cela vous aidera de toute façon ... p>

Mise à jour forte>

Ok je vois, d'un fil de fond.
Utilisez-vous une ICOLLECTIONVIEW pour lier votre ComboBox aussi? Si tel est le cas, vous pouvez utiliser la propriété actuelle pour conserver une référence. J'ai fait une maquette rapide et cela fonctionne sur ma configuration. Cela suppose que vous avez une référence à votre UI: p>

xaml em> p> xxx pré>

Voir / ViewModel EM> P>

public partial class Window1 : Window {
   public Window1() {
        InitializeComponent();
        this.DataContext = new ViewModel(this);
   }
}

public class ViewModel
{
    private readonly Window1 window;
    private ObservableCollection<Item> items;
    private ICollectionView view;

    public ViewModel(Window1 window) {
        this.window = window;
        items = new ObservableCollection<Item>
            {
                new Item("qwerty"),
                new Item("hello"),
                new Item("world"),
            };

        view = CollectionViewSource.GetDefaultView(items);
    }

    public ObservableCollection<Item> Items { get { return items; } }

    public ICommand UpdateCommand {
        get { return new RelayCommand(DoUpdate); }
    }

    public Item SelectedItem { get; set; }

    private void DoUpdate(object obj) {
        var act = new Func<List<Item>>(DoUpdateAsync);
        act.BeginInvoke(CallBack, act);
    }

    private List<Item> DoUpdateAsync() {
        return new List<Item> {
                new Item("hello"),
                new Item("world"),
                new Item("qwerty"),
            };
    }

    private void CallBack(IAsyncResult result) {
        try {
            var act = (Func<List<Item>>)result.AsyncState;
            var list = act.EndInvoke(result);

            window.Dispatcher.Invoke(new Action<List<Item>>(delegate(List<Item> lst) {
                                                                    var current = lst.Single(i => i.Name == ((Item)view.CurrentItem).Name);
                                                                    Items.Clear();
                                                                    lst.ForEach(Items.Add);
                                                                    view.MoveCurrentTo(current);
                                                                }), list);

        } catch(Exception exc){ Debug.WriteLine(exc); }
    }
}

public class Item {
    public Item(string name) {
        Name = name; 
    }
    public string Name { get; set; }
}

Peut-être que vous pouvez utiliser observablecollection au lieu de votre ienumerable ? Ensuite, sur changements d'arrière-plan, vous ne ferez que ajouter / supprimer des éléments qui sont nouveaux / absents dans la nouvelle liste, l'élément sélectionné devrait rester, à moins qu'il ne soit supprimé par le changement.

Vous pouvez mettre à jour votre collection observable dans un fil séparé avec un petit hack autour de .