internal void AsyncResultCallTest()
{
ManualResetEvent eventa = new ManualResetEvent(false);
AsyncCallResultDelegate delegateInstance =
delegate(ISuperPoolClient client, AsyncResultParams parameters)
{
if ((parameters.State is int == false) ||
(int)parameters.State != 152)
{
Assert.Fail("Parameter fail.");
}
if (parameters.Result != null)
{
// Do something with result.
string resultString = parameters.Result.ToString();
}
eventa.Set();
};
Client1.Call <ITestInterface>(Client2.Id, delegateInstance, 152).AsyncResultMethod(1500);
if (eventa.WaitOne(60000) == false)
{
Assert.Fail("Failed to receive async result.");
}
}
internal void AsyncTimeoutResultCallTest()
{
ManualResetEvent eventa = new ManualResetEvent(false);
DateTime start = DateTime.Now;
AsyncCallResultDelegate delegateInstance =
delegate(ISuperPoolClient client, AsyncResultParams parameters)
{
TimeSpan time = DateTime.Now - start;
Console.WriteLine("Async call result received in " + time.TotalMilliseconds + "ms.");
eventa.Set();
string p = parameters.Result as string;
};
Client1.CallAll <ITestInterface>(delegateInstance, 152, TimeSpan.FromSeconds(2)).AsyncResultMethod(500);
eventa.WaitOne(60000);
if (Client1.PendingSyncCallsCount != 1)
{
throw new Exception("Pending sync calls count not 1.");
}
// Allow time for the client GC to gather the call.
Thread.Sleep(SuperPoolClient.GarbageCollectorIntervalMs * 3);
if (Client1.PendingSyncCallsCount != 0)
{
throw new Exception("Pending sync calls count not 0.");
}
}
/// <summary>
/// Perform the actual call.
/// </summary>
protected TType DoCall <TType>(ComponentId receiverId, TimeSpan?requestConfirmTimeout,
TimeSpan?timeout, AsyncCallResultDelegate asyncResultDelegate, object asyncResultState,
TimeSpan?asyncResultTimeout, SuperPoolProxyCall.ModeEnum callMode, CallOutcome outcome)
where TType : class
{
Matrix.Framework.SuperPool.Core.SuperPool pool = _superPool;
if (pool == null)
{
return(null);
}
SuperPoolProxyCall proxyCall;
TType result;
if (pool.Call <TType>(this, receiverId, out result, out proxyCall) == false)
{
// Call failed.
return(null);
}
proxyCall.AsyncResultDelegate = asyncResultDelegate;
proxyCall.AsyncResultState = asyncResultState;
proxyCall.AsyncResultTimeout = asyncResultTimeout;
proxyCall.RequestConfirmTimeout = requestConfirmTimeout;
proxyCall.Timeout = timeout;
proxyCall.Mode = callMode;
proxyCall.Outcome = outcome;
return(result);
}
/// <summary>
/// This method shows a few ways to perform calls.
/// </summary>
public void PerformCalls(ISuperPoolClient otherClient)
{
ISample otherSource = otherClient.Source as ISample;
string result;
ComponentId recipientId = otherClient.Id;
ComponentId[] recipientsIds = new ComponentId[] { otherClient.Id };
AsyncCallResultDelegate asyncDelegate = delegate(ISuperPoolClient clientInstance, AsyncResultParams param)
{
};
// Strongly Coupled Synchronous Invocation.
// This is the typical, strong coupled way of communication, or invocation.
result = otherSource.MyMethod(12);
// Decoupled “DirectCall” Invocation (Very fast, Local only)
// The closest invocation to the classical strongly coupled approach, this
// method is very fast, synchronous, and loosely coupled.
client.CallDirectLocal <ISample>(recipientId).MyMethod(12);
// Decoupled Synchronous Invocation (Local and remote, Timeout configurable)
client.CallSync <ISample>(recipientId).MyMethod(12);
// Decoupled Asynchronous Invocation.
client.Call <ISample>(recipientId).MyMethod(12);
// Decoupled Asynchronous Invocation with Result.
client.Call <ISample>(recipientId, asyncDelegate).MyMethod(12);
// Decoupled Asynchronous Invocation to Multiple Receivers (Addressed or Non-addressed).
client.Call <ISample>(recipientsIds).MyMethod(12); // Addressed
client.CallAll <ISample>().MyMethod(12); // Non-addressed
}
internal void AsyncTimeoutResultCallTestException()
{
ManualResetEvent eventa = new ManualResetEvent(false);
AsyncCallResultDelegate delegateInstance =
delegate(ISuperPoolClient client, AsyncResultParams parameters)
{
if (parameters.Exception == null)
{ // No exception was received, this is not expected.
}
else
{
eventa.Set();
}
};
Client1.CallAll <ITestInterface>(delegateInstance, 152, TimeSpan.FromSeconds(2)).ExceptionMethod();
if (eventa.WaitOne(20000) == false)
{
throw new Exception("Test failed due to no exception received.");
}
}
/// <summary>
/// Call and receive any result that may come with the usage of asyncDelegate; use state to
/// track any call identification information you may wish to use in the callback.
///
/// Since in this version no direct receiver is identified, make sure to specify a maximum number of
/// results to accept, as well as how long to wait for results to come.
/// </summary>
/// <param name="maxResultCount">Maximum number of accepted results, as a result of this non addressed call.</param>
/// <param name="resultWaitTimeout">How long to wait for results coming in.</param>
public TType CallAll <TType>(AsyncCallResultDelegate asyncDelegate, object state, TimeSpan asyncResultTimeout)
where TType : class
{
return(DoCall <TType>(null, null, null, asyncDelegate, state, asyncResultTimeout, SuperPoolProxyCall.ModeEnum.Default, null));
}
/// <summary>
/// Call and receive any result that may come with the usage of asyncDelegate; use state to
/// track any call identification information you may wish to use in the callback.
/// </summary>
public TType Call <TType>(ComponentId receiverId, AsyncCallResultDelegate asyncDelegate) where TType : class
{
return(DoCall <TType>(null, null, null, asyncDelegate, null, null, SuperPoolProxyCall.ModeEnum.Default, null));
}
public TType CallAll <TType>(AsyncCallResultDelegate asyncDelegate, object state, TimeSpan asyncResultTimeout) where TType : class
{
return(this.DoCall <TType>((ComponentId)null, new TimeSpan?(), new TimeSpan?(), asyncDelegate, state, new TimeSpan?(asyncResultTimeout), SuperPoolProxyCall.ModeEnum.Default, (CallOutcome)null));
}
public TType Call <TType>(ComponentId receiverId, AsyncCallResultDelegate asyncDelegate) where TType : class
{
return(this.DoCall <TType>((ComponentId)null, new TimeSpan?(), new TimeSpan?(), asyncDelegate, (object)null, new TimeSpan?(), SuperPoolProxyCall.ModeEnum.Default, (CallOutcome)null));
}
protected TType DoCall <TType>(ComponentId receiverId, TimeSpan?requestConfirmTimeout, TimeSpan?timeout, AsyncCallResultDelegate asyncResultDelegate, object asyncResultState, TimeSpan?asyncResultTimeout, SuperPoolProxyCall.ModeEnum callMode, CallOutcome outcome) where TType : class
{
SuperPool superPool = this._superPool;
if (superPool == null)
{
return(default(TType));
}
TType result;
SuperPoolProxyCall call;
if (!superPool.Call <TType>(this, receiverId, out result, out call))
{
return(default(TType));
}
call.AsyncResultDelegate = asyncResultDelegate;
call.AsyncResultState = asyncResultState;
call.AsyncResultTimeout = asyncResultTimeout;
call.RequestConfirmTimeout = requestConfirmTimeout;
call.Timeout = timeout;
call.Mode = callMode;
call.Outcome = outcome;
return(result);
}
