Правильно избавляйтесь от производителя событий от другой нити

Question

Это упрощенный код, просто иллюстрирующий проблему, которую я пытаюсь решить (не скомпилировал, поэтому, пожалуйста, игнорируйте любые синтаксические ошибки). Предположим, у меня есть ProducerProxy как:

public class ProducerProxy : IDisposable { 
    public event EventHandler<EventArgs> NotificationEvent; 
    private volatile bool itsKeepProducing = true; 

    public DoStuff() { 
     Task.Factory.StartNew(() => { 
     while (itsKeepProducing) { 
      RaiseNotificationEvent(); 
      Thread.Sleep(100); 
     } 
     } 
    } 

    public void Dispose() { 
     itsKeepProducing = false; 
     DestroySomeStuff(); 
    } 
} 

Пусть теперь у меня есть класс, который использует этот ProducerProxy:

public class Consumer : IDisposable { 
    private ProducerProxy itsProducerProxy; 

    public void Consumer() { 
     itsProducerProxy = new ProducerProxy(); 
     itsProducerProxy.NotificationEvent += OnNotificationEvent; 
    } 

    public void Start() { 
     itsProducerProxy.DoStuff(); 
    } 

    public void OnNotificationEvent(object sender, EventArgs args) { 
     DealWithNotification(args); //this could take some time maybe 1-2 seconds 
    } 

    public void Dispose() { 
     //how do I dispose of the producer here? 
     //I can't just do the following because notifications might still be processing in OnNotification event: 
     if (itsProducerProxy != null) { 
      itsProducerProxy.NotificationEvent -= OnNotificationEvent; 
      itsProducerProxy.Dispose(); 
      itsProducerProxy = null; 
     } 
    } 

Так что мой вариант использования (да, это должно быть сделано с помощью try/catch или с помощью using но что отвлекает от вопроса - просто иллюстрирующей точку)

var consumer = new Consumer(); 
consumer.Start(); 
... //do some stuff 
consumer.Dispose(); 

что такое правильная/надлежащей поточно-реализация для Consumer.Dispose()? или, возможно, для Producer.Dispose()?

Answer 1

Вы можете использовать кооперативную шаблон отмены нить, передавая CancellationToken в процесс ...

public class Consumer : IDisposable {  
    private ProducerProxy itsProducerProxy; 

    // how we signal others that we are disposed 
    private CancellationTokenSource _cts = new CancellationTokenSource(); 

    /* SNIP */ 

    public void OnNotificationEvent(object sender, EventArgs args) { 
     // We now provide the inner process with the cancellation token 
     DealWithNotification(_cts.Token); 
    } 

    public void Dispose() 
    { 
     // not thread safe but you get the gist 
     if (_cts!= null) { 
      _cts.Cancel(); 
      _cts.Dispose(); 
      _cts = null; 
     } 
     /* SNIP */ 
    } 
} 

где внутренний процесс короткого замыкания, когда отмена была запрошена

private void DealWithNotification(CancellationToken token) 
{ 
    if(token.IsCancellationRequested) return; 
    var foo = "omgwtflol" + bar; 
    if(token.IsCancellationRequested) return; 
    Thread.Sleep(2); 
    if(token.IsCancellationRequested) return; 
    var reallyEveryTime = File.ReadAllBytes(foo); 
    if(token.IsCancellationRequested) return; 
    foreach(var b in reallyEveryTime) 
    { 
     if(token.IsCancellationRequested) return; 
     InnerProcess(token); 
    } 
    // etc etc etc you get the idea 
}