Ist es möglich, die explizite Implementierung einer Schnittstelle (oder Teilen davon) zu erzwingen?

Question

Lets sagen, ich habe eine Schnittstelle wie folgt aus:

public interface MyInterface 
{ 
    int Property1 
    { 
     get; 
    } 

    void Method1(); 
    void Method2(); 
} 

Gibt es eine Möglichkeit, die Implementierer der Schnittstelle zu zwingen, Teile davon explizit zu implementieren? Etwas wie:

public interface MyInterface 
{ 
    int Property1 
    { 
     get; 
    } 

    explicit void Method1(); 
    explicit void Method2(); 
} 

Edit: Warum interessiere ich mich, ob die Schnittstelle explizit implementiert ist oder nicht; Es ist nicht so wichtig, was die Funktionalität betrifft, aber es könnte hilfreich sein, einige unnötige Details vor Leuten zu verstecken, die den Code verwenden.

Ich versuche, Mehrfachvererbung in meinem System, mit diesem Muster zu imitieren:

public interface IMovable 
{ 
    MovableComponent MovableComponent 
    { 
     get; 
    } 
} 

public struct MovableComponent 
{ 
    private Vector2 position; 
    private Vector2 velocity; 
    private Vector2 acceleration; 

    public int Method1() 
    { 
     // Implementation 
    } 

    public int Method2() 
    { 
     // Implementation 
    } 

} 

public static IMovableExtensions 
{ 
    public static void Method1(this IMovable movableObject) 
    { 
     movableObject.MovableComponent.Method1(); 
    } 

    public static void Method2(this IMovable movableObject) 
    { 
     movableObject.MovableComponent.Method2(); 
    } 
} 

public class MovableObject : IMovable 
{ 
    private readonly MovableComponent movableComponent = new MovableComponent(); 

    public MovableComponent MovableComponent 
    { 
     get { return movableComponent; } // Preferably hiddem, all it's methods are available through extension methods. 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
      MovableObject movableObject = new MovableObject(); 
      movableObject.Method1(); // Extension method 
      movableObject.Method2(); // Extension method 
      movableObject.MovableComponent // Should preferably be hidden. 

    } 
} 

Wenn die MovableComponent Eigenschaft explizit implementiert wurde, es würde in den meisten Fällen, von versteckt werden, wer die Klasse wurde mit . Ich hoffe, diese Erklärung war nicht zu schrecklich.

Answer 1

Nein, es ist nicht möglich, Implementierer zu zwingen, die explizite oder implizite Implementierung einer Schnittstelle auszuwählen.

Answer 2

Was Sie suchen ist eine abstrakte Klasse namens