Como adicionar um delegado a uma interface C #

Eu preciso ter alguns delegados em minha classe.

Eu gostaria de usar a interface para me "lembrar" de definir esses delegados.

Como?

Minha classe é assim:

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();
}

Preciso de uma interface para forçar esses delegados:

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

Esses são tipos de delegado declarantes . Eles não pertencem a uma interface. Os eventos que usam esses tipos de delegado podem estar na interface, embora:

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

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

A implementação não redeclarará (e não deve) redeclarar o tipo de delegado, assim como não redeclararia qualquer outro tipo usado em uma interface.

Desde o .NET 3.5, você também pode usar os delegados System.Action, sem a necessidade de declarar seu próprio tipo.

Isso resultaria na seguinte interface:

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

   event Action Started;
}

Apenas exponha o delegado como uma propriedade

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

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

A resposta de Jon Skeet está certa, eu só quero adicionar uma nota.

As interfaces não existem para "lembrar" o que fazer ou o que incluir nas aulas. Interfaces são meios de abstração, usados ​​em programação orientada a objetos e métodos de design. Talvez você não precise de uma declaração de interface, a menos que queira ver algumas instâncias de classe concretas como a interface em outro lugar em seu programa (Abstração).

Se você deseja impor alguns padrões de codificação em seu projeto, pode tentar usar ferramentas de análise de código (como no Visual Studio) - Elas permitem extensões, que você pode incorporar para adicionar suas próprias regras de análise de código.

Usando a análise de código, se você "esquecer" de adicionar os delegados (embora eu não veja por que esquecê-lo, como se o delegado não fosse usado, não é necessário), você receberá um aviso / erro.

Um de seus comentários fez referência ao tipo de retorno do manipulador de eventos. Você está mais preocupado com o tipo de manipulador ou com os dados que retornam do evento? Se for o último, isso pode ajudar. Caso contrário, esta solução não será suficiente, mas pode ajudar a chegar mais perto do que você está procurando.

Tudo o que você precisa fazer é declarar seus manipuladores de eventos como manipuladores de eventos genéricos na interface e em sua implementação e você pode personalizar os resultados de retorno.

Sua classe de conteúdo ficaria assim:

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();
}

Sua interface ficaria assim:

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

Agora que os argumentos de evento estão retornando seus tipos, você pode conectá-los a qualquer manipulador que definir.

Para referência: https://msdn.microsoft.com/en-us/library/edzehd2t(v=vs.110).aspx

A interface herdada em sua classe derivada o lembrará de definir e vincular as coisas que você declarou nela.

Mas você também pode querer usá-lo explicitamente e ainda precisará associá-lo a um objeto.

Por exemplo, usando um padrão de Inversão de Controle:

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})";
   }
 }

Você pode tentar algo assim.

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);
  }
}