Caching.FIFOCache.AddReplace C# (CSharp) Метод

        public bool AddReplace(string key, object val)
        {
            if (String.IsNullOrEmpty(key)) throw new ArgumentNullException(nameof(key));

            lock (CacheLock)
            {
                if (Cache.Count >= Capacity)
                {
                    Cache = Cache.OrderBy(x => x.Item3).Skip(EvictCount).ToList();
                }

                List<Tuple<string, object, DateTime>> dupes = new List<Tuple<string, object, DateTime>>();

                if (Cache.Count > 0) dupes = Cache.Where(x => x.Item1.ToLower() == key).ToList();
                else dupes = null;

                if (dupes == null)
                {
                    #region New-Entry

                    Cache.Add(new Tuple<string, object, DateTime>(key, val, DateTime.Now));
                    return true;

                    #endregion
                }
                else if (dupes.Count > 0)
                {
                    #region Duplicate-Entries-Exist

                    foreach (Tuple<string, object, DateTime> curr in dupes)
                    {
                        Cache.Remove(curr);
                    }

                    Cache.Add(new Tuple<string, object, DateTime>(key, val, DateTime.Now));
                    return true;

                    #endregion
                }
                else
                {
                    #region New-Entry

                    Cache.Add(new Tuple<string, object, DateTime>(key, val, DateTime.Now));
                    return true;

                    #endregion
                }
            }
        }

        static void FIFOCacheTest()
        {
            try
            {
                bool runForever = true;
                int capacity = 2048;
                int evictCount = 512;
                int loadCount = 256;
                bool cacheDebug = true;
                int dataLen = 4096;
                byte[] data = InitByteArray(dataLen, 0x00);

                FIFOCache cache = new FIFOCache(capacity, evictCount, cacheDebug);
                Thread.Sleep(250);

                while (runForever)
                {
                    Console.WriteLine("-------------------------------------------------------------------------------");
                    Console.WriteLine("Available commands (FIFO Cache Test):");
                    Console.WriteLine("  get              Get entry by key");
                    Console.WriteLine("  load             Load " + loadCount + " new records");
                    Console.WriteLine("  oldest           Get the oldest entry");
                    Console.WriteLine("  newest           Get the newest entry");
                    Console.WriteLine("  count            Get the count of cached entries");
                    Console.WriteLine("  clear            Clear the cache");
                    Console.WriteLine("  quit             Exit the application");
                    Console.WriteLine("  debug            Flip the cache debug flag (currently " + cache.Debug + ")");

                    Console.WriteLine("");
                    Console.Write("Command > ");
                    string userInput = Console.ReadLine();
                    if (String.IsNullOrEmpty(userInput)) continue;

                    switch (userInput.ToLower())
                    {
                        case "get":
                            Console.Write("Key > ");
                            string getKey = Console.ReadLine();
                            if (String.IsNullOrEmpty(getKey)) break;
                            byte[] keyData = (byte[])cache.Get(getKey);
                            if (keyData == null) Console.WriteLine("Cache miss");
                            else Console.WriteLine("Cache hit");
                            break;

                        case "load":
                            DateTime startTime = DateTime.Now;

                            for (int i = 0; i < loadCount; i++)
                            {
                                string loadKey = Guid.NewGuid().ToString();
                                Console.Write("Adding entry " + i + " of " + loadCount + "                      \r");
                                cache.AddReplace(loadKey, data);
                            }

                            Console.WriteLine(
                                "Loaded " + loadCount +
                                " records in " + TotalTimeFrom(startTime) + ": " +
                                DecimalToString(TotalMsFrom(startTime) / loadCount) + "ms per entry");
                            break;

                        case "oldest":
                            Console.WriteLine("Oldest key: " + cache.Oldest());
                            break;

                        case "newest":
                            Console.WriteLine("Newest key: " + cache.Newest());
                            break;

                        case "count":
                            Console.WriteLine("Cache count: " + cache.Count());
                            break;

                        case "clear":
                            cache.Clear();
                            Console.WriteLine("Cache cleared");
                            break;

                        case "q":
                        case "quit":
                            runForever = false;
                            break;

                        case "debug":
                            cache.Debug = !cache.Debug;
                            break;

                        default:
                            continue;
                    }
                }

                Console.WriteLine("Goodbye!");
                return;
            }
            catch (Exception e)
            {
                PrintException(e);
            }
            finally
            {
                Console.WriteLine("");
                Console.Write("Press ENTER to exit.");
                Console.ReadLine();
            }
        }