public void Init()
{
var _ss = new SerializationServiceBuilder().Build();
var dataList = new List <KeyValuePair <IData, object> >();
dataList.Add(new KeyValuePair <IData, object>(_ss.ToData(0), "0"));
dataList.Add(new KeyValuePair <IData, object>(_ss.ToData(1), _ss.ToData("1")));
dataList.Add(new KeyValuePair <IData, object>(_ss.ToData(2), _ss.ToData("2")));
dataList.Add(new KeyValuePair <IData, object>(_ss.ToData(3), "3"));
_testCollection = new ReadOnlyLazyDictionary <int, string, object>(dataList, _ss);
}
/// <summary>
/// Gets all entries for keys.
/// </summary>
/// <param name="ownerKeys">Keys.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>The values for the specified keys.</returns>
protected virtual async Task <ReadOnlyLazyDictionary <TKey, TValue> > GetAsync(Dictionary <Guid, Dictionary <int, List <IData> > > ownerKeys, CancellationToken cancellationToken)
{
// create parallel tasks to fire a request for each owner
var tasks = new List <Task <ClientMessage> >();
foreach (var(ownerId, part) in ownerKeys)
{
foreach (var(partitionId, list) in part)
{
if (list.Count == 0)
{
continue;
}
var requestMessage = MapGetAllCodec.EncodeRequest(Name, list);
requestMessage.PartitionId = partitionId;
var task = Cluster.Messaging.SendToMemberAsync(requestMessage, ownerId, cancellationToken);
tasks.Add(task);
}
}
// and wait on all tasks, gathering the responses
await Task.WhenAll(tasks).CAF();
// decode all responses, in 1 thread: this is CPU-bound
// (we may want to introduce some parallelism, though, depending on # of cores)
var result = new ReadOnlyLazyDictionary <TKey, TValue>(SerializationService);
// ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
foreach (var task in tasks)
{
var responseMessage = task.Result; // safe: we know the task has completed
var response = MapGetAllCodec.DecodeResponse(responseMessage).Response;
result.Add(response);
}
return(result);
}
