none
Como organizar grid pelo tamanho do numero. RRS feed

  • Pergunta

  • Galera, na minha grid tenho uma coluna de códigos, mas quando organizo ela, ela nao organiza pelo tamanho do numero, e sim por indices. Queria organizar pelo tamanho do numero. Segue imagem em anexo.

    Alguem me da uma forcinha ai?

    quarta-feira, 7 de março de 2018 00:35

Respostas

  • Olá bom dia,

    Com relação ao Componente "DataGridView", possui uma sincronia melhor com o tipo de dados BindList<T> para databind, no entanto é necessário fazer algumas modificações para que a ordenação funcione para todas as Colunas, conforme https://msdn.microsoft.com/en-us/library/ms993236.aspx?f=255&MSPPError=-2147217396:

    Primeiro vamos criar uma classe que Herde de BindList<T> e criarmos o núcleo de ordenação.

    public class SortableBindingList<T> : BindingList<T> where T : class
        {
            private bool _isSorted;
            private ListSortDirection _sortDirection = ListSortDirection.Ascending;
            private PropertyDescriptor _sortProperty;
    
            /// <summary>
            /// Initializes a new instance of the <see cref="SortableBindingList{T}"/> class.
            /// </summary>
            public SortableBindingList()
            {
            }
    
            /// <summary>
            /// Initializes a new instance of the <see cref="SortableBindingList{T}"/> class.
            /// </summary>
            /// <param name="list">An <see cref="T:System.Collections.Generic.IList`1" /> of items to be contained in the <see cref="T:System.ComponentModel.BindingList`1" />.</param>
            public SortableBindingList(IList<T> list)
                : base(list)
            {
            }
    
            /// <summary>
            /// Gets a value indicating whether the list supports sorting.
            /// </summary>
            protected override bool SupportsSortingCore
            {
                get { return true; }
            }
    
            /// <summary>
            /// Gets a value indicating whether the list is sorted.
            /// </summary>
            protected override bool IsSortedCore
            {
                get { return _isSorted; }
            }
    
            /// <summary>
            /// Gets the direction the list is sorted.
            /// </summary>
            protected override ListSortDirection SortDirectionCore
            {
                get { return _sortDirection; }
            }
    
            /// <summary>
            /// Gets the property descriptor that is used for sorting the list if sorting is implemented in a derived class; otherwise, returns null
            /// </summary>
            protected override PropertyDescriptor SortPropertyCore
            {
                get { return _sortProperty; }
            }
    
            /// <summary>
            /// Removes any sort applied with ApplySortCore if sorting is implemented
            /// </summary>
            protected override void RemoveSortCore()
            {
                _sortDirection = ListSortDirection.Ascending;
                _sortProperty = null;
                _isSorted = false; //thanks Luca
            }
    
            /// <summary>
            /// Sorts the items if overridden in a derived class
            /// </summary>
            /// <param name="prop"></param>
            /// <param name="direction"></param>
            protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
            {
                _sortProperty = prop;
                _sortDirection = direction;
    
                List<T> list = Items as List<T>;
                if (list == null) return;
    
                list.Sort(Compare);
    
                _isSorted = true;
                //fire an event that the list has been changed.
                OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
            }
    
    
            private int Compare(T lhs, T rhs)
            {
                var result = OnComparison(lhs, rhs);
                //invert if descending
                if (_sortDirection == ListSortDirection.Descending)
                    result = -result;
                return result;
            }
    
            private int OnComparison(T lhs, T rhs)
            {
                object lhsValue = lhs == null ? null : _sortProperty.GetValue(lhs);
                object rhsValue = rhs == null ? null : _sortProperty.GetValue(rhs);
                if (lhsValue == null)
                {
                    return (rhsValue == null) ? 0 : -1; //nulls are equal
                }
                if (rhsValue == null)
                {
                    return 1; //first has value, second doesn't
                }
                if (lhsValue is IComparable)
                {
                    return ((IComparable)lhsValue).CompareTo(rhsValue);
                }
                if (lhsValue.Equals(rhsValue))
                {
                    return 0; //both are the same
                }
                //not comparable, compare ToString
                return lhsValue.ToString().CompareTo(rhsValue.ToString());
            }
        }

    Bom agora basta realizar o databind, fiz um exemplo com a classe Aluno:

          SortableBindingList<Aluno> alunos = new SortableBindingList<Aluno>()
                {
                    new Aluno() { ID = 10 , Nome = "Felipe Santos" },
                    new Aluno() {  ID = 2, Nome = "Tamara Neves"},
                    new Aluno() { ID = 3, Nome = "Edson Loris" }
                };
                this.dataGridView1.DataSource = alunos;

    Repare que é adicionado um botão de ordenação:

    Sendo assim poderá ordenar por qualquer coluna, há sim, caso queira iniciar com uma coluna já ordenada basta adicionar o código abaixo:

         this.dataGridView1.DataSource = alunos;
         dataGridView1.Sort(dataGridView1.Columns[0], ListSortDirection.Ascending); //ESSE AQUI

    Espero ter ajudado! Um abraço!

    quarta-feira, 7 de março de 2018 13:34