Сортировка List<T> по разным параметрам

 class MyClass: IComparable
    {
        private string _name;
        private string _fullname;
        private DateTime _dateCreation;
        private long _size;
  }

private List<MyClass> _listFl;

static public int MyClassCompareDate(MyFile mf1, MyFile mf2)
        {
            return mf1.CreationDate.CompareTo(mf2.CreationDate);
        }

_listFl.Sort(MyClass.MyClassCompareDate);

_listFl.Sort((a, b) => a._dateCreation.CompareTo(b._dateCreation));

=>

.Sort(delegate(MyClass a, MyClass b)
        {
            return a._dateCreation.CompareTo(b._dateCreation);
        });

  public class ListIndex<T>
  {
    private string id;
    public string ID
    {
      get { return id; }
    }
 
    private int direction;
    public int Direction
    {
      get { return direction; }
    }
 
    private List<T> list;
    public List<T> List
    {
      get { return list; }
    }
 
    public ListIndex(string id):this(id,false)
    {
    }
 
    public ListIndex(string id,bool backDirection)
    {
      this.id=id;
      list=new List<T>();
      this.direction=backDirection?-1:1;
    }
 
    public void Dispose()
    {
      if (list!=null)
      {
        list.Clear();
        list=null;
      }
    }
 
    ~ListIndex()
    {
      Dispose();
    }
  }
 
  public class IndexedList<T> where T:class
  {
    private List<T> list;
    public List<T> List
    {
      get { return list; }
    }
 
    List<ListIndex<T>> indexes;
    BindingFlags bindingAttr=BindingFlags.Public | BindingFlags.Instance;
 
    public IndexedList()
    {
      list=new List<T>();
      indexes=new List<ListIndex<T>>();
    }
 
    private bool TestField(string fieldID)
    {
      Type objType=typeof(T);
      PropertyInfo[] propertyInfo=objType.GetProperties(bindingAttr);
      for (int i=0;i<propertyInfo.Length;i++)
        if (propertyInfo[i].Name==fieldID) return true;
      return false;
    }
 
    public ListIndex<T> GetIndexator(string indexID)
    {
      for (int i=0;i<indexes.Count;i++)
      {
        ListIndex<T> index=indexes[i];
        if (index.ID==indexID)
        {
          return index;
        }
      }
      return null;
    }
 
    public int IndexInIdex(ListIndex<T> index,T obj,bool inserting)
    {
      Type objType=obj.GetType();
      object v=objType.InvokeMember(index.ID,bindingAttr | BindingFlags.GetProperty,null,obj,null);
      return Search4index(index,v,inserting);
    }
 
    public T BinarySearch(string indexID,object v)
    {
      return BinarySearch(GetIndexator(indexID),v);
    }
 
    public T BinarySearch(ListIndex<T> index,object v)
    {
      if (index!=null)
      {
        int pos=Search4index(index,v,false);
        if (pos!=-1) return index.List[pos];
      }
      return null;
    }
    
    public int Search4index(ListIndex<T> index,object v,bool inserting)
    {
      int typeCase=0;
      if (v!=null)
      {
        Type vType=v.GetType();
        if (vType==typeof(int) || vType==typeof(short) || vType==typeof(sbyte) || vType==typeof(long) || vType==typeof(char))
          typeCase=1;
        else if (vType==typeof(uint) || vType==typeof(ushort) || vType==typeof(byte) || vType==typeof(ulong))
          typeCase=2;
        else if (vType==typeof(float) || vType==typeof(double))
          typeCase=3;
        else if (vType==typeof(decimal))
          typeCase=4;
        else if (vType==typeof(string) || vType==typeof(StringBuilder))
          typeCase=5;
        else return -1;
      
        int direction=1;
        int si=0;
        int count=index.List.Count;
        int ei=count-1;
        if (count>0)
        {
          string indexID=index.ID;
          int indexDirection=index.Direction;
          Type objType=typeof(T);
          do
          {
            int i=(si+ei)/2;
 
            object v2=objType.InvokeMember(indexID,bindingAttr | BindingFlags.GetProperty,null,index.List[i],null);
            if (typeCase==0)
              if (v2==null) direction=0;
              else direction=indexDirection;
            else if (typeCase==1)
              direction=(Convert.ToInt64(v)).CompareTo(Convert.ToInt64(v2))*indexDirection;
            else if (typeCase==2)
              direction=(Convert.ToUInt64(v)).CompareTo(Convert.ToUInt64(v2))*indexDirection;
            else if (typeCase==3)
              direction=(Convert.ToDouble(v)).CompareTo(Convert.ToDouble(v2))*indexDirection;
            else if (typeCase==4)
              direction=(Convert.ToDecimal(v)).CompareTo(Convert.ToDecimal(v2))*indexDirection;
            else
              direction=v.ToString().CompareTo(v2.ToString())*indexDirection;
 
            if (direction<0) ei=i-1;
            else if (direction>0) si=i+1;
            else return i;
 
            if (inserting && si>ei)
              if (direction>0) return i+1;
              else return i;
          } while (si<=ei);
        }
        else if (inserting) return 0;
      }
 
      return -1;
    }
 
    public void Add(T obj)
    {
      list.Add(obj);
 
      //now update indexes
      for (int i=0;i<indexes.Count;i++)
      {
        int insPos=IndexInIdex(indexes[i],obj,true);
        indexes[i].List.Insert(insPos,obj);
      }
    }
 
    public void Delete(T obj)
    {
      list.Remove(obj);
      //now update indexes
      for (int i=0;i<indexes.Count;i++)
      {
        int objPos=IndexInIdex(indexes[i],obj,false);
        if (objPos!=-1) indexes[i].List.RemoveAt(objPos);
      }
    }
 
    public bool AddIndex(string id)
    {
      return AddIndex(id,false);
    }
    
    public bool AddIndex(string id,bool backDirection)
    {
      if (TestField(id))
      {
        ListIndex<T> index=new ListIndex<T>(id,backDirection);
        indexes.Add(index);
 
        //fill index list
        for (int i=0;i<list.Count;i++)
        {
          int insPos=IndexInIdex(index,list[i],true);
          index.List.Insert(insPos,list[i]);
        }
        return true;
      }
      return false;
    }
 
    public void DelIndex(string id)
    {
      for (int i=0;i<indexes.Count;i++)
        if (indexes[i].ID==id)
        {
          indexes[i].Dispose();
          indexes.RemoveAt(i);
          return;
        }
    }
 
    public void Dispose()
    {
      for (int i=0;i<indexes.Count;i++)
        indexes[i].Dispose();
      list.Clear();
    }
 
    ~IndexedList()
    {
      Dispose();
    }
  }

  public class myClass
  {
    private static Random rnd=new Random();
    public static Random Rnd
    {
      get { return rnd; }
    }
    
    private int a;
    public int A
    {
      get { return a; }
    }
    private double b;
    public double B
    {
      get { return b; }
    }
    private string s;
    public string S
    {
      get { return s; }
    }
 
    public myClass()
    {
      a=rnd.Next(1,10001);
      b=rnd.NextDouble();
      int ccount=rnd.Next(1,11);
      StringBuilder sb=new StringBuilder(10);
      for (int i=0;i<ccount;i++) sb.Append((char) rnd.Next(65,90));
      s=sb.ToString();
    }
  }

      list=new IndexedList<myClass>();
      list.AddIndex("S");
      list.AddIndex("B",true);
      for (int i=0;i<10000;i++)
        list.Add(new myClass());
      list.AddIndex("A");
 
      int count=50;
      myClass[] testArray=new myClass[count];
      for (int i=0;i<count;i++)
      {
        int j=myClass.Rnd.Next(1,10000);
        testArray[i]=list.List[j];
      }
 
      IdleTimerCore<IdleStopwatchTimer,int> timerCore2=new IdleTimerCore<IdleStopwatchTimer,int>();
      timerCore2.Add("speedTimer",10,null);
      Console.WriteLine("serial search int field");
      for (int i=0;i<count;i++)
      {
        for (int j=0;j<list.List.Count;j++)
          if (list.List[j].A==testArray[i].A)
          {
            Console.Write(list.List[j].A+" ");
            break;
          }
      }
      Console.WriteLine("\nserial search double field");
      for (int i=0;i<count;i++)
      {
        for (int j=0;j<list.List.Count;j++)
          if (list.List[j].B==testArray[i].B)
          {
            Console.Write(list.List[j].B+" ");
            break;
          }
      }
      Console.WriteLine("\nserial search string field");
      for (int i=0;i<count;i++)
      {
        for (int j=0;j<list.List.Count;j++)
          if (list.List[j].S==testArray[i].S)
          {
            Console.Write(list.List[j].S+" ");
            break;
          }
      }
      Console.WriteLine("Ellapsed time="+timerCore2.Get("speedTimer").EllapsedTime);
 
      timerCore2.Add("speedTimer",10,null);
 
      ListIndex<myClass> indexatorA=list.GetIndexator("A");
      ListIndex<myClass> indexatorB=list.GetIndexator("B");
      ListIndex<myClass> indexatorS=list.GetIndexator("S");
      Console.WriteLine("\nBinary indexed search int field");
      for (int i=0;i<count;i++)
      {
        Console.Write(list.BinarySearch(indexatorA,testArray[i].A).A+" ");
      }
      Console.WriteLine("\nBinary indexed search double field");
      for (int i=0;i<count;i++)
      {
        Console.Write(list.BinarySearch(indexatorB,testArray[i].B).B+" ");
      }
      Console.WriteLine("\nBinary indexed search string field");
      for (int i=0;i<count;i++)
      {
        Console.Write(list.BinarySearch(indexatorS,testArray[i].S).S+" ");
      }
      Console.WriteLine("\nEllapsed time="+timerCore2.Get("speedTimer").EllapsedTime);
      timerCore2.Delete("speedTimer");

