Интерфейсы зачем их использовать

    class Brick // класс кирпич. Летать не умеет (увы)
    {
        private string material;
 
        public Brick(string mat)
        {
            material = mat;
        }
 
        public Drop()
        {
            Console.WriteLine("Brick of {0} has been dropped", material);
        }
    }
 
 
 
public class FlyingBrick : IFlyable
{
   private Brick brick;
   public FlyingBrick(Brick brick)
   {
      this.brick = brick;
   }
 
   public void Fly();
   {
      Console.WriteLine("Lifting a brick...");
      brick.Drop();
   }
}

interface IAdapter
    {
        string Method_3();
    }
    interface IAdapter2
    {
        string Method_3(); //метод имеет то же название
    }
 
    class A : IAdapter, IAdapter2
    {
        public string Method_1() { return "привет1"; }
        public string Method_2 () { return "привет2"; }
        string IAdapter.Method_3() { return "привет3"; }//явная реализация интерфейса
        string IAdapter2.Method_3() { return "привет3333333"; }//явная реализация интерфейса
    }
    //*************************************************************
    class Program
    {     
        static void Main(string[] args)
        {
            string str;
            A obj = new A();
            str=obj.Method_1();    //после ввода точки будут видны только Method_1 и Method_2
            Console.WriteLine(str); //печатает привет1
 
            str =(obj as IAdapter).Method_3();//после точки виден только Method_3 
            Console.WriteLine(str);//печатает привет3
 
            str = (obj as IAdapter2).Method_3();//после точки виден тоже Method_3, но он другой 
            Console.WriteLine(str);                           //печатает привет3333333
 
            Console.ReadLine();
        }     
    }

      public void MySort(int[] arr)
        {
            int buff;
            for(int i = 0;i<arr.Length-1;i++)
                for(int j = i+1;j<arr.Length;j++)
                {
                    if(arr[j]<arr[i])
                    {
                        buff = arr[i];
                        arr[i] = arr[j];
                        arr[j] = buff;
                    }
                }
        }

public class Class1
    {
        public int CompareByItem<T>(T first, T second)
        {
           // Здесь по идее нужно как то сравнивать элементы массива,
           // и возвращать 1, -1, или 0
           // Но запись if(first > second) не получится
        }
        // Делегат на метод сравнения
        public delegate int Comparison<T>(T first, T second); 
        public void BubbleSort<T>(T[] a, Comparison<T> compare)
        {
            for (int i = 0; i < a.Length; i++)
            {
                for (int j = i + 1; j < a.Length; j++)
                {
                    //Сортируем по возрастанию
                    if (compare(a[i], a[j]) < 0)
                    {
                        var temp = a[i];
                        a[i] = a[j];
                        a[j] = temp;
                    }
                }
            }
        }
 
    }

public class Class1
{
    public static void BubbleSort<T>(T[] a, Comparison<T> compare)
    {
        for (int i = 0; i < a.Length; i++)
        {
            for (int j = i + 1; j < a.Length; j++)
            {
                if (compare(a[i], a[j]) > 0)
                {
                    var temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }
}

byte[] array = new byte[10];
new Random().NextBytes(array);
// По возрастанию
Class1.BubbleSort(array, (x,y) => x > y ? 1 : x < y ? -1 : 0);
//array.Dump(); // Для LINQPad
// По убыванию
Class1.BubbleSort(array, (x,y) => x > y ? -1 : x < y ? 1 : 0);
//array.Dump(); // Для LINQPad

public static void BubbleSort<T>(T[] array)
{
    for (int i = 0; i < array.Length; i++)
    {
        for (int j = i + 1; j < array.Length; j++)
        {
            if (array[i] is IComparable<T> comparable)
            {
                if (comparable.CompareTo(array[j]) > 0)
                {
                    (array[i], array[j]) = (array[j], array[i]);
                }
            }
            else throw new InvalidOperationException("Type must implement IComparable<T>");
        }
    }
}