From 671e159869912ad8f37edf15a65040927225d98e Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Fri, 5 Aug 2022 13:28:11 -0400
Subject: [PATCH 01/21] Skeleton

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs  | 32 +++++++++++++++++++
 .../OptimizelySDK.Tests.csproj                |  2 +-
 OptimizelySDK/Odp/LruCache.cs                 |  7 ++++
 OptimizelySDK/OptimizelySDK.csproj            |  2 +-
 4 files changed, 41 insertions(+), 2 deletions(-)
 create mode 100644 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
 create mode 100644 OptimizelySDK/Odp/LruCache.cs

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
new file mode 100644
index 00000000..977e9a5a
--- /dev/null
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -0,0 +1,32 @@
+using NUnit.Framework;
+
+namespace OptimizelySDK.Tests.OdpTests
+{
+    [TestFixture]
+    public class LruCacheTest
+    {
+        [SetUp]
+        public void Setup() { }
+
+        [Test]
+        public void ShouldCreateSaveAndLookupOneItem() { }
+
+        [Test]
+        public void ShouldSaveAndLookupMultipleItems() { }
+        
+        [Test]
+        public void ShouldHandleWhenCacheIsDisabled() { }
+        
+        [Test]
+        public void ShouldThrowWhenItemsExpire() { }
+        
+        [Test]
+        public void ShouldHandleWhenCacheReachesMaxSize() { }
+        
+        [Test]
+        public void ShouldHandleWhenMaxSizeIsReducedInBetween() { }
+
+        [Test]
+        public void ShouldHandleWhenCacheIsReset() { }
+    }
+}
\ No newline at end of file
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index d0a2d2ae..c563d781 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -80,6 +80,7 @@
     <Compile Include="DefaultErrorHandlerTest.cs" />
     <Compile Include="EntityTests\IntegrationTest.cs" />
     <Compile Include="EventTests\EventProcessorProps.cs" />
+    <Compile Include="OdpTests\LruCacheTest.cs" />
     <Compile Include="OptimizelyConfigTests\OptimizelyConfigTest.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecisionTest.cs" />
     <Compile Include="OptimizelyJSONTest.cs" />
@@ -150,7 +151,6 @@
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
new file mode 100644
index 00000000..de583c81
--- /dev/null
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -0,0 +1,7 @@
+namespace OptimizelySDK.Odp
+{
+    public class LruCache
+    {
+        
+    }
+}
\ No newline at end of file
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 2db6cd33..8e8b75ce 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -88,6 +88,7 @@
     <Compile Include="Entity\IdKeyEntity.cs" />
     <Compile Include="Entity\Integration.cs" />
     <Compile Include="Event\Entity\DecisionMetadata.cs" />
+    <Compile Include="Odp\LruCache.cs" />
     <Compile Include="OptimizelyDecisions\DecisionMessage.cs" />
     <Compile Include="OptimizelyDecisions\DecisionReasons.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecideOption.cs" />
@@ -176,7 +177,6 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup />
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

From 3d1ae151c050bcfc2bc7b7833872884305fe4103 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Fri, 5 Aug 2022 16:01:36 -0400
Subject: [PATCH 02/21] LruCache initial implementation

---
 OptimizelySDK/Odp/ILruCache.cs     |   9 ++
 OptimizelySDK/Odp/LruCache.cs      | 130 ++++++++++++++++++++++++++++-
 OptimizelySDK/OptimizelySDK.csproj |   1 +
 3 files changed, 137 insertions(+), 3 deletions(-)
 create mode 100644 OptimizelySDK/Odp/ILruCache.cs

