Die Sortierung von benutzerdefinierten Spalten in einem DataGridView an eine BindingList

ENDGÜLTIGE Bearbeitung/Antwort: ich kann nicht denken, ein Weg, dies zu tun, während immer noch die Sortier-Mechanismus integriert das DataGridView. Wenn ich in deinen Schuhen wäre, würde ich wahrscheinlich ändern Sie einfach die SortMode jeder Spalte auf "Programmatische" und dann mit der "ColumnHeaderMouseClick" selbst. An diesem Punkt sollten Sie rufen eine sort-Methode in Ihrer modifizierten BindingList-Klasse, die die Sortierung durchzuführen, wie dies nach dem, welche Spalte geklickt wurde. Dies vermeidet die Verwendung der Sort-Methode des DGV und die Art der zugrunde liegenden Liste direkt.

Vollständigen Diskurs, der Sich in den Kommentaren Abschnitt. Original-Antwort folgt sofort:

EDIT: Aufgrund einiger Verwirrung über das problem und die anschließende Diskussion darüber, ich habe einen neuen Vorschlag unten in den Kommentaren mit dieser Antwort. Ich bin dabei die ursprüngliche Antwort, die ich gepostet, damit wir auf ihn verweisen zu können.

Ich vor kurzem hatte, dies zu tun - und ich werde nicht Lügen, es war eine echte Schmerzen. Ich habe eine Lösung (mit Hilfe von einigen Freunden hier bei), SO hier geht. Ich habe eine neue IComparer-basierte Schnittstelle, können Sie angeben, sowohl eine Spalten-und eine Richtung. Ich habe das nur getan, weil ich brauche meine Sortierung code so allgemein wie möglich - ich habe ZWEI Netze, die Notwendigkeit, Art, wie dieser, und ich will nicht behaupten zweimal den code. Hier ist die Schnittstelle, ganz einfach:

   public interface IByColumnComparer : IComparer
   {
      string SortColumn { get; set; }
      bool SortDescending { get; set; }
   }

Offensichtlich, wenn Sie nicht besorgt über die Dinge zu halten, die generische (sollte man wohl), als dies ist nicht unbedingt notwendig. Dann baute ich eine neue Klasse, basierend auf BindingList<>. Dies erlaubte mir, zu überschreiben Sortieren-code und meinen eigenen IByColumnComparer auf eine Spalte um Spalte basis das ist, was erlaubt die Flexibilität, die ich brauchte. Check this out:

public class SortableGenericCollection<T> : BindingList<T>
{
  IByColumnComparer GenericComparer = null; 

  public SortableGenericCollection(IByColumnComparer SortingComparer)
  {
     GenericComparer = SortingComparer;
  }


  protected override bool SupportsSortingCore
  {
     get
     {
        return true;
     }
  }

  protected override bool IsSortedCore
  {
     get
     {
        for (int i = 0; i < Items.Count - 1; ++i)
        {
           T lhs = Items[i];
           T rhs = Items[i + 1];
           PropertyDescriptor property = SortPropertyCore;
           if (property != null)
           {
              object lhsValue = lhs == null ? null :
              property.GetValue(lhs);
              object rhsValue = rhs == null ? null :
              property.GetValue(rhs);
              int result;
              if (lhsValue == null)
              {
                 result = -1;
              }
              else if (rhsValue == null)
              {
                 result = 1;
              }
              else
              {
                 result = GenericComparer.Compare(lhs, rhs); 
              }
              if (result >= 0)
              {
                 return false;
              }
           }
        }
        return true;
     }
  }

  private ListSortDirection sortDirection;
  protected override ListSortDirection SortDirectionCore
  {
     get
     {
        return sortDirection;
     }
  }

  private PropertyDescriptor sortProperty;
  protected override PropertyDescriptor SortPropertyCore
  {
     get
     {
        return sortProperty;
     }
  }

  protected override void ApplySortCore(PropertyDescriptor prop,
  ListSortDirection direction)
  {
     sortProperty = prop;
     sortDirection = direction;

     GenericComparer.SortColumn = prop.Name;
     GenericComparer.SortDescending = direction == ListSortDirection.Descending ? true : false;

     List<T> list = (List<T>)Items;
     list.Sort(delegate(T lhs, T rhs)
     {
        if (sortProperty != null)
        {
           object lhsValue = lhs == null ? null :
           sortProperty.GetValue(lhs);
           object rhsValue = rhs == null ? null :
           sortProperty.GetValue(rhs);
           int result;
           if (lhsValue == null)
           {
              result = -1;
           }
           else if (rhsValue == null)
           {
              result = 1;
           }
           else
           {
              result = GenericComparer.Compare(lhs, rhs);
           }
           return result;
        }
        else
        {
           return 0;
        }
     });
  }

  protected override void RemoveSortCore()
  {
     sortDirection = ListSortDirection.Ascending;
     sortProperty = null;
  }
}

Nun, wie Sie sehen können, in der ApplySortCore Methode, erhalte ich die Spalte und die Richtung direkt aus dem DataGridView - das heißt, ich fordere nicht das programmgesteuert. Das klingt nicht, was Sie tun möchten, aber Sie können leicht ändern Sie diesen code, wenn Sie anrufen möchten, müssen Sie programmgesteuert und übergeben Sie die entsprechende IByColumnComparer. Mein Punkt in der Ihnen zeigt all dies, damit Sie verstehen können, wie das ändern der Sortier-Algorithmus, die sehr nützlich ist.

Besonderen Dank an @MartinhoFernandes für die Anregungen dazu, dass wir in dieser Klasse mehr Generika.

InformationsquelleAutor Chris Barlow