public static void GetEnumerator_EnumerationsAreSnapshots() { var bag = new ConcurrentBag <int>(); Assert.Empty(bag); using (IEnumerator <int> e1 = bag.GetEnumerator()) { bag.Add(1); using (IEnumerator <int> e2 = bag.GetEnumerator()) { bag.Add(2); using (IEnumerator <int> e3 = bag.GetEnumerator()) { int item; Assert.True(bag.TryTake(out item)); using (IEnumerator <int> e4 = bag.GetEnumerator()) { Assert.False(e1.MoveNext()); Assert.True(e2.MoveNext()); Assert.False(e2.MoveNext()); Assert.True(e3.MoveNext()); Assert.True(e3.MoveNext()); Assert.False(e3.MoveNext()); Assert.True(e4.MoveNext()); Assert.False(e4.MoveNext()); } } } } }
public virtual async Task EnqueueMultipleItemsSucceeds() { // Arrange var queue = Create(); var items = new ConcurrentBag <T>(); var count = 100; for (int i = 0; i < count; i++) { var item = Fixture.Create <T>(); items.Add(item); } // Act var enumerator = items.GetEnumerator(); var tasks = Enumerable .Range(0, count) .Where(i => enumerator.MoveNext()) .Select(i => Task.Run(async() => await queue.EnqueueAsync(enumerator.Current))); await Task.WhenAll(tasks); // Assert AssertEquals(await queue.GetLengthAsync(), count); while (await queue.GetLengthAsync() > 0) { var item = await queue.DequeueOrDefaultAsync(); AssertIsTrue(items.Contains(item)); } AssertEquals(await queue.GetLengthAsync(), 0); }
/// <summary> /// Returns an enumerator that iterates through the <see cref="SocketAwaitablePool" />. /// </summary> /// <returns> /// An enumerator for the contents of the <see cref="SocketAwaitablePool" />. /// </returns> /// <exception cref="ObjectDisposedException"> /// The <see cref="SocketAwaitablePool" /> has been disposed. /// </exception> public IEnumerator <SocketAwaitable> GetEnumerator() { if (!IsDisposed) { return(_bag.GetEnumerator()); } throw new ObjectDisposedException(TypeName); }
static void ReadDataInternal() { var sb = new StringBuilder(); var enumerator = _storage.GetEnumerator(); while (enumerator.MoveNext()) { sb.Append($"{enumerator.Current}, "); } Console.WriteLine($"Peek result: {sb} count: {_counter}"); }
private void SetList <T>(ConcurrentBag <T> concurrent, Func <T, List <T>, bool> comparer, List <T> list) { var en = concurrent.GetEnumerator(); while (en.MoveNext()) { if (comparer(en.Current, list)) { list.Add(en.Current); } } }
/// <summary> /// Shortcut to thread safe enumeration of Concurrent Bags /// </summary> /// <typeparam name="TVal"></typeparam> /// <param name="collection"></param> /// <param name="action"></param> public static void ForeachConcurrent <TVal>( this ConcurrentBag <TVal> collection, Action <TVal> action) { using (var enumerator = collection.GetEnumerator()) { while (enumerator.MoveNext()) { action(enumerator.Current); } } }
public void UpdateUser(User user) { IEnumerator <KeyValuePair <int, User> > it = instance.GetEnumerator(); foreach (var variable in instance) { if (variable.Key == user.Id) { variable.Value.Name = user.Name; } else { it.MoveNext(); } } }
public static void Clear_DuringEnumeration_DoesntAffectEnumeration() { const int ExpectedCount = 100; var bag = new ConcurrentBag <int>(Enumerable.Range(0, ExpectedCount)); using (IEnumerator <int> e = bag.GetEnumerator()) { bag.Clear(); int count = 0; while (e.MoveNext()) { count++; } Assert.Equal(ExpectedCount, count); } }
public static async Task GetEnumerator_Generic_ExpectedElementsYielded(int numItems, bool consumeFromSameThread) { var bag = new ConcurrentBag <int>(); using (var e = bag.GetEnumerator()) { Assert.False(e.MoveNext()); } // Add, and validate enumeration after each item added for (int i = 1; i <= numItems; i++) { bag.Add(i); Assert.Equal(i, bag.Count); Assert.Equal(i, bag.Distinct().Count()); } // Take, and validate enumerate after each item removed. Action consume = () => { for (int i = 1; i <= numItems; i++) { int item; Assert.True(bag.TryTake(out item)); Assert.Equal(numItems - i, bag.Count); Assert.Equal(numItems - i, bag.Distinct().Count()); } }; if (consumeFromSameThread) { consume(); } else { await Task.Factory.StartNew(consume, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); } }
public virtual async Task EnqueueMultipleItemsSucceeds() { // Arrange var(senderQueue, receiverQueue) = Create(); var items = new ConcurrentBag <T>(); var count = 100; for (int i = 0; i < count; i++) { var item = CreateItem(); items.Add(item); } // Act var enumerator = items.GetEnumerator(); var tasks = Enumerable .Range(0, count) .Where(_ => enumerator.MoveNext()) .Select(_ => Task.Run(async() => await senderQueue.EnqueueAsync(enumerator.Current, CancellationToken))); await Task.WhenAll(tasks); // Assert foreach (var itemBag in items) { var item = await receiverQueue.DequeueAsync(CancellationToken); if (item == null) { break; } AssertIsTrue(items.Contains(item)); } }
public IEnumerator <T> GetEnumerator() { return(_data.GetEnumerator()); }
public IEnumerator <Tuple <T, TimeSpan?> > GetEnumerator() { return(Enabled ? _bag.GetEnumerator() : new Bag <Tuple <T, TimeSpan?> >().GetEnumerator()); }
public IEnumerator <XOrder> GetEnumerator() { return(m_orders.GetEnumerator()); }
public IEnumerator <CacheKeyMapDescriptor> GetEnumerator() { return(mapList.GetEnumerator()); }
IEnumerator <Attribute> IEnumerable <Attribute> .GetEnumerator() { return(_attributes.GetEnumerator()); }
public IEnumerator <object> GetEnumerator() { return(m_buffer.GetEnumerator()); }
public IEnumerator <double> Enumerable() { return(bag.GetEnumerator()); }
public IEnumerator <T> GetEnumerator() { return(_available.GetEnumerator()); }
public IEnumerator <T> GetEnumerator() { return(_objects.GetEnumerator()); }
/// <inheritdoc/> IEnumerator GetEnumerator() => _rules.GetEnumerator();
/// <summary> /// Returns an enumerator that iterates through a collection. /// </summary> /// <returns><see cref="System.Collections.Generic.IEnumerator<IMediaTemplate>" />.</returns> public IEnumerator <IMediaTemplate> GetEnumerator() { return(_items.GetEnumerator()); }
public IEnumerator <IValueTypeConverter> GetEnumerator() { return(_coverters.GetEnumerator()); }
IEnumerator IEnumerable.GetEnumerator() { return(_objects?.GetEnumerator()); }
static void Main(string[] args) { // CONSTRUCTORS ConcurrentBag <int> cbag = new ConcurrentBag <int>(new int[] { 1, 2, 4, 7, 12, 222 }); ConcurrentBag <string> cb = new ConcurrentBag <string>(); // PROPERTIES Console.WriteLine("Count = {0}", cb.Count); // 0 Console.WriteLine("Is cb empty? {0}", cb.IsEmpty); // true // FUNCTIONS cb.Add(item: "cow"); cb.Add(item: "chicken"); cb.Add(item: "duck"); cb.Add(item: "sheep"); Console.WriteLine("cb = "); foreach (string s in cb) { Console.Write("{0}, ", s); } // {"cow", "chicken", "duck", "sheep"} Console.WriteLine(); // cb.Clear(); cb = new ConcurrentBag <string>(); Console.WriteLine("cb after clear is empty? {0}", cb.IsEmpty); // true cb.Add(item: "Germany"); cb.Add(item: "Spain"); cb.Add(item: "Sweden"); cb.Add(item: "Serbia"); string[] arr = new string[cb.Count]; cb.CopyTo(array: arr, index: 0); Console.WriteLine("arr = "); foreach (string s in arr) { Console.Write("{0}, ", s); } // {"Germany", "Spain", "Sweden", "Serbia"} Console.WriteLine(); ConcurrentBag <string> cb_copy = new ConcurrentBag <string>(cb); Console.WriteLine("cb is equal to its copy? {0}", cb.Equals(cb_copy)); // true IEnumerator <string> en = cb.GetEnumerator(); Console.Write("cb = "); while (en.MoveNext()) { Console.Write("{0}, ", en.Current); } Console.WriteLine(); Console.WriteLine("cb hashcode = {0}", cb.GetHashCode()); Console.WriteLine("cb type = {0}", cb.GetType().FullName); arr = cb.ToArray(); Console.WriteLine("arr afteer using ToArray on cb = "); foreach (string s in arr) { Console.Write("{0}, ", s); } // {"Germany", "Spain", "Sweden", "Serbia"} Console.WriteLine(); Console.WriteLine("string version of cb = {0}", cb.ToString()); string result_str; Console.WriteLine("peeking = {0}", cb.TryPeek(result: out result_str)); // true Console.WriteLine("peeking result = {0}", result_str); // Console.WriteLine("taking = {0}", cb.TryTaking(result: out result_str)); // true // Console.WriteLine("taking result = {0}", result_str); // Threading int num = 0; Thread threadAdd = new Thread(() => { for (int i = num; i < num + 10; i++) { cb.Add(item: i.ToString()); Console.WriteLine("threadAdd: {0}", i); } num += 10; Console.WriteLine(); }); Thread threadAddWord = new Thread(() => { for (int i = 1; i < 10; i++) { cb.Add(item: "Word"); Console.WriteLine("threadAddWord: {0}", i); } Console.WriteLine(); }); Thread threadFinal = new Thread(() => { Console.WriteLine("cb after threading = "); foreach (string s in cb) { Console.Write("{0}, ", s); } Console.WriteLine(); }); threadAdd.Start(); threadAddWord.Start(); threadAdd.Join(); threadAddWord.Join(); threadFinal.Start(); }
public IEnumerator GetEnumerator() { return(_runtimeTypes.GetEnumerator()); }
public static void HandleClient(Object obj) { TcpClient client = (TcpClient)obj; StreamWriter writer = new StreamWriter(client.GetStream(), Encoding.ASCII); TextWriter sWriter = writer; Console.WriteLine("I got a connection"); while (client.Connected) { StreamReader reader = new StreamReader(client.GetStream(), Encoding.ASCII); TextReader sReader = reader; try { ChatCommand command = JsonSerializer.Deserialize <ChatCommand>(sReader.ReadLine()); switch (command.Command) { case Command.nick: if (!connectedClients.ContainsKey(command.User)) { Console.WriteLine("We have a new user: "******"they want to know what channels are available"); var index = channels.Keys.GetEnumerator(); var keys = new StringBuilder(); while (index.MoveNext()) { keys.Append(index.Current); keys.Append(", "); } keys.Remove(keys.Length - 2, 1); command.Message = keys.ToString(); command.Command = Command.receive_message; sWriter.WriteLine(JsonSerializer.Serialize <ChatCommand>(command)); sWriter.Flush(); break; case Command.join: Console.WriteLine($"User {command.User} would like to join a channel {command.Arguments}"); if (channels.ContainsKey(command.Arguments)) { ConcurrentBag <TcpClient> list = (ConcurrentBag <TcpClient>)channels[command.Arguments]; list.Add(client); } break; case Command.leave: break; case Command.quit: break; case Command.help: break; case Command.stats: break; case Command.send_message: ChatCommand newCommand = new ChatCommand { User = "******", Command = Command.receive_message, Arguments = String.Empty, Message = (String)command.Message.Clone() }; Console.WriteLine($"user: {command.User}; Channel: {command.Arguments}; Message: {command.Message}"); ConcurrentBag <TcpClient> users = (ConcurrentBag <TcpClient>)channels[command.Arguments]; var currentTcpClient = users.GetEnumerator(); foreach (TcpClient tcp in users) { if (tcp != client) { TextWriter w = new StreamWriter(tcp.GetStream(), Encoding.ASCII); w.WriteLine(JsonSerializer.Serialize <ChatCommand>(newCommand)); w.Flush(); } } break; default: break; } } catch (System.IO.IOException e) { Console.Error.WriteLine(e.Message); } } }
public IEnumerator <T> GetEnumerator() { return(_pool.GetEnumerator()); }
public static IEnumerator <T> GetEnumerator <T>(ConcurrentBag <T> concurrentBag) { ConcurrentCollectionHelper.Interleave(); return(concurrentBag.GetEnumerator()); }
public IEnumerator <T> GetEnumerator() => collection.GetEnumerator();
public IEnumerator <T> GetEnumerator() { return(_observations.GetEnumerator()); }