WPF DataGrid CustomSort pour chaque colonne

J'ai un WPF DataGrid lié à un objet collectionviewsource qui encapsule une ObservableCollection. Cet objet collectionviewsource a deux objectifs principaux:

1) de groupe De chaque élément par une propriété spécifique de T. je suis à l'aide d'un ValueConverter dans le GroupDescription pour obtenir le regroupement de comportement que je veux.

2) Pour trier la grille par un), principalement le nom du groupe (tel que défini ci-dessus) et b) les éléments de groupe. Je suis atteinte de cet par la fixation d'une coutume IComparer à l'objet collectionviewsource " CustomSort la propriété.

Cela fonctionne très bien pour la plupart, cependant dès qu'un en-tête de colonne est cliqué, la logique de tri est remplacée. Je ne veux pas désactiver le tri, mais je me demandais si il était possible d'attribuer un ordre de tri personnalisé pour une colonne spécifique?

Pour rendre les choses un peu plus clair, supposons qu'un utilisateur clique sur 'ColumnA' - à l'heure actuelle, la logique de tri encapsulé par mon CustomSorter est ignorée et le contrôle DataGrid est maintenant triée par cette propriété. Plutôt que le tri par la propriété sélectionnée, je voudrais, au lieu d'inverser la logique de la CustomSorter.

source d'informationauteur trilson86

.net c#collectionviewsource datagrid wpf

J'ai créé un couple de propriétés attachées qui traitent ce problème. J'espère que c'est pratique pour quelqu'un!

Première - une interface simple pour votre directionalised comparer. Cela s'étend IComparer mais nous donne un de plus la propriété (SortDirection). Votre application doit utiliser pour déterminer le classement correct des éléments (qui autrement auraient été perdues).

public interface ICustomSorter : IComparer
{
    ListSortDirection SortDirection { get; set; }
}

Suivant est le comportement attaché - cela ne signifie deux choses: 1) indique la grille de tri personnalisé logique (AllowCustomSort=true) et b) nous donne la possibilité de définir cette logique au niveau des colonnes.

public class CustomSortBehaviour
{
public static readonly DependencyProperty CustomSorterProperty =
DependencyProperty.RegisterAttached("CustomSorter", typeof(ICustomSorter), typeof(CustomSortBehavior));
public static ICustomSorter GetCustomSorter(DataGridColumn gridColumn)
{
return (ICustomSorter)gridColumn.GetValue(CustomSorterProperty);
}
public static void SetCustomSorter(DataGridColumn gridColumn, ICustomSorter value)
{
gridColumn.SetValue(CustomSorterProperty, value);
}
public static readonly DependencyProperty AllowCustomSortProperty =
DependencyProperty.RegisterAttached("AllowCustomSort", typeof(bool),
typeof(CustomSortBehavior), new UIPropertyMetadata(false, OnAllowCustomSortChanged));
public static bool GetAllowCustomSort(DataGrid grid)
{
return (bool)grid.GetValue(AllowCustomSortProperty);
}
public static void SetAllowCustomSort(DataGrid grid, bool value)
{
grid.SetValue(AllowCustomSortProperty, value);
}
private static void OnAllowCustomSortChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var existing = d as DataGrid;
if (existing == null) return;
var oldAllow = (bool)e.OldValue;
var newAllow = (bool)e.NewValue;
if (!oldAllow && newAllow)
{
existing.Sorting += HandleCustomSorting;
}
else
{
existing.Sorting -= HandleCustomSorting;
}
}
private static void HandleCustomSorting(object sender, DataGridSortingEventArgs e)
{
var dataGrid = sender as DataGrid;
if (dataGrid == null || !GetAllowCustomSort(dataGrid)) return;
var listColView = dataGrid.ItemsSource as ListCollectionView;
if (listColView == null)
throw new Exception("The DataGrid's ItemsSource property must be of type, ListCollectionView");
//Sanity check
var sorter = GetCustomSorter(e.Column);
if (sorter == null) return;
//The guts.
e.Handled = true;
var direction = (e.Column.SortDirection != ListSortDirection.Ascending)
? ListSortDirection.Ascending
: ListSortDirection.Descending;
e.Column.SortDirection = sorter.SortDirection = direction;
listColView.CustomSort = sorter;
}
}