diff --git a/OptimizelySDK/Odp/ILruCache.cs b/OptimizelySDK/Odp/ILruCache.cs
new file mode 100644
index 00000000..d06ee06c
--- /dev/null
+++ b/OptimizelySDK/Odp/ILruCache.cs
@@ -0,0 +1,9 @@
+namespace OptimizelySDK.Odp
+{
+    public interface ILruCache<T>
+    {
+        void Save(string key, T value);
+        T Lookup(string key);
+        void Reset();
+    }
+}
\ No newline at end of file
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index de583c81..6e44e1b2 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -1,7 +1,131 @@
-namespace OptimizelySDK.Odp
+using OptimizelySDK.Logger;
+using System;
+using System.Collections.Specialized;
+
+namespace OptimizelySDK.Odp
 {
-    public class LruCache
+    public class LruCache<T> : ILruCache<T>
     {
-        
+        private const int DEFAULT_MAX_SIZE = 10000;
+        private const int DEFAULT_TIMEOUT_SECONDS = 600;
+
+        private readonly ILogger _logger;
+        private readonly object _mutex = new object();
+        private int _maxSize;
+        private long _timeoutMilliseconds;
+        private readonly OrderedDictionary _orderedDictionary = new OrderedDictionary();
+
+        public LruCache() : this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, null) { }
+
+        public LruCache(ILogger logger) :
+            this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, logger) { }
+
+        public LruCache(int maxSize, int timeoutSeconds, ILogger logger)
+        {
+            _maxSize = maxSize < 0 ? default(int) : maxSize;
+            _timeoutMilliseconds = (timeoutSeconds < 0) ? 0 : (timeoutSeconds * 1000L);
+            _logger = logger ?? new DefaultLogger();
+        }
+
+        public void SetMaxSize(int size)
+        {
+            lock (_mutex)
+            {
+                if (_orderedDictionary.Count > 0)
+                {
+                    if (size >= _orderedDictionary.Count)
+                    {
+                        _maxSize = size;
+                    }
+                    else
+                    {
+                        _logger.Log(LogLevel.WARN,
+                            "Cannot set max cache size less than current size.");
+                    }
+                }
+                else
+                {
+                    var sizeToSet = size;
+                    if (size < 0)
+                    {
+                        sizeToSet = 0;
+                    }
+
+                    _maxSize = sizeToSet;
+                }
+            }
+        }
+
+        public void SetTimeout(long timeoutSeconds)
+        {
+            _timeoutMilliseconds = timeoutSeconds * 1000;
+        }
+
+        public void Save(string key, T value)
+        {
+            if (_maxSize == 0)
+            {
+                // Cache is disabled when maxSize = 0
+                return;
+            }
+
+            lock (_mutex)
+            {
+                _orderedDictionary.Add(key, new ItemWrapper(value));
+            }
+        }
+
+        public T Lookup(string key)
+        {
+            if (_maxSize == 0)
+            {
+                // Cache is disabled when maxSize = 0
+                return default;
+            }
+
+            lock (_mutex)
+            {
+                if (!_orderedDictionary.Contains(key))
+                {
+                    return default;
+                }
+
+                ItemWrapper item = (ItemWrapper)_orderedDictionary[key];
+                var nowMs = DateTime.Now.Millisecond;
+
+                // ttl = 0 means items never expire.
+                if (_timeoutMilliseconds == 0 ||
+                    (nowMs - item.Timestamp < _timeoutMilliseconds))
+                {
+                    return item.Value;
+                }
+
+                _orderedDictionary.Remove(key);
+
+                return default;
+            }
+        }
+
+        public void Reset()
+        {
+            lock (_mutex)
+            {
+                _orderedDictionary.Clear();
+            }
+        }
+
+        private class ItemWrapper
+        {
+            public T Value;
+            public long Timestamp;
+
+            public ItemWrapper(T value)
+            {
+                Value = value;
+                Timestamp = Convert.ToInt64(
+                    DateTime.Now.Subtract(new DateTime(1970, 1, 1)).
+                        TotalMilliseconds);
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 8e8b75ce..e2472f7b 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -88,6 +88,7 @@
     <Compile Include="Entity\IdKeyEntity.cs" />
     <Compile Include="Entity\Integration.cs" />
     <Compile Include="Event\Entity\DecisionMetadata.cs" />
+    <Compile Include="Odp\ILruCache.cs" />
     <Compile Include="Odp\LruCache.cs" />
     <Compile Include="OptimizelyDecisions\DecisionMessage.cs" />
     <Compile Include="OptimizelyDecisions\DecisionReasons.cs" />

From b987d9d1f60efeb79a64479ab9010ac7babb6a05 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Fri, 5 Aug 2022 17:32:02 -0400
Subject: [PATCH 03/21] Add helper extensions

---
 .../OdpTests/CollectionExtensions.cs               | 14 ++++++++++++++
 OptimizelySDK.Tests/OptimizelySDK.Tests.csproj     |  1 +
 OptimizelySDK/Odp/DateTimeExtension.cs             | 14 ++++++++++++++
 OptimizelySDK/OptimizelySDK.csproj                 |  1 +
 4 files changed, 30 insertions(+)
 create mode 100644 OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
 create mode 100644 OptimizelySDK/Odp/DateTimeExtension.cs

diff --git a/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs b/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
new file mode 100644
index 00000000..813604ed
--- /dev/null
+++ b/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
@@ -0,0 +1,14 @@
+using System.Collections;
+
+namespace OptimizelySDK.Tests.OdpTests
+{
+    public static class CollectionTestExtensions
+    {
+        public static string[] ToKeyCollection(this ICollection keys)
+        {
+            var keyArray = new string[keys.Count];
+            keys.CopyTo(keyArray, 0);
+            return keyArray;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index c563d781..30eb4d2c 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -80,6 +80,7 @@
     <Compile Include="DefaultErrorHandlerTest.cs" />
     <Compile Include="EntityTests\IntegrationTest.cs" />
     <Compile Include="EventTests\EventProcessorProps.cs" />
+    <Compile Include="OdpTests\CollectionExtensions.cs" />
     <Compile Include="OdpTests\LruCacheTest.cs" />
     <Compile Include="OptimizelyConfigTests\OptimizelyConfigTest.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecisionTest.cs" />
diff --git a/OptimizelySDK/Odp/DateTimeExtension.cs b/OptimizelySDK/Odp/DateTimeExtension.cs
new file mode 100644
index 00000000..b8444d92
--- /dev/null
+++ b/OptimizelySDK/Odp/DateTimeExtension.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace OptimizelySDK.Odp
+{
+    public static class DateTimeExtension
+    {
+        // Because we're only on .NET Framework 4.5
+        public static long ToUnixTimeMilliseconds(this DateTime dateTime)
+        {
+            var unixTimeStart = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+            return Convert.ToInt64(dateTime.Subtract(unixTimeStart).TotalMilliseconds);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index e2472f7b..0c3e5eb3 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -88,6 +88,7 @@
     <Compile Include="Entity\IdKeyEntity.cs" />
     <Compile Include="Entity\Integration.cs" />
     <Compile Include="Event\Entity\DecisionMetadata.cs" />
+    <Compile Include="Odp\DateTimeExtension.cs" />
     <Compile Include="Odp\ILruCache.cs" />
     <Compile Include="Odp\LruCache.cs" />
     <Compile Include="OptimizelyDecisions\DecisionMessage.cs" />

From 295fdd25f99aeef416efde718116fcb7f80db862 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Fri, 5 Aug 2022 17:32:52 -0400
Subject: [PATCH 04/21] WIP Fill unit tests

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 179 +++++++++++++++++--
 OptimizelySDK/Odp/LruCache.cs                |  27 +--
 2 files changed, 183 insertions(+), 23 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 977e9a5a..e26331ca 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -1,32 +1,189 @@
 using NUnit.Framework;
+using OptimizelySDK.Entity;
+using OptimizelySDK.Odp;
+using System.Collections.Generic;
+using System.Threading;
 
 namespace OptimizelySDK.Tests.OdpTests
 {
     [TestFixture]
     public class LruCacheTest
     {
+        private List<string> _segments1And2 = new List<string>
+        {
+            "segment1",
+            "segment2",
+        };
+
+        private List<string> _segments3And4 = new List<string>
+        {
+            "segment3",
+            "segment4",
+        };
+
+        private List<string> _segments5And6 = new List<string>
+        {
+            "segment5",
+            "segment6",
+        };
+
         [SetUp]
         public void Setup() { }
 
         [Test]
-        public void ShouldCreateSaveAndLookupOneItem() { }
+        public void ShouldCreateSaveAndLookupOneItem()
+        {
+            var cache = new LruCache<string>();
+            Assert.IsNull(cache.Lookup("key1"));
+
+            cache.Save("key1", "value1");
+            Assert.AreEqual("value1", cache.Lookup("key1"));
+        }
 
         [Test]
-        public void ShouldSaveAndLookupMultipleItems() { }
-        
+        public void ShouldSaveAndLookupMultipleItems()
+        {
+            var cache = new LruCache<List<string>>();
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            var itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            Assert.AreEqual("user1", itemKeys[0]);
+            Assert.AreEqual("user2", itemKeys[1]);
+            Assert.AreEqual("user3", itemKeys[2]);
+
+            Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
+
+            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            // Lookup should move user1 to bottom of the list and push up others.
+            Assert.AreEqual("user2", itemKeys[0]);
+            Assert.AreEqual("user3", itemKeys[1]);
+            Assert.AreEqual("user1", itemKeys[2]);
+
+            Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
+
+            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            // Lookup should move user2 to bottom of the list and push up others.
+            Assert.AreEqual("user3", itemKeys[0]);
+            Assert.AreEqual("user1", itemKeys[1]);
+            Assert.AreEqual("user2", itemKeys[2]);
+
+            Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
+
+            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            // Lookup should move user3 to bottom of the list and push up others.
+            Assert.AreEqual("user1", itemKeys[0]);
+            Assert.AreEqual("user2", itemKeys[1]);
+            Assert.AreEqual("user3", itemKeys[2]);
+        }
+
         [Test]
-        public void ShouldHandleWhenCacheIsDisabled() { }
-        
+        public void ShouldReorderListOnSave()
+        {
+            var cache = new LruCache<List<string>>();
+            
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            var itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            Assert.AreEqual("user1", itemKeys[0]);
+            Assert.AreEqual("user2", itemKeys[1]);
+            Assert.AreEqual("user3", itemKeys[2]);
+
+            cache.Save("user1", _segments1And2);
+
+            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            // save should move user1 to bottom of the list and push up others.
+            Assert.AreEqual("user2", itemKeys[0]);
+            Assert.AreEqual("user3", itemKeys[1]);
+            Assert.AreEqual("user1", itemKeys[2]);
+
+            cache.Save("user2", _segments3And4);
+
+            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            // save should move user2 to bottom of the list and push up others.
+            Assert.AreEqual("user3", itemKeys[0]);
+            Assert.AreEqual("user1", itemKeys[1]);
+            Assert.AreEqual("user2", itemKeys[2]);
+
+            cache.Save("user3", _segments5And6);
+
+            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            // save should move user3 to bottom of the list and push up others.
+            Assert.AreEqual("user1", itemKeys[0]);
+            Assert.AreEqual("user2", itemKeys[1]);
+            Assert.AreEqual("user3", itemKeys[2]);
+        }
+
         [Test]
-        public void ShouldThrowWhenItemsExpire() { }
-        
+        public void ShouldHandleWhenCacheIsDisabled()
+        {
+            var cache = new LruCache<List<string>>(0, LruCache<object>.DEFAULT_TIMEOUT_SECONDS);
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            Assert.IsNull(cache.Lookup("user1"));
+            Assert.IsNull(cache.Lookup("user2"));
+            Assert.IsNull(cache.Lookup("user3"));
+        }
+
         [Test]
-        public void ShouldHandleWhenCacheReachesMaxSize() { }
-        
+        public void ShouldHandleWhenItemsExpire()
+        {
+            var cache = new LruCache<List<string>>(LruCache<object>.DEFAULT_MAX_SIZE, 1);
+
+            cache.Save("user1", _segments1And2);
+
+            Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
+            Assert.AreEqual(1, cache._orderedDictionary.Count);
+
+            Thread.Sleep(1200);
+
+            Assert.IsNull(cache.Lookup("user1"));
+            Assert.AreEqual(0, cache._orderedDictionary.Count);
+        }
+
         [Test]
-        public void ShouldHandleWhenMaxSizeIsReducedInBetween() { }
+        public void ShouldHandleWhenCacheReachesMaxSize()
+        {
+            var cache = new LruCache<List<string>>(2, LruCache<object>.DEFAULT_TIMEOUT_SECONDS);
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            Assert.AreEqual(2, cache._orderedDictionary.Count);
+
+            Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
+            Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
+            Assert.IsNull(cache.Lookup("user1"));
+        }
 
         [Test]
-        public void ShouldHandleWhenCacheIsReset() { }
+        public void ShouldHandleWhenCacheIsReset() { 
+            var cache = new LruCache<List<string>>();
+            
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
+            Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
+            Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
+
+            Assert.AreEqual(3, cache._orderedDictionary.Count);
+
+            cache.Reset();
+
+            Assert.IsNull(cache.Lookup("user1"));
+            Assert.IsNull(cache.Lookup("user2"));
+            Assert.IsNull(cache.Lookup("user3"));
+
+            Assert.AreEqual(0, cache._orderedDictionary.Count);}
     }
 }
\ No newline at end of file
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 6e44e1b2..3b14d52e 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -1,26 +1,30 @@
 using OptimizelySDK.Logger;
 using System;
 using System.Collections.Specialized;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("OptimizelySDK.Tests")]
 
 namespace OptimizelySDK.Odp
 {
     public class LruCache<T> : ILruCache<T>
     {
-        private const int DEFAULT_MAX_SIZE = 10000;
-        private const int DEFAULT_TIMEOUT_SECONDS = 600;
+        public const int DEFAULT_MAX_SIZE = 10000;
+        public const int DEFAULT_TIMEOUT_SECONDS = 600;
 
         private readonly ILogger _logger;
         private readonly object _mutex = new object();
         private int _maxSize;
         private long _timeoutMilliseconds;
-        private readonly OrderedDictionary _orderedDictionary = new OrderedDictionary();
+        internal OrderedDictionary _orderedDictionary = new OrderedDictionary();
 
         public LruCache() : this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, null) { }
 
         public LruCache(ILogger logger) :
             this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, logger) { }
 
-        public LruCache(int maxSize, int timeoutSeconds, ILogger logger)
+
+        public LruCache(int maxSize, int timeoutSeconds, ILogger logger = null)
         {
             _maxSize = maxSize < 0 ? default(int) : maxSize;
             _timeoutMilliseconds = (timeoutSeconds < 0) ? 0 : (timeoutSeconds * 1000L);
@@ -91,11 +95,10 @@ public T Lookup(string key)
                 }
 
                 ItemWrapper item = (ItemWrapper)_orderedDictionary[key];
-                var nowMs = DateTime.Now.Millisecond;
+                var nowMs = DateTime.Now.ToUnixTimeMilliseconds();
 
                 // ttl = 0 means items never expire.
-                if (_timeoutMilliseconds == 0 ||
-                    (nowMs - item.Timestamp < _timeoutMilliseconds))
+                if (_timeoutMilliseconds == 0 || (nowMs - item.Timestamp < _timeoutMilliseconds))
                 {
                     return item.Value;
                 }
@@ -116,16 +119,16 @@ public void Reset()
 
         private class ItemWrapper
         {
-            public T Value;
-            public long Timestamp;
+            public readonly T Value;
+            public readonly long Timestamp;
 
             public ItemWrapper(T value)
             {
                 Value = value;
-                Timestamp = Convert.ToInt64(
-                    DateTime.Now.Subtract(new DateTime(1970, 1, 1)).
-                        TotalMilliseconds);
+                Timestamp = DateTime.Now.ToUnixTimeMilliseconds();
             }
         }
+
+       
     }
 }
\ No newline at end of file

From 50fd4e154fd0d9a3c6ddf2bd2b47dc4903ff6c70 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Fri, 5 Aug 2022 17:49:27 -0400
Subject: [PATCH 05/21] WIP corrections based on tests 2 more failing

---
 OptimizelySDK/Odp/LruCache.cs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 3b14d52e..7d544de1 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -26,7 +26,7 @@ public LruCache(ILogger logger) :
 
         public LruCache(int maxSize, int timeoutSeconds, ILogger logger = null)
         {
-            _maxSize = maxSize < 0 ? default(int) : maxSize;
+            _maxSize = maxSize < 0 ? default : maxSize;
             _timeoutMilliseconds = (timeoutSeconds < 0) ? 0 : (timeoutSeconds * 1000L);
             _logger = logger ?? new DefaultLogger();
         }
@@ -73,6 +73,11 @@ public void Save(string key, T value)
                 return;
             }
 
+            if (_orderedDictionary.Count >= _maxSize)
+            {
+                _orderedDictionary.RemoveAt(0);
+            }
+
             lock (_mutex)
             {
                 _orderedDictionary.Add(key, new ItemWrapper(value));
@@ -94,7 +99,7 @@ public T Lookup(string key)
                     return default;
                 }
 
-                ItemWrapper item = (ItemWrapper)_orderedDictionary[key];
+                var item = (ItemWrapper)_orderedDictionary[key];
                 var nowMs = DateTime.Now.ToUnixTimeMilliseconds();
 
                 // ttl = 0 means items never expire.
@@ -128,7 +133,5 @@ public ItemWrapper(T value)
                 Timestamp = DateTime.Now.ToUnixTimeMilliseconds();
             }
         }
-
-       
     }
 }
\ No newline at end of file

From 22acf8e678ea2e04c3e14f2ba0588cd63eaaec0a Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Mon, 8 Aug 2022 12:44:07 -0400
Subject: [PATCH 06/21] Remove SetTimeout, fix for non-passing test

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 10 +++------
 OptimizelySDK/Odp/LruCache.cs                | 23 +++++++++++---------
 2 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index e26331ca..7feae0ee 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -1,5 +1,4 @@
 using NUnit.Framework;
-using OptimizelySDK.Entity;
 using OptimizelySDK.Odp;
 using System.Collections.Generic;
 using System.Threading;
@@ -9,27 +8,24 @@ namespace OptimizelySDK.Tests.OdpTests
     [TestFixture]
     public class LruCacheTest
     {
-        private List<string> _segments1And2 = new List<string>
+        private readonly List<string> _segments1And2 = new List<string>
         {
             "segment1",
             "segment2",
         };
 
-        private List<string> _segments3And4 = new List<string>
+        private readonly List<string> _segments3And4 = new List<string>
         {
             "segment3",
             "segment4",
         };
 
-        private List<string> _segments5And6 = new List<string>
+        private readonly List<string> _segments5And6 = new List<string>
         {
             "segment5",
             "segment6",
         };
 
-        [SetUp]
-        public void Setup() { }
-
         [Test]
         public void ShouldCreateSaveAndLookupOneItem()
         {
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 7d544de1..43d37c1c 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -60,11 +60,6 @@ public void SetMaxSize(int size)
             }
         }
 
-        public void SetTimeout(long timeoutSeconds)
-        {
-            _timeoutMilliseconds = timeoutSeconds * 1000;
-        }
-
         public void Save(string key, T value)
         {
             if (_maxSize == 0)
@@ -73,13 +68,18 @@ public void Save(string key, T value)
                 return;
             }
 
-            if (_orderedDictionary.Count >= _maxSize)
-            {
-                _orderedDictionary.RemoveAt(0);
-            }
-
             lock (_mutex)
             {
+                if (_orderedDictionary.Contains(key))
+                {
+                    _orderedDictionary.Remove(key);
+                }
+
+                if (_orderedDictionary.Count >= _maxSize)
+                {
+                    _orderedDictionary.RemoveAt(0);
+                }
+
                 _orderedDictionary.Add(key, new ItemWrapper(value));
             }
         }
