static void Main(string[] args)
{
var obj = new TestClass();
obj.Method(); // error
}

interface ITest
{
void Method()
{
}
}

class TestClass : ITest
{
}

internal interface ICompletelyDifferentInterface
{
    void Method() => Console.WriteLine(nameof(ICompletelyDifferentInterface));
}

Q>internal interface ICompletelyDifferentInterface
Q>{
Q>    void Method() => Console.WriteLine(nameof(ICompletelyDifferentInterface));
Q>}
Q>

  interface I1 {
    default void method() {
      System.out.println("I1");
    }
  }

  interface I2 {
    default void method() {
      System.out.println("I2");
    }
  }

  static class TestClass implements I1, I2 {
  }

  static class TestClass implements I1, I2 {
    @Override
    public void method() {
      I1.super.method();
    }
  }

does not contain a definition for 'Method' and no accessible extension method 'Method' accepting a first argument of type 'Program.TestClass' could be found

java: types test.Test.I1 and test.Test.I2 are incompatible;
class test.Test.TestClass inherits unrelated defaults for method() from types test.Test.I1 and test.Test.I2

Doc>Ну да, а так по тихому поменяли контракт. Правда у нас теперь "Периметр()" круга равен "Периметр()" квадрата (возвращаясь к примеру выше), но это мелочи, ведь билд не ломается.

public interface IA
{
 void F();
}

static class X
{
 public UseIAF(IA a)
 {
  a.F();
 }
}

class A : IA
{
 public void F() { .. .}
}

public interface IA
{
 void F();

 void G() { }
}

static class X
{
 public UseIAF(IA a)
 {
  a.F();
 }

 public UseIAG(IA a)
 {
  a.G();
 }
}

class A : IA
{
 public void F() { .. .}
}

Doc>Плюс, теперь можно валить на собесах вопросом "чем отличается интерфейс от класса"

interface IA
{
  int Value {get;set;}
}

interface ICountableEnumerable {
  bool next();

  int aCount() {
    int times = 0;
    while(next()) {
       times++;
    }
    return times;
  }
}

class List: ICountableEnumerable {
  int aCount() { return size; } // более оптимальная реализация
}


interface ICollectionWithFeatures {
  IReadonlyCollection asReadonly() {
    var copy = ...;// копируем исходный набор данных, что бы call-site не "сломался"
    return copy;
  }
}

class ReadonlyList: ICollectionWithFeatures, IReadonlyCollection {
  IReadonlyCollection asReadonly() {
    return this; // можно не копировать, т.к. мы не даем методов модификации текущей коллекции
  }
}

vsb>  static class TestClass implements I1, I2 {
vsb>    @Override
vsb>    public void method() {
vsb>      I1.super.method();
vsb>    }
vsb>  }
vsb>

using System;

public class HelloWorld
{
    static void Main(string[] args)
    {
        var obj = new TestClass();
        obj.Method();
        I1 i1 = obj;
        i1.Method();
        I2 i2 = obj;
        i2.Method();
    }
}

interface I1
{
    void Method()
    {
        Console.WriteLine("I1");
    }
}

interface I2
{
    void Method()
    {
        Console.WriteLine("I2");
    }
}

class TestClass : I1, I2
{
    public void Method()
    {
        Console.WriteLine("TestClass");
    }
}

TestClass
TestClass
TestClass

public static class Enumerable
{
  public static int Count<T>(IEnumerable<T> enumerable)
  {
     var i=0;
     foreach(var _ in enumerable) i++;
     return i;  
  } 
}

public static class Enumerable
{
  public static int Count<T>(this IEnumerable<T> enumerable)
  {
     var i=0;
     foreach(var _ in enumerable) i++;
     return i;  
  } 
}

 public UseIAG(IA a)
 {
  a.G();
 }

M> public UseIAG(IA a)
M> {
M>  a.G();
M> }

M> public UseIAG(IA a)
M> {
M>  a.G();
M> }
M>

public interface ICharReader
{
   char? Read();
   int Read(char[] destination, int count)
   {
      var readCount = 0;
      char? r;
      while((r = Read()).HasValue && readCount<count) 
        destination[readCount++] = r.Value;
      return readCount;
   }
}

public interface ICharReader
{
   char? Read() => null;
   int Read(char[] destination, int count)
   {
      var readCount = 0;
      char? r;
      while((r = Read()).HasValue && readCount<count) 
        destination[readCount++] = r.Value;
      return readCount;
   }
}

public interface ICharReader
{
   char? Read()
   {
     var chars = new char[1];
     return (Read(chars, 1) == 1) ? chars[0] : null;
   }

   int Read(char[] destination, int count)
   {
      var readCount = 0;
      char? r;
      while((r = Read()).HasValue && readCount<count) 
        destination[readCount++] = r.Value;
      return readCount;
   }
}

var items = expression.ToList();
if (items.Count < 2)
{
  ...
}

if (items.Count() > 0)
{
  foreach (var item in items)
  {
    ...
  }
}
else
{
  ...
}

S>То рано или поздно вам придётся это починить, т.к. по соглашению все Count/Count() возвращают int. А ваш метод должен называться LongCount()

As it turns out, adding default interface implementations provides the elements of the "traits" language feature (https://en.wikipedia.org/wiki/Trait_(computer_programming)). Traits have proven to be a powerful programming technique.

Traits combine aspects of protocols (interfaces) and mixins. Like an interface, a trait defines one or more method signatures, of which implementing classes must provide implementations. Like a mixin, a trait provides additional behavior for the implementing class.

public static int Count<TSource>(this IEnumerable<TSource> source) {
        if (source == null) throw Error.ArgumentNull("source");
        ICollection<TSource> collectionoft = source as ICollection<TSource>;
        if (collectionoft != null) return collectionoft.Count;
        ICollection collection = source as ICollection;
        if (collection != null) return collection.Count;
        int count = 0;
        using (IEnumerator<TSource> e = source.GetEnumerator()) {
                checked {
                        while (e.MoveNext()) count++;
                }
        }
        return count;
}

  static void Main (string[]args)
  {
    var obj = new TestClass();
      obj.Method(); // error
  }
  interface ITest
  {
    void Method();
  }

  class TestClass:ITest
  {
      void ITest.Method() {}
  }