De l'utiliser, de mettre en œuvre un ICustomComparer (avec un constructeur sans paramètre) et dans votre XAML:

<UserControl.Resources>
<converters:MyComparer x:Key="MyComparer"/>
<!-- add more if you need them -->
</UserControl.Resources>
<DataGrid behaviours:CustomSortBehaviour.AllowCustomSort="True" ItemsSource="{Binding MyListCollectionView}">
<DataGrid.Columns>
<DataGridTextColumn Header="Test" Binding="{Binding MyValue}" behaviours:CustomSortBehaviour.CustomSorter="{StaticResource MyComparer}" />
</DataGrid.Columns>
</DataGrid>

4

La réponse donnée par trilson86 est excellent. Cependant, le troisième paramètre dans les deux DependencyProperty déclarations est incorrect. Au lieu de DataGrid et DataGridColumn, ils devraient être CustomSortBehaviour, en tant que tel:
```
public static readonly DependencyProperty AllowCustomSortProperty =
DependencyProperty.RegisterAttached("AllowCustomSort", 
typeof(bool),
typeof(CustomSortBehaviour), //<- Here
new UIPropertyMetadata(false, OnAllowCustomSortChanged));
public static readonly DependencyProperty CustomSorterProperty =
DependencyProperty.RegisterAttached("CustomSorter", 
typeof(ICustomSorter), 
typeof(CustomSortBehaviour));  //<- Here
```
J'ai continué à obtenir un avertissement que le AllowCustomSort propriété était déjà inscrit. Une petite recherche m'a conduit à la réponse ici.

En tout cas, c'est une excellente réponse, alors je vous remercie.
2

Je l'ai fait en remplaçant la OnSorting de l'événement et la mise en œuvre moi-même.

http://msdn.microsoft.com/en-us/library/system.windows.controls.datagrid.onsorting.aspx

Qui essentiellement signifie re de tri de la ListCollectionView.

Désolé ce n'est pas trop en profondeur une réponse.

J'ai changé @trilson86 la réponse de sorte que vous avez seulement besoin d'un custom trieur de classe pour l'ensemble de la grille de données.

D'abord l'Interface:

public interface ICustomSorter : IComparer
{
ListSortDirection SortDirection { get; set; }
string SortMemberPath { get; set; }
}

Suivant la Bevaviour de la classe qui définit la CustomSorterProperty de telle façon que vous pouvez l'utiliser directement sur la grille de données, pas sur le DateGridRow. Dans HandleCustomSorting() de la propriété SortMemberPath de la CustomSorter ist rempli avec la valeur réelle de la colonne, vous pouvez utiliser cette valeur dans votre CustomSorter pour trier à l'encontre de la colonne souhaitée.