Type objType=index.List[0].GetType();

Type objType=typeof(T);

    /// <summary>
    /// Change value of fieldID property of instance, which can be found
    /// by keyFieldAlias and keyValue, to value
    /// </summary>
    public bool ChangeIndexedFieldValue(string keyFieldAlias,object keyValue,
      string fieldID,object value)
    {
    }
    /// <summary>
    /// Change value of obj.fieldID property to value.
    /// it is safe for all indexer on this property
    /// </summary>
    public bool ChangeIndexedFieldValue(T obj,string fieldID,object value)
    {
    }

CompareTo(...)

: IComparable

MyFile mf1, MyFile mf2

    /// <summary>
    /// Класс содержащий 2 поля
    /// </summary>
    public class GROUPS : IComparable<GROUPS>
    {
        /// <summary>
        /// Класс содержащий 2 поля
        /// </summary>
        /// <param name="ID">Id группы VK</param>
        /// <param name="Name">Имя группы</param>
        public GROUPS(uint ID, string Name)
        {
            this.ID = ID; this.Name = Name;
        }
        public uint ID;
        public string Name;
 
        public int CompareTo(object obj)
        {
            return Name.CompareTo(obj);
        }
 
        public int CompareTo(GROUPS other)//сортировка по по полю Name
        {
            if (other == null)
                return 1;
 
            else
                return this.Name.CompareTo(other.Name);
        }
    }

List<GROUPS> Collection= new List<GROUPS>();
Collection.Add(new GROUPS(222, "Имя группы 222");
Collection.Add(new GROUPS(111, "Имя группы 111");
Collection.Add(new GROUPS(333, "Имя группы 333");
Collection.Sort();
//Результат сортировки Collection:
//111 Имя группы 111
//222 Имя группы 222
//333 Имя группы 333