Esempio n. 1
0
        public async Task NonBlockingGetValueWorkWithAsyncFactory()
        {
            var lazy  = new AsyncLazy.Lazy <int>(async() => { await Task.Delay(10); return(42); });
            var value = await lazy.GetValueAsync();

            value.Should().Be(42);
        }
Esempio n. 2
0
        public async Task NonBlockingGetValueWorkWithNormalFactory()
        {
            var lazy  = new AsyncLazy.Lazy <int>(() => 42);
            var value = await lazy.GetValueAsync();

            value.Should().Be(42);
        }
Esempio n. 3
0
        public void IsValueCreatedIsTrueAfterFactoryIsCalled()
        {
            var lazy = new AsyncLazy.Lazy <int>(() => 42);

            lazy.IsValueCreated.Should().BeFalse();
            var value = lazy.Value; // calls the factory

            lazy.IsValueCreated.Should().BeTrue();
        }
Esempio n. 4
0
        public void FactoryIsOnlyCalledOnce()
        {
            int callCount = 0;
            var lazy      = new AsyncLazy.Lazy <int>(() =>
            {
                callCount++;
                return(42);
            });

            callCount.Should().Be(0);
            lazy.Value.Should().Be(42);
            callCount.Should().Be(1);
            lazy.Value.Should().Be(42);
            callCount.Should().Be(1);
        }
Esempio n. 5
0
        public async Task FactoryOnlyCalledOnceInMultiTaskContext()
        {
            int         counter = 0;
            var         lazy    = new AsyncLazy.Lazy <int>(() => ++ counter);
            List <Task> tasks   = new List <Task>();

            for (int i = 0; i < 10; i++)
            {
                tasks.Add(Task.Run(async() =>
                {
                    await Task.Delay(10);
                    return((await lazy.GetValueAsync()).Should().Be(1));
                }));
            }
            await Task.WhenAll(tasks);
        }
Esempio n. 6
0
        public void FactoryOnlyCalledOnceInMultitreadedContext()
        {
            int           counter = 0;
            var           lazy    = new AsyncLazy.Lazy <int>(() => ++ counter);
            List <Thread> threads = new List <Thread>();

            for (int i = 0; i < 10; i++)
            {
                threads.Add(new Thread(() =>
                {
                    Thread.Sleep(10);
                    lazy.Value.Should().Be(1);
                }));
            }
            threads.ForEach(thread => thread.Start());
            threads.ForEach(thread => thread.Join());
            counter.Should().Be(1);
        }