@@ -105,6 +105,9 @@ public T Lookup(string key)
                 // ttl = 0 means items never expire.
                 if (_timeoutMilliseconds == 0 || (nowMs - item.Timestamp < _timeoutMilliseconds))
                 {
+                    _orderedDictionary.Remove(key);
+                    _orderedDictionary.Add(key, item);
+
                     return item.Value;
                 }
 

From d2e3373787f13d8f3491f8dbbeccf674cf2b1b1d Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Mon, 8 Aug 2022 12:47:50 -0400
Subject: [PATCH 07/21] Add copyright notices

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 20 ++++++++++++++++++--
 OptimizelySDK/Odp/DateTimeExtension.cs       | 20 ++++++++++++++++++--
 OptimizelySDK/Odp/ILruCache.cs               | 20 ++++++++++++++++++--
 OptimizelySDK/Odp/LruCache.cs                | 20 ++++++++++++++++++--
 4 files changed, 72 insertions(+), 8 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 7feae0ee..9abd77a1 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -1,4 +1,20 @@
-using NUnit.Framework;
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using NUnit.Framework;
 using OptimizelySDK.Odp;
 using System.Collections.Generic;
 using System.Threading;
@@ -182,4 +198,4 @@ public void ShouldHandleWhenCacheIsReset() {
 
             Assert.AreEqual(0, cache._orderedDictionary.Count);}
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/Odp/DateTimeExtension.cs b/OptimizelySDK/Odp/DateTimeExtension.cs
index b8444d92..6c024574 100644
--- a/OptimizelySDK/Odp/DateTimeExtension.cs
+++ b/OptimizelySDK/Odp/DateTimeExtension.cs
@@ -1,4 +1,20 @@
-using System;
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
 
 namespace OptimizelySDK.Odp
 {
@@ -11,4 +27,4 @@ public static long ToUnixTimeMilliseconds(this DateTime dateTime)
             return Convert.ToInt64(dateTime.Subtract(unixTimeStart).TotalMilliseconds);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/Odp/ILruCache.cs b/OptimizelySDK/Odp/ILruCache.cs
index d06ee06c..3b0cc9f9 100644
--- a/OptimizelySDK/Odp/ILruCache.cs
+++ b/OptimizelySDK/Odp/ILruCache.cs
@@ -1,4 +1,20 @@
-namespace OptimizelySDK.Odp
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK.Odp
 {
     public interface ILruCache<T>
     {
@@ -6,4 +22,4 @@ public interface ILruCache<T>
         T Lookup(string key);
         void Reset();
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 43d37c1c..0a5c3a1b 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -1,4 +1,20 @@
-using OptimizelySDK.Logger;
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using OptimizelySDK.Logger;
 using System;
 using System.Collections.Specialized;
 using System.Runtime.CompilerServices;
@@ -137,4 +153,4 @@ public ItemWrapper(T value)
             }
         }
     }
-}
\ No newline at end of file
+}

From d758efb54ba22a87f1368398f3e0fd61ba217af7 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Mon, 8 Aug 2022 13:52:54 -0400
Subject: [PATCH 08/21] Remove InternalsVisibleTo for testing

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 26 ++++++++++----------
 OptimizelySDK/Odp/LruCache.cs                | 13 +++++++---
 2 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 9abd77a1..44ac8ceb 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -61,14 +61,14 @@ public void ShouldSaveAndLookupMultipleItems()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            var itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
             Assert.AreEqual("user3", itemKeys[2]);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
 
-            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             // Lookup should move user1 to bottom of the list and push up others.
             Assert.AreEqual("user2", itemKeys[0]);
             Assert.AreEqual("user3", itemKeys[1]);
@@ -76,7 +76,7 @@ public void ShouldSaveAndLookupMultipleItems()
 
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
 
-            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             // Lookup should move user2 to bottom of the list and push up others.
             Assert.AreEqual("user3", itemKeys[0]);
             Assert.AreEqual("user1", itemKeys[1]);
@@ -84,7 +84,7 @@ public void ShouldSaveAndLookupMultipleItems()
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             // Lookup should move user3 to bottom of the list and push up others.
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
@@ -100,14 +100,14 @@ public void ShouldReorderListOnSave()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            var itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
             Assert.AreEqual("user3", itemKeys[2]);
 
             cache.Save("user1", _segments1And2);
 
-            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             // save should move user1 to bottom of the list and push up others.
             Assert.AreEqual("user2", itemKeys[0]);
             Assert.AreEqual("user3", itemKeys[1]);
@@ -115,7 +115,7 @@ public void ShouldReorderListOnSave()
 
             cache.Save("user2", _segments3And4);
 
-            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             // save should move user2 to bottom of the list and push up others.
             Assert.AreEqual("user3", itemKeys[0]);
             Assert.AreEqual("user1", itemKeys[1]);
@@ -123,7 +123,7 @@ public void ShouldReorderListOnSave()
 
             cache.Save("user3", _segments5And6);
 
-            itemKeys = cache._orderedDictionary.Keys.ToKeyCollection();
+            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
             // save should move user3 to bottom of the list and push up others.
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
@@ -152,12 +152,12 @@ public void ShouldHandleWhenItemsExpire()
             cache.Save("user1", _segments1And2);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
-            Assert.AreEqual(1, cache._orderedDictionary.Count);
+            Assert.AreEqual(1, cache.ReadCurrentCache().Count);
 
             Thread.Sleep(1200);
 
             Assert.IsNull(cache.Lookup("user1"));
-            Assert.AreEqual(0, cache._orderedDictionary.Count);
+            Assert.AreEqual(0, cache.ReadCurrentCache().Count);
         }
 
         [Test]
@@ -169,7 +169,7 @@ public void ShouldHandleWhenCacheReachesMaxSize()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            Assert.AreEqual(2, cache._orderedDictionary.Count);
+            Assert.AreEqual(2, cache.ReadCurrentCache().Count);
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
@@ -188,7 +188,7 @@ public void ShouldHandleWhenCacheIsReset() {
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            Assert.AreEqual(3, cache._orderedDictionary.Count);
+            Assert.AreEqual(3, cache.ReadCurrentCache().Count);
 
             cache.Reset();
 
@@ -196,6 +196,6 @@ public void ShouldHandleWhenCacheIsReset() {
             Assert.IsNull(cache.Lookup("user2"));
             Assert.IsNull(cache.Lookup("user3"));
 
-            Assert.AreEqual(0, cache._orderedDictionary.Count);}
+            Assert.AreEqual(0, cache.ReadCurrentCache().Count);}
     }
 }
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 0a5c3a1b..afedee4c 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -17,9 +17,6 @@
 using OptimizelySDK.Logger;
 using System;
 using System.Collections.Specialized;
-using System.Runtime.CompilerServices;
-
-[assembly: InternalsVisibleTo("OptimizelySDK.Tests")]
 
 namespace OptimizelySDK.Odp
 {
@@ -32,7 +29,7 @@ public class LruCache<T> : ILruCache<T>
         private readonly object _mutex = new object();
         private int _maxSize;
         private long _timeoutMilliseconds;
-        internal OrderedDictionary _orderedDictionary = new OrderedDictionary();
+        private OrderedDictionary _orderedDictionary = new OrderedDictionary();
 
         public LruCache() : this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, null) { }
 
@@ -152,5 +149,13 @@ public ItemWrapper(T value)
                 Timestamp = DateTime.Now.ToUnixTimeMilliseconds();
             }
         }
+
+        public OrderedDictionary ReadCurrentCache()
+        {
+            lock (_mutex)
+            {
+                return _orderedDictionary;
+            }
+        }
     }
 }

From da33c993e978edb3d23e1840c0e52cdc997934b8 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Mon, 8 Aug 2022 15:19:12 -0400
Subject: [PATCH 09/21] Add new line at end of files via .editorconfig

---
 .editorconfig                                        | 2 +-
 OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index 20fe9082..86bad1fa 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -13,7 +13,7 @@ tab_width = 4
 
 # New line preferences
 end_of_line = crlf
-insert_final_newline = false
+insert_final_newline = true
 
 #### .NET Coding Conventions ####
 
diff --git a/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs b/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
index 813604ed..72f17102 100644
--- a/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
+++ b/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
@@ -11,4 +11,4 @@ public static string[] ToKeyCollection(this ICollection keys)
             return keyArray;
         }
     }
-}
\ No newline at end of file
+}

From 9fe246e47268c99e6ac674fff1885fa867e68f79 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Mon, 8 Aug 2022 17:04:08 -0400
Subject: [PATCH 10/21] Readonly and remove excess methods/constructor

---
 OptimizelySDK/Odp/LruCache.cs | 39 +++--------------------------------
 1 file changed, 3 insertions(+), 36 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index afedee4c..703e754a 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -27,16 +27,12 @@ public class LruCache<T> : ILruCache<T>
 
         private readonly ILogger _logger;
         private readonly object _mutex = new object();
-        private int _maxSize;
-        private long _timeoutMilliseconds;
-        private OrderedDictionary _orderedDictionary = new OrderedDictionary();
+        private readonly int _maxSize;
+        private readonly long _timeoutMilliseconds;
+        private readonly OrderedDictionary _orderedDictionary = new OrderedDictionary();
 
         public LruCache() : this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, null) { }
 
-        public LruCache(ILogger logger) :
-            this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, logger) { }
-
-
         public LruCache(int maxSize, int timeoutSeconds, ILogger logger = null)
         {
             _maxSize = maxSize < 0 ? default : maxSize;
@@ -44,35 +40,6 @@ public LruCache(int maxSize, int timeoutSeconds, ILogger logger = null)
             _logger = logger ?? new DefaultLogger();
         }
 
-        public void SetMaxSize(int size)
-        {
-            lock (_mutex)
-            {
-                if (_orderedDictionary.Count > 0)
-                {
-                    if (size >= _orderedDictionary.Count)
-                    {
-                        _maxSize = size;
-                    }
-                    else
-                    {
-                        _logger.Log(LogLevel.WARN,
-                            "Cannot set max cache size less than current size.");
-                    }
-                }
-                else
-                {
-                    var sizeToSet = size;
-                    if (size < 0)
-                    {
-                        sizeToSet = 0;
-                    }
-
-                    _maxSize = sizeToSet;
-                }
-            }
-        }
-
         public void Save(string key, T value)
         {
             if (_maxSize == 0)

From 33dc181e3d16b64c17de340385eb7fd2ec639f7b Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Wed, 10 Aug 2022 14:17:25 -0400
Subject: [PATCH 11/21] Code review corrections

---
 OptimizelySDK/Odp/{ILruCache.cs => ICache.cs} | 2 +-
 OptimizelySDK/Odp/LruCache.cs                 | 6 +++---
 OptimizelySDK/OptimizelySDK.csproj            | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)
 rename OptimizelySDK/Odp/{ILruCache.cs => ICache.cs} (95%)

