Сравнение обобщенных переменных

    public class A<T>
    {
        public T Inside { get; set; }
 
        /// <summary>
        /// Что то вставляем
        /// </summary>
        /// <param name="outside">Внешняя переменная</param>
        public void Insert(T outside)
        {
            // Внутреннюю переменную сравниваем с внешней
            if (Inside > outside)
            {
                // Что-то происходит
            }
        }
    }

      public class A<T> where T : IComparable<T>
      {
         public T Inside { get; set; }
 
         /// <summary>
         /// Что то вставляем
         /// </summary>
         /// <param name="outside">Внешняя переменная</param>
         public void Insert(T outside)
         {
            // Внутреннюю переменную сравниваем с внешней
            if(Inside.CompareTo(outside) > 0)
            {
               // Что-то происходит
            }
         }
      }

    public class A<T>
    {
        private readonly Comparison<T> compare;
        public T Inside { get; set; }
 
        public A() : this(Comparer<T>.Default) { }
 
        public A(IComparer<T> comparer) : this(comparer?.Compare) { }
 
        public A(Comparison<T> compare)
        {
            this.compare = compare ?? throw ArgumentNullException(nameof(compare));
        }
 
        /// <summary>
        /// Что то вставляем
        /// </summary>
        /// <param name="outside">Внешняя переменная</param>
        public void Insert(T outside)
        {
            // Внутреннюю переменную сравниваем с внешней
            if (compare(Inside, outside) > 0)
            {
                // Что-то происходит
            }
        }
    }

new A<int>();  // Использование сравнения по умолчанию, если такое определено для типа.
new A<int>(new MySuperComparer());  // Использование собственного класса, реализующего IComparer<int>
new A<int>((x, y) => -x.CompareTo(y)); // Использование лямбды. В данном случае — обратное сравнение.