Phát hiện thân chủ chết trong Hợp đồng Duplex WCF

Question

Tôi đang cố gắng xây dựng một SOA nơi khách hàng có thể thực hiện các truy vấn chạy dài trên máy chủ và máy chủ trả lời bằng cách sử dụng gọi lại.

Tôi muốn có thể phát hiện xem máy khách có ngắt kết nối (thông qua tắt máy do người dùng khởi tạo, ngoại lệ không được giải quyết hoặc mất kết nối mạng) để máy chủ có thể chọn hủy yêu cầu đắt tiền.

Tôi đang thử nghiệm nhiều trường hợp lỗi khác nhau nhưng tôi dường như không thể xử lý sự kiện nhất định để kích hoạt.

Trường hợp lỗi được kiểm tra: Giết quá trình khách hàng Sau khi yêu cầu. Sử dụng chương trình như CurrPorts để đóng Kết nối TCP.

Mã kiểm tra:

using System; 
using System.ServiceModel; 
using System.Threading; 

namespace WCFICommunicationObjectExperiments 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var binding = new NetTcpBinding(SecurityMode.None); 

      var serviceHost = new ServiceHost(typeof (Server)); 
      serviceHost.AddServiceEndpoint(typeof (IServer), binding, "net.tcp://localhost:5000/Server"); 
      serviceHost.Open(); 
      Console.WriteLine("Host is running, press <ENTER> to exit."); 
      Console.ReadLine(); 
     } 

    } 

    [ServiceContract(CallbackContract = typeof(IClient))] 
    public interface IServer 
    { 
     [OperationContract] 
     void StartProcessing(string Query); 
    } 

    public interface IClient 
    { 
     [OperationContract] 
     void RecieveResults(string Results); 
    } 

    [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)] 
    public class Server : IServer 
    { 

     public void StartProcessing(string Query) 
     { 
      Thread.Sleep(5000); 

      //Callback Channel 
      var clientCallback = OperationContext.Current.GetCallbackChannel<IClient>(); 
      var clientCallbackCommunicationObject = ((ICommunicationObject) clientCallback); 
      EventHandler faultedHandlerCallback = (o, s) => Console.WriteLine("Client Channel Faulted."); 
      EventHandler closedHandlerCallback = (o, s) => Console.WriteLine("Client Channel Closed."); 
      clientCallbackCommunicationObject.Faulted += faultedHandlerCallback; 
      clientCallbackCommunicationObject.Closed += closedHandlerCallback; 

      //Request Channel 
      var requestChannel = OperationContext.Current.Channel; 
      EventHandler faultedHandlerRequest = (o, s) => Console.WriteLine("Request Channel Faulted."); 
      EventHandler closedHandlerRequest = (o, s) => Console.WriteLine("Request Channel Closed."); 
      requestChannel.Faulted += faultedHandlerRequest; 
      requestChannel.Closed += closedHandlerRequest; 

      try 
      { 
       clientCallback.RecieveResults("42."); 
      } 
      catch (CommunicationObjectAbortedException ex) 
      { 
       Console.WriteLine("Client Aborted the connection"); 
      } 
      catch (CommunicationObjectFaultedException ex) 
      { 
       Console.WriteLine("Client Died."); 
      } 
      clientCallbackCommunicationObject.Faulted -= faultedHandlerCallback; 
      clientCallbackCommunicationObject.Faulted -= closedHandlerCallback; 
      requestChannel.Faulted -= faultedHandlerRequest; 
      requestChannel.Closed -= closedHandlerRequest; 
     } 
    } 

    public class ClientToTestStates : IClient 
    { 
     private IServer m_Server; 

     private readonly ManualResetEvent m_ReceivedEvent = new ManualResetEvent(false); 
     private readonly ManualResetEvent m_ChannelFaulted = new ManualResetEvent(false); 
     private readonly ManualResetEvent m_ChannelClosed = new ManualResetEvent(false); 

     public ClientToTestStates() 
     { 
      var binding = new NetTcpBinding(SecurityMode.None); 
      var channelFactory = new DuplexChannelFactory<IServer>(this, binding, new EndpointAddress("net.tcp://localhost:5000/Server")); 
      m_Server = channelFactory.CreateChannel(); 
      ((ICommunicationObject)m_Server).Open(); 
      ((ICommunicationObject)m_Server).Faulted += ChannelFaulted; 
      ((ICommunicationObject)m_Server).Closed += ChannelClosed; 

      m_Server.StartProcessing("What is the answer?"); 

      WaitHandle.WaitAny(new WaitHandle[] {m_ReceivedEvent, m_ChannelFaulted, m_ChannelClosed}); 
     } 

     void ChannelFaulted(object sender, EventArgs e) 
     { 
      m_ChannelFaulted.Set(); 
      Console.WriteLine("Channel Faulted."); 
     } 

     void ChannelClosed(object sender, EventArgs e) 
     { 
      m_ChannelClosed.Set(); 
      Console.WriteLine("Channel Closed."); 
     } 


     public void RecieveResults(string results) 
     { 
      m_ReceivedEvent.Set(); 
      Console.WriteLine("Recieved Results {0}", results); 
     } 
    } 
} 

các thực hành tốt nhất để xử lý các loại trường hợp thất bại là gì? Tôi muốn có thể sử dụng kết nối tcp cơ bản để phát hiện một số trong những điều này.

Answer 1

Trong cuốn sách 'Lập trình WCF', Juval Lowy giải thích rằng WCF không cung cấp mechansim để quản lý cuộc gọi dịch vụ và điều này phải được quản lý bởi dịch vụ và khách hàng một cách rõ ràng. Nếu dịch vụ cố gắng gọi một cuộc gọi lại đã được đóng trên máy khách, một ObjectDisposedException sẽ được ném vào kênh dịch vụ.

Anh khuyên bạn nên thêm phương thức Kết nối và Ngắt kết nối vào hợp đồng dịch vụ - vì cuộc gọi lại phải được cung cấp cho dịch vụ khi chúng được gọi, dịch vụ có thể quản lý cuộc gọi lại của khách hàng. Sau đó nó được gửi tới máy khách để đảm bảo rằng nó gọi Ngắt kết nối khi nó không còn muốn nhận các cuộc gọi lại từ dịch vụ và dịch vụ phải xử lý bất kỳ ngoại lệ nào khi gọi các cuộc gọi lại đến máy khách.

Answer 2

thử này để kiểm tra nếu đối tượng gọi lại vẫn còn hợp lệ:

(((ICommunicationObject)myCallbackObject).State == CommunicationState.Opened) 

myCallbackObject trong trường hợp này là các đối tượng thông qua đó bạn có thể thực hiện gọi lại, tức là thực hiện hợp đồng callback