diff --git a/OptimizelySDK/Odp/ILruCache.cs b/OptimizelySDK/Odp/ICache.cs
similarity index 95%
rename from OptimizelySDK/Odp/ILruCache.cs
rename to OptimizelySDK/Odp/ICache.cs
index 3b0cc9f9..abcfaa16 100644
--- a/OptimizelySDK/Odp/ILruCache.cs
+++ b/OptimizelySDK/Odp/ICache.cs
@@ -16,7 +16,7 @@
 
 namespace OptimizelySDK.Odp
 {
-    public interface ILruCache<T>
+    public interface ICache<T>
     {
         void Save(string key, T value);
         T Lookup(string key);
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 703e754a..8a8319a7 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -20,7 +20,7 @@
 
 namespace OptimizelySDK.Odp
 {
-    public class LruCache<T> : ILruCache<T>
+    public class LruCache<T> : ICache<T>
     {
         public const int DEFAULT_MAX_SIZE = 10000;
         public const int DEFAULT_TIMEOUT_SECONDS = 600;
@@ -35,8 +35,8 @@ public LruCache() : this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, null) { }
 
         public LruCache(int maxSize, int timeoutSeconds, ILogger logger = null)
         {
-            _maxSize = maxSize < 0 ? default : maxSize;
-            _timeoutMilliseconds = (timeoutSeconds < 0) ? 0 : (timeoutSeconds * 1000L);
+            _maxSize = maxSize < 0 ? 0 : maxSize;
+            _timeoutMilliseconds = timeoutSeconds < 0 ? 0 : timeoutSeconds * 1000L;
             _logger = logger ?? new DefaultLogger();
         }
 
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 0c3e5eb3..dcc17332 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -89,7 +89,7 @@
     <Compile Include="Entity\Integration.cs" />
     <Compile Include="Event\Entity\DecisionMetadata.cs" />
     <Compile Include="Odp\DateTimeExtension.cs" />
-    <Compile Include="Odp\ILruCache.cs" />
+    <Compile Include="Odp\ICache.cs" />
     <Compile Include="Odp\LruCache.cs" />
     <Compile Include="OptimizelyDecisions\DecisionMessage.cs" />
     <Compile Include="OptimizelyDecisions\DecisionReasons.cs" />

From 2f35de34541d3104d092b259fa089c543913e6f2 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Wed, 10 Aug 2022 16:09:29 -0400
Subject: [PATCH 12/21] WIP code review changes

---
 .../OdpTests/CollectionExtensions.cs          | 14 ----
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs  | 67 +++++++++++--------
 .../OptimizelySDK.Tests.csproj                |  1 -
 OptimizelySDK/Odp/DateTimeExtension.cs        | 30 ---------
 OptimizelySDK/Odp/ICache.cs                   |  3 +-
 OptimizelySDK/Odp/LruCache.cs                 | 21 +++---
 OptimizelySDK/OptimizelySDK.csproj            |  1 -
 7 files changed, 51 insertions(+), 86 deletions(-)
 delete mode 100644 OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
 delete mode 100644 OptimizelySDK/Odp/DateTimeExtension.cs

diff --git a/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs b/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
deleted file mode 100644
index 72f17102..00000000
--- a/OptimizelySDK.Tests/OdpTests/CollectionExtensions.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System.Collections;
-
-namespace OptimizelySDK.Tests.OdpTests
-{
-    public static class CollectionTestExtensions
-    {
-        public static string[] ToKeyCollection(this ICollection keys)
-        {
-            var keyArray = new string[keys.Count];
-            keys.CopyTo(keyArray, 0);
-            return keyArray;
-        }
-    }
-}
diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 44ac8ceb..3a99c67b 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -21,26 +21,31 @@
 
 namespace OptimizelySDK.Tests.OdpTests
 {
-    [TestFixture]
     public class LruCacheTest
     {
-        private readonly List<string> _segments1And2 = new List<string>
-        {
-            "segment1",
-            "segment2",
-        };
-
-        private readonly List<string> _segments3And4 = new List<string>
-        {
-            "segment3",
-            "segment4",
-        };
+        private List<string> _segments1And2;
+        private List<string> _segments3And4;
+        private List<string> _segments5And6;
 
-        private readonly List<string> _segments5And6 = new List<string>
+        [SetUp]
+        public void SetUp()
         {
-            "segment5",
-            "segment6",
-        };
+            _segments1And2 = new List<string>
+            {
+                "segment1",
+                "segment2",
+            };
+            _segments3And4 = new List<string>
+            {
+                "segment3",
+                "segment4",
+            };
+            _segments5And6 = new List<string>
+            {
+                "segment5",
+                "segment6",
+            };
+        }
 
         [Test]
         public void ShouldCreateSaveAndLookupOneItem()
@@ -61,14 +66,16 @@ public void ShouldSaveAndLookupMultipleItems()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            var itemKeys = new string[3];
+
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
             Assert.AreEqual("user3", itemKeys[2]);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
 
-            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             // Lookup should move user1 to bottom of the list and push up others.
             Assert.AreEqual("user2", itemKeys[0]);
             Assert.AreEqual("user3", itemKeys[1]);
@@ -76,7 +83,7 @@ public void ShouldSaveAndLookupMultipleItems()
 
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
 
-            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             // Lookup should move user2 to bottom of the list and push up others.
             Assert.AreEqual("user3", itemKeys[0]);
             Assert.AreEqual("user1", itemKeys[1]);
@@ -84,7 +91,7 @@ public void ShouldSaveAndLookupMultipleItems()
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             // Lookup should move user3 to bottom of the list and push up others.
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
@@ -95,19 +102,21 @@ public void ShouldSaveAndLookupMultipleItems()
         public void ShouldReorderListOnSave()
         {
             var cache = new LruCache<List<string>>();
-            
+
             cache.Save("user1", _segments1And2);
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            var itemKeys = new string[3];
+
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
             Assert.AreEqual("user3", itemKeys[2]);
 
             cache.Save("user1", _segments1And2);
 
-            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             // save should move user1 to bottom of the list and push up others.
             Assert.AreEqual("user2", itemKeys[0]);
             Assert.AreEqual("user3", itemKeys[1]);
@@ -115,7 +124,7 @@ public void ShouldReorderListOnSave()
 
             cache.Save("user2", _segments3And4);
 
-            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             // save should move user2 to bottom of the list and push up others.
             Assert.AreEqual("user3", itemKeys[0]);
             Assert.AreEqual("user1", itemKeys[1]);
@@ -123,7 +132,7 @@ public void ShouldReorderListOnSave()
 
             cache.Save("user3", _segments5And6);
 
-            itemKeys = cache.ReadCurrentCache().Keys.ToKeyCollection();
+            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
             // save should move user3 to bottom of the list and push up others.
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
@@ -177,9 +186,10 @@ public void ShouldHandleWhenCacheReachesMaxSize()
         }
 
         [Test]
-        public void ShouldHandleWhenCacheIsReset() { 
+        public void ShouldHandleWhenCacheIsReset()
+        {
             var cache = new LruCache<List<string>>();
-            
+
             cache.Save("user1", _segments1And2);
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
@@ -196,6 +206,7 @@ public void ShouldHandleWhenCacheIsReset() {
             Assert.IsNull(cache.Lookup("user2"));
             Assert.IsNull(cache.Lookup("user3"));
 
-            Assert.AreEqual(0, cache.ReadCurrentCache().Count);}
+            Assert.AreEqual(0, cache.ReadCurrentCache().Count);
+        }
     }
 }
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index 30eb4d2c..c563d781 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -80,7 +80,6 @@
     <Compile Include="DefaultErrorHandlerTest.cs" />
     <Compile Include="EntityTests\IntegrationTest.cs" />
     <Compile Include="EventTests\EventProcessorProps.cs" />
-    <Compile Include="OdpTests\CollectionExtensions.cs" />
     <Compile Include="OdpTests\LruCacheTest.cs" />
     <Compile Include="OptimizelyConfigTests\OptimizelyConfigTest.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecisionTest.cs" />
diff --git a/OptimizelySDK/Odp/DateTimeExtension.cs b/OptimizelySDK/Odp/DateTimeExtension.cs
deleted file mode 100644
index 6c024574..00000000
--- a/OptimizelySDK/Odp/DateTimeExtension.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-/* 
- * Copyright 2022, Optimizely
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-
-namespace OptimizelySDK.Odp
-{
-    public static class DateTimeExtension
-    {
-        // Because we're only on .NET Framework 4.5
-        public static long ToUnixTimeMilliseconds(this DateTime dateTime)
-        {
-            var unixTimeStart = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-            return Convert.ToInt64(dateTime.Subtract(unixTimeStart).TotalMilliseconds);
-        }
-    }
-}
diff --git a/OptimizelySDK/Odp/ICache.cs b/OptimizelySDK/Odp/ICache.cs
index abcfaa16..92a76fd6 100644
--- a/OptimizelySDK/Odp/ICache.cs
+++ b/OptimizelySDK/Odp/ICache.cs
@@ -16,7 +16,8 @@
 
 namespace OptimizelySDK.Odp
 {
-    public interface ICache<T>
+    public interface ICache<T> 
+        where T : class
     {
         void Save(string key, T value);
         T Lookup(string key);
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 8a8319a7..3bd7cf2a 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -15,12 +15,14 @@
  */
 
 using OptimizelySDK.Logger;
+using OptimizelySDK.Utils;
 using System;
 using System.Collections.Specialized;
 
 namespace OptimizelySDK.Odp
 {
     public class LruCache<T> : ICache<T>
+        where T : class
     {
         public const int DEFAULT_MAX_SIZE = 10000;
         public const int DEFAULT_TIMEOUT_SECONDS = 600;
@@ -31,12 +33,12 @@ public class LruCache<T> : ICache<T>
         private readonly long _timeoutMilliseconds;
         private readonly OrderedDictionary _orderedDictionary = new OrderedDictionary();
 
-        public LruCache() : this(DEFAULT_MAX_SIZE, DEFAULT_TIMEOUT_SECONDS, null) { }
-
-        public LruCache(int maxSize, int timeoutSeconds, ILogger logger = null)
+        public LruCache(int maxSize = DEFAULT_MAX_SIZE,
+            int timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, ILogger logger = null
+        )
         {
-            _maxSize = maxSize < 0 ? 0 : maxSize;
-            _timeoutMilliseconds = timeoutSeconds < 0 ? 0 : timeoutSeconds * 1000L;
+            _maxSize = Math.Max(0, maxSize);
+            _timeoutMilliseconds = Math.Max(0, timeoutSeconds) * 1000L;
             _logger = logger ?? new DefaultLogger();
         }
 
@@ -80,7 +82,7 @@ public T Lookup(string key)
                 }
 
                 var item = (ItemWrapper)_orderedDictionary[key];
-                var nowMs = DateTime.Now.ToUnixTimeMilliseconds();
+                var nowMs = DateTime.Now.MillisecondsSince1970();
 
                 // ttl = 0 means items never expire.
                 if (_timeoutMilliseconds == 0 || (nowMs - item.Timestamp < _timeoutMilliseconds))
@@ -113,16 +115,13 @@ private class ItemWrapper
             public ItemWrapper(T value)
             {
                 Value = value;
-                Timestamp = DateTime.Now.ToUnixTimeMilliseconds();
+                Timestamp = DateTime.Now.MillisecondsSince1970();
             }
         }
 
         public OrderedDictionary ReadCurrentCache()
         {
-            lock (_mutex)
-            {
-                return _orderedDictionary;
-            }
+            return _orderedDictionary;
         }
     }
 }
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index dcc17332..4d08ff70 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -88,7 +88,6 @@
     <Compile Include="Entity\IdKeyEntity.cs" />
     <Compile Include="Entity\Integration.cs" />
     <Compile Include="Event\Entity\DecisionMetadata.cs" />
-    <Compile Include="Odp\DateTimeExtension.cs" />
     <Compile Include="Odp\ICache.cs" />
     <Compile Include="Odp\LruCache.cs" />
     <Compile Include="OptimizelyDecisions\DecisionMessage.cs" />

From 24737fe6388065fcf9992c302c01046a7fe5de7c Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Wed, 10 Aug 2022 16:16:53 -0400
Subject: [PATCH 13/21] Possibly better solution to cast

---
 OptimizelySDK/Odp/LruCache.cs | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 3bd7cf2a..96d6f0ea 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -81,16 +81,18 @@ public T Lookup(string key)
                     return default;
                 }
 
