WPF DataGrid negeert SortDescription

Ik heb het antwoord van Hendrik een beetje verbeterd om MVVM te gebruiken in plaats van een evenement.

    public static readonly DependencyProperty SortDescriptionsProperty = DependencyProperty.Register("SortDescriptions", typeof(List), typeof(ReSolverDataGrid), new PropertyMetadata(null));

    /// 

    /// Sort descriptions for when grouped LCV is being used. Due to bu*g in WCF this must be set otherwise sort is ignored.
    /// 
    /// 
    /// IN YOUR XAML, THE ORDER OF BINDINGS IS IMPORTANT! MAKE SURE SortDescriptions IS SET BEFORE ITEMSSOURCE!!! 
    /// 
    public List SortDescriptions
    {
        get { return (List)GetValue(SortDescriptionsProperty); }
        set { SetValue(SortDescriptionsProperty, value); }
    }

    protected override void OnItemsSourceChanged(System.Collections.IEnumerable oldValue, System.Collections.IEnumerable newValue)
    {
        //Only do this if the newValue is a listcollectionview - in which case we need to have it re-populated with sort descriptions due to DG bug
        if (SortDescriptions != null && ((newValue as ListCollectionView) != null))
        {
            var listCollectionView = (ListCollectionView)newValue;
            listCollectionView.SortDescriptions.AddRange(SortDescriptions);
        }

        base.OnItemsSourceChanged(oldValue, newValue);
    }

Ik gebruikte de geïnteresseerde DataGrid van kat om een ​​gedrag voor de wpf DataGrid te creëren.

The behavior saves the initial SortDescriptions and applies them on every change of ItemsSource. You can also provide a IEnumerable which will cause a resort on every change.

Gedrag

public class DataGridSortBehavior : Behavior
{
    public static readonly DependencyProperty SortDescriptionsProperty = DependencyProperty.Register(
        "SortDescriptions",
        typeof (IEnumerable),
        typeof (DataGridSortBehavior),
        new FrameworkPropertyMetadata(null, SortDescriptionsPropertyChanged));

    /// 

    ///     Storage for initial SortDescriptions
    /// 
    private IEnumerable _internalSortDescriptions;

    /// 

    ///     Property for providing a Binding to Custom SortDescriptions
    /// 
    public IEnumerable SortDescriptions
    {
        get { return (IEnumerable) GetValue(SortDescriptionsProperty); }
        set { SetValue(SortDescriptionsProperty, value); }
    }


    protected override void OnAttached()
    {
        var dpd = DependencyPropertyDescriptor.FromProperty(ItemsControl.ItemsSourceProperty, typeof (DataGrid));
        if (dpd != null)
        {
            dpd.AddValueChanged(AssociatedObject, OnItemsSourceChanged);
        }
    }

    protected override void OnDetaching()
    {
        var dpd = DependencyPropertyDescriptor.FromProperty(ItemsControl.ItemsSourceProperty, typeof (DataGrid));
        if (dpd != null)
        {
            dpd.RemoveValueChanged(AssociatedObject, OnItemsSourceChanged);
        }
    }

    private static void SortDescriptionsPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is DataGridSortBehavior)
        {
            ((DataGridSortBehavior) d).OnItemsSourceChanged(d, EventArgs.Empty);                
        }
    }

    public void OnItemsSourceChanged(object sender, EventArgs eventArgs)
    {
       //save description only on first call, SortDescriptions are always empty after ItemsSourceChanged
        if (_internalSortDescriptions == null)
        {
           //save initial sort descriptions
            var cv = (AssociatedObject.ItemsSource as ICollectionView);
            if (cv != null)
            {
                _internalSortDescriptions = cv.SortDescriptions.ToList();
            }
        }
        else
        {
           //do not resort first time - DataGrid works as expected this time
            var sort = SortDescriptions ?? _internalSortDescriptions;

            if (sort != null)
            {
                sort = sort.ToList();
                var collectionView = AssociatedObject.ItemsSource as ICollectionView;
                if (collectionView != null)
                {
                    using (collectionView.DeferRefresh())
                    {
                        collectionView.SortDescriptions.Clear();
                        foreach (var sorter in sort)
                        {
                            collectionView.SortDescriptions.Add(sorter);
                        }
                    }
                }
            }
        }
    }
}

XAML met optionele SortDescriptions-parameter

ViewModel ICollectionView Setup

View = CollectionViewSource.GetDefaultView(_collection);
View.SortDescriptions.Add(new SortDescription("Sequence", ListSortDirection.Ascending));

Optioneel: ViewModel-eigenschap voor het verstrekken van veranderbare Sorteerbeschrijvingen

public IEnumerable SortDescriptions
{
    get
    {
        return new List {new SortDescription("Sequence", ListSortDirection.Ascending)};
    }
}

Als u CollectionViewSource.GetDefaultView (..) in dezelfde verzameling aanroept, krijgt u hetzelfde collectieweergaveobject terug, wat zou kunnen verklaren waarom het toevoegen van een identieke sortdescription struct geen wijziging teweegbrengt.

