Interne Schnittstellen - meine Unwissenheit aussetzt

Question

Ich bin mir dessen bewusst thesetwo Fragen, die erklären, warum ich nicht eine geschützte/private Methode in einer Schnittstelle haben kann, was ich versuche, herauszufinden, ist, wie zu steuern, von wo Meine Methoden werden kurz genannt:

Verbraucher können die Standard-IStateMachine verwenden oder ihre eigenen rollen.

Ich frage mich, ob es eine Möglichkeit gibt, sicherzustellen, dass Action_-Methoden nur innerhalb einer IStateMachine aufgerufen werden, so dass die Verbraucher nicht anfangen, mit State-Zeug rumzualbern. Ich vermute, es gibt keine Möglichkeit, das zu tun, aber ich frage mich, ob ich etwas verpasse. Ich bin kein Design Pattern Guru.

Answer 1

Sie können zwar keine Zugriffsmodifizierer für Schnittstellen haben, aber hier ist eine Möglichkeit, die Member zu verbergen und dennoch für IStateMachine-Implementierer zugänglich zu machen.

public interface IEditActions 
{ 
    void Action_Commit() {} 
    void Action_Undo() {} 
} 

public interface IStateMachine 
{ 
    void Initialize(IEditActions editActions); 
} 

public class EditField : IEditField 
{ 
    private class EditActions : IEditActions 
    { 
    EditField _editField; 

    public EditActions(EditField editField) 
    { 
     _editField = editField; 
    } 

    public void Action_Commit() 
    { 
     _editField.Action_Commit(); 
    } 
    public void Action_Undo() 
    { 
     _editField.Action_Undo(); 
    } 
    } 

    public EditField() {} 
    public EditField(IStateMachine stateMachine) 
    { 
    stateMachine.Initialize(new EditActions(this)); 
    } 

    private void Action_Commit() {} 
    private void Action_Undo() {} 
} 

Answer 2

Ich bin mir nicht sicher, ob ich verstehe, was Sie tun möchten. Aber um Dinge zu verstecken, implementiere ich Schnittstellen normalerweise explizit. Wenn jemand Zugriff auf einige Dinge benötigt und nicht auf andere, sollten Sie die Schnittstelle wahrscheinlich auch in zwei Teile zerlegen.

Answer 3

Hmm, was Sie tun können, ist die Action_ Methoden zu verstecken, indem Sie diese Methoden explizit implementieren.

Wenn Sie dies tun, können Benutzer diese Methoden nur aufrufen, wenn sie die Klasse an die Schnittstelle zurückgeben. Es wird sie zwar nicht davon abhalten, diese Methoden aufzurufen, aber vielleicht wird es dadurch weniger offensichtlich, dass es möglich ist.

public class EditField : IEditField 
{ 
    public EditField(IStateMachine stateMachine) {} 

    void IEditField.Action_Commit() {} 

    void IEditField.Action_Undo() {} 

} 

Durch diese Methoden wie diese umgesetzt werden, wird der Benutzer nicht in der Lage sein, dies zu tun:

EditField ef = new EditField(); 
ef.Action_Commit(); // compile-error 

Jedoch ist es möglich, diese Methoden zu nennen, wenn sie dies tun:

IEditField ef = new EditField(); 
ef.Action_Commit(); 

oder

EditField ef = new EditField() 
((IEditField)ef).Action_Commit(); 

Aber, ist es nicht eine bessere Lösung/möglich, diese Commit & Rückgängig-Methoden ein Teil Ihrer IStateMachine stattdessen?

Und wenn Sie das Design nicht ändern können, um diese Commit & Rückgängig-Methoden Teil der IStateMachine zu haben, dann können Sie vielleicht eine abstrakte Klasse anstelle der IEditField-Schnittstelle erstellen?
In dieser abstrakten Klasse können Sie diese Action_-Methoden schützen.