-                var item = (ItemWrapper)_orderedDictionary[key];
-                var nowMs = DateTime.Now.MillisecondsSince1970();
-
-                // ttl = 0 means items never expire.
-                if (_timeoutMilliseconds == 0 || (nowMs - item.Timestamp < _timeoutMilliseconds))
+                var currentTimestamp = DateTime.Now.MillisecondsSince1970();
+                if (_orderedDictionary[key] is ItemWrapper item)
                 {
-                    _orderedDictionary.Remove(key);
-                    _orderedDictionary.Add(key, item);
-
-                    return item.Value;
+                    // ttl = 0 means items never expire.
+                    if (_timeoutMilliseconds == 0 ||
+                        (currentTimestamp - item.Timestamp < _timeoutMilliseconds))
+                    {
+                        _orderedDictionary.Remove(key);
+                        _orderedDictionary.Add(key, item);
+
+                        return item.Value;
+                    }
                 }
 
                 _orderedDictionary.Remove(key);

From e042d994d5301a4457c54eac469cbcd3074c3c5a Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Wed, 10 Aug 2022 16:24:27 -0400
Subject: [PATCH 14/21] Move readonlys into constructor

---
 OptimizelySDK/Odp/LruCache.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 96d6f0ea..703b24af 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -28,18 +28,20 @@ public class LruCache<T> : ICache<T>
         public const int DEFAULT_TIMEOUT_SECONDS = 600;
 
         private readonly ILogger _logger;
-        private readonly object _mutex = new object();
+        private readonly object _mutex;
         private readonly int _maxSize;
         private readonly long _timeoutMilliseconds;
-        private readonly OrderedDictionary _orderedDictionary = new OrderedDictionary();
+        private readonly OrderedDictionary _orderedDictionary;
 
         public LruCache(int maxSize = DEFAULT_MAX_SIZE,
             int timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, ILogger logger = null
         )
         {
+            _mutex  = new object();
             _maxSize = Math.Max(0, maxSize);
             _timeoutMilliseconds = Math.Max(0, timeoutSeconds) * 1000L;
             _logger = logger ?? new DefaultLogger();
+            _orderedDictionary = new OrderedDictionary();
         }
 
         public void Save(string key, T value)

From 67491827c1987601eb0cbde4e121e8f77f414be4 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Thu, 11 Aug 2022 17:13:27 -0400
Subject: [PATCH 15/21] Switch to using TimeSpan + refactors

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 33 ++++++++---------
 OptimizelySDK/Odp/LruCache.cs                | 38 +++++++++++++-------
 2 files changed, 43 insertions(+), 28 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 3a99c67b..9ae17fc6 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -16,6 +16,7 @@
 
 using NUnit.Framework;
 using OptimizelySDK.Odp;
+using System;
 using System.Collections.Generic;
 using System.Threading;
 
@@ -68,14 +69,14 @@ public void ShouldSaveAndLookupMultipleItems()
 
             var itemKeys = new string[3];
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
             Assert.AreEqual("user3", itemKeys[2]);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             // Lookup should move user1 to bottom of the list and push up others.
             Assert.AreEqual("user2", itemKeys[0]);
             Assert.AreEqual("user3", itemKeys[1]);
@@ -83,7 +84,7 @@ public void ShouldSaveAndLookupMultipleItems()
 
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             // Lookup should move user2 to bottom of the list and push up others.
             Assert.AreEqual("user3", itemKeys[0]);
             Assert.AreEqual("user1", itemKeys[1]);
@@ -91,7 +92,7 @@ public void ShouldSaveAndLookupMultipleItems()
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             // Lookup should move user3 to bottom of the list and push up others.
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
@@ -109,14 +110,14 @@ public void ShouldReorderListOnSave()
 
             var itemKeys = new string[3];
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
             Assert.AreEqual("user3", itemKeys[2]);
 
             cache.Save("user1", _segments1And2);
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             // save should move user1 to bottom of the list and push up others.
             Assert.AreEqual("user2", itemKeys[0]);
             Assert.AreEqual("user3", itemKeys[1]);
@@ -124,7 +125,7 @@ public void ShouldReorderListOnSave()
 
             cache.Save("user2", _segments3And4);
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             // save should move user2 to bottom of the list and push up others.
             Assert.AreEqual("user3", itemKeys[0]);
             Assert.AreEqual("user1", itemKeys[1]);
@@ -132,7 +133,7 @@ public void ShouldReorderListOnSave()
 
             cache.Save("user3", _segments5And6);
 
-            cache.ReadCurrentCache().Keys.CopyTo(itemKeys, 0);
+            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
             // save should move user3 to bottom of the list and push up others.
             Assert.AreEqual("user1", itemKeys[0]);
             Assert.AreEqual("user2", itemKeys[1]);