public class CustomSortBehaviour
{
#region Fields and Constants
public static readonly DependencyProperty CustomSorterProperty =
DependencyProperty.RegisterAttached("CustomSorter", typeof (ICustomSorter), typeof (CustomSortBehaviour));
public static readonly DependencyProperty AllowCustomSortProperty =
DependencyProperty.RegisterAttached("AllowCustomSort",
typeof (bool),
typeof (CustomSortBehaviour),
new UIPropertyMetadata(false, OnAllowCustomSortChanged));
#endregion
#region public Methods
public static bool GetAllowCustomSort(DataGrid grid)
{
return (bool) grid.GetValue(AllowCustomSortProperty);
}
public static ICustomSorter GetCustomSorter(DataGrid grid)
{
return (ICustomSorter)grid.GetValue(CustomSorterProperty);
}
public static void SetAllowCustomSort(DataGrid grid, bool value)
{
grid.SetValue(AllowCustomSortProperty, value);
}
public static void SetCustomSorter(DataGrid grid, ICustomSorter value)
{
grid.SetValue(CustomSorterProperty, value);
}
#endregion
#region nonpublic Methods
private static void HandleCustomSorting(object sender, DataGridSortingEventArgs e)
{
var dataGrid = sender as DataGrid;
if (dataGrid == null || !GetAllowCustomSort(dataGrid))
{
return;
}
var listColView = dataGrid.ItemsSource as ListCollectionView;
if (listColView == null)
{
throw new Exception("The DataGrid's ItemsSource property must be of type, ListCollectionView");
}
//Sanity check
var sorter = GetCustomSorter(dataGrid);
if (sorter == null)
{
return;
}
//The guts.
e.Handled = true;
var direction = (e.Column.SortDirection != ListSortDirection.Ascending)
? ListSortDirection.Ascending
: ListSortDirection.Descending;
e.Column.SortDirection = sorter.SortDirection = direction;
sorter.SortMemberPath = e.Column.SortMemberPath;
listColView.CustomSort = sorter;
}
private static void OnAllowCustomSortChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var existing = d as DataGrid;
if (existing == null)
{
return;
}
var oldAllow = (bool) e.OldValue;
var newAllow = (bool) e.NewValue;
if (!oldAllow && newAllow)
{
existing.Sorting += HandleCustomSorting;
}
else
{
existing.Sorting -= HandleCustomSorting;
}
}
#endregion
}

Vous pouvez l'utiliser dans le code XAML comme ceci:

<Window x:Class="..."
xmlns:sorter="clr-namespace:...Sorting"
...
>
<Window.Resources>
<sorter:CustomSorter x:Key="MySorter"/>
</Window.Resources>
<Grid>
<DataGrid ItemsSource="{Binding ...}"
sorter:CustomSortBehaviour.AllowCustomSort="True"
sorter:CustomSortBehaviour.CustomSorter="{StaticResource MySorter}" >
<DataGrid.Columns>
<DataGridTextColumn Header="Column 1" Binding="{Binding Column1}"/>
<DataGridTextColumn Header="Column 2" Binding="{Binding Column2}"/>
<DataGridTextColumn Header="Column 3" Binding="{Binding Column3}"/>
</DataGrid.Columns>
</DataGrid>
</Grid>
</Window>

voici de l'extension de @trilson86 ICustomeSorter

qui font de la Trieuse plus générique à utiliser

NumericComparer basé sur cette ressource

http://www.codeproject.com/Articles/11016/Numeric-String-Sort-in-C

public class GenericNumericComparer : ICustomSorter
{
private PropertyInfo _propertyInfo;
private Type _objectType;
public string SortMemberPath { get; set; }
private readonly NumericComparer _comparer = new NumericComparer();
public Type ObjectType
{
get { return _objectType; }
set
{
_objectType = value;
if (_objectType != null) _propertyInfo = ObjectType.GetProperty(SortMemberPath);
}
}
private int CompareHelper(object x, object y)
{
if (_propertyInfo != null)
{
var value1 = _propertyInfo.GetValue(x);
var value2 = _propertyInfo.GetValue(y);
return _comparer.Compare(value1, value2);
}
return 0;
}
public int Compare(object x, object y)
{
var i = CompareHelper(x, y);
if (SortDirection == ListSortDirection.Ascending)
return i;
return i*-1;
}
public ListSortDirection SortDirection { get; set; }
}

-2

vous pouvez l'utiliser dans le cas où vous ajoutant les colonnes par programmation .

dg_show.Items.SortDescriptions.Add(new System.ComponentModel.SortDescription("val1", System.ComponentModel.ListSortDirection.Descending));

"val1" ici, c'est le chemin de liaison pour la colonne, nous avons ajouté , et vous pouvez également utiliser une autre ligne comme un deuxième tri . comme celui-ci .

        dg_show.Items.SortDescriptions.Add(new System.ComponentModel.SortDescription("val2", System.ComponentModel.ListSortDirection.Ascending));

Vous devez vous connecter pour publier un commentaire.