Example #1
0
        public async Task Tasks_FromSync()
        {
            var ids = new string[] { "iddqd", "idkfq", "abba5", "acdc1" };

            var tasks = new List <Task <SensorDto> >();

            foreach (var id in ids)
            {
                var task = Task.Run(() =>
                {
                    var value = SensorData.GetSensorSync(id);
                    return(value);
                });

                // var task = Task.Run(() => SensorData.GetSensorSync(id));

                tasks.Add(task);
            }

            var results = await Task.WhenAll(tasks);

            // Same with Linq
            var tasksLinq = ids.Select(i => Task.Run(() => SensorData.GetSensorSync(i))).ToList();

            var resultsLinq = await Task.WhenAll(tasksLinq);
        }
        public async Task RunAtBackground()
        {
            var cts   = new CancellationTokenSource();
            var token = cts.Token;

            var collection = new BlockingCollection <string>();

            // Explain why task has token and why it is checked in while loop
            var backgroundTask = Task.Run(() =>
            {
                while (token.IsCancellationRequested == false)
                {
                    var sensorToFetch = collection.Take(token);
                    var sensorData    = SensorData.GetSensorSync(sensorToFetch);

                    // Do something nice with the result
                    Trace.WriteLine(JsonConvert.SerializeObject(sensorData));
                }
            }, token);

            // Application keeps getting requests from somewhere
            while (true)
            {
                await Task.Delay(5000);

                collection.Add(DateTime.Now.Ticks % 2 == 0 ? "abba5" : "iddqd");
            }
        }
Example #3
0
        public async Task Tasks_FromSync_Linq()
        {
            var ids = new string[] { "iddqd", "idkfq", "abba5", "acdc1" };

            var tasks = ids.Select(i => Task.Run(() => SensorData.GetSensorSync(i))).ToList();

            var results = await Task.WhenAll(tasks);
        }
        public void RunTask()
        {
            void BackgroundExecution()
            {
                while (true)
                {
                    var data = SensorData.GetSensorSync();
                    Thread.Sleep(1000);
                    Trace.WriteLine($"In the background: {data.Data}");
                }
            }

            var task = Task.Run(() => BackgroundExecution());

            while (task.IsCompleted == false)
            {
                Thread.Sleep(1000);
            }
        }
        public void RunThread()
        {
            void BackgroundExecution()
            {
                while (true)
                {
                    // Do something important
                    var data = SensorData.GetSensorSync();
                    Thread.Sleep(1000);
                    Trace.WriteLine($"In the background: {data.Data}");
                }
            }

            var t = new Thread(new ThreadStart(BackgroundExecution));

            t.Start();

            while (t.IsAlive)
            {
                Thread.Sleep(1000);
            }
        }
        public void RunTaskReturn()
        {
            // Often tasks return something rather than just run "forever" on the background

            double BackgroundExecution()
            {
                var data = SensorData.GetSensorSync();

                Thread.Sleep(1000);
                return(data.Data);
            }

            var task = Task.Run(() => BackgroundExecution());

            while (task.IsCompleted == false)
            {
                Thread.Sleep(1000);
            }

            var result = task.Result;

            Assert.Equal(2, result);
        }