@@ -142,7 +143,7 @@ public void ShouldReorderListOnSave()
         [Test]
         public void ShouldHandleWhenCacheIsDisabled()
         {
-            var cache = new LruCache<List<string>>(0, LruCache<object>.DEFAULT_TIMEOUT_SECONDS);
+            var cache = new LruCache<List<string>>(maxSize: 0);
 
             cache.Save("user1", _segments1And2);
             cache.Save("user2", _segments3And4);
@@ -156,29 +157,29 @@ public void ShouldHandleWhenCacheIsDisabled()
         [Test]
         public void ShouldHandleWhenItemsExpire()
         {
-            var cache = new LruCache<List<string>>(LruCache<object>.DEFAULT_MAX_SIZE, 1);
+            var cache = new LruCache<List<string>>(timeout: TimeSpan.FromSeconds(1));
 
             cache.Save("user1", _segments1And2);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
-            Assert.AreEqual(1, cache.ReadCurrentCache().Count);
+            Assert.AreEqual(1, cache._readCurrentCache().Count);
 
             Thread.Sleep(1200);
 
             Assert.IsNull(cache.Lookup("user1"));
-            Assert.AreEqual(0, cache.ReadCurrentCache().Count);
+            Assert.AreEqual(0, cache._readCurrentCache().Count);
         }
 
         [Test]
         public void ShouldHandleWhenCacheReachesMaxSize()
         {
-            var cache = new LruCache<List<string>>(2, LruCache<object>.DEFAULT_TIMEOUT_SECONDS);
+            var cache = new LruCache<List<string>>(maxSize: 2);
 
             cache.Save("user1", _segments1And2);
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            Assert.AreEqual(2, cache.ReadCurrentCache().Count);
+            Assert.AreEqual(2, cache._readCurrentCache().Count);
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
@@ -198,7 +199,7 @@ public void ShouldHandleWhenCacheIsReset()
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            Assert.AreEqual(3, cache.ReadCurrentCache().Count);
+            Assert.AreEqual(3, cache._readCurrentCache().Count);
 
             cache.Reset();
 
@@ -206,7 +207,7 @@ public void ShouldHandleWhenCacheIsReset()
             Assert.IsNull(cache.Lookup("user2"));
             Assert.IsNull(cache.Lookup("user3"));
 
-            Assert.AreEqual(0, cache.ReadCurrentCache().Count);
+            Assert.AreEqual(0, cache._readCurrentCache().Count);
         }
     }
 }
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 703b24af..dbadfa28 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -24,22 +24,35 @@ namespace OptimizelySDK.Odp
     public class LruCache<T> : ICache<T>
         where T : class
     {
-        public const int DEFAULT_MAX_SIZE = 10000;
-        public const int DEFAULT_TIMEOUT_SECONDS = 600;
-
         private readonly ILogger _logger;
         private readonly object _mutex;
         private readonly int _maxSize;
-        private readonly long _timeoutMilliseconds;
+        private readonly TimeSpan _timeout;
         private readonly OrderedDictionary _orderedDictionary;
 
-        public LruCache(int maxSize = DEFAULT_MAX_SIZE,
-            int timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, ILogger logger = null
+        public LruCache(int? maxSize = null,
+            TimeSpan? timeout = null, ILogger logger = null
         )
         {
-            _mutex  = new object();
-            _maxSize = Math.Max(0, maxSize);
-            _timeoutMilliseconds = Math.Max(0, timeoutSeconds) * 1000L;
+            int defaultMaxSize = 10000;
+            TimeSpan defaultTimeout = TimeSpan.FromMinutes(10);
+
+            _mutex = new object();
+            _maxSize = !maxSize.HasValue || maxSize < 0 ? defaultMaxSize : maxSize.Value;
+            
+            if (timeout is null)
+            {
+                _timeout = defaultTimeout;
+            }
+            else if (timeout?.TotalMilliseconds < 0)
+            {
+                _timeout = TimeSpan.Zero;
+            }
+            else
+            {
+                _timeout = timeout.Value;
+            }
+
             _logger = logger ?? new DefaultLogger();
             _orderedDictionary = new OrderedDictionary();
         }
@@ -87,8 +100,8 @@ public T Lookup(string key)
                 if (_orderedDictionary[key] is ItemWrapper item)
                 {
                     // ttl = 0 means items never expire.
-                    if (_timeoutMilliseconds == 0 ||
-                        (currentTimestamp - item.Timestamp < _timeoutMilliseconds))
+                    if (_timeout == TimeSpan.Zero ||
+                        (currentTimestamp - item.Timestamp < _timeout.TotalMilliseconds))
                     {
                         _orderedDictionary.Remove(key);
                         _orderedDictionary.Add(key, item);
@@ -123,8 +136,9 @@ public ItemWrapper(T value)
             }
         }
 
-        public OrderedDictionary ReadCurrentCache()
+        public OrderedDictionary _readCurrentCache()
         {
+            _logger.Log(LogLevel.WARN, "_ReadCurrentCache used for non-testing purpose");
             return _orderedDictionary;
         }
     }

From 2bac0039cb28591034fac94633d1f5185088611a Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Thu, 11 Aug 2022 17:21:50 -0400
Subject: [PATCH 16/21] A few more refactors

---
 OptimizelySDK/Odp/LruCache.cs | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index dbadfa28..f82cafbc 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -34,18 +34,32 @@ public LruCache(int? maxSize = null,
             TimeSpan? timeout = null, ILogger logger = null
         )
         {
-            int defaultMaxSize = 10000;
-            TimeSpan defaultTimeout = TimeSpan.FromMinutes(10);
+            var defaultMaxSize = 10000;
+            var defaultTimeout = TimeSpan.FromMinutes(10);
 
             _mutex = new object();
-            _maxSize = !maxSize.HasValue || maxSize < 0 ? defaultMaxSize : maxSize.Value;
-            
+
+            if (maxSize is null)
+            {
+                _maxSize = defaultMaxSize;
+            }
+            else if (maxSize < 0)
+            {
+                // Cache is disabled when maxSize = 0
+                _maxSize = 0;
+            }
+            else
+            {
+                _maxSize = maxSize.Value;
+            }
+
             if (timeout is null)
             {
                 _timeout = defaultTimeout;
             }
             else if (timeout?.TotalMilliseconds < 0)
             {
+                // ttl = 0 means items never expire.
                 _timeout = TimeSpan.Zero;
             }
             else
@@ -54,6 +68,7 @@ public LruCache(int? maxSize = null,
             }
 
             _logger = logger ?? new DefaultLogger();
+
             _orderedDictionary = new OrderedDictionary();
         }
 
@@ -61,7 +76,6 @@ public void Save(string key, T value)
         {
             if (_maxSize == 0)
             {
-                // Cache is disabled when maxSize = 0
                 return;
             }
 
@@ -85,7 +99,6 @@ public T Lookup(string key)
         {
             if (_maxSize == 0)
             {
-                // Cache is disabled when maxSize = 0
                 return default;
             }
 
@@ -99,7 +112,6 @@ public T Lookup(string key)
                 var currentTimestamp = DateTime.Now.MillisecondsSince1970();
                 if (_orderedDictionary[key] is ItemWrapper item)
                 {
-                    // ttl = 0 means items never expire.
                     if (_timeout == TimeSpan.Zero ||
                         (currentTimestamp - item.Timestamp < _timeout.TotalMilliseconds))
                     {
@@ -138,7 +150,7 @@ public ItemWrapper(T value)
 
         public OrderedDictionary _readCurrentCache()
         {
-            _logger.Log(LogLevel.WARN, "_ReadCurrentCache used for non-testing purpose");
+            _logger.Log(LogLevel.WARN, "_readCurrentCache used for non-testing purpose");
             return _orderedDictionary;
         }
     }

From 03c9abfa4282f3e5ae43f20582e118fbf5ffc0b5 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Fri, 12 Aug 2022 12:14:09 -0400
Subject: [PATCH 17/21] Change underlying implementation of LRU

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 100 +++++++++----------
 OptimizelySDK/Odp/LruCache.cs                |  90 ++++++++++-------
 OptimizelySDK/OptimizelySDK.csproj           |   3 +
 OptimizelySDK/packages.config                |   1 +
 4 files changed, 106 insertions(+), 88 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 9ae17fc6..2e56523a 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -18,6 +18,7 @@
 using OptimizelySDK.Odp;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 
 namespace OptimizelySDK.Tests.OdpTests
@@ -67,36 +68,35 @@ public void ShouldSaveAndLookupMultipleItems()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var itemKeys = new string[3];
+            var cacheKeys = cache._readCurrentCacheKeys().ToArray();
 
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            Assert.AreEqual("user1", itemKeys[0]);
-            Assert.AreEqual("user2", itemKeys[1]);
-            Assert.AreEqual("user3", itemKeys[2]);
+            Assert.AreEqual("user3", cacheKeys[0]);
+            Assert.AreEqual("user2", cacheKeys[1]);
+            Assert.AreEqual("user1", cacheKeys[2]);
 
+            // Lookup should move user1 to top of the list and push down others.
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
 
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            // Lookup should move user1 to bottom of the list and push up others.
-            Assert.AreEqual("user2", itemKeys[0]);
-            Assert.AreEqual("user3", itemKeys[1]);
-            Assert.AreEqual("user1", itemKeys[2]);
+            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            Assert.AreEqual("user1", cacheKeys[0]);
+            Assert.AreEqual("user3", cacheKeys[1]);
+            Assert.AreEqual("user2", cacheKeys[2]);
 
+            // Lookup should move user2 to the beginning of the list and push others.
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
 
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            // Lookup should move user2 to bottom of the list and push up others.
-            Assert.AreEqual("user3", itemKeys[0]);
-            Assert.AreEqual("user1", itemKeys[1]);
-            Assert.AreEqual("user2", itemKeys[2]);
+            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            Assert.AreEqual("user2", cacheKeys[0]);
+            Assert.AreEqual("user1", cacheKeys[1]);
+            Assert.AreEqual("user3", cacheKeys[2]);
 
+            // Lookup moves user3 to top and pushes others down.
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            // Lookup should move user3 to bottom of the list and push up others.
-            Assert.AreEqual("user1", itemKeys[0]);
-            Assert.AreEqual("user2", itemKeys[1]);
-            Assert.AreEqual("user3", itemKeys[2]);
+            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            Assert.AreEqual("user3", cacheKeys[0]);
+            Assert.AreEqual("user2", cacheKeys[1]);
+            Assert.AreEqual("user1", cacheKeys[2]);
         }
 
         [Test]
@@ -108,36 +108,36 @@ public void ShouldReorderListOnSave()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var itemKeys = new string[3];
-
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            Assert.AreEqual("user1", itemKeys[0]);
-            Assert.AreEqual("user2", itemKeys[1]);
-            Assert.AreEqual("user3", itemKeys[2]);
+            var cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            
+            // last added should be at the top of the list
+            Assert.AreEqual("user3",cacheKeys[0]);
+            Assert.AreEqual("user2",cacheKeys[1]);
+            Assert.AreEqual("user1" ,cacheKeys[2]);
 
+            // save should move user1 to the top of the list and push down others.
             cache.Save("user1", _segments1And2);
+            
+            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            Assert.AreEqual("user1",cacheKeys[0]);
+            Assert.AreEqual("user3",cacheKeys[1]);
+            Assert.AreEqual("user2",cacheKeys[2]);
 
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            // save should move user1 to bottom of the list and push up others.
-            Assert.AreEqual("user2", itemKeys[0]);
-            Assert.AreEqual("user3", itemKeys[1]);
-            Assert.AreEqual("user1", itemKeys[2]);
-
+            // save user2 should bring it to the top and push down others.
             cache.Save("user2", _segments3And4);
+            
+            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            Assert.AreEqual("user2",cacheKeys[0]);
+            Assert.AreEqual("user1",cacheKeys[1]);
+            Assert.AreEqual("user3",cacheKeys[2]);
 
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            // save should move user2 to bottom of the list and push up others.
-            Assert.AreEqual("user3", itemKeys[0]);
-            Assert.AreEqual("user1", itemKeys[1]);
-            Assert.AreEqual("user2", itemKeys[2]);
-
+            // saving user3 again should return to the original insertion order.
             cache.Save("user3", _segments5And6);
-
-            cache._readCurrentCache().Keys.CopyTo(itemKeys, 0);
-            // save should move user3 to bottom of the list and push up others.
-            Assert.AreEqual("user1", itemKeys[0]);
-            Assert.AreEqual("user2", itemKeys[1]);
-            Assert.AreEqual("user3", itemKeys[2]);
+            
+            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            Assert.AreEqual("user3",cacheKeys[0]);
+            Assert.AreEqual("user2",cacheKeys[1]);
+            Assert.AreEqual("user1" ,cacheKeys[2]);
         }
 
         [Test]
@@ -157,17 +157,17 @@ public void ShouldHandleWhenCacheIsDisabled()
         [Test]
         public void ShouldHandleWhenItemsExpire()
         {
-            var cache = new LruCache<List<string>>(timeout: TimeSpan.FromSeconds(1));
+            var cache = new LruCache<List<string>>(itemTimeout: TimeSpan.FromSeconds(1));
 
             cache.Save("user1", _segments1And2);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
-            Assert.AreEqual(1, cache._readCurrentCache().Count);
+            Assert.AreEqual(1, cache._readCurrentCacheKeys().Count);
 
             Thread.Sleep(1200);
 
             Assert.IsNull(cache.Lookup("user1"));
-            Assert.AreEqual(0, cache._readCurrentCache().Count);
+            Assert.AreEqual(0, cache._readCurrentCacheKeys().Count);
         }
 
         [Test]
@@ -179,7 +179,7 @@ public void ShouldHandleWhenCacheReachesMaxSize()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            Assert.AreEqual(2, cache._readCurrentCache().Count);
+            Assert.AreEqual(2, cache._readCurrentCacheKeys().Count);
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
@@ -199,7 +199,7 @@ public void ShouldHandleWhenCacheIsReset()
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            Assert.AreEqual(3, cache._readCurrentCache().Count);
+            Assert.AreEqual(3, cache._readCurrentCacheKeys().Count);
 
             cache.Reset();
 
@@ -207,7 +207,7 @@ public void ShouldHandleWhenCacheIsReset()
             Assert.IsNull(cache.Lookup("user2"));
             Assert.IsNull(cache.Lookup("user3"));
 
-            Assert.AreEqual(0, cache._readCurrentCache().Count);
+            Assert.AreEqual(0, cache._readCurrentCacheKeys().Count);
         }
     }
 }
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index f82cafbc..08f14c61 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -17,59 +17,62 @@
 using OptimizelySDK.Logger;
 using OptimizelySDK.Utils;
 using System;
-using System.Collections.Specialized;
+using System.Collections.Generic;
 
 namespace OptimizelySDK.Odp
 {
     public class LruCache<T> : ICache<T>
         where T : class
     {
-        private readonly ILogger _logger;
-        private readonly object _mutex;
         private readonly int _maxSize;
+        private readonly object _mutex;
         private readonly TimeSpan _timeout;
-        private readonly OrderedDictionary _orderedDictionary;
+        private readonly TimeSpan _timeoutDisabled = TimeSpan.Zero;
+        private readonly ILogger _logger;
+        private readonly Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)> _cache;
+        private readonly LinkedList<string> _list;
 
         public LruCache(int? maxSize = null,
-            TimeSpan? timeout = null, ILogger logger = null
+            TimeSpan? itemTimeout = null, ILogger logger = null
         )
         {
-            var defaultMaxSize = 10000;
+            const int DEFAULT_MAX_SIZE = 10000;
+            const int CACHE_DISABLED = 0;
             var defaultTimeout = TimeSpan.FromMinutes(10);
 
             _mutex = new object();
 
             if (maxSize is null)
             {
-                _maxSize = defaultMaxSize;
+                _maxSize = DEFAULT_MAX_SIZE;
             }
             else if (maxSize < 0)
             {
-                // Cache is disabled when maxSize = 0
-                _maxSize = 0;
+                _maxSize = CACHE_DISABLED;
             }
             else
             {
                 _maxSize = maxSize.Value;
             }
 
-            if (timeout is null)
+            if (itemTimeout is null)
             {
                 _timeout = defaultTimeout;
             }
-            else if (timeout?.TotalMilliseconds < 0)
+            else if (itemTimeout?.TotalMilliseconds < 0)
             {
-                // ttl = 0 means items never expire.
-                _timeout = TimeSpan.Zero;
+                _timeout = _timeoutDisabled;
             }
             else
             {
-                _timeout = timeout.Value;
+                _timeout = itemTimeout.Value;
             }
 
             _logger = logger ?? new DefaultLogger();
 
-            _orderedDictionary = new OrderedDictionary();
+            _cache =
+                new Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)>(_maxSize);
+            _list = new LinkedList<string>();
         }
 
         public void Save(string key, T value)
@@ -81,17 +84,24 @@ public void Save(string key, T value)
 
             lock (_mutex)
             {
-                if (_orderedDictionary.Contains(key))
+                if (_cache.ContainsKey(key))
                 {
-                    _orderedDictionary.Remove(key);
+                    (LinkedListNode<string> node, ItemWrapper item) = _cache[key];
+                    _list.Remove(node);
+                    _list.AddFirst(node);
+                    _cache[key] = (node, item);
                 }
-
-                if (_orderedDictionary.Count >= _maxSize)
+                else
                 {
-                    _orderedDictionary.RemoveAt(0);
-                }
+                    if (_cache.Count >= _maxSize)
+                    {
+                        var removeKey = _list.Last.Value;
+                        _cache.Remove(removeKey);
+                        _list.RemoveLast();
+                    }
 
-                _orderedDictionary.Add(key, new ItemWrapper(value));
+                    _cache.Add(key, (_list.AddFirst(key), new ItemWrapper(value)));
+                }
             }
         }
 
@@ -104,25 +114,28 @@ public T Lookup(string key)
 
             lock (_mutex)
             {
-                if (!_orderedDictionary.Contains(key))
+                if (!_cache.ContainsKey(key))
                 {
                     return default;
                 }
 
+                (LinkedListNode<string> node, ItemWrapper item) = _cache[key];
+
                 var currentTimestamp = DateTime.Now.MillisecondsSince1970();
-                if (_orderedDictionary[key] is ItemWrapper item)
+
+                if (_timeout == _timeoutDisabled ||
+                    (currentTimestamp - item.CreationTimestamp < _timeout.TotalMilliseconds))
                 {
-                    if (_timeout == TimeSpan.Zero ||
-                        (currentTimestamp - item.Timestamp < _timeout.TotalMilliseconds))
-                    {
-                        _orderedDictionary.Remove(key);
-                        _orderedDictionary.Add(key, item);
+                    _list.Remove(node);
+                    _list.AddFirst(node);
 
-                        return item.Value;
-                    }
+                    _cache[key] = (node, item);
+
+                    return item.Value;
                 }
 
-                _orderedDictionary.Remove(key);
+                _cache.Remove(key);
+                _list.Remove(node);
 
                 return default;
             }
