Lösen Sie das Problem, dass DataGridView nach der Bindungsliste nicht sortiert werden kann

In der Vergangenheit wurden Tabellen nicht immer zum direkten Binden von DataGridView verwendet, und es gab kein Problem, wenn ich List zum ersten Mal ausprobierte, stellte ich fest, dass die Sortierfunktion nicht implementiert werden konnte, egal was ein Freund sagte

Jede Spalte des DataGridView hat eine Sortierbarkeit. Die Standardeinstellung ist „NotSortable“. Egal, was das Ergebnis ist, es funktioniert immer noch nicht.

Einige Freunde sagten, dass man ein bindingsource-Steuerelement ziehen kann bindingsource.datasource=generische Sammlung datagridview.datasource=bindingsource;

Ich habe festgestellt, dass es auch nicht funktioniert. Was soll ich also tun? Finden Sie es heraus, nachdem Sie die Informationen überprüft haben

Durch die Verwendung von Generika gehen die Eigenschaften von DateTable verloren. Sie müssen System.Collections.Generic.IComparer<T> implementieren, um eine Sortierung zu erreichen.

Es gibt keinen anderen Weg, als es zu erkennen

Schauen Sie sich den Code unten an, er sieht im Grunde so aus

Code
Verwenden des Systems;
mit System.ComponentModel;
mit System.Collections.Generic;
Verwenden von System.Reflection;

Namespace BaseFunction
{
Klasse ObjectPropertyCompare<T>: System.Collections.Generic.IComparer<T>
{
private PropertyDescriptor-Eigenschaft;
private ListSortDirection-Richtung;

public ObjectPropertyCompare(PropertyDescriptor-Eigenschaft, ListSortDirection-Richtung)
{
this.property = Eigenschaft;
this.direction = Richtung;
}

#region IComparer<T>

/// <Zusammenfassung>
/// Vergleichsmethode
/// </summary>
/// <param name="x">Relatives Attribut x</param>
/// <param name="y">Relatives Attribut y</param>
/// <returns></returns>
public int Compare(T x, T y)
{
object xValue = x.GetType().GetProperty(property.Name).GetValue(x, null);
object yValue = y.GetType().GetProperty(property.Name).GetValue(y, null);

int returnValue;

if (xValue ist IComparable)
{
returnValue = ((IComparable)xValue).CompareTo(yValue);
}
sonst wenn (xValue.Equals(yValue))
{
returnValue = 0;
}
anders
{
returnValue = xValue.ToString().CompareTo(yValue.ToString());
}

if (direction == ListSortDirection.Ascending)
{
return returnValue;
}
anders
{
return returnValue * -1;
}
}

public bool Equals(T xWord, T yWord)
{
return xWord.Equals(yWord);
}

public int GetHashCode(T obj)
{
return obj.GetHashCode();
}

#endregion
}
}

Nach der Implementierung dieser Schnittstelle gibt es keine Eile, um eine SortableBindingList <T> :BindingList <T>-Klasse zu schreiben, um Daten zu binden.

Grundlegende Implementierung

Code
Verwenden des Systems;
mit System.ComponentModel;
mit System.Collections.Generic;
mit System.IO;
mit System.Runtime.Serialization.Formatters.Binary;
Verwenden von System.Text;

Namespace BaseFunction
{
öffentliche Klasse BindingCollection<T> : BindingList<T>
{
privater Bool isSorted;
private PropertyDescriptor sortProperty;
private ListSortDirection sortDirection;

protected override bool IsSortedCore
{
get { return isSorted }
}

protected override bool UnterstütztSortingCore
{
get { return true }
}

protected überschreiben ListSortDirection SortDirectionCore
{
get { return sortDirection }
}

protected override PropertyDescriptor SortPropertyCore
{
get { return sortProperty }
}

protected override bool Unterstützt SearchingCore
{
get { return true }
}

protected override void ApplySortCore(PropertyDescriptor-Eigenschaft, ListSortDirection-Richtung)
{
List<T> items = this.Items as List<T>;

if (items != null)
{
ObjectPropertyCompare<T> pc = new ObjectPropertyCompare<T>(property, Direction);
items.Sort(pc);
isSorted = true;
}
anders
{
isSorted = false;
}

sortProperty = Eigenschaft;
sortDirection = Richtung;

this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}

protected override void RemoveSortCore()
{
isSorted = false;
this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
//Sortieren
public void Sort(PropertyDescriptor-Eigenschaft, ListSortDirection-Richtung)
{
this.ApplySortCore(property, Direction);
}
}
}

Jetzt ist es an der Zeit, herauszufinden, wie man es benutzt. Es ist eigentlich ganz einfach.

direkt

BindingCollection<object> objList = new BindingCollection<object>();
objList =Ihre Ergebnismenge;
this.dataGridView1.DataSource = objList;

Aber jetzt ist das Problem, dass ich List zuvor verwendet habe und es nicht ändern möchte. Außerdem wird die DLL aufgerufen und es wird eine Liste zurückgegeben. Ich habe keine Möglichkeit, sie in BindingCollection<object> zu ändern.

Nachdem ich lange darüber nachgedacht hatte, habe ich es endlich herausgefunden, aber ich weiß nicht, wie es in Bezug auf Leistung und andere Aspekte ist, also werde ich den Code veröffentlichen und lass uns darüber diskutieren.

So habe ich es erreicht

Code
//Klassen, die eine Sortierung implementieren können
BindingCollection<historyorderInfo> objList = new BindingCollection<historyorderInfo>();
//Daten laden
foreach (historyorderInfo-Element in tmpList)
{
objList.Add(item);
}
dgvhistory.DataSource = objList;

Die tmpList hier ist die Originalliste des Systems, das ich zuvor verwendet habe, um die Originaldaten in die BindingCollection zu importieren.

Diese Entschlossenheit kann den gewünschten Effekt erzielen. Ich weiß nicht, was daran falsch ist. Ich hoffe, ich kann einen Rat von einem Experten bekommen, haha