none
Ordenar Colunas DataGridView RRS feed

Respostas

  • Olá Guilherme,

     dessa maneira não seria possivel pois se verificar sua classe base chamada "BindingList" no construtor ela espera o tipo IList<T> ou seja que seja uma coleção que implemente os métodos da interface IList, o que pode ser feito é alterar o retorno como mencionado ou criar sua própria classe de ordenação.

    • Marcado como Resposta Marcos SJ sexta-feira, 11 de março de 2016 19:35
    sexta-feira, 11 de março de 2016 11:21

Todas as Respostas

  • Olá Guilherme Walter,

    Tudo bem?

    Poderia compartilhar aqui o seu código?

    Atenciosamente


    Marcos SJ

    Esse conteúdo e fornecido sem garantias de qualquer tipo, seja expressa ou implícita

    MSDN Community Support

    Por favor, lembre-se de Marcar como Resposta as postagens que resolveram o seu problema. Essa é uma maneira comum de reconhecer aqueles que o ajudaram e fazer com que seja mais fácil para os outros visitantes encontrarem a resolução mais tarde.

    sexta-feira, 4 de março de 2016 20:23
  • Classe SortableBindingList 

     public class SortableBindingList<T> : BindingList<T>
        {
            private readonly Dictionary<Type, PropertyComparer<T>> comparers;
            private bool isSorted;
            private ListSortDirection listSortDirection;
            private PropertyDescriptor propertyDescriptor;
    
            public SortableBindingList()
                : base(new List<T>())
            {
                this.comparers = new Dictionary<Type, PropertyComparer<T>>();
            }
    
            public SortableBindingList(IEnumerable<T> enumeration)
                : base(new List<T>(enumeration))
            {
                this.comparers = new Dictionary<Type, PropertyComparer<T>>();
            }
    
            protected override bool SupportsSortingCore
            {
                get { return true; }
            }
    
            protected override bool IsSortedCore
            {
                get { return this.isSorted; }
            }
    
            protected override PropertyDescriptor SortPropertyCore
            {
                get { return this.propertyDescriptor; }
            }
    
            protected override ListSortDirection SortDirectionCore
            {
                get { return this.listSortDirection; }
            }
    
            protected override bool SupportsSearchingCore
            {
                get { return true; }
            }
    
            protected override void ApplySortCore(PropertyDescriptor property, ListSortDirection direction)
            {
                List<T> itemsList = (List<T>)this.Items;
    
                Type propertyType = property.PropertyType;
                PropertyComparer<T> comparer;
                if (!this.comparers.TryGetValue(propertyType, out comparer))
                {
                    comparer = new PropertyComparer<T>(property, direction);
                    this.comparers.Add(propertyType, comparer);
                }
    
                comparer.SetPropertyAndDirection(property, direction);
                itemsList.Sort(comparer);
    
                this.propertyDescriptor = property;
                this.listSortDirection = direction;
                this.isSorted = true;
    
                this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
            }
    
            protected override void RemoveSortCore()
            {
                this.isSorted = false;
                this.propertyDescriptor = base.SortPropertyCore;
                this.listSortDirection = base.SortDirectionCore;
    
                this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
            }
    
            protected override int FindCore(PropertyDescriptor property, object key)
            {
                int count = this.Count;
                for (int i = 0; i < count; ++i)
                {
                    T element = this[i];
                    if (property.GetValue(element).Equals(key))
                    {
                        return i;
                    }
                }
    
                return -1;
            }
        }
    }

    Classe PropertyCompare

    public class PropertyComparer<T> : IComparer<T>
        {
            private readonly IComparer comparer;
            private PropertyDescriptor propertyDescriptor;
            private int reverse;
    
            public PropertyComparer(PropertyDescriptor property, ListSortDirection direction)
            {
                this.propertyDescriptor = property;
                Type comparerForPropertyType = typeof(Comparer<>).MakeGenericType(property.PropertyType);
                this.comparer = (IComparer)comparerForPropertyType.InvokeMember("Default", BindingFlags.Static | BindingFlags.GetProperty | BindingFlags.Public, null, null, null);
                this.SetListSortDirection(direction);
            }
    
            #region IComparer<T> Members
    
            public int Compare(T x, T y)
            {
                return this.reverse * this.comparer.Compare(this.propertyDescriptor.GetValue(x), this.propertyDescriptor.GetValue(y));
            }
    
            #endregion
    
            private void SetPropertyDescriptor(PropertyDescriptor descriptor)
            {
                this.propertyDescriptor = descriptor;
            }
    
            private void SetListSortDirection(ListSortDirection direction)
            {
                this.reverse = direction == ListSortDirection.Ascending ? 1 : -1;
            }
    
            public void SetPropertyAndDirection(PropertyDescriptor descriptor, ListSortDirection direction)
            {
                this.SetPropertyDescriptor(descriptor);
                this.SetListSortDirection(direction);
            }
    
        }
    }

    No método que popula o grid eu faço assim:

                    int limit = Convert.ToInt32(ComboRegistroCliente.SelectedItem); //pegar valor do combo
                    SortableBindingList<Cliente> clientes = new SortableBindingList<Cliente>(Cliente.FindAll().Take(limit).ToList());
                    this.GridConsultaCliente.DataSource = clientes;

    Quando utiliza  BindingSource igual abaixo apresenta o erro conforme a imagem:

     BindingSource bds = new BindingSource();
                    List<Cliente> clientes = Cliente.FindAll();
    
                    using (var conexao = new Conexao())
                    {
                        bds.DataSource = (from cli in clientes
                                         where cli.AtivoInativo == 1
                                         && cli.DataNascimento != null && (
                                         cli.DataNascimento.Value.Day == DateTime.Now.Day
                                         && cli.DataNascimento.Value.Month == DateTime.Now.Month)
                                         select new
                                         {
                                             Id = cli.Id,
                                             NomeRazao = cli.NomeRazao,
                                             DataNascimento = cli.DataNascimento,
                                             Fone = cli.Fone,
                                             Fone2 = cli.Fone2,
                                             Celular = cli.Celular,
                                             Celular2 = cli.Celular2,
                                             Email = cli.EmailPrincipal,
                                             AtivoInativo = cli.AtivoInativo
                                         }); //SELECT PARA MONTAR A TELA                         
                    }
    
                    return bds;

    sexta-feira, 4 de março de 2016 20:48
  • Olá Guilherme, 

     o erro é pq sua classe possui esse construtor :

     public SortableBindingList(IEnumerable<T> enumeration)
                : base(new List<T>(enumeration))
            {
                this.comparers = new Dictionary<Type, PropertyComparer<T>>();
            }
     Veja que espera o Tipo IEnumerable<T> onde T é a sua classe tipada, no seu método você retorna o tipo Binding Source, então não vai funcionar mesmo ! Sugestão retorna da sua classe uma Lista usando método extensão "ToList()" e depois com retorno da sua classe transforme para Binding Source ou utilize como lista mesmo. Pq se utilizar dessa maneira vai necessitar mexer na sua classe SortableBinding.

    • Marcado como Resposta Marcos SJ segunda-feira, 7 de março de 2016 20:25
    • Não Marcado como Resposta Guilherme Walter terça-feira, 8 de março de 2016 02:29
    segunda-feira, 7 de março de 2016 11:45
  • Tens como dar um exemplo Daniel de como ficaria? essa classe eu peguei ela pronta, e ela faz as ordenação de todas colunas Crescente/Decrescente clicando em cima da coluna.
    • Editado Guilherme Walter terça-feira, 8 de março de 2016 02:39 erro digitacao
    terça-feira, 8 de março de 2016 02:29
  • Olá,

     o exemplo seria de seu método ? Se for veja:

                    List<Cliente> clientes = Cliente.FindAll();
    
                    using (var conexao = new Conexao())
                    {
                        clientes = (from cli in clientes
                                         where cli.AtivoInativo == 1
                                         && cli.DataNascimento != null && (
                                         cli.DataNascimento.Value.Day == DateTime.Now.Day
                                         && cli.DataNascimento.Value.Month == DateTime.Now.Month)
                                         select new Cliente
                                         {
                                             Id = cli.Id,
                                             NomeRazao = cli.NomeRazao,
                                             DataNascimento = cli.DataNascimento,
                                             Fone = cli.Fone,
                                             Fone2 = cli.Fone2,
                                             Celular = cli.Celular,
                                             Celular2 = cli.Celular2,
                                             Email = cli.EmailPrincipal,
                                             AtivoInativo = cli.AtivoInativo
                                         }); //SELECT PARA MONTAR A TELA                         
                    }
    
                    return clientes;
     Na verdade basta retornar uma coleção de clientes.

    quarta-feira, 9 de março de 2016 11:48
  • E quando for assim:

     public static BindingSource MontaGrid(int limit)
            {
                try
                {
                    BindingSource bds = new BindingSource();
                    List<Cep> lCeps = Cep.FindAll();
                    List<Fornecedor> lFornecedor = Fornecedor.FindAll();
    
                    if (lFornecedor.Count <= 0)
                        return null;//
    
                    using (var conexao = new Conexao())
                    {
                        bds.DataSource = (from F in lFornecedor
                                          join C in lCeps on F.IdCep equals C.Id into _cep
                                          from leftCep in _cep.DefaultIfEmpty()
                                          orderby F.Id ascending
                                          select new 
                                          { 
                                              Id = F.Id,
                                              IdCep = F.IdCep,
                                              RazaoNome = F.RazaoNome,
                                              CnpjCpf = F.CnpjCpf,
                                              Cidade = (string.IsNullOrEmpty(leftCep.Cidade) ? string.Empty : leftCep.Cidade),
                                              Telefone = F.Telefone
                                          }).Take(limit); //SELECT PARA MONTAR A TELA                    
    
                    }
    
                    return bds;
    

    quarta-feira, 9 de março de 2016 14:45
  • Olá Guilherme,

     dessa maneira não seria possivel pois se verificar sua classe base chamada "BindingList" no construtor ela espera o tipo IList<T> ou seja que seja uma coleção que implemente os métodos da interface IList, o que pode ser feito é alterar o retorno como mencionado ou criar sua própria classe de ordenação.

    • Marcado como Resposta Marcos SJ sexta-feira, 11 de março de 2016 19:35
    sexta-feira, 11 de março de 2016 11:21
  • Certo, e para criar a propria classe de ordenação, voce tem um exemplo ou ja fez algo assim? não tem como alterar a classe BindingList para que também consiga ordenar BindingSource
    sábado, 12 de março de 2016 01:13
  • Olá,

     nunca fiz não ! Essa classe teria que alterar toda estrutrura sendo que a ordenação na classe base utiliza o tipo "List<T>" ! 

    segunda-feira, 21 de março de 2016 11:55
  • Seria mais fácil criar uma nova para usar nesses casos, mas eu não sei como fazer. você tem algum outro método de ordenar as colunas?
    segunda-feira, 21 de março de 2016 13:56
  • Olá amigo,

    infelizmente não tenho, se utilizar WPF ordenação é automaticamente não havendo a necessidade de utilizar classes para isso.

    domingo, 27 de março de 2016 01:08