@@ -132,26 +145,27 @@ public void Reset()
         {
             lock (_mutex)
             {
-                _orderedDictionary.Clear();
+                _cache.Clear();
+                _list.Clear();
             }
         }
 
         private class ItemWrapper
         {
             public readonly T Value;
-            public readonly long Timestamp;
+            public readonly long CreationTimestamp;
 
             public ItemWrapper(T value)
             {
                 Value = value;
-                Timestamp = DateTime.Now.MillisecondsSince1970();
+                CreationTimestamp = DateTime.Now.MillisecondsSince1970();
             }
         }
 
-        public OrderedDictionary _readCurrentCache()
+        public LinkedList<string> _readCurrentCacheKeys()
         {
-            _logger.Log(LogLevel.WARN, "_readCurrentCache used for non-testing purpose");
-            return _orderedDictionary;
+            _logger.Log(LogLevel.WARN, "_readCurrentCacheKeys used for non-testing purpose");
+            return _list;
         }
     }
 }
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 4d08ff70..47805084 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -54,6 +54,9 @@
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
     <Reference Include="System.Net.Http" />
+    <Reference Include="System.ValueTuple, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.ValueTuple.4.5.0\lib\netstandard1.0\System.ValueTuple.dll</HintPath>
+    </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="System.Data" />
diff --git a/OptimizelySDK/packages.config b/OptimizelySDK/packages.config
index c8732913..de2ca84c 100644
--- a/OptimizelySDK/packages.config
+++ b/OptimizelySDK/packages.config
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="System.ValueTuple" version="4.5.0" targetFramework="net45" />
   <package id="murmurhash-signed" version="1.0.2" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net45" />
   <package id="NJsonSchema" version="8.30.6304.31883" targetFramework="net45" />

From 209c3bd8e54b8f721efa2f56bc565679ea57f9ca Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Tue, 16 Aug 2022 09:22:53 -0400
Subject: [PATCH 18/21] Attempt to fulfill a default Timespan

---
 OptimizelySDK/Odp/LruCache.cs | 104 ++++++++++++++++++++++++----------
 1 file changed, 75 insertions(+), 29 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 08f14c61..7fc25069 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -24,50 +24,65 @@ namespace OptimizelySDK.Odp
     public class LruCache<T> : ICache<T>
         where T : class
     {
+        /// <summary>
+        /// Default maximum number of elements to store
+        /// </summary>
+        private const int DEFAULT_MAX_SIZE = 10000;
+
+        /// <summary>
+        /// The maximum number of elements that should be stored
+        /// </summary>
         private readonly int _maxSize;
+        
+        /// <summary>
+        /// An object for obtaining a mutually exclusive lock for thread safety
+        /// </summary>
         private readonly object _mutex;
+        
+        /// <summary>
+        /// The maximum age of an object in the cache
+        /// </summary>
         private readonly TimeSpan _timeout;
+        
+        /// <summary>
+        /// Indication that timeout is disabled and objects should remain in cache indefinitely
+        /// </summary>
         private readonly TimeSpan _timeoutDisabled = TimeSpan.Zero;
+        
+        /// <summary>
+        /// Implementation used for recording LRU events or errors 
+        /// </summary>
         private readonly ILogger _logger;
+        
+        /// <summary>
+        /// Indexed data held in the cache 
+        /// </summary>
         private readonly Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)> _cache;
+        
+        /// <summary>
+        /// Ordered list of objects being held in the cache 
+        /// </summary>
         private readonly LinkedList<string> _list;
 
-        public LruCache(int? maxSize = null,
-            TimeSpan? itemTimeout = null, ILogger logger = null
+        /// <summary>
+        /// A Least Recently Used in-memory cache
+        /// </summary>
+        /// <param name="maxSize">Maximum number of elements to allow in the cache</param>
+        /// <param name="itemTimeout">Timeout or time to live for each item</param>
+        /// <param name="logger">Implementation used for recording LRU events or errors</param>
+        public LruCache(int maxSize = DEFAULT_MAX_SIZE,
+            TimeSpan? itemTimeout = default, ILogger logger = null
         )
         {
-            const int DEFAULT_MAX_SIZE = 10000;
             const int CACHE_DISABLED = 0;
-            var defaultTimeout = TimeSpan.FromMinutes(10);
 
             _mutex = new object();
 
-            if (maxSize is null)
-            {
-                _maxSize = DEFAULT_MAX_SIZE;
-            }
-            else if (maxSize < 0)
-            {
-                _maxSize = CACHE_DISABLED;
-            }
-            else
-            {
-                _maxSize = maxSize.Value;
-            }
-
-            if (itemTimeout is null)
-            {
-                _timeout = defaultTimeout;
-            }
-            else if (itemTimeout?.TotalMilliseconds < 0)
-            {
-                _timeout = _timeoutDisabled;
-            }
-            else
-            {
-                _timeout = itemTimeout.Value;
-            }
+            _maxSize = Math.Max(CACHE_DISABLED, maxSize);
 
+            _timeout = TimeSpan.FromTicks(Math.Max(_timeoutDisabled.Ticks,
+                (itemTimeout ?? TimeSpan.FromMinutes(10)).Ticks));
+            
             _logger = logger ?? new DefaultLogger();
 
             _cache =
@@ -75,6 +90,11 @@ public LruCache(int? maxSize = null,
             _list = new LinkedList<string>();
         }
 
+        /// <summary>
+        /// Saves a new element into the cache
+        /// </summary>
+        /// <param name="key">Key of the element used for future retrieval</param>
+        /// <param name="value">Strongly-typed value to store against the key</param>
         public void Save(string key, T value)
         {
             if (_maxSize == 0)
@@ -105,6 +125,11 @@ public void Save(string key, T value)
             }
         }
 
+        /// <summary>
+        /// Retrieves an element from the cache, reordering the elements
+        /// </summary>
+        /// <param name="key">Key of element to find and retrieve</param>
+        /// <returns>Strongly-typed value from the cache</returns>
         public T Lookup(string key)
         {
             if (_maxSize == 0)
@@ -141,6 +166,9 @@ public T Lookup(string key)
             }
         }
 
+        /// <summary>
+        /// Clears all the elements from the cache 
+        /// </summary>
         public void Reset()
         {
             lock (_mutex)
@@ -150,11 +178,25 @@ public void Reset()
             }
         }
 
+        /// <summary>
+        /// Wrapping class around a generic value stored in the cache
+        /// </summary>
         private class ItemWrapper
         {
+            /// <summary>
+            /// Value of the item
+            /// </summary>
             public readonly T Value;
+            
+            /// <summary>
+            /// Unix timestamp of when the item was added  
+            /// </summary>
             public readonly long CreationTimestamp;
 
+            /// <summary>
+            /// Initialize the wrapper
+            /// </summary>
+            /// <param name="value">Item to be stored</param>
             public ItemWrapper(T value)
             {
                 Value = value;
@@ -162,6 +204,10 @@ public ItemWrapper(T value)
             }
         }
 
+        /// <summary>
+        /// Read the current cache index/linked list for unit testing
+        /// </summary>
+        /// <returns></returns>
         public LinkedList<string> _readCurrentCacheKeys()
         {
             _logger.Log(LogLevel.WARN, "_readCurrentCacheKeys used for non-testing purpose");

From 42a735d0a1d4c6e41fc2caf551b401d742a684e0 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Tue, 16 Aug 2022 09:32:07 -0400
Subject: [PATCH 19/21] Add logging; use 0s instead of descriptive consts

---
 OptimizelySDK/Odp/LruCache.cs | 34 +++++++++++++++-------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index 7fc25069..c83b3bcf 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -33,32 +33,28 @@ public class LruCache<T> : ICache<T>
         /// The maximum number of elements that should be stored
         /// </summary>
         private readonly int _maxSize;
-        
+
         /// <summary>
         /// An object for obtaining a mutually exclusive lock for thread safety
         /// </summary>
         private readonly object _mutex;
-        
+
         /// <summary>
         /// The maximum age of an object in the cache
         /// </summary>
         private readonly TimeSpan _timeout;
-        
-        /// <summary>
-        /// Indication that timeout is disabled and objects should remain in cache indefinitely
-        /// </summary>
-        private readonly TimeSpan _timeoutDisabled = TimeSpan.Zero;
-        
+
         /// <summary>
         /// Implementation used for recording LRU events or errors 
         /// </summary>
         private readonly ILogger _logger;
-        
+
         /// <summary>
         /// Indexed data held in the cache 
         /// </summary>
-        private readonly Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)> _cache;
-        
+        private readonly Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)>
+            _cache;
+
         /// <summary>
         /// Ordered list of objects being held in the cache 
         /// </summary>
