static void Main(string[] args)
{
if (args.Length >= 1)
{
name = args[0];
}
if (args.Length >= 2)
{
headnode = args[1];
}
if (args.Length >= 3)
{
messageCount = int.Parse(args[2]);
}
Console.WriteLine("Creating session...");
using (Session session = Session.CreateSession(new SessionStartInfo(headnode, "HelloWorld")))
{
using (BrokerClient<IHelloWorld> brokerClient = new BrokerClient<IHelloWorld>(session))
{
brokerClient.SetResponseHandler<SayHelloResponse>(ResponseHandler);
Console.WriteLine("Sending requests...");
for (int i = 0; i < messageCount; i++)
{
brokerClient.SendRequest(new SayHelloRequest(name));
}
Console.WriteLine("Committing requests...");
brokerClient.EndRequests();
Console.WriteLine("Waiting for responses...");
Console.ReadLine();
}
}
}
public static void SendRequests(Session session, List<BrokerClient<ISoamSvc>> clientList)
{
ThreadStart runnalbe = new ThreadStart(() =>
{
// Create a BrokerClient proxy
// This proxy is able to map One-Way, Duplex message exchange patterns
// with the Request / Reply Services. As such, the client program can send the
// requests, exit and re-attach to the session to retrieve responses (see the
// FireNRecollect project for details
String clientId = Guid.NewGuid().ToString();
BrokerClient<ISoamSvc> client = new BrokerClient<ISoamSvc>(clientId, session);
clientList.Add(client);
for (int i = 0; i < numBatchRequests; i++)
{
// SoamInvokeRequest are created as you add Service Reference
// SoamInvokeService to the project
MyInput input = new MyInput();
SoamInvokeRequest request = new SoamInvokeRequest();
request.SetSoamInputObject(input);
client.SendRequest<SoamInvokeRequest>(request, i);
//Console.WriteLine("\tSent request {0}: {1}", i, input);
}
// Flush the message. After this call, the runtime system
// starts processing the request messages. If this call is not called,
// the system will not process the requests. The client.GetResponses() will return
// with an empty collection
client.EndRequests();
});
Thread[] threads = new Thread[numBatchs];
for (int i = 0; i < numBatchs; i++)
{
threads[i] = new Thread(runnalbe);
threads[i].Start();
}
for (int i = 0; i < numBatchs; i++)
{
try
{
threads[i].Join();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
public void BvtCase3()
{
Info("Start BVT");
List <string> results = new List <string>();
SessionStartInfo sessionStartInfo;
sessionStartInfo = BuildSessionStartInfo(Server, EchoSvcName, null, null, null, null, SessionUnitType.Node, null, null, null);
sessionStartInfo.Secure = false;
sessionStartInfo.BrokerSettings.SessionIdleTimeout = 60 * 10 * 1000;
Info("Begin to create session");
string serviceJobId;
int clients = 2;
AutoResetEvent evt = new AutoResetEvent(false);
Session session = Session.CreateSession(sessionStartInfo);
SessionAttachInfo sessionAttachInfo = new SessionAttachInfo(sessionStartInfo.Headnode, session.Id);
session = Session.AttachSession(sessionAttachInfo);
serviceJobId = session.Id;
var epr = new EndpointAddress(string.Format(NetTcpEndpointPattern, Server, serviceJobId));
Info("EPR: {0}", epr);
Task[] tasks = new Task[2];
for (int i = 0; i < 2; i++)
{
var idx = i;
tasks[i] = Task.Run(
() =>
{
string guid = Guid.NewGuid().ToString();
try
{
Info("Client {0}: Begin to send requests.", guid);
using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(guid, session))
{
for (int j = 0; j < NumberOfCalls; j++)
{
client.SendRequest <EchoRequest>(new EchoRequest(j.ToString()), j + ":" + guid);
}
Info("Client {0}: Begin to call EndOfMessage.", guid);
client.EndRequests();
Info("Client {0}: Begin to get responses.", guid);
int count = 0;
if (idx == 0)
{
foreach (BrokerResponse <EchoResponse> response in client.GetResponses <EchoResponse>())
{
count++;
Info(response.Result.EchoResult);
string[] rtn = response.Result.EchoResult.Split(new[] { ':' });
Assert(
rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid,
"Result is corrupt: expected:computername:{0}, actual:{1}",
response.GetUserData <string>().Split(new[] { ':' })[0],
response.Result.EchoResult);
}
}
else
{
foreach (var response in client.GetResponses())
{
count++;
EchoResponse result = (EchoResponse)response.Result;
Info(result.EchoResult);
string[] rtn = result.EchoResult.Split(new[] { ':' });
Assert(
rtn[rtn.Length - 1] == response.GetUserData <string>().Split(new[] { ':' })[0] && response.GetUserData <string>().Split(new[] { ':' })[1] == guid,
"Result is corrupt: expected:computername:{0}, actual:{1}",
response.GetUserData <string>(),
result.EchoResult);
}
}
if (count == NumberOfCalls)
{
Info("Client {0}: Total {1} calls returned.", guid, count);
}
else
{
Error("Client {0}: Total {1} calls returned, but losing {2} results.", guid, count, NumberOfCalls - count);
}
}
}
catch (Exception e)
{
Error("Unexpected exception of Client {0}", e.ToString());
throw;
}
finally
{
if (Interlocked.Decrement(ref clients) <= 0)
{
evt.Set();
}
}
});
}
evt.WaitOne();
Task.WaitAll(tasks);
session.Close(true);
session.Dispose();
// VerifyJobStatus(serviceJobId);
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "localhost";
const string serviceName = "JavaEchoSvc1";
const int numRequests = 12;
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
Console.Write("Creating a session for EchoService...");
// Create a durable session
// Request and response messages in a durable session are persisted so that
// in event of failure, no requests nor responses will be lost. Another authorized
// client can attached to a session with the same session Id and retrieve responses
using (DurableSession session = DurableSession.CreateSession(info))
{
Console.WriteLine("done session id = {0}", session.Id);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
// Create a BrokerClient proxy
// This proxy is able to map One-Way, Duplex message exchange patterns
// with the Request / Reply Services. As such, the client program can send the
// requests, exit and re-attach to the session to retrieve responses (see the
// FireNRecollect project for details
using (BrokerClient<IEchoSvc> client = new BrokerClient<IEchoSvc>(session, binding))
{
Console.Write("Sending {0} requests...", numRequests);
for (int i = 0; i < numRequests; i++)
{
// EchoRequest are created as you add Service Reference
// EchoService to the project
EchoRequest request = new EchoRequest("hello world!");
client.SendRequest<EchoRequest>(request, i);
}
// Flush the message. After this call, the runtime system
// starts processing the request messages. If this call is not called,
// the system will not process the requests. The client.GetResponses() will return
// with an empty collection
client.EndRequests();
Console.WriteLine("done");
Console.WriteLine("Retrieving responses...");
// GetResponses from the runtime system
// EchoResponse class is created as you add Service Reference "EchoService"
// to the project
foreach (var response in client.GetResponses<EchoResponse>())
{
try
{
string reply = response.Result.EchoResult;
Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData<int>(), reply);
}
catch (Exception ex)
{
Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData<int>(), ex.Message);
}
}
Console.WriteLine("Done retrieving {0} responses", numRequests);
}
//explict close the session to free the resource
session.Close();
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
const string headnode = "[headnode]";
const string serviceName = "EchoService";
const int numRequests = 12;
int count = 0;
SessionStartInfo info = new SessionStartInfo(headnode, serviceName);
AutoResetEvent done = new AutoResetEvent(false);
Console.Write("Creating a session for EchoService...");
using (Session session = Session.CreateSession(info))
{
Console.WriteLine("done session id = {0}", session.Id);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding))
{
//set getresponse handler
client.SetResponseHandler <EchoResponse>((item) =>
{
try
{
Console.WriteLine("\tReceived response for request {0}: {1}",
item.GetUserData <int>(), item.Result.EchoResult);
}
catch (SessionException ex)
{
Console.WriteLine("SessionException while getting responses in callback: {0}", ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Exception while getting responses in callback: {0}", ex.Message);
}
if (Interlocked.Increment(ref count) == numRequests)
{
done.Set();
}
});
// start to send requests
Console.Write("Sending {0} requests...", numRequests);
for (int i = 0; i < numRequests; i++)
{
EchoRequest request = new EchoRequest("hello world!");
client.SendRequest <EchoRequest>(request, i);
}
client.EndRequests();
Console.WriteLine("done");
Console.WriteLine("Retrieving responses...");
// Main thread block here waiting for the retrieval process
// to complete. As the thread that receives the "numRequests"-th
// responses does a Set() on the event, "done.WaitOne()" will pop
done.WaitOne();
Console.WriteLine("Done retrieving {0} responses", numRequests);
}
// Close connections and delete messages stored in the system
session.Close();
}
Console.WriteLine("Press any key to exit.");
Console.Read();
}
static void Main(string[] args)
{
string hostname = "[headnode]";
// DataClient Id used to identify the data, this should be unique across the cluster
string raw_data_id = "raw_data_id";
string dictionary_data_id = "dictionary_data_id";
Console.WriteLine("Start. " + DateTime.Now.ToLongTimeString());
// Create a DataClient to store a Dictionary data
using (DataClient client = DataClient.Create(hostname, dictionary_data_id))
{
Console.WriteLine("Data {0} Created. {1} ", dictionary_data_id, DateTime.Now.ToLongTimeString());
// Here we have a DataClient whose life cycle is not managed by SOA
Dictionary <string, string> objects = new Dictionary <string, string>();
objects.Add("key1", "value1");
objects.Add("key2", "value2");
// WriteAll() can only be called once on a data client.
client.WriteAll <Dictionary <string, string> >(objects);
}
SessionStartInfo sessionStartInfo = new SessionStartInfo(hostname, "CommonDataService");
// Pass DataClient Id in SOA session's environment variable so that it could be read from service code
sessionStartInfo.Environments.Add("DICTIONARY_DATA_ID", dictionary_data_id);
using (Session session = Session.CreateSession(sessionStartInfo))
{
Console.WriteLine("Session {0} Created. {1} ", session.Id, DateTime.Now.ToLongTimeString());
// Create a DataClient to store the raw data read from the file
using (DataClient client = DataClient.Create(hostname, raw_data_id))
{
Console.WriteLine("Data {0} Created {1}. ", client.Id, DateTime.Now.ToLongTimeString());
// Add a data life cycle management so that it'll be deleted when session is done
// Otherwise, the data will have to be cleaned up by client
client.SetDataLifeCycle(new DataLifeCycle(session.Id));
// WriteRawBytesAll() doesn't serialize the object and will write the byte stream directly.
// Use this when you want to transport a file or have non-.Net code that cannot handle .net serialization.
client.WriteRawBytesAll(File.ReadAllBytes("DataFile.txt"));
}
// Send/Receive SOA requests
using (BrokerClient <ICommonDataService> client = new BrokerClient <ICommonDataService>(session))
{
Console.WriteLine("Send Requests. " + DateTime.Now.ToLongTimeString());
client.SendRequest <GetDataRequest>(new GetDataRequest(raw_data_id));
client.EndRequests();
Console.WriteLine("Get Response. " + DateTime.Now.ToLongTimeString());
foreach (BrokerResponse <GetDataResponse> resp in client.GetResponses <GetDataResponse>())
{
string result = resp.Result.GetDataResult;
Console.WriteLine(result);
}
}
Console.WriteLine("Start closing session. " + DateTime.Now.ToLongTimeString());
}
Console.WriteLine("Session Closed. " + DateTime.Now.ToLongTimeString());
Console.WriteLine("Start cleaning up the Data {0}. {1} ", dictionary_data_id, DateTime.Now.ToLongTimeString());
// We should delete the DataClient "dictionary_data_id" here since it's not managed by SOA
DataClient.Delete(hostname, dictionary_data_id);
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public void doSubmit(Dictionary <string, string> runParameters)
{
m_start = System.Environment.TickCount;
//
// Configure session with cluster:
//
string[] parameterKeys = { "HeadNode", "Service", "JobTemplate", "Tasks", "TaskTime" };
foreach (string parameterKey in parameterKeys)
{
if (!runParameters.ContainsKey(parameterKey))
{
outputError(parameterKey);
}
}
string headNode = runParameters["HeadNode"];
SessionStartInfo info = new SessionStartInfo(headNode, runParameters["Service"]);
info.SessionResourceUnitType = SessionUnitType.Core;
if (runParameters.ContainsKey("MinCores"))
{
info.MinimumUnits = Convert.ToInt32(runParameters["MinCores"]);
}
if (runParameters.ContainsKey("MaxCores"))
{
info.MaximumUnits = Convert.ToInt32(runParameters["MaxCores"]);
}
if (runParameters.ContainsKey("Priority"))
{
info.SessionPriority = Convert.ToInt32(runParameters["Priority"]);
}
info.Secure = false; // generally off in the classroom:
info.BrokerSettings.SessionIdleTimeout = 15000; // 15 secs:
info.JobTemplate = runParameters["JobTemplate"];
int tasks = Convert.ToInt32(runParameters["Tasks"]);
int taskTime = Convert.ToInt32(runParameters["TaskTime"]);
double taskFailureChance = 0.0;
if (runParameters.ContainsKey("TaskFailureChance"))
{
taskFailureChance = Convert.ToDouble(runParameters["TaskFailureChance"]);
}
int taskTimeDeviation = 0;
if (runParameters.ContainsKey("TaskTimeDeviation"))
{
taskTimeDeviation = Convert.ToInt32(runParameters["TaskTimeDeviation"]);
}
int taskThrottling = 0;
if (runParameters.ContainsKey("TaskThrottling"))
{
taskThrottling = Convert.ToInt32(runParameters["TaskThrottling"]);
}
//
// User is prompted for run-as credentials, then session
// is opened for business:
//
Session.SetInterfaceMode(false /*GUI*/, (IntPtr)0);
Console.WriteLine("Creating session: {0}ms", System.Environment.TickCount - m_start);
using (var session = Session.CreateSession(info))
{
Console.WriteLine("Session Created: {0}ms", System.Environment.TickCount - m_start);
var mode = (info.Secure) ? SecurityMode.Transport : SecurityMode.None;
var binding = new NetTcpBinding(mode);
using (var proxy = new BrokerClient <ClusterTesterService.IClusterTesterService>(session, binding))
{
m_signal = new Semaphore(0, 1);
proxy.SetResponseHandler <ClusterTesterService.RunTaskResponse>(doSubmit_ServiceCallback, m_signal);
Console.WriteLine("Connected to session {0}: {1}ms", session.Id, System.Environment.TickCount - m_start);
//
// Make the N service calls:
//
Console.WriteLine("Sending requests: {0}", System.Environment.TickCount - m_start);
Random random = new Random();
int thisTaskTime;
for (int i = 0; i < tasks; i++)
{
if (taskTimeDeviation != 0)
{
thisTaskTime = Math.Max(0, gaussian(random, taskTime, taskTimeDeviation));
}
else
{
thisTaskTime = taskTime;
}
if (taskThrottling > 0)
{
Thread.Sleep(taskThrottling);
}
proxy.SendRequest(new ClusterTesterService.RunTaskRequest(i, thisTaskTime, taskFailureChance));
}
proxy.EndRequests();
Console.WriteLine("End requests: {0}ms", System.Environment.TickCount - m_start);
//
// wait on callbacks
//
m_signal.WaitOne();
session.Close();
}
}
Console.WriteLine("Exit program: {0}ms", System.Environment.TickCount - m_start);
m_stop = System.Environment.TickCount;
}
private static void V3ClientSample(SessionStartInfo startInfo)
{
using (DurableSession session = DurableSession.CreateSession(startInfo))
{
using (BrokerClient <IGenericServiceV3> client = new BrokerClient <IGenericServiceV3>(session))
{
GenericServiceRequest request1 = new GenericServiceRequest();
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
{
writer.Write((int)0);
writer.Write((int)123);
}
request1.Data = Convert.ToBase64String(ms.ToArray());
}
// Use user data to differentiate operations
// 0 stands for GetData()
// 1 stands for GetDataUsingDataContract()
client.SendRequest <GenericServiceRequest>(request1, 0);
GenericServiceRequest request2 = new GenericServiceRequest();
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
{
writer.Write((int)1);
writer.Write(true);
writer.Write("DataData");
}
request2.Data = Convert.ToBase64String(ms.ToArray());
}
client.SendRequest <GenericServiceRequest>(request2, 1);
client.EndRequests();
foreach (BrokerResponse <GenericServiceResponse> response in client.GetResponses <GenericServiceResponse>())
{
int operationIndex = response.GetUserData <int>();
switch (operationIndex)
{
case 0:
// GetData
Console.WriteLine("GetDataResult: {0}", response.Result.Data);
break;
case 1:
// GetDataUsingDataContract
CompositeType result;
using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(response.Result.Data)))
using (BinaryReader reader = new BinaryReader(ms))
{
result = new CompositeType();
result.BoolValue = reader.ReadBoolean();
result.StringValue = reader.ReadString();
}
Console.WriteLine("GetDataUsingDataContractResult: BoolValue={0}\tStringValue={1}", result.BoolValue, result.StringValue);
break;
}
}
}
session.Close();
}
}
static void Main(string[] args)
{
//change the headnode name here
const string headnode = "[headnode]";
const string serviceName = "EchoService";
const int numRequests = 12;
SessionStartInfo startInfo = new SessionStartInfo(headnode, serviceName);
startInfo.BrokerSettings.SessionIdleTimeout = 15 * 60 * 1000;
startInfo.BrokerSettings.ClientIdleTimeout = 15 * 60 * 1000;
Console.Write("Creating a session for EchoService...");
// Create a durable session
int sessionId = 0;
DurableSession session = null;
bool successFlag = false;
int retryCount = 0;
const int retryCountMax = 20;
const int retryIntervalMs = 5000;
while (!successFlag && retryCount++ < retryCountMax)
{
try
{
session = DurableSession.CreateSession(startInfo);
successFlag = true;
}
catch (EndpointNotFoundException e)
{
Console.WriteLine("EndpointNotFoundException {0}", e.ToString());
}
catch (CommunicationException e)
{
Console.WriteLine("CommunicationException {0}", e.ToString());
}
catch (TimeoutException e)
{
Console.WriteLine("TimeoutException {0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
Console.WriteLine("General exception {0}", e.ToString());
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
if (!successFlag)
{
Console.WriteLine("Create durable session failed.");
return;
}
sessionId = session.Id;
Console.WriteLine("Done session id = {0}", sessionId);
//send requests
successFlag = false;
retryCount = 0;
const int sendTimeoutMs = 5000;
const int clientPurgeTimeoutMs = 60000;
while (!successFlag && retryCount++ < retryCountMax)
{
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
Console.Write("Sending {0} requests...", numRequests);
try
{
for (int i = 0; i < numRequests; i++)
{
//client.SendRequest<EchoFaultRequest>(new EchoFaultRequest("dividebyzeroexception"), i, sendTimeoutMs);
client.SendRequest <EchoDelayRequest>(new EchoDelayRequest(5000), i, sendTimeoutMs);
}
client.EndRequests();
successFlag = true;
Console.WriteLine("done");
}
catch (TimeoutException e)
{
// Timeout exceptions
Console.WriteLine("TimeoutException {0}", e.ToString());
}
catch (CommunicationException e)
{
//CommunicationException
Console.WriteLine("CommunicationException {0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
if (SOAFaultCode.Broker_BrokerUnavailable == e.ErrorCode)
{
Console.WriteLine("SessionException : BrokerUnavailable {0}", e.ToString());
}
// Session Exceptions are unrecoverable unless they are application errors
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.ApplicationError))
{
Console.WriteLine("SessionExceptionCategory : ApplicationError {0}", e.ToString());
}
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
//general exceptions
Console.WriteLine("Exception {0}", e.ToString());
}
//purge client if not succeeded, needed?
if (!successFlag)
{
try
{
client.Close(true, clientPurgeTimeoutMs);
}
catch (Exception e)
{
Console.WriteLine("Failed to purge the client after send request failure {0}", e.ToString());
}
}
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
if (!successFlag)
{
Console.WriteLine("Send requests failed.");
return;
}
//dispose the session here
session.Dispose();
//attach the session
SessionAttachInfo attachInfo = new SessionAttachInfo(headnode, sessionId);
successFlag = false;
retryCount = 0;
const int attachTimeoutMs = 15000;
while (!successFlag && retryCount++ < retryCountMax)
{
try
{
session = DurableSession.AttachSession(attachInfo);
successFlag = true;
}
catch (EndpointNotFoundException e)
{
Console.WriteLine("{0}", e.ToString());
}
catch (CommunicationException e)
{
Console.WriteLine("{0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
Console.WriteLine("General exception {0}", e.ToString());
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
if (!successFlag)
{
Console.WriteLine("Attach durable session failed.");
return;
}
successFlag = false;
retryCount = 0;
const int getTimeoutMs = 30000;
const int clientCloseTimeoutMs = 15000;
Console.WriteLine("Retrieving responses...");
while (!successFlag && retryCount++ < retryCountMax)
{
using (BrokerClient <IService1> client = new BrokerClient <IService1>(session))
{
// GetResponses from the runtime system
// EchoResponse class is created as you add Service Reference "EchoService" to the project
try
{
//foreach (var response in client.GetResponses<EchoFaultResponse>(getTimeoutMs))
foreach (var response in client.GetResponses <EchoDelayResponse>(getTimeoutMs))
{
try
{
//string reply = response.Result.EchoFaultResult ;
int reply = response.Result.EchoDelayResult;
Console.WriteLine("\tReceived response for delay request {0}: {1}", response.GetUserData <int>(), reply);
}
catch (FaultException <DivideByZeroException> e)
{
// Application exceptions
Console.WriteLine("FaultException<DivideByZeroException> {0}", e.ToString());
}
catch (FaultException e)
{
// Application exceptions
Console.WriteLine("FaultException {0}", e.ToString());
}
catch (RetryOperationException e)
{
// RetryOperationExceptions may or may not be recoverable
Console.WriteLine("RetryOperationException {0}", e.ToString());
}
}
successFlag = true;
Console.WriteLine("Done retrieving {0} responses", numRequests);
}
catch (TimeoutException e)
{
// Timeout exceptions
Console.WriteLine("TimeoutException {0}", e.ToString());
}
catch (CommunicationException e)
{
//CommunicationException
Console.WriteLine("CommunicationException {0}", e.ToString());
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
if (SOAFaultCode.Broker_BrokerUnavailable == e.ErrorCode)
{
Console.WriteLine("SessionException : BrokerUnavailable {0}", e.ToString());
}
// Session Exceptions are unrecoverable unless they are application errors
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.ApplicationError))
{
Console.WriteLine("SessionExceptionCategory : ApplicationError {0}", e.ToString());
}
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
//general exceptions
Console.WriteLine("Exception {0}", e.ToString());
}
try
{
client.Close(false, clientCloseTimeoutMs);
}
catch (Exception e)
{
Console.WriteLine("Exception", e.ToString());
}
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
//explict close the session to free the resource
successFlag = false;
retryCount = 0;
Console.WriteLine("Close the session...");
while (!successFlag && retryCount++ < retryCountMax)
{
try
{
session.Close(true);
successFlag = true;
}
catch (SessionException e)
{
Console.WriteLine("SessionException {0}, error code 0x{1:x}", e.ToString(), e.ErrorCode);
// if session fatal errors happen, no retry
if (SOAFaultCode.Category(e.ErrorCode).Equals(SOAFaultCodeCategory.SessionFatalError))
{
Console.WriteLine("SessionExceptionCategory : SessionFatalError {0}", e.ToString());
Console.WriteLine("No retry.");
retryCount = retryCountMax;
continue;
}
}
catch (Exception e)
{
Console.WriteLine("{0}", e.ToString());
}
if (!successFlag)
{
Console.WriteLine("=== Sleep {0} ms to retry. Retry count left {1}. ===", retryIntervalMs, retryCountMax - retryCount);
Thread.Sleep(retryIntervalMs);
}
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}