Resuelva el problema de que DataGridView no se puede ordenar después de vincular la Lista

En el pasado, las tablas no siempre se usaban para vincular directamente DataGridView y no había ningún problema de no poder ordenar. Cuando probé List por primera vez, descubrí que la función de clasificación no se podía implementar sin importar nada.

Cada columna de DataGridView tiene un Sortable. El valor predeterminado es Automático. Lo cambié a NotSortable. No importa cuál sea el resultado, todavía no funciona.

Algunos amigos dijeron que puedes arrastrar un control de fuente vinculante.

Descubrí que tampoco funciona, entonces, ¿qué debo hacer? Infórmate después de comprobar la información.

El uso de genéricos perderá las características de DateTable. Debe implementar System.Collections.Generic.IComparer<T> para lograr la clasificación.

No hay otra manera que darse cuenta

Eche un vistazo al código a continuación, básicamente se ve así

código
usando Sistema;
usando System.ComponentModel;
usando System.Collections.Generic;
usando System.Reflection;

función base del espacio de nombres
{
clase ObjectPropertyCompare<T>: System.Collections.Generic.IComparer<T>
{
propiedad privada PropertyDescriptor;
dirección privada ListSortDirection;

public ObjectPropertyCompare (propiedad PropertyDescriptor, dirección ListSortDirection)
{
esta.propiedad = propiedad;
esta.dirección = dirección;
}

#región IComparer<T>

/// <resumen>
/// Método de comparación
/// </summary>
/// <param name="x">Atributo relativo x</param>
/// <param name="y">Atributo relativo y</param>
/// <devoluciones></devoluciones>
comparación int pública (T x, T y)
{
objeto xValue = x.GetType().GetProperty(propiedad.Nombre).GetValue(x, null);
objeto yValue = y.GetType().GetProperty(property.Name).GetValue(y, null);

int valor de retorno;

si (xValue es IComparable)
{
returnValue = ((IComparable)xValue).CompareTo(yValue);
}
de lo contrario si (xValue.Equals(yValue))
{
valorderetorno = 0;
}
demás
{
returnValue = xValue.ToString().CompareTo(yValue.ToString());
}

si (dirección == ListSortDirection.Ascending)
{
devolver valor de retorno;
}
demás
{
devolver valor de retorno * -1;
}
}

public bool es igual a (T xPalabra, T yPalabra)
{
devolver xWord.Equals(yWord);
}

público int GetHashCode (T obj)
{
devolver obj.GetHashCode();
}

#regiónfinal
}
}

Después de implementar esta interfaz, no hay prisa. Tenemos que escribir una clase SortableBindingList <T> :BindingList <T> para vincular datos.

Implementación básica

código
usando Sistema;
usando System.ComponentModel;
usando System.Collections.Generic;
usando System.IO;
usando System.Runtime.Serialization.Formatters.Binary;
usando System.Text;

función base del espacio de nombres
{
clase pública BindingCollection<T>: BindingList<T>
{
bool privado está ordenado;
propiedad descriptiva de propiedad privada sortProperty;
lista privadaOrdenarDirectionordenarDirection;

bool de anulación protegida IsSortedCore
{
obtener {retorno está ordenado}
}

bool de anulación protegida SupportsSortingCore
{
obtener {regresar verdadero}
}

anulación protegida ListSortDirection SortDirectionCore
{
obtener {return sortDirection}
}

anulación protegida PropertyDescriptor SortPropertyCore
{
obtener {return sortProperty}
}

bool de anulación protegida SupportsSearchingCore
{
obtener {regresar verdadero}
}

anulación protegida void ApplySortCore (propiedad PropertyDescriptor, dirección ListSortDirection)
{
Lista<T> elementos = this.Items as List<T>;

si (elementos! = nulo)
{
ObjectPropertyCompare<T> pc = new ObjectPropertyCompare<T>(propiedad, dirección);
artículos.Ordenar(pc);
está ordenado = verdadero;
}
demás
{
está ordenado = falso;
}

ordenarProperty = propiedad;
sortDirection = dirección;

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

anulación protegida anulación RemoveSortCore()
{
está ordenado = falso;
this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
//Clasificar
Ordenación vacía pública (propiedad PropertyDescriptor, dirección ListSortDirection)
{
this.ApplySortCore(propiedad, dirección);
}
}
}

Ahora es el momento de descubrir cómo usarlo. En realidad, es muy simple.

directo

BindingCollection<objeto> objList = nueva BindingCollection<objeto>();
objList =tu conjunto de resultados;
this.dataGridView1.DataSource = objList;

Pero ahora el problema es que usé List antes y no quiero cambiarlo. Además, se llama al Dll y lo que se devuelve es una Lista. No tengo forma de cambiarlo a BindingCollection<object>.

Después de pensarlo durante mucho tiempo, finalmente lo descubrí, pero no sé cómo es en términos de rendimiento y otros aspectos, así que publicaré el código y lo discutiremos.

Así lo logré

código
//Clases que pueden implementar la clasificación
BindingCollection<historyorderInfo> objList = nueva BindingCollection<historyorderInfo>();
//Cargar datos
foreach (elemento historialorderInfo en tmpList)
{
objList.Add(elemento);
}
dgvhistory.DataSource = objList;

La tmpList aquí es la lista original del sistema que usé antes para importar los datos originales a BindingCollection.

Esta determinación puede lograr el efecto que quiero. No sé qué hay de malo en esto. Espero poder recibir algún consejo de un experto, jaja.