Korzystanie z WCF, zamykanie i rozszerzenia

Question

Jestem zaskoczony. Być może ktoś może rzucić trochę światła na zachowanie klienta WCF, którego obserwuję.

Korzystając z próbek WCF, zacząłem grać z różnymi podejściami do komunikacji klient/serwer WCF. Podczas wykonywania 1M żądania testowego równolegle, używałem SysInternals TcpView do monitorowania otwartych portów. Teraz, istnieją co najmniej 4 różne sposoby, aby zadzwonić do klienta:

1. utworzyć klienta, rób swoje i niech GC zbierać to
2. Tworzenie klienta w wykorzystaniem bloku, niż rób swoje
3. Tworzenie kanału klienta z wykorzystaniem fabrycznie w bloku, nie rób swoje
4. Tworzenie klienta lub kanału, ale używać WCF Extensions robić swoje rzeczy

teraz, o ile mi wiadomo, tylko opcje 2-4, jawnie zadzwoń client.Close(). Podczas ich wykonywania widzę wiele portów pozostawionych w stanie TIME_WAIT. Spodziewałbym się, że opcja 1 będzie najgorszym scenariuszem, z powodu polegania na GC. Jednak, ku mojemu zaskoczeniu, wydaje się być najczystszym z nich wszystkich, co oznacza, że ​​nie pozostawia żadnych długich portów.

Czego mi brakuje?

UPDATE: kod

private static void RunClientWorse(ConcurrentBag<double> cb) 
    { 
     var client = new CalculatorClient(); 
     client.Endpoint.Address = new EndpointAddress("net.tcp://localhost:8000/ServiceModelSamples/service"); 
     RunClientCommon(cb, client);       
    } 

    private static void RunClientBetter(ConcurrentBag<double> cb) 
    { 
     using (var client = new CalculatorClient()) 
     { 
      client.Endpoint.Address = new EndpointAddress("net.tcp://localhost:8000/ServiceModelSamples/service"); 
      RunClientCommon(cb, client); 
     } 
    } 

    private static void RunClientBest(ConcurrentBag<double> cb) 
    { 
     const string Uri = "net.tcp://localhost:8000/ServiceModelSamples/service"; 
     var address = new EndpointAddress(Uri); 
     //var binding = new NetTcpBinding("netTcpBinding_ICalculator"); 
     using (var factory = new ChannelFactory<ICalculator>("netTcpBinding_ICalculator",address)) 
     { 
      ICalculator client = factory.CreateChannel(); 
      ((IContextChannel)client).OperationTimeout = TimeSpan.FromSeconds(60); 
      RunClientCommon(cb, client); 
     } 
    } 

    private static void RunClientBestExt(ConcurrentBag<double> cb) 
    { 
     const string Uri = "net.tcp://localhost:8000/ServiceModelSamples/service"; 
     var address = new EndpointAddress(Uri); 
     //var binding = new NetTcpBinding("netTcpBinding_ICalculator"); 
     new ChannelFactory<ICalculator>("netTcpBinding_ICalculator", address).Using(
      factory => 
       { 
        ICalculator client = factory.CreateChannel(); 
        ((IContextChannel)client).OperationTimeout = TimeSpan.FromSeconds(60); 
        RunClientCommon(cb, client); 
       }); 
    } 

Answer 1

mam zorientowaliśmy się źródło, myślę. GC nie wywoła opcji Dispose w ClientBase. Dlatego połączenia nie są pozostawione w stanie TIME_WAIT. Postanowiłem więc według tego samego wzoru i stworzył nową WCF rozszerzenia:

public static void UsingAbort<T>(this T client, Action<T> work) 
     where T : ICommunicationObject 
    { 
     try 
     { 
      work(client); 
      client.Abort(); 
     } 
     catch (CommunicationException e) 
     { 
      Logger.Warn(e); 
      client.Abort(); 
     } 
     catch (TimeoutException e) 
     { 
      Logger.Warn(e); 
      client.Abort(); 
     } 
     catch (Exception e) 
     { 
      Logger.Warn(e); 
      client.Abort(); 
      throw; 
     } 
    } 
} 

ten sposób na koniec wniosek to po prostu przerwać połączenie zamiast zamykania.