@@ -74,15 +70,13 @@ public LruCache(int maxSize = DEFAULT_MAX_SIZE,
             TimeSpan? itemTimeout = default, ILogger logger = null
         )
         {
-            const int CACHE_DISABLED = 0;
-
             _mutex = new object();
 
-            _maxSize = Math.Max(CACHE_DISABLED, maxSize);
+            _maxSize = Math.Max(0, maxSize);
+
+            _timeout =
+                TimeSpan.FromTicks(Math.Max(0, (itemTimeout ?? TimeSpan.FromMinutes(10)).Ticks));
 
-            _timeout = TimeSpan.FromTicks(Math.Max(_timeoutDisabled.Ticks,
-                (itemTimeout ?? TimeSpan.FromMinutes(10)).Ticks));
-            
             _logger = logger ?? new DefaultLogger();
 
             _cache =
@@ -99,6 +93,7 @@ public void Save(string key, T value)
         {
             if (_maxSize == 0)
             {
+                _logger.Log(LogLevel.WARN, "Unable to Save(). LRU Cache is disabled. Set maxSize > 0 to enable.");
                 return;
             }
 
@@ -134,6 +129,7 @@ public T Lookup(string key)
         {
             if (_maxSize == 0)
             {
+                _logger.Log(LogLevel.WARN, "Unable to Lookup(). LRU Cache is disabled. Set maxSize > 0 to enable.");
                 return default;
             }
 
@@ -148,7 +144,7 @@ public T Lookup(string key)
 
                 var currentTimestamp = DateTime.Now.MillisecondsSince1970();
 
-                if (_timeout == _timeoutDisabled ||
+                if (_timeout == TimeSpan.Zero ||
                     (currentTimestamp - item.CreationTimestamp < _timeout.TotalMilliseconds))
                 {
                     _list.Remove(node);
@@ -187,7 +183,7 @@ private class ItemWrapper
             /// Value of the item
             /// </summary>
             public readonly T Value;
-            
+
             /// <summary>
             /// Unix timestamp of when the item was added  
             /// </summary>

From 722780c5dfe63c7f6a7bb48f1c4a1248ffbe13c3 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Tue, 16 Aug 2022 16:40:02 -0400
Subject: [PATCH 20/21] Remove Tuple from LRU Cache

---
 OptimizelySDK.Tests/OdpTests/LruCacheTest.cs | 26 +++---
 OptimizelySDK/Odp/LruCache.cs                | 90 ++++++++++++--------
 2 files changed, 69 insertions(+), 47 deletions(-)

diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
index 2e56523a..a1443956 100644
--- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -68,7 +68,7 @@ public void ShouldSaveAndLookupMultipleItems()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            var cacheKeys = cache._readCurrentCacheKeys();
 
             Assert.AreEqual("user3", cacheKeys[0]);
             Assert.AreEqual("user2", cacheKeys[1]);
@@ -77,7 +77,7 @@ public void ShouldSaveAndLookupMultipleItems()
             // Lookup should move user1 to top of the list and push down others.
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
 
-            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            cacheKeys = cache._readCurrentCacheKeys();
             Assert.AreEqual("user1", cacheKeys[0]);
             Assert.AreEqual("user3", cacheKeys[1]);
             Assert.AreEqual("user2", cacheKeys[2]);
@@ -85,7 +85,7 @@ public void ShouldSaveAndLookupMultipleItems()
             // Lookup should move user2 to the beginning of the list and push others.
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
 
-            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            cacheKeys = cache._readCurrentCacheKeys();
             Assert.AreEqual("user2", cacheKeys[0]);
             Assert.AreEqual("user1", cacheKeys[1]);
             Assert.AreEqual("user3", cacheKeys[2]);
@@ -93,7 +93,7 @@ public void ShouldSaveAndLookupMultipleItems()
             // Lookup moves user3 to top and pushes others down.
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            cacheKeys = cache._readCurrentCacheKeys();
             Assert.AreEqual("user3", cacheKeys[0]);
             Assert.AreEqual("user2", cacheKeys[1]);
             Assert.AreEqual("user1", cacheKeys[2]);
@@ -108,7 +108,7 @@ public void ShouldReorderListOnSave()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            var cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            var cacheKeys = cache._readCurrentCacheKeys();
             
             // last added should be at the top of the list
             Assert.AreEqual("user3",cacheKeys[0]);
@@ -118,7 +118,7 @@ public void ShouldReorderListOnSave()
             // save should move user1 to the top of the list and push down others.
             cache.Save("user1", _segments1And2);
             
-            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            cacheKeys = cache._readCurrentCacheKeys();
             Assert.AreEqual("user1",cacheKeys[0]);
             Assert.AreEqual("user3",cacheKeys[1]);
             Assert.AreEqual("user2",cacheKeys[2]);
@@ -126,7 +126,7 @@ public void ShouldReorderListOnSave()
             // save user2 should bring it to the top and push down others.
             cache.Save("user2", _segments3And4);
             
-            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            cacheKeys = cache._readCurrentCacheKeys();
             Assert.AreEqual("user2",cacheKeys[0]);
             Assert.AreEqual("user1",cacheKeys[1]);
             Assert.AreEqual("user3",cacheKeys[2]);
@@ -134,7 +134,7 @@ public void ShouldReorderListOnSave()
             // saving user3 again should return to the original insertion order.
             cache.Save("user3", _segments5And6);
             
-            cacheKeys = cache._readCurrentCacheKeys().ToArray();
+            cacheKeys = cache._readCurrentCacheKeys();
             Assert.AreEqual("user3",cacheKeys[0]);
             Assert.AreEqual("user2",cacheKeys[1]);
             Assert.AreEqual("user1" ,cacheKeys[2]);
@@ -162,12 +162,12 @@ public void ShouldHandleWhenItemsExpire()
             cache.Save("user1", _segments1And2);
 
             Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
-            Assert.AreEqual(1, cache._readCurrentCacheKeys().Count);
+            Assert.AreEqual(1, cache._readCurrentCacheKeys().Length);
 
             Thread.Sleep(1200);
 
             Assert.IsNull(cache.Lookup("user1"));
-            Assert.AreEqual(0, cache._readCurrentCacheKeys().Count);
+            Assert.AreEqual(0, cache._readCurrentCacheKeys().Length);
         }
 
         [Test]
@@ -179,7 +179,7 @@ public void ShouldHandleWhenCacheReachesMaxSize()
             cache.Save("user2", _segments3And4);
             cache.Save("user3", _segments5And6);
 
-            Assert.AreEqual(2, cache._readCurrentCacheKeys().Count);
+            Assert.AreEqual(2, cache._readCurrentCacheKeys().Length);
 
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
@@ -199,7 +199,7 @@ public void ShouldHandleWhenCacheIsReset()
             Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
             Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
 
-            Assert.AreEqual(3, cache._readCurrentCacheKeys().Count);
+            Assert.AreEqual(3, cache._readCurrentCacheKeys().Length);
 
             cache.Reset();
 
@@ -207,7 +207,7 @@ public void ShouldHandleWhenCacheIsReset()
             Assert.IsNull(cache.Lookup("user2"));
             Assert.IsNull(cache.Lookup("user3"));
 
-            Assert.AreEqual(0, cache._readCurrentCacheKeys().Count);
+            Assert.AreEqual(0, cache._readCurrentCacheKeys().Length);
         }
     }
 }
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
index c83b3bcf..c7b04d86 100644
--- a/OptimizelySDK/Odp/LruCache.cs
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -18,6 +18,7 @@
 using OptimizelySDK.Utils;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace OptimizelySDK.Odp
 {
@@ -52,13 +53,12 @@ public class LruCache<T> : ICache<T>
         /// <summary>
         /// Indexed data held in the cache 
         /// </summary>
-        private readonly Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)>
-            _cache;
+        private readonly Dictionary<string, ItemWrapper> _cache;
 
         /// <summary>
         /// Ordered list of objects being held in the cache 
         /// </summary>
-        private readonly LinkedList<string> _list;
+        private readonly LinkedList<ItemWrapper> _list;
 
         /// <summary>
         /// A Least Recently Used in-memory cache
@@ -66,22 +66,27 @@ public class LruCache<T> : ICache<T>
         /// <param name="maxSize">Maximum number of elements to allow in the cache</param>
         /// <param name="itemTimeout">Timeout or time to live for each item</param>
         /// <param name="logger">Implementation used for recording LRU events or errors</param>
-        public LruCache(int maxSize = DEFAULT_MAX_SIZE,
-            TimeSpan? itemTimeout = default, ILogger logger = null
+        public LruCache(int maxSize = DEFAULT_MAX_SIZE, TimeSpan? itemTimeout = default,
+            ILogger logger = null
         )
         {
             _mutex = new object();
 
             _maxSize = Math.Max(0, maxSize);
 
-            _timeout =
-                TimeSpan.FromTicks(Math.Max(0, (itemTimeout ?? TimeSpan.FromMinutes(10)).Ticks));
-
             _logger = logger ?? new DefaultLogger();
 
-            _cache =
-                new Dictionary<string, (LinkedListNode<string> node, ItemWrapper value)>(_maxSize);
-            _list = new LinkedList<string>();
+            _timeout = itemTimeout ?? TimeSpan.FromMinutes(10);
+            if (_timeout < TimeSpan.Zero)
+            {
+                _logger.Log(LogLevel.WARN,
+                    "Negative item timeout provided. Items will not expire in cache.");
+                _timeout = TimeSpan.Zero;
+            }
+
+            _cache = new Dictionary<string, ItemWrapper>(_maxSize);
+
+            _list = new LinkedList<ItemWrapper>();
         }
 
         /// <summary>
@@ -93,7 +98,8 @@ public void Save(string key, T value)
         {
             if (_maxSize == 0)
             {
-                _logger.Log(LogLevel.WARN, "Unable to Save(). LRU Cache is disabled. Set maxSize > 0 to enable.");
+                _logger.Log(LogLevel.WARN,
+                    "Unable to Save(). LRU Cache is disabled. Set maxSize > 0 to enable.");
                 return;
             }
 
@@ -101,21 +107,32 @@ public void Save(string key, T value)
             {
                 if (_cache.ContainsKey(key))
                 {
-                    (LinkedListNode<string> node, ItemWrapper item) = _cache[key];
-                    _list.Remove(node);
-                    _list.AddFirst(node);
-                    _cache[key] = (node, item);
+                    var item = _cache[key];
+                    _list.Remove(item);
+                    _list.AddFirst(item);
+                    _cache[key] = item;
                 }
                 else
                 {
                     if (_cache.Count >= _maxSize)
                     {
-                        var removeKey = _list.Last.Value;
-                        _cache.Remove(removeKey);
-                        _list.RemoveLast();
+                        var leastRecentlyUsedItem = _list.Last;
+
+                        var leastRecentlyUsedItemKey = (from cacheItem in _cache
+                            where cacheItem.Value == leastRecentlyUsedItem.Value
+                            select cacheItem.Key).FirstOrDefault();
+
+                        if (leastRecentlyUsedItemKey != null)
+                        {
+                            _cache.Remove(leastRecentlyUsedItemKey);
+                        }
+
+                        _list.Remove(leastRecentlyUsedItem);
                     }
 
-                    _cache.Add(key, (_list.AddFirst(key), new ItemWrapper(value)));
+                    var item = new ItemWrapper(value);
+                    _list.AddFirst(item);
+                    _cache.Add(key, item);
                 }
             }
         }
@@ -129,7 +146,8 @@ public T Lookup(string key)
         {
             if (_maxSize == 0)
             {
-                _logger.Log(LogLevel.WARN, "Unable to Lookup(). LRU Cache is disabled. Set maxSize > 0 to enable.");
+                _logger.Log(LogLevel.WARN,
+                    "Unable to Lookup(). LRU Cache is disabled. Set maxSize > 0 to enable.");
                 return default;
             }
 
@@ -140,25 +158,26 @@ public T Lookup(string key)
                     return default;
                 }
 
-                (LinkedListNode<string> node, ItemWrapper item) = _cache[key];
+                ItemWrapper item = _cache[key];
 
                 var currentTimestamp = DateTime.Now.MillisecondsSince1970();
 
+                var itemReturn = default(T);
                 if (_timeout == TimeSpan.Zero ||
                     (currentTimestamp - item.CreationTimestamp < _timeout.TotalMilliseconds))
                 {
-                    _list.Remove(node);
-                    _list.AddFirst(node);
+                    _list.Remove(item);
+                    _list.AddFirst(item);
 
-                    _cache[key] = (node, item);
-
-                    return item.Value;
+                    itemReturn = item.Value;
+                }
+                else
+                {
+                    _cache.Remove(key);
+                    _list.Remove(item);
                 }
 
-                _cache.Remove(key);
-                _list.Remove(node);
-
-                return default;
+                return itemReturn;
             }
         }
 
@@ -177,7 +196,7 @@ public void Reset()
         /// <summary>
         /// Wrapping class around a generic value stored in the cache
         /// </summary>
-        private class ItemWrapper
+        public class ItemWrapper
         {
             /// <summary>
             /// Value of the item
@@ -204,10 +223,13 @@ public ItemWrapper(T value)
         /// Read the current cache index/linked list for unit testing
         /// </summary>
         /// <returns></returns>
-        public LinkedList<string> _readCurrentCacheKeys()
+        public string[] _readCurrentCacheKeys()
         {
             _logger.Log(LogLevel.WARN, "_readCurrentCacheKeys used for non-testing purpose");
-            return _list;
+
+            return (from listItem in _list
+                join cacheItem in _cache on listItem equals cacheItem.Value
+                select cacheItem.Key).ToArray();
         }
     }
 }

From ea2f32a0de876187d853c5b8f1da0b91faad82a1 Mon Sep 17 00:00:00 2001
From: Mike Chu <michael.chu@optimizely.com>
Date: Tue, 16 Aug 2022 16:43:18 -0400
Subject: [PATCH 21/21] Remove System.ValueTuple NuGet package

---
 OptimizelySDK/OptimizelySDK.csproj | 3 ---
 OptimizelySDK/packages.config      | 1 -
 2 files changed, 4 deletions(-)

diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 47805084..4d08ff70 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -54,9 +54,6 @@
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
     <Reference Include="System.Net.Http" />
-    <Reference Include="System.ValueTuple, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.ValueTuple.4.5.0\lib\netstandard1.0\System.ValueTuple.dll</HintPath>
-    </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="System.Data" />
diff --git a/OptimizelySDK/packages.config b/OptimizelySDK/packages.config
index de2ca84c..c8732913 100644
--- a/OptimizelySDK/packages.config
+++ b/OptimizelySDK/packages.config
@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="System.ValueTuple" version="4.5.0" targetFramework="net45" />
   <package id="murmurhash-signed" version="1.0.2" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net45" />
   <package id="NJsonSchema" version="8.30.6304.31883" targetFramework="net45" />