error CS0019: Operator '<' Pomocy!!!

Mam problem z błędem error CS0019: Operator '<' cannot be applied to operands of type 'T' and 'T'.
W C++ coś takiego było dozwolone. Wiem, że można to ominąć tylko nie wiem do końca jak. Proszę o pomoc.

using System;
using System.IO;
using System.Collections.Generic;


class List<T>
{
    #region Class Node

    private class Node
    {
        private T _Item;

        public T Item
        {
            get
            {
                return _Item;
            }
            set
            {
                _Item = value;
            }
        }

        public Node(T t)
        {
            Item = t;
        }
    }
    #endregion

    #region Members

    private int BufforSize;
    private int ReSizeBuffor;
    private int Numbers;
    Node[] NewList;

    #endregion

    #region Constructors;

    public List(int newBufforSize)
    {
        if (newBufforSize <= 0) throw new ArgumentException();
        
        BufforSize = newBufforSize;
        ReSizeBuffor = newBufforSize;
        NewList = new Node[BufforSize];
        Numbers = 0;

        for (int i = 0; i < BufforSize; i++)
        {
            NewList[i] = null;
        }
    }
    #endregion

    #region Metods

    public void Print()
    {
        for (int i = 0; i < Numbers; i++)
        {
            Console.WriteLine(NewList[i].Item);
        }
    }

    public void AddNewItem(T t)
    {
        if (Numbers == BufforSize)
        {
            BufforSize += ReSizeBuffor;
            System.Array.Resize<Node>(ref NewList, BufforSize);
        }

              if (t<NewList[Numbers - 1].Item)   //chodzi o ten operator <
              {
                  int i = Numbers - 1;

                  do
                  {
                      T temp = NewList[i].Item;
                      NewList[i].Item = t;
                      NewList[i + 1].Item = temp;
                      i--;
                  }
                  while (t < NewList[i].Item);    // i ten operator

                  Numbers++;
              }

              else
              {
                  Node tempNode = new Node(t);

                  NewList[Numbers] = tempNode;
                  Numbers++;
              }

        /*Node tempNode = new Node(t);

        NewList[Numbers] = tempNode;
        Numbers++;*/

    }

    public void DeleteItem(int index)
    {
        if (index > Numbers || index < 0)
            throw new IndexOutOfRangeException();

        do
        {
            NewList[index] = NewList[index + 1];
            index++;
        }
        while (index == Numbers);

        NewList[Numbers] = null;
        Numbers--;


    }
    #endregion

}

#region Class TestList
class TestList
{
    public static void Main()
    {
        List<int> lista = new List<int>(8);
        lista.AddNewItem(6);
        lista.AddNewItem(8);
        lista.DeleteItem(1);
        lista.Print();
          
    }
}
#endregion

Dodaj:
class List<T> where T : IComparable
dzieki temu bedziesz na pewno mogl tworzyc klase z typow, ktore mozna porownywac.

Niestety nie wiem jak sprawdzac znakami mniejszosci/wiekszosci ale mozesz sprawdzic to albo rzutujac na interfejs IComparable albo poprzez
Comparer.Default.Compare(wartoscA, wartoscB);

Mozesz przeciazyc operatory porownania, tutaj troche wiecej.

no tak, to to jak najbardziej... ale jesli chce sie porownywac te generyczne T to poki co nie wiem czy tak w ogole sie da.

Hmm... nie doczytalem. W sumie to sie kompilator powinien domyslic, ze dla int istnieja operatory...

takiego operatora nie można używać używając szablonów, bo jest on poprawny tylko dla pewnych typów. Rozwiązanie podał wasiu w drugim poście.

Więcej o regułach o ograniczeniach dla generics: http://msdn.microsoft.com/msdnmag/issues/06/00/net/default.aspx