Estou trabalhando com uma estrutura que executa seu próprio distribuidor de eventos em um thread separado. A estrutura pode gerar alguns eventos.

class SomeDataSource {

    public event OnFrameworkEvent;

    void FrameworkCallback() {

        // This function runs on framework's thread.

        if (OnFrameworkEvent != null)
            OnFrameworkEvent(args);
    }
}

Desejo entregar esses eventos a um objeto Winforms no thread do Winforms. Eu obviamente verificoInvokeRequired e despache-o para o segmento Winforms, se necessário.

class SomeForm : Form {

    // ...

    public void SomeAction(SomeArgs args) {
        if (InvokeRequired) {
            BeginInvoke(new Action(SomeAction), args);
            return;
        }

        // ...
    }

}

Agora, os eventos podem ser entregues quando o formulário está em processo de fechamento, o que causa todos os tipos de problemas, por isso, cancelo o registro do manipulador de eventos do formulário da fonte de eventos da estrutura no thread do Winforms da seguinte maneira:

var form = new SomeForm();
var src = new SomeDataSource();

// ...

src.OnFrameworkEvent += form.SomeAction;
form.Closing += (sender, eargs) => src.OnFrameworkEvent -= form.SomeAction;

Agora,essa abordagem é segura para threads? Se o formulário estiver em processo de fechamento e um segmento externo chamarBeginInvoke, a invocação ainda será enfileirada para execução se o formulário estiver fechado? (o que significa que ainda tenho a chance de encontrar o mesmo problema)

Existe uma abordagem melhor ou um padrão recomendado para o tratamento de eventos entre threads?