Лучшая частичная реализация интерфейса C # в базовом / абстрактном классе

.net не допускает частичную реализацию интерфейса в базовых классах. В качестве смягчения я пришел к 3 альтернативным решениям. Пожалуйста, помогите мне решить, что более универсально с точки зрения рефакторинга, ошибок компиляции / выполнения, удобочитаемости. Но сначала пара комментариев.

• Конечно, вы всегда можете привести объект к IFoo и вызвать любой метод без предупреждения компилятора. Но это не логично, вы бы этого не сделали нормально. Эта конструкция не возникнет в результате рефакторинга.
• Я хочу максимальной разлуки. Контракт прямого класса (общедоступные методы и свойства) следует разделять реализациями интерфейса. Я часто использую интерфейсы для разделения взаимодействий между объектами.

Мое сравнение:

1. BaseClass1 / MyClass1:
   • Минусы: необходимо создавать виртуальные аннотации в BaseClass1 для каждого нереализованного метода IFoo.
   • Минусы: Дополнительный перенос метода - небольшое влияние на производительность во время выполнения.
2. BaseClass2 / MyClass2:
   • против: нет предупреждения компилятора, если в MyClass2 отсутствует реализация Method2. Вместо этого исключение времени выполнения. Рефакторинг с плохим покрытием модульных тестов может потенциально дестабилизировать код.
   • Con: необходимо добавить дополнительную устаревшую конструкцию, чтобы предотвратить прямой вызов метода из дочерних классов.
   • con: Method2 является общедоступным для BaseClass1, поэтому теперь он является частью контракта класса.Придется поставить конструкцию «Устаревшая» для предотвращения прямого вызова, а не через IFoo.
3. BaseClass3 / MyClass3:
   • pro: (По сравнению с №2). Более читабельный. Вы видите, что MyClass2.Method2 - это реализация IFoo, а не просто какой-то переопределенный метод.

public interface IFoo
{
    void Method1();
    void Method2();
}

public abstract class BaseClass1 : IFoo
{
    void IFoo.Method1()
    { 
        //some implementation
    }

    void IFoo.Method2()
    {
        IFooMethod2();
    }

    protected abstract void IFooMethod2();
}

public class MyClass1 : BaseClass1
{
    [Obsolete("Prohibited direct call from child classes. only inteface implementation")]
    protected override void IFooMethod2()
    {
        //some implementation
    }
}

public abstract class BaseClass2 : IFoo
{
    void IFoo.Method1()
    {
        //some implementation
    }

    [Obsolete("Prohibited direct call from child classes. only inteface implementation")]
    public virtual void Method2()
    {
        throw new NotSupportedException();
    }
}

public abstract class MyClass2 : BaseClass2
{
    public override void Method2()
    {
        //some implementation
    }
}

public abstract class BaseClass3 : IFoo
{
    void IFoo.Method1()
    {
        //some implementation
    }

    void IFoo.Method2()
    {
        throw new NotSupportedException();
    }
}

public abstract class MyClass3 : BaseClass3, IFoo
{
    void IFoo.Method2()
    {
        //some implementation
    }
}