Resolva o problema de que o DataGridView não pode ser classificado após vincular a lista

No passado, as tabelas nem sempre eram usadas para vincular diretamente o DataGridView e não havia problema em não conseguir classificar. Quando tentei o List pela primeira vez, descobri que a função de classificação não poderia ser implementada, não importa o que acontecesse.

Cada coluna do DataGridView possui um Classificável. O padrão é Automático. Alterei para NotSortable.

Alguns amigos disseram que você pode arrastar um controle bindsource.datasource=coleção genérica datagridview.datasource=bindingsource;

Descobri que também não funciona, então o que devo fazer? Descubra depois de verificar as informações

O uso de genéricos perderá as características de DateTable. Você deve implementar System.Collections.Generic.IComparer<T> para obter a classificação.

Não há outra maneira senão perceber isso

Dê uma olhada no código abaixo, basicamente se parece com isso

código
usando o sistema;
usando System.ComponentModel;
usando System.Collections.Generic;
usando System.Reflection;

namespace BaseFunction
{
classe ObjectPropertyCompare<T>: System.Collections.Generic.IComparer<T>
{
propriedade privada PropertyDescriptor;
direção ListSortDirection privada;

public ObjectPropertyCompare (propriedade PropertyDescriptor, direção ListSortDirection)
{
esta.propriedade = propriedade;
this.direction = direção;
}

#region IComparer<T>

/// <resumo>
/// Método de comparação
/// </sumário>
/// <param name="x">Atributo relativo x</param>
/// <param name="y">Atributo relativo y</param>
/// <retorna></retorna>
público int Comparar (T x, T y)
{
objeto xValue = x.GetType().GetProperty(property.Name).GetValue(x, null);
objeto yValue = y.GetType().GetProperty(property.Name).GetValue(y, null);

int valor de retorno;

if (xValue é IComparable)
{
returnValue = ((IComparable)xValue).CompareTo(yValue);
}
senão if (xValue.Equals(yValue))
{
valorderetorno = 0;
}
outro
{
returnValue = xValue.ToString().CompareTo(yValue.ToString());
}

if (direção == ListSortDirection.Ascendente)
{
return valorderetorno;
}
outro
{
return valorderetorno * -1;
}
}

bool público Igual a (T xWord, T yWord)
{
retornar xWord.Equals(yWord);
}

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

#endregion
}
}

Depois de implementar esta interface, não há pressa. Temos que escrever uma classe SortableBindingList <T> :BindingList <T> para vincular os dados.

Implementação básica

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

namespace BaseFunction
{
classe pública BindingCollection<T> : BindingList<T>
{
bool privado é classificado;
private PropertyDescriptor sortProperty;
private ListSortDirection sortDirection;

substituição protegida bool IsSortedCore
{
obter {retornar é classificado};
}

substituição protegida bool SupportsSortingCore
{
obter {retornar verdadeiro};
}

substituição protegida ListSortDirection SortDirectionCore
{
obter { return sortDirection }
}

substituição protegida PropertyDescriptor SortPropertyCore
{
obter {retornar propriedade de classificação};
}

substituição protegida bool SupportsSearchingCore
{
obter {retornar verdadeiro};
}

substituição protegida void ApplySortCore (propriedade PropertyDescriptor, direção ListSortDirection)
{
Lista<T> itens = this.Items as List<T>;

if (itens! = nulo)
{
ObjectPropertyCompare<T> pc = new ObjectPropertyCompare<T>(propriedade, direção);
itens.Classificar(pc);
isOrdenado = verdadeiro;
}
outro
{
isOrdenado = falso;
}

sortProperty = propriedade;
sortDirection = direção;

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

substituição protegida nula RemoveSortCore()
{
isOrdenado = falso;
this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
//Organizar
public void Sort (propriedade PropertyDescriptor, direção ListSortDirection)
{
this.ApplySortCore(propriedade, direção);
}
}
}

Agora é hora de descobrir como usá-lo. Na verdade, é muito simples.

direto

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

Mas agora o problema é que eu usei List antes e não quero alterá-lo. Além disso, a DLL é chamada e o que é retornado é uma List, não tenho como alterá-la para BindingCollection<object>.

Depois de muito pensar nisso, finalmente descobri, mas não sei como é em termos de desempenho e outros aspectos, então vou postar o código e vamos discutir.

Foi assim que consegui

código
//Classes que podem implementar ordenação
BindingCollection<historyorderInfo> objList = new BindingCollection<historyorderInfo>();
//Carrega dados
foreach (item historicorderInfo em tmpList)
{
objList.Add(item);
}
dgvhistory.DataSource = objList;

O tmpList aqui é a lista original do sistema que usei antes para importar os dados originais para o BindingCollection.

Essa determinação pode alcançar o efeito que desejo. Não sei o que há de errado nisso. Espero poder receber conselhos de um especialista, haha