interface IA
{
    void M() { WriteLine("IA.M"); }
}

class C : IA { } // OK

// ...

IA i = new C();
i.M(); // prints "IA.M"

interface IA
{
    void M() { WriteLine("IA.M"); }
}
interface IB : IA
{
    override void IA.M() { WriteLine("IB.M"); }
}
interface IC : IA
{
    override void IA.M() { WriteLine("IC.M"); }
}

class D : IA, IB, IC
{
    void IA.M() { IB.base.M(); } 
}

interface IA
{
    void M() { WriteLine("IA.M"); }
}

class C : IA { } // OK

// ...

IA i = new C();
i.M(); // prints "IA.M"

interface IA
{
    void M();
}

class OldGoodMixin
{
  public void M()
  {
    WriteLine("IA.M");
  }
}

class C : IA
{
  public void M()
  {
    _mixin.M();
  }
  private OldGoodMixin _mixin = new OldGoodMixin();
}
// ...

IA i = new C();
i.M(); // prints "IA.M"

IA i = new C();
i.M(); // prints "IA.M"

C c = new C();
c.M(); // prints "IA.M"

public interface IOut
{
   void PrintChar(char c);
   void PrintString(string chars)
   {
     foreach(var c in chars)
       PrintChar(c);
   }
}

public class C: IOut
{
  public void PrintChar(char c)
  {
    System.Console.Write(c);
  }
}

interface IA
{
   void PrintChar(char c);
   void PrintString(string chars)
}

class OldGoodMixin
{
  public OldGoodMixin(IOut o)
  {
    _o = o;
  }
  private IOut _o;

  public void PrintString(string chars)
  {
     foreach(var c in chars)
       _o.PrintChar(c);
  }
}

class C : IA
{
  public void PrintChar(char c)
  {
    System.Console.Write(c);
  }
  public void PrintString(string s)
  {
    _mixin.PrintString(s);
  }

  private OldGoodMixin _mixin;
  public C()
  {
     _mixin = new OldGoodMixin();
  }
}

S>public interface IOut
S>{
S>   void PrintChar(char c);
S>   void PrintString(string chars)
S>   {
S>     foreach(var c in chars)
S>       PrintChar(c);
S>   }
S>}

S>public class C: IOut
S>{
S>  public void PrintChar(char c)
S>  {
S>    System.Console.Write(c);
S>  }
S>}
S>

public interface IOut
{
   void PrintChar(char c);
}

static class OldGoodMixin
{
  public static void PrintString(this IOut o, string chars)
  {
     foreach(var c in chars)
       o.PrintChar(c);
  }
}

public class C: IOut
{
  public void PrintChar(char c)
  {
    System.Console.Write(c);
  }
}

IOut out1 = new C();
IOut out2 = new B();

out1.PrintString2(); // Default PrintString2
out2.PrintString2(); // Updated PrintString2

TK>IOut out1 = new C();
TK>IOut out2 = new B();

TK>out1.PrintString2(); // Default PrintString2
TK>out2.PrintString2(); // Updated PrintString2
TK>

static class OldGoodMixin
{
  public static void PrintString2(this IOut o)
  {
     // ...
  }
}

public class B: IOut
{
  public void PrintString2()
  {
     // ...
  }
}

TK>Запускать будем? Ключевой момент я жирным выделил

static class OldGoodMixin
{
  public static void PrintString2(this IOut o)
  {
    if (o is B)
    {
     // ...
    }
    else
    {
     // ...
    }
  }
}

ARK>public interface IOut
ARK>{
ARK>   void PrintChar(char c);
ARK>}

ARK>static class OldGoodMixin
ARK>{
ARK>  public static void PrintString(this IOut o, string chars)
ARK>  {
ARK>     foreach(var c in chars)
ARK>       o.PrintChar(c);
ARK>  }
ARK>}

ARK>public class C: IOut
ARK>{
ARK>  public void PrintChar(char c)
ARK>  {
ARK>    System.Console.Write(c);
ARK>  }
ARK>}
ARK>

public class C: IOut
{
   public void PrintChar(char c)
   {
      using(w = StreamWriter.OpenWrite("out.txt", true))
       w.Write(c);
   }
   public void PrintString(string chars)
   {
      using(w = StreamWriter.OpenWrite("out.txt", true))
       w.Write(chars);
   }
}

public static class D
{
   public static void Test()
   {
     var c = new C();
     TestClass(c);
     TestIntf(c);
   } 
   public static void TestClass(C output)
   {
     output.PrintString("Hello, world!"); 
   }
   public static void TestIntf(IOut output)
   {
     output.PrintString("Hello, world!"); // упс - мы вызываем дефолтную неэффективную реализацию вместо оптимизированной удобной.
   }
}

    class Parent
    {
        private class Interface1Impl : IInterface1
        {
            public Interface1Impl(Parent p)
            {
                _p = p;
            }
            Parent _p; //Для реализации интерфейса нужен доступ в Parent
        }
        public Parent()
        {
            _interface1Impl=new Interface1Impl(this);
            _some = new Some(_interface1Impl);
        }
        private Some _some;
        private Interface1Impl _interface1Impl;
    }

    class Parent: private IInterface1
    {        
        public Parent()
        {
            _some = new Some(this);
        }
        private Some _some;
    }

Perhaps I am stirring up quite a bit of controversy with this statement, but I believe the lack of support for multiple inheritance in our type system is the single biggest contributor to the complexity of the .NET Framework. When we designed the type system, we explicitly decided not to add support for multiple inheritance so as to provide simplicity. In retrospect, this decision had the exact opposite effect. The lack of multiple inheritance forced us to add the concept of interfaces, which in turn are responsible for problems with the evolution of the framework, deeper inheritance hierarchies, and many other problems.

   public trait Foo
   {
     ...
   }

HH>   public trait Foo
HH>   {
HH>     ...
HH>   }
HH>

public class Test
{
    public class trait { }
    public trait IFoo { get; set;}
}

public class Test
{
    public class interface { }
    public interface IFoo { get; set;}
}

S>public class Test
S>{
S>    public class trait { }
S>    public trait IFoo { get; set;}
S>}
S>

class var{
  public static implicit var(int n){...}
}
//...

var x = 42;

Doc>Зачем мешать контракт и реализацию? Печаль

interface IEnumerable<T>
{
  //...
  bool Contains(T value)
  {
    foreach(var item in this)
    {
      if(item == value)
        return true;
    }

    return false;
  }
}

class HashSet<T>: IEnumerable<T>, ISet<T>
{
  bool Contains(T value)
  {
    //более эффективная реализация, но с тем же результатом
  }
}

void Do(IEnumerable<T> items)
{
  b = items.Contains(...);
  //вместо такого:
  if(items is ISet<T>)
    b = (ISet<T>)items.Contains(...);
  else if(items is SomethingElseThatIsSupposedToHaveEffectiveContains<T>)
    b = ...
}