fahrtenDG.Items.Refresh() kan niet werken omdat u de gebonden verzameling niet vernieuwt.

CollectionViewSource.GetDefaultView (_fahrten) .Refresh() zou moeten werken - ik zou er een verwijzing naar houden.

Van je uitleg krijg ik niet de verandering van datacontext - verander je het in een nieuw object? Als dat het geval is, moeten al uw bindingen opnieuw worden geëvalueerd. Is dit altijd dezelfde verzameling en uw Index-eigenschap op de lijstelementen verandert, en daarom verwacht u een wijziging - zo ja, uw lijstelement heeft mogelijk een INotifyPropertyChanged-implementatie nodig, want als de verzameling niet verandert, hoeft u niet verder te gaan toevlucht.

De implementatie van OnItemsSourceChanged (..) lijkt een hack :)

Ik probeerde dit probleem te omzeilen met het weergavemodel - door ICollectionUITZICHT opnieuw te maken in de getter en verwoed DeferRefresh() aan te roepen. Ik kan echter bevestigen dat Hendriks oplossing de enige is die betrouwbaar werkt. Ik wilde de volledige code hieronder plaatsen voor het geval het iemand zou helpen.

UITZICHT

UITZICHT MODEL

public ObservableCollection Info { get; private set; }
public ICollectionUITZICHT InfoSorted { get; private set; }
public IEnumerable PermanentSort { get; private set; }

DOUANE CONTROLE

public class SortableDataGrid : DataGrid
    {
        public static readonly DependencyProperty PermanentSortProperty = DependencyProperty.Register(
            "PermanentSort",
            typeof(IEnumerable),
            typeof(SortableDataGrid),
            new FrameworkPropertyMetadata(null));

        public IEnumerable PermanentSort
        {
            get { return (IEnumerable)this.GetValue(PermanentSortProperty); }
            set { this.SetValue(PermanentSortProperty, value); }
        }

        protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
        {
            var sort = this.PermanentSort;
            if (sort != null)
            {
                sort = sort.ToList();
                var collectionUITZICHT = newValue as ICollectionUITZICHT;
                if (collectionUITZICHT != null)
                {
                    using (collectionUITZICHT.DeferRefresh())
                    {
                        collectionUITZICHT.SortDescriptions.Clear();
                        foreach (SortDescription sorter in sort)
                        {
                            collectionUITZICHT.SortDescriptions.Add(sorter);
                        }
                    }
                }
            }

            base.OnItemsSourceChanged(oldValue, newValue);
        }
    }

Ik sta achter aanpak van Juergen voor het gebruik van bijgevoegd gedrag. Omdat mijn versie van dit probleem echter ontstond toen ik het CollectionViewSource-object in de viewmodelklasse had gedeclareerd, vond ik het directer om het probleem op te lossen door de gebeurtenishandler SortDescriptions_CollectionChanged toe te voegen, zoals weergegeven in de onderstaande code . Deze code valt volledig binnen de klasse van het weergavemodel.

public CollectionViewSource FilteredOptionsView
{
    get
    {
        if (_filteredOptionsView == null)
        {
            _filteredOptionsView = new CollectionViewSource
            {
                Source = Options,
                IsLiveSortingRequested = true
            };
            SetOptionsViewSorting(_filteredOptionsView);
            _filteredOptionsView.View.Filter = o => ((ConstantOption)o).Value != null;
        }
        return _filteredOptionsView;
    }
}
private CollectionViewSource _filteredOptionsView;

protected void SetOptionsViewSorting(CollectionViewSource viewSource)
{
   //define the sorting
    viewSource.SortDescriptions.Add(_optionsViewSortDescription);
   //subscribe to an event in order to handle a bug caused by the DataGrid that may be
   //bound to the CollectionViewSource
    ((INotifyCollectionChanged)viewSource.View.SortDescriptions).CollectionChanged
                                    += SortDescriptions_CollectionChanged;
}

protected static SortDescription _optionsViewSortDescription
                    = new SortDescription("SortIndex", ListSortDirection.Ascending);

void SortDescriptions_CollectionChanged(Object sender, NotifyCollectionChangedEventArgs e)
{
    var collection = sender as SortDescriptionCollection;
    if (collection == null) return;
   //The SortDescriptions collection should always contain exactly one SortDescription.
   //However, when DataTemplate containing the DataGrid bound to the ICollectionView
   //is unloaded, the DataGrid erroneously clears the collection.
    if (collection.None())
        collection.Add(_optionsViewSortDescription);
}

Bedankt! Dit maakte me gek! Ik heb je code aangepast om aan mijn behoeften te voldoen. Het blijft in principe de soort beschrijvingen en herstelt ze wanneer ze worden weggeblazen. Dit kan anderen helpen:

private List SortDescriptions = null;

protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
{
 if (newValue is CollectionView collectionView)
  if (SortDescriptions == null)
   SortDescriptions = new List(collectionView.SortDescriptions);
  else
   foreach (SortDescription sortDescription in SortDescriptions)
    collectionView.SortDescriptions.Add(sortDescription);

 base.OnItemsSourceChanged(oldValue, newValue);
}