Eu estou tentando escrever um SortableBindingList que eu possa usar para o meu aplicativo. Eu encontrei muita discussão sobre como implementar suporte básico de classificação para que o BindingList irá classificar quando usado no contexto de um DataGridView ou algum outro controle vinculado incluindo este post do StackOverflow:
Classificação do DataGridView e por ex. BindingList <T> no .NET

Isso tudo é muito útil e eu implementei o código, testei, etc. e está tudo funcionando, mas na minha situação particular, eu preciso ser capaz de suportar uma chamada simples para Sort () e fazer com que a chamada use o padrão IComparable. CompareTo () para fazer a classificação, em vez de fazer uma chamada para ApplySortCore (PropertyDescriptor, ListSortDirection).

A razão é porque eu tenho uma grande quantidade de código que depende da chamada Sort () porque essa classe em particular herdou originalmente da List e foi alterada recentemente para ser uma BindingList.

Então, especificamente, eu tenho uma classe chamada VariableCode e uma classe de coleção chamada VariableCodeList. VariableCode implementa IComparable e a lógica lá é moderadamente complexa baseada em várias propriedades, etc ...

public class VariableCode : ...  IComparable ...
{
    public int CompareTo(object p_Target)
    {
        int output = 0;
        //some interesting stuff here
        return output;
    }
}

public class VariableCodeList : SortableBindingList<VariableCode>
{
    public void Sort()
    {
        //This is where I need help
        //  How do I sort this list using the IComparable
        //  logic from the class above?
    }
}

Eu fiz algumas tentativas fracassadas de redirecionar o método ApplySortCore no Sort (), mas o que me impede é que o ApplySortCore espere que um PropertyDescriptor faça o seu tipo e eu não consigo descobrir como fazer isso para usar o IComparable Lógica .CompareTo ().

Alguém pode me apontar na direção certa?

Muito Obrigado.

EDIT: Este é o código final com base na resposta de Marc para referência futura.

  /// <summary>
  /// Sorts using the default IComparer of T
  /// </summary>
  public void Sort()
  {
     sort(null, null);
  }
  public void Sort(IComparer<T> p_Comparer)
  {
     sort(p_Comparer, null);
  }
  public void Sort(Comparison<T> p_Comparison)
  {
     sort(null, p_Comparison);
  }
  private void sort(IComparer<T> p_Comparer, Comparison<T> p_Comparison)
  {

     m_SortProperty = null;
     m_SortDirection = ListSortDirection.Ascending;

     //Extract items and sort separately
     List<T> sortList = new List<T>();
     this.ForEach(item => sortList.Add(item));//Extension method for this call
     if (p_Comparison == null)
     {
        sortList.Sort(p_Comparer);
     }//if
     else
     {
        sortList.Sort(p_Comparison);
     }//else

     //Disable notifications, rebuild, and re-enable notifications
     bool oldRaise = RaiseListChangedEvents;
     RaiseListChangedEvents = false;
     try
     {
        ClearItems();
        sortList.ForEach(item => this.Add(item));
     }
     finally
     {
        RaiseListChangedEvents = oldRaise;
        ResetBindings();
     }

  }