public async Task ClearAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
if (reliableDictionary == null)
{
await InitializeReliableDictionary();
}
await reliableDictionary.ClearAsync(timeout, cancellationToken);
}
public async Task ClearMessagesAsync()
{
IReliableDictionary <DateTime, Message> messagesDictionary =
await this.StateManager.GetOrAddAsync <IReliableDictionary <DateTime, Message> >("messages");
await messagesDictionary.ClearAsync();
}
private async Task ExecuteClearAsync(IReliableDictionary <string, Order> orders)
{
using (ITransaction tx = this.stateManager.CreateTransaction())
{
await orders.ClearAsync();
}
}
public async Task <ConditionalValue <IReliableDictionary <TKey, TValue> > > TryCopyToReliableDictionary <TKey, TValue>(Dictionary <TKey, TValue> source, string targetKey, IReliableStateManager stateManager) where TKey : IComparable <TKey>, IEquatable <TKey>
{
var conditionalValue = await reliableStateManagerHelper.TryGetAsync <IReliableDictionary <TKey, TValue> >(stateManager, targetKey);
if (!conditionalValue.HasValue)
{
return(new ConditionalValue <IReliableDictionary <TKey, TValue> >(false, null));
}
IReliableDictionary <TKey, TValue> reliableDictionary = conditionalValue.Value;
using (ITransaction tx = stateManager.CreateTransaction())
{
await reliableDictionary.ClearAsync();
var tasks = new List <Task>();
foreach (var kvp in source)
{
tasks.Add(reliableDictionary.SetAsync(tx, kvp.Key, kvp.Value));
}
Task.WaitAll(tasks.ToArray());
await tx.CommitAsync();
}
return(new ConditionalValue <IReliableDictionary <TKey, TValue> >(true, reliableDictionary));
}
public async Task Clear()
{
DateTimeOffset now = DateTimeOffset.Now;
var toKeep = new List <KeyValuePair <Guid, DateTimeOffset> >();
using (ITransaction tx = this.sm.CreateTransaction())
{
var asyncEnumerable = await dictionary.CreateEnumerableAsync(tx);
using (var asyncEnumerator = asyncEnumerable.GetAsyncEnumerator())
{
while (await asyncEnumerator.MoveNextAsync(CancellationToken.None))
{
if ((now - asyncEnumerator.Current.Value).TotalSeconds < maxDelaySeconds)
{
toKeep.Add(asyncEnumerator.Current);
}
}
}
await dictionary.ClearAsync();
foreach (var pair in toKeep)
{
await dictionary.TryAddAsync(tx, pair.Key, pair.Value);
}
await tx.CommitAsync();
lastClear = DateTimeOffset.Now;
}
}
public async Task DeleteAllStoryPointEntries()
{
IReliableDictionary <Guid, perStoryData> storypointdata =
await _stateManager.GetOrAddAsync <IReliableDictionary <Guid, perStoryData> >("storypointdata");
using (ITransaction tx = _stateManager.CreateTransaction())
{
await storypointdata.ClearAsync();
await tx.CommitAsync();
}
}
public async Task <ConditionalValue <IReliableDictionary <TKey, TValue> > > TryCopyToReliableDictionary <TKey, TValue>(string sourceKey, string targetKey, IReliableStateManager stateManager) where TKey : IComparable <TKey>, IEquatable <TKey>
{
var conditionalValue = await reliableStateManagerHelper.TryGetAsync <IReliableDictionary <TKey, TValue> >(stateManager, sourceKey);
if (!conditionalValue.HasValue)
{
return(new ConditionalValue <IReliableDictionary <TKey, TValue> >(false, null));
}
IReliableDictionary <TKey, TValue> source = conditionalValue.Value;
conditionalValue = await reliableStateManagerHelper.TryGetAsync <IReliableDictionary <TKey, TValue> >(stateManager, targetKey);
if (!conditionalValue.HasValue)
{
return(new ConditionalValue <IReliableDictionary <TKey, TValue> >(false, null));
}
IReliableDictionary <TKey, TValue> target = conditionalValue.Value;
using (ITransaction tx = stateManager.CreateTransaction())
{
await target.ClearAsync();
var asyncEnumerable = await source.CreateEnumerableAsync(tx);
var asyncEnumerator = asyncEnumerable.GetAsyncEnumerator();
CancellationTokenSource tokenSource = new CancellationTokenSource();
var tasks = new List <Task>();
while (await asyncEnumerator.MoveNextAsync(tokenSource.Token))
{
var currentEntry = asyncEnumerator.Current;
tasks.Add(target.SetAsync(tx, currentEntry.Key, currentEntry.Value));
}
Task.WaitAll(tasks.ToArray());
await tx.CommitAsync();
}
return(new ConditionalValue <IReliableDictionary <TKey, TValue> >(true, target));
}
public Task ClearAsync(TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) => m_dictionary.ClearAsync(timeout.DefaultToInfinite(), cancellationToken);
private async Task SetScadaModel(string name, Dictionary <Tuple <RegisterType, int>, BasePoint> dictionary)
{
historian = new HistoryServiceProxy(ConfigurationReader.ReadValue(_context, "Settings", "History"));
IReliableDictionary <int, BasePoint> result = null;
using (var tx = _stateManager.CreateTransaction())
{
result = await _stateManager.GetOrAddAsync <IReliableDictionary <int, BasePoint> >(tx, name, TimeSpan.FromSeconds(60));
if (dictionary == null)
{
await result.ClearAsync();
await tx.CommitAsync();
return;
}
await tx.CommitAsync();
}
using (var tx = _stateManager.CreateTransaction())
{
var historyData = new List <HistoryDbModel>();
foreach (var item in dictionary)
{
var point = await result.TryGetValueAsync(tx, MakeKey(item.Key.Item1, item.Key.Item2), TimeSpan.FromSeconds(60), CancellationToken.None);
if (point.HasValue)
{
switch (item.Key.Item1)
{
case RegisterType.BINARY_INPUT:
case RegisterType.BINARY_OUTPUT:
{
((DiscretePoint)point.Value).TimeStamp = (item.Value as DiscretePoint).TimeStamp;
if (((DiscretePoint)point.Value).Value != (item.Value as DiscretePoint).Value)
{
((DiscretePoint)point.Value).Value = (item.Value as DiscretePoint).Value;
((DiscretePoint)point.Value).Alarm = (item.Value as DiscretePoint).Alarm;
historyData.Add((((DiscretePoint)point.Value)).ToHistoryDbModel());
}
break;
}
case RegisterType.ANALOG_INPUT:
case RegisterType.ANALOG_OUTPUT:
{
((AnalogPoint)point.Value).TimeStamp = (item.Value as AnalogPoint).TimeStamp;
if (((AnalogPoint)point.Value).Value != (item.Value as AnalogPoint).Value)
{
((AnalogPoint)point.Value).Value = (item.Value as AnalogPoint).Value;
((AnalogPoint)point.Value).Alarm = (item.Value as AnalogPoint).Alarm;
historyData.Add((((AnalogPoint)point.Value)).ToHistoryDbModel());
}
break;
}
}
await result.SetAsync(tx, MakeKey(item.Key.Item1, item.Key.Item2), point.Value, TimeSpan.FromSeconds(60), CancellationToken.None);
}
else
{
await result.SetAsync(tx, MakeKey(item.Key.Item1, item.Key.Item2), item.Value, TimeSpan.FromSeconds(60), CancellationToken.None);
}
}
await tx.CommitAsync();
if (historyData.Count > 0)
{
await historian.AddRange(historyData);
}
}
}