internal static async Task PopulateDictionaryAsync <ValueType>(
TransactionalReplicator transactionalReplicator,
Uri dictionaryName,
long startingNumber,
int batchCount,
int batchSize,
ValueType value)
{
var dictionary = transactionalReplicator.TryGetStateProvider(dictionaryName).Value as IReliableDictionary <long, ValueType>;
var distributedDictionary = dictionary as IDistributedDictionary <long, ValueType>;
var startingCount = distributedDictionary.Count;
for (var batchIndex = 0; batchIndex < batchCount; batchIndex++)
{
using (var txn = transactionalReplicator.CreateTransaction())
{
for (var key = (batchIndex * batchSize) + startingNumber; key < ((batchIndex + 1) * batchSize) + startingNumber; key++)
{
await dictionary.AddAsync(txn, key, value).ConfigureAwait(false);
}
// Data has not been added yet.
Assert.AreEqual(startingCount + (batchIndex * batchSize), distributedDictionary.Count);
await txn.CommitAsync().ConfigureAwait(false);
}
// Data is added and committed now.
Assert.AreEqual(startingCount + ((batchIndex + 1) * batchSize), distributedDictionary.Count);
}
var finalCount = distributedDictionary.Count;
Assert.AreEqual(startingCount + (batchCount * batchSize), finalCount);
}
internal static IReliableDictionary <TKey, TValue> GetDictionary <TKey, TValue>(TransactionalReplicator transactionalReplicator, Uri dictionaryName)
where TKey : IComparable <TKey>, IEquatable <TKey>
{
var result = transactionalReplicator.TryGetStateProvider(dictionaryName);
Assert.IsTrue(result.HasValue, "State Provider must exist");
var dictionary = result.Value as IReliableDictionary <TKey, TValue>;
Assert.IsNotNull(dictionary, "State provider named '{0}' is not an IDistributedDictionary<long, long>", dictionaryName);
return(dictionary);
}
internal static IReliableConcurrentQueue <T> GetConcurrentQueue <T>(TransactionalReplicator transactionalReplicator, Uri concurrentQueueName)
{
var result = transactionalReplicator.TryGetStateProvider(concurrentQueueName);
Assert.IsTrue(result.HasValue, "State Provider must exist");
var queue = result.Value as IReliableConcurrentQueue <T>;
Assert.IsNotNull(queue, "State provider named '{0}' is not an IReliableConcurrentQueue<T>", concurrentQueueName);
return(queue);
}
internal static IReliableQueue <T> GetQueue <T>(TransactionalReplicator transactionalReplicator, Uri queueName)
{
var result = transactionalReplicator.TryGetStateProvider(queueName);
Assert.IsTrue(result.HasValue, "State Provider must exist");
var queue = result.Value as IReliableQueue <T>;
Assert.IsNotNull(
queue,
"State provider named '{0}' is not an IDistributedDictionary<long, long>",
queueName);
return(queue);
}
