Wie kann man diesen Wettlauf verhindern?

Question

Wir haben eine Client Klasse, die eine BaseClass erweitert.

Die Baseclass hat diese Methoden:

protected void Proxy() 
    { 
     Error = null; 
     _proxy = new WebServiceClient<T>(_fullURL); 
     Error = _proxy.Error; 
    } 

    protected virtual void Cleanup() 
    { 
     if (_proxy != null) 
     { 
      _proxy.Dispose(); 
      _proxy = null; 
     } 
    } 

Und der Kunde enthält mehrere Operationen, die parallel aufgerufen werden. Client ist kein Singleton, wir erzeugen jedes Mal eine Instanz.

Die Operationen sind wie:

public void OperationAsync(Action<BaseResult> callback) 
{ 

    TaskCompletionSource<String> taskSrc = new TaskCompletionSource<String>(); 
    Task<String> tsk = taskSrc.Task; 
    try 
    { 
     Proxy(); 

     ThreadPool.QueueUserWorkItem(t => 
     { 
      try 
      { 
       String result = _proxy.Channel.ExecuteOperation(SecurityToken()); 
       taskSrc.SetResult(result); 
      } 
      catch (Exception ex) 
      { 
       taskSrc.SetException(ex); 
      } 
     }); 

     tsk.Wait(); 

     BaseResult r = new BaseResult(); 
     r.Value = tsk.Result; 
     r.Error = tsk.Exception; 
     Cleanup(); 

     if (callback != null) 
     { 
      callback(r); 
     } 

    } 
    catch (Exception ex) 
    { 
     FileManager.Log(ex); 
    } 
} 

Wie Sie sehen können, jede Operation ruft die Proxy und CleanUp Operationen.

Wir fanden keine Verhaltensmuster entdecken hat noch nicht, aber manchmal (vielleicht einmal am Tag) wir diesen Fehler in der Protokolldatei finden Sie unter:

mindestens ein Fehler aufgetreten .. Innerexception: System.ObjectDisposedException: Kann nicht Zugriff auf ein entsorgtes Objekt. Objektname: 'System.ServiceModel.Channels.ServiceChannel'.

Es passiert nicht bei einer bestimmten Operation. Es variiert alle Zeiten. Ich glaube, dass der Proxy während des Konstruktors und der CleanUp während der Entsorgung durchgeführt werden muss, aber es bedeutet, dass mehrere Dinge geändert werden, und ich möchte sicher sein.

Ich würde wirklich jede Idee schätzen, wie es verbessern kann.

Answer 1

Da der ursprüngliche Code tsk.Wait(); aufgerufen hat, blockierten Sie den aufrufenden Thread, während Sie Ihren Proxy-Code auf einem Hintergrundthread ausführen. Es gibt keinen Vorteil und wahrscheinlich erhöhte Kosten, die es so machen.

So, hier ist, wie die Race-Bedingung zu verhindern:

public void OperationAsync(Action<BaseResult> callback) 
{ 
    try 
    { 
     var r = new BaseResult(); 
     using (var proxy = new WebServiceClient<T>(_fullURL)) 
     { 
      try 
      { 
       r.Value = proxy.Channel.ExecuteOperation(SecurityToken()); 
      } 
      catch (Exception ex) 
      { 
       r.Error = ex; 
      } 
     } 
     if (callback != null) 
     { 
      callback(r); 
     } 
    } 
    catch (Exception ex) 
    { 
     FileManager.Log(ex); 
    } 
}