28
मैं एक एसओए बनाने की कोशिश कर रहा हूं जहां ग्राहक सर्वर पर लंबे समय से चलने वाले प्रश्न कर सकते हैं और सर्वर कॉलबैक का उपयोग कर जवाब देता है।डब्ल्यूसीएफ डुप्लेक्स अनुबंधों में ग्राहक मौत का पता लगाने
मैं यह पता लगाने में सक्षम होना चाहता हूं कि क्या ग्राहक डिस्कनेक्ट करता है (उपयोगकर्ता द्वारा शुरू किए गए शटडाउन, अनचाहे अपवाद या नेटवर्क कनेक्टिविटी के नुकसान के माध्यम से) ताकि सर्वर महंगा अनुरोध रद्द कर सके।
मैं कई प्रकार के विफलता मामलों का परीक्षण कर रहा हूं लेकिन मुझे कुछ ईवेंट हैंडलर आग लगने लगते हैं।
परीक्षण विफलता मामले: अनुरोध के बाद ग्राहक प्रक्रिया को मारना। टीसीपी कनेक्शन को बंद करने के लिए CurrPorts जैसे प्रोग्राम का उपयोग करना।
टेस्ट कोड:
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);
}
}
}
सबसे अच्छा अभ्यास विफलता के मामलों की इन प्रकार संभाल करने के लिए क्या है? मैं इन चीजों में से कुछ का पता लगाने के लिए अंतर्निहित टीसीपी कनेक्शन का उपयोग करने में सक्षम होना चाहता हूं।
आप शामिल हैं को लागू करने यानी विश्वसनीयता पर मोड़ने की कोशिश की? टीसीपी पॉइंट-टू-पॉइंट विश्वसनीयता प्रदान करता है।
संदेश विश्वसनीयता (डब्ल्यूएस-विश्वसनीयता के माध्यम से) अंत तक विश्वसनीयता प्रदान करता है।
और बदले में मेरा मानना है कि आप दोनों को सूचित करेंगे जब दोनों तरफ 'अनजाने में' अनजाने में। इसका समर्थन करने वाले परिवहन के लिए, हमेशा विश्वसनीयता को चालू करना सबसे अच्छा अभ्यास है, हालांकि कुछ नेटवर्क 'goo' इसका समर्थन नहीं कर सकता –