using Microsoft.Extensions.Caching.Memory;

using Microsoft.Extensions.DependencyInjection;

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

using System.Threading;

​

​

class Program

    {

​

        public static ConcurrentDictionary<int, byte> PROCESSED = new ConcurrentDictionary<int, byte>();

​

        static void Main(string[] args)

        {

            var services = new ServiceCollection();

            services.AddMemoryCache();

            services.AddTransient<JobService>();

            services.AddTransient<MyCacheService>();

            services.AddTransient<Worker>();

            var serviceProvider = services.BuildServiceProvider();

​

            var workers = Enumerable.Range(1, 100)

                .ToArray()

                .Select(x =>

                {

                    var w = serviceProvider.GetService<Worker>();

                    w.WorkerID = x;

                    w.Skills = new int[] { 1, 2 };

                    w.Title = "BASIC";

                    w.WorkItemID = 1;

                    return w;

                }).ToList();

​

            var masterWorkers = Enumerable.Range(101, 100)

                .ToArray()

                .Select(x =>

                {

                    var w = serviceProvider.GetService<Worker>();

                    w.WorkerID = x;

                    w.Skills = new int[] { 4, 5 };

                    w.Title = "MASTER";

                    w.WorkItemID = 2;

                    return w;

                }).ToList();

​

            workers.AddRange(masterWorkers);

​

            var start = DateTime.Now;

            Parallel.ForEach(workers, (w) =>

            {

                w.DoWork();

            });

            var end = DateTime.Now;

​

            Console.WriteLine("Total Time {0}", end.Subtract(start));

            Console.WriteLine("Total Processed {0}", PROCESSED.Count);

            Console.WriteLine("Press any key");

            Console.ReadKey();

        }

    }

​

    public class MyCacheService

    {

        private readonly IMemoryCache _memoryCache = null;

        static object myLock = new object();

​

        public MyCacheService(IMemoryCache memoryCache)

        {

            _memoryCache = memoryCache ?? throw new ArgumentNullException(nameof(memoryCache));

        }       

​

        public Job Find(int key, string title, int[] skills, Func<int, List<Job>> getJobs)

        {

            lock (myLock)

            {

                List<Job> cachedJobs = null;

                if (!_memoryCache.TryGetValue(key, out cachedJobs))

                {

                    var jobs = getJobs(key);

​

                    var cacheEntryOptions = new MemoryCacheEntryOptions()

                        .SetSlidingExpiration(TimeSpan.FromMinutes(30));

                    cachedJobs = _memoryCache.Set(key, jobs, cacheEntryOptions);

                }

​

                if (cachedJobs != null)

                {

                    var job = cachedJobs.Where(j => j.Title == title &&

                                       !j.Skills.Except(skills).Any())

                                  .FirstOrDefault();

​

                    if (job == null)

                    {

                        return null;

                    }

​

                    cachedJobs.Remove(job);

                    return job;

                }

​

                return null;

            }

        }

    }   

​

    public class Worker

    {

        public int WorkerID;

        public int WorkItemID;

        public string Title;

        public int[] Skills;

​

        private readonly MyCacheService _cacheService;

        private readonly JobService _jobService;

​

        public Worker(MyCacheService cacheService, JobService jobService)

        {

            _cacheService = cacheService;

            _jobService = jobService;

        }

​

        public void DoWork()

        {

            while (true)

            {

                var start = DateTime.Now;

                var job = _cacheService.Find(WorkItemID, Title, Skills, _jobService.GetJobs);

                var end = DateTime.Now;

                if (job == null)

                {

                    break;

                }

                Program.PROCESSED.TryAdd<int, byte>(job.JobID, 1);

                Console.WriteLine("Job ID: {0}, WorkerID: {1}, Title:{2}, Time:{3}", job.JobID, WorkerID, Title, end.Subtract(start));

            }

        }

    }

​

    public class JobService

    {

        public List<Job> GetJobs(int workItemID)

        {

            List<Job> jobs = new List<Job>();

            int jobID = 1;

            for (int i = 0; i < 5000; i++)

            {

                jobs.Add(new Job()

                {

                    JobID = jobID,

                    Title = "BASIC",

                    Skills = new int[] { 1, 2 }

                });

​

                jobID++;

            }

​

            for (int i = 0; i < 5000; i++)

            {

                jobs.Add(new Job()

                {

                    JobID = jobID,

                    Title = "MASTER",

                    Skills = new int[] { 4 }

                });

​

                jobID++;

            }

​

            return jobs;

        }

    }

​

    public class Job

    {

        public int JobID { get; set; }

        public string Title { get; set; }

        public int[] Skills { get; set; }

    }

​