Абстрактные классы и интерфейсы. Разница

    class B
    {
        public int c(int k, int l)
        {
            return 0;
        }
        public int d(int k, int l)
        {
            return 0;
        }
        public int e(int k, int l)
        {
            return 0;
        }
    }

   interface A
   {
      int c(int k, int l);
   }
 
   interface C
   {
      int c(int k, int l);
   }
 
   class B : A, C
   {
      int A.c(int k, int l)
      {
         throw new NotImplementedException();
      }
 
      int C.c(int k, int l)
      {
         throw new NotImplementedException();
      }
 
      public int c(int k, int l)
      {
         throw new NotImplementedException();
      }
   }

    class Program
    {
        static void Main(string[] args)
        {
            for (var k = 0; k < 5; k++)
            {
 
                var sw = new Stopwatch();
 
                //
                BaseMyClass _base = new MyClass();
                sw.Restart();
                for (var i = 0; i < int.MaxValue; i++)
                    _base.Nyan();
                sw.Stop();
                Console.WriteLine(sw.Elapsed);
 
                //
                IMyClass _interface = new MyClass();
                sw.Restart();
                for (var i = 0; i < int.MaxValue; i++)
                    _interface.Nyan();
                sw.Stop();
                Console.WriteLine(sw.Elapsed);
 
                //
                MyClass _class = new MyClass();
                sw.Restart();
                for (var i = 0; i < int.MaxValue; i++)
                    _class.Nyan();
                sw.Stop();
                Console.WriteLine(sw.Elapsed);
                Console.WriteLine("Nya!");
 
            }
            Console.ReadKey();
        }
    }
 
    interface IMyClass
    {
        void Nyan();
    }
 
    abstract class BaseMyClass
    {
        public virtual void Nyan() { }
    }
 
    class MyClass : BaseMyClass, IMyClass
    {
        public override void Nyan() { }
    }

...
interface IMyInteface
{
    void Method();
}
abstract class AbstractClass
{
    public abstract void Method();
}
 
class AInterface : IMyInteface
{
    public void Method() {}
}
class AClass : AbstractClass
{
    public override void Method() {}
}
 
class Program
{
    static void Main(string[] args)
    {   
        AInterface ai = new AInterface();
        AClass ac = new AClass();
        var sw = new Stopwatch();
 
        sw.Restart();
        for( int i = 0; i < int.MaxValue; i++ )
            ai.Method();
        sw.Stop();
        Console.WriteLine( "Invoke interface method: {0}", sw.Elapsed );
 
        sw.Restart();
        for( int i = 0; i < int.MaxValue; i++ )
            ac.Method();
        sw.Stop();
        Console.WriteLine( "Invoke abstract class method: {0}", sw.Elapsed );
 
        Console.ReadLine();
    }
}

Invoke interface method: 00:00:20.5515762
Invoke abstract class method: 00:00:26.6089119

class MyClass : IMyInterface
{
    void IMyInterface.Method()
    {
        ...
    }
}