private static async Task RunSetSamplesAsync(ISet <Data> set) { var data = new Data() { Name = "A name", Value = 5 }; // A set is a collection of unique items await set.AddAsync(data); // Adding the same item again overwrites the existing. // Usually this doesn't makes any difference, but depend of how the implementation compares the values. // For instance, the memory set uses an equality comparer, and the SQL uses the item's primary key values. await set.AddAsync(data); if (await set.ContainsAsync(data)) { Console.WriteLine($"The value '{data}' exists in the set"); } // The set also supports the IAsyncEnumerable interface, that allows async enumeration of the items. IAsyncEnumerable <Data> enumerable = await set.AsEnumerableAsync(); // Some async extensions are available Console.WriteLine($"There are '{await enumerable.CountAsync()}' items in the set, which are:"); await enumerable.ForEachAsync(i => Console.WriteLine($"- {i}"), CancellationToken.None); }
public virtual async Task SynchronizeAsync(ISet <T> source, ISet <T> target) { using (var cts = new CancellationTokenSource(_synchronizationTimeout)) { var targetEnumerable = await target.AsEnumerableAsync().ConfigureAwait(false); // Copy the keys to be removed to the memory, to avoid problems with changing the collection while enumerating. var targetToRemove = new List <T>(); await targetEnumerable.ForEachAsync(async v => { if (!await source.ContainsAsync(v).ConfigureAwait(false)) { targetToRemove.Add(v); } }, cts.Token); foreach (var key in targetToRemove) { await target.TryRemoveAsync(key).ConfigureAwait(false); } var sourceEnumerable = await source.AsEnumerableAsync().ConfigureAwait(false); await sourceEnumerable.ForEachAsync(async v => { await target.AddAsync(v).ConfigureAwait(false); }, cts.Token); } }
/// <summary> /// Adds multiple instances of <see cref="T"/> to the set. /// </summary> /// <param name="set"></param> /// <param name="items"></param> /// <param name="cancellationToken"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public static async Task AddRangeAsync <T>(this ISet <T> set, IAsyncEnumerable <T> items, CancellationToken cancellationToken = default) { await foreach (var item in items.WithCancellation(cancellationToken).ConfigureAwait(false)) { await set.AddAsync(item, cancellationToken).ConfigureAwait(false); } }
public async Task AddAsync(T value, CancellationToken cancellationToken = default) { await _set.AddAsync(value, cancellationToken).ConfigureAwait(false); await _writeHandler(value, cancellationToken).ConfigureAwait(false); }
public virtual Task AddAsync(TItem value, CancellationToken cancellationToken = default) { return(_set.AddAsync(value)); }
public async Task AddAsync(T value, CancellationToken cancellationToken = default) { await Task.Delay(_delay, cancellationToken); await _set.AddAsync(value, cancellationToken); }
public async Task AddAsync(T value) { await _set.AddAsync(value).ConfigureAwait(false); await _addTrigger(value).ConfigureAwait(false); }
public virtual Task AddAsync(TItem value) { return(_set.AddAsync(value)); }
public virtual Task AddAsync(TItem value, CancellationToken cancellationToken = default) => _set.AddAsync(value, cancellationToken);