using System;

using System.Collections.Generic;

using System.Collections.Concurrent;

using System.Linq;

using System.Threading.Tasks;

public class Program

{

    public static void Main()

    {

        /**********************************************************/

        /*** Run this program MULTIPLE times to provoke errors. ***/

        /**********************************************************/

        // While Container2 uses thread-safe collections and does not crash... 

        TestContainer(new Container2());

        // ... Container1 uses locks which is not as safe as one might think.

        TestContainer(new Container1());

    }

    private static void TestContainer(IContainer container)

    {

        Console.Write("Count:");

        Parallel.For(0, 100, _ =>

        {

            container.Add();

            var objects = container.GetAsync().GetAwaiter().GetResult().ToList();

            Console.Write(" " + objects.Count.ToString());

        });

        Console.WriteLine();

    }

    private interface IContainer

    {

        void Add();

        Task<IEnumerable<object>> GetAsync();

    }

    private sealed class Container1 : IContainer

    {

        private readonly object lockObject = new object();

        private readonly List<Wrapper> list = new List<Wrapper>();

        public void Add()

        {

            Task.Run(() =>

            {

                lock (this.lockObject)

                {

                    this.list.Add(new Wrapper(new object()));

                }

            });

        }

        public Task<IEnumerable<object>> GetAsync()

        {

            return Task.Run(() =>

            {

                lock(this.lockObject)

                {

                    return this.list.Select(wrapper => wrapper.WrappedObject);

                }

            });

        }

    }

    private sealed class Container2 : IContainer

    {

        private readonly ConcurrentBag<Wrapper> bag = new ConcurrentBag<Wrapper>();

        public void Add()

        {

            Task.Run(() =>

            {

                this.bag.Add(new Wrapper(new object()));

            });

        }

        public Task<IEnumerable<object>> GetAsync()

        {

            return Task.Run(() =>

            {

                return this.bag.Select(wrapper => wrapper.WrappedObject);

            });

        }

    }

    private sealed class Wrapper

    {

        public Wrapper(object wrappedObject)

        {

            this.WrappedObject = wrappedObject;

        }       

        public object WrappedObject { get; }

    }

}