Jak dodać delegata do interfejsu C #

Muszę mieć kilku delegatów w mojej klasie.

Chciałbym użyć interfejsu do „przypomnienia” mi o ustawieniu tych delegatów.

Jak?

Moja klasa wygląda tak:

public class ClsPictures : myInterface
{
    // Implementing the IProcess interface
    public event UpdateStatusEventHandler UpdateStatusText;
    public delegate void UpdateStatusEventHandler(string Status);

    public event StartedEventHandler Started;
    public delegate void StartedEventHandler();
}

Potrzebuję interfejsu, aby wymusić na tych delegatach:

public interface myInterface
{
   // ?????
}

To są deklaracje typów delegatów . Nie należą do interfejsu. Jednak zdarzenia korzystające z tych typów delegatów mogą znajdować się w interfejsie:

public delegate void UpdateStatusEventHandler(string status);
public delegate void StartedEventHandler();

public interface IMyInterface
{       
    event UpdateStatusEventHandler StatusUpdated;    
    event StartedEventHandler Started;
}

Implementacja nie będzie (i nie powinna) ponownie zadeklarować typu delegata, nie bardziej niż ponownie zadeklarowałaby jakikolwiek inny typ używany w interfejsie.

Od .NET 3.5 można również używać delegatów System.Action, bez konieczności deklarowania własnego typu.

Spowodowałoby to następujący interfejs:

public interface myInterface
{       
   // Implementing the IProcess interface
   event Action<String> UpdateStatusText;

   event Action Started;
}

Po prostu ujawnij delegata jako właściwość

public delegate void UpdateStatusEventHandler(string status);
public delegate void StartedEventHandler();

public interface IMyInterface
{       
    UpdateStatusEventHandler StatusUpdated {get; set;}    
    StartedEventHandler Started {get; set;}
}

Odpowiedź Jona Skeeta jest prawidłowa, chcę tylko dodać notatkę.

Interfejsy nie służą do „przypominania” o tym, co należy zrobić lub co należy uwzględnić na zajęciach. Interfejsy są środkami abstrakcji używanymi w programowaniu obiektowym i metodach projektowania. Może w ogóle nie potrzebujesz deklaracji interfejsu, chyba że chcesz zobaczyć kilka konkretnych instancji klas jako interfejs w innym miejscu w programie (abstrakcja).

Jeśli chcesz wymusić pewne standardy kodowania w swoim projekcie, możesz spróbować użyć narzędzi do analizy kodu (takich jak Visual Studio) - zezwalają na rozszerzenia, które możesz włączyć, aby dodać własne reguły analizy kodu.

Używając analizy kodu, jeśli „zapomnisz” o dodaniu delegatów (chociaż nie widzę sensu zapominania o tym, tak jakby delegat nie był używany, nie jest potrzebny), otrzymasz ostrzeżenie / błąd.

Jeden z komentarzy odwoływał się do zwracanego typu programu obsługi zdarzeń. Czy bardziej interesuje Cię typ programu obsługi lub dane pochodzące ze zdarzenia? Jeśli to drugie, może to pomóc. Jeśli nie, to rozwiązanie nie wystarczy, ale może pomóc Ci zbliżyć się do tego, czego szukasz.

Wszystko, co musisz zrobić, to zadeklarować swoje programy obsługi zdarzeń jako ogólne programy obsługi zdarzeń zarówno w interfejsie, jak i w implementacji, i możesz dostosować zwracane wyniki.

Twoja klasa betonu wyglądałaby tak:

public class ClsPictures : myInterface
{
    // Implementing the IProcess interface
    public event EventHandler<UpdateStatusEventArgs> UpdateStatusText;
    //no need for this anymore: public delegate void UpdateStatusEventHandler(string Status);

    public event EventHandler<StartedEventArgs> Started;
    //no need for this anymore: public delegate void StartedEventHandler();
}

Twój interfejs wyglądałby tak:

public interface myInterface
{
   event EventHandler<StartedEventArgs> Started;
   event EventHandler<UpdateStatusEventArgs> UpdateStatusText;
}

Teraz, gdy argumenty zdarzeń zwracają Twoje typy, możesz podłączyć je do dowolnego zdefiniowanego przez siebie modułu obsługi.

Dla odniesienia: https://msdn.microsoft.com/en-us/library/edzehd2t(v=vs.110).aspx

Interfejs odziedziczony w ramach Twojej klasy pochodnej przypomni Ci o zdefiniowaniu i powiązaniu rzeczy, które w nim zadeklarowałeś.

Ale możesz również chcieć użyć go jawnie i nadal będziesz musiał powiązać go z obiektem.

Na przykład używając wzorca Inversion of Control:

class Form1 : Form, IForm {
   public Form1() {
     Controls.Add(new Foo(this));
   }

   // Required to be defined here.
   void IForm.Button_OnClick(object sender, EventArgs e) {
     ...
     // Cast qualifier expression to 'IForm' assuming you added a property for StatusBar.
     //((IForm) this).StatusBar.Text = $"Button clicked: ({e.RowIndex}, {e.SubItem}, {e.Model})";
   }
 }

Możesz spróbować czegoś takiego.

interface IForm {
  void Button_OnClick(object sender, EventArgs e);
}


class Foo : UserControl {
  private Button btn = new Button();

  public Foo(IForm ctx) {
     btn.Name = "MyButton";
     btn.ButtonClick += ctx.Button_OnClick;
     Controls.Add(btn);
  }
}