Run automatic code cleanup

thomasgalliker · thomasgalliker · commit 3cfdb0f66eef · 2022-05-07T12:01:05.000+02:00
diff --git a/HttpClient.Caching/Abstractions/CacheDataExtensions.cs b/HttpClient.Caching/Abstractions/CacheDataExtensions.cs
@@ -7,8 +7,8 @@ public static class CacheDataExtensions
     {
         public static byte[] Serialize(this CacheData cacheData)
         {
-            string json = JsonConvert.SerializeObject(cacheData);
-            byte[] bytes = new byte[json.Length * sizeof(char)];
+            var json = JsonConvert.SerializeObject(cacheData);
+            var bytes = new byte[json.Length * sizeof(char)];
             Buffer.BlockCopy(json.ToCharArray(), 0, bytes, 0, bytes.Length);
             return bytes;
         }
@@ -17,9 +17,9 @@ public static CacheData Deserialize(this byte[] cacheData)
         {
             try
             {
-                char[] chars = new char[cacheData.Length / sizeof(char)];
+                var chars = new char[cacheData.Length / sizeof(char)];
                 Buffer.BlockCopy(cacheData, 0, chars, 0, cacheData.Length);
-                string json = new string(chars);
+                var json = new string(chars);
                 var data = JsonConvert.DeserializeObject<CacheData>(json);
                 return data;
             }
diff --git a/HttpClient.Caching/Abstractions/CacheExtensions.cs b/HttpClient.Caching/Abstractions/CacheExtensions.cs
@@ -8,22 +8,19 @@ public static class CacheExtensions
     {
         public static object Get(this IMemoryCache cache, object key)
         {
-            object obj = null;
-            cache.TryGetValue(key, out obj);
+            cache.TryGetValue(key, out var obj);
             return obj;
         }
 
         public static TItem Get<TItem>(this IMemoryCache cache, object key)
         {
-            TItem obj;
-            cache.TryGetValue(key, out obj);
+            cache.TryGetValue(key, out TItem obj);
             return obj;
         }
 
         public static bool TryGetValue<TItem>(this IMemoryCache cache, object key, out TItem value)
         {
-            object obj;
-            if (cache.TryGetValue(key, out obj))
+            if (cache.TryGetValue(key, out var obj))
             {
                 value = (TItem)obj;
                 return true;
@@ -35,15 +32,15 @@ public static bool TryGetValue<TItem>(this IMemoryCache cache, object key, out T
 
         public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value)
         {
-            ICacheEntry entry = cache.CreateEntry(key);
+            var entry = cache.CreateEntry(key);
             entry.Value = value;
             entry.Dispose();
             return value;
         }
 
         public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, DateTimeOffset absoluteExpiration)
         {
-            ICacheEntry entry = cache.CreateEntry(key);
+            var entry = cache.CreateEntry(key);
             DateTimeOffset? nullable = absoluteExpiration;
             entry.AbsoluteExpiration = nullable;
             entry.Value = value;
@@ -53,7 +50,7 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,
 
         public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, TimeSpan absoluteExpirationRelativeToNow)
         {
-            ICacheEntry entry = cache.CreateEntry(key);
+            var entry = cache.CreateEntry(key);
             TimeSpan? nullable = absoluteExpirationRelativeToNow;
             entry.AbsoluteExpirationRelativeToNow = nullable;
             entry.Value = value;
@@ -63,8 +60,8 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,
 
         public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, IChangeToken expirationToken)
         {
-            ICacheEntry entry = cache.CreateEntry(key);
-            IChangeToken expirationToken1 = expirationToken;
+            var entry = cache.CreateEntry(key);
+            var expirationToken1 = expirationToken;
             entry.AddExpirationToken(expirationToken1);
             entry.Value = value;
             entry.Dispose();
@@ -73,7 +70,7 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,
 
         public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, MemoryCacheEntryOptions options)
         {
-            using (ICacheEntry entry = cache.CreateEntry(key))
+            using (var entry = cache.CreateEntry(key))
             {
                 if (options != null)
                 {
@@ -88,10 +85,9 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,
 
         public static TItem GetOrCreate<TItem>(this IMemoryCache cache, object key, Func<ICacheEntry, TItem> factory)
         {
-            object obj;
-            if (!cache.TryGetValue(key, out obj))
+            if (!cache.TryGetValue(key, out var obj))
             {
-                ICacheEntry entry = cache.CreateEntry(key);
+                var entry = cache.CreateEntry(key);
                 obj = factory(entry);
                 entry.SetValue(obj);
                 entry.Dispose();
@@ -102,10 +98,9 @@ public static TItem GetOrCreate<TItem>(this IMemoryCache cache, object key, Func
 
         public static async Task<TItem> GetOrCreateAsync<TItem>(this IMemoryCache cache, object key, Func<ICacheEntry, Task<TItem>> factory)
         {
-            object obj;
-            if (!cache.TryGetValue(key, out obj))
+            if (!cache.TryGetValue(key, out var obj))
             {
-                ICacheEntry entry = cache.CreateEntry(key);
+                var entry = cache.CreateEntry(key);
                 obj = await factory(entry);
                 entry.SetValue(obj);
                 entry.Dispose();
diff --git a/HttpClient.Caching/Abstractions/StatusCodeExtensions.cs b/HttpClient.Caching/Abstractions/StatusCodeExtensions.cs
@@ -17,11 +17,10 @@ public static class StatusCodeExtensions
         /// <returns>A TimeSpan that should be used for the given status code when putting it into the cache.</returns>
         public static TimeSpan GetAbsoluteExpirationRelativeToNow(this HttpStatusCode statusCode, IDictionary<HttpStatusCode, TimeSpan> mapping)
         {
-            int code = (int)statusCode;
-            TimeSpan expiration;
+            var code = (int)statusCode;
 
             // get the expiration settings for the given status code
-            if (mapping.TryGetValue(statusCode, out expiration))
+            if (mapping.TryGetValue(statusCode, out var expiration))
             {
                 return expiration;
             }
diff --git a/HttpClient.Caching/InMemory/CacheEntry.cs b/HttpClient.Caching/InMemory/CacheEntry.cs
@@ -159,8 +159,8 @@ private bool CheckForExpiredTime(DateTimeOffset now)
 
             if (this.slidingExpiration.HasValue)
             {
-                TimeSpan timeSpan = now - this.LastAccessed;
-                TimeSpan? slidingExpiration = this.slidingExpiration;
+                var timeSpan = now - this.LastAccessed;
+                var slidingExpiration = this.slidingExpiration;
                 if ((slidingExpiration.HasValue ? (timeSpan >= slidingExpiration.GetValueOrDefault() ? 1 : 0) : 0) != 0)
                 {
                     this.SetExpired(EvictionReason.Expired);
@@ -175,7 +175,7 @@ internal bool CheckForExpiredTokens()
         {
             if (this.expirationTokens != null)
             {
-                for (int index = 0; index < ((ICollection<IChangeToken>)this.expirationTokens).Count; ++index)
+                for (var index = 0; index < this.expirationTokens.Count; ++index)
                 {
                     if (this.expirationTokens[index].HasChanged)
                     {
@@ -197,9 +197,9 @@ internal void AttachTokens()
 
             lock (this.Lock)
             {
-                for (int i = 0; i < this.expirationTokens.Count; ++i)
+                for (var i = 0; i < this.expirationTokens.Count; ++i)
                 {
-                    IChangeToken expirationToken = this.expirationTokens[i];
+                    var expirationToken = this.expirationTokens[i];
                     if (expirationToken.ActiveChangeCallbacks)
                     {
                         if (this.expirationTokenRegistrations == null)
@@ -248,10 +248,10 @@ internal void InvokeEvictionCallbacks()
                 return;
             }
 
-            TaskFactory factory = Task.Factory;
-            CancellationToken none = CancellationToken.None;
-            TaskScheduler scheduler = TaskScheduler.Default;
-            factory.StartNew((Action<object>)(state => InvokeCallbacks((CacheEntry)state)), (object)this, none, TaskCreationOptions.DenyChildAttach, scheduler);
+            var factory = Task.Factory;
+            var none = CancellationToken.None;
+            var scheduler = TaskScheduler.Default;
+            factory.StartNew(state => InvokeCallbacks((CacheEntry)state), this, none, TaskCreationOptions.DenyChildAttach, scheduler);
         }
 
         private static void InvokeCallbacks(CacheEntry entry)
diff --git a/HttpClient.Caching/InMemory/CacheEntryExtensions.cs b/HttpClient.Caching/InMemory/CacheEntryExtensions.cs
@@ -78,7 +78,7 @@ public static ICacheEntry RegisterPostEvictionCallback(this ICacheEntry entry, P
                 throw new ArgumentNullException("callback");
             }
 
-            return entry.RegisterPostEvictionCallback(callback, (object)null);
+            return entry.RegisterPostEvictionCallback(callback, null);
         }
 
         /// <summary>
diff --git a/HttpClient.Caching/InMemory/IMemoryCacheExtensions.cs b/HttpClient.Caching/InMemory/IMemoryCacheExtensions.cs
@@ -19,8 +19,7 @@ public static Task<CacheData> TryGetAsync(this IMemoryCache cache, string key)
         {
             try
             {
-                byte[] binaryData = null;
-                if (cache.TryGetValue(key, out binaryData))
+                if (cache.TryGetValue(key, out byte[] binaryData))
                 {
                     return Task.FromResult(binaryData.Deserialize());
                 }
@@ -49,7 +48,7 @@ public static Task TrySetAsync(this IMemoryCache cache, string key, CacheData va
                 cache.Set(key, value.Serialize(), absoluteExpirationRelativeToNow);
                 return Task.FromResult(true);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 // ignore all exceptions
                 return Task.FromResult(false);
diff --git a/HttpClient.Caching/InMemory/InMemoryCacheHandler.cs b/HttpClient.Caching/InMemory/InMemoryCacheHandler.cs
@@ -23,7 +23,7 @@ public class InMemoryCacheHandler : DelegatingHandler
         /// Cache key provider being used
         /// </summary>
         public ICacheKeysProvider CacheKeysProvider { get; }
-        
+
 
         /// <summary>
         ///     Create a new InMemoryCacheHandler.
@@ -93,7 +93,7 @@ public void InvalidateCache(Uri uri, HttpMethod method = null)
             foreach (var m in methods)
             {
                 var request = new HttpRequestMessage(m, uri);
-                var key = CacheKeysProvider.GetKey(request);
+                var key = this.CacheKeysProvider.GetKey(request);
                 this.responseCache.Remove(key);
             }
         }
diff --git a/HttpClient.Caching/InMemory/Internal/SystemClock.cs b/HttpClient.Caching/InMemory/Internal/SystemClock.cs
@@ -8,9 +8,6 @@ namespace Microsoft.Extensions.Caching.InMemory.Internal
     public class SystemClock : ISystemClock
     {
         /// <summary>Retrieves the current system time in UTC.</summary>
-        public DateTimeOffset UtcNow
-        {
-            get { return DateTimeOffset.UtcNow; }
-        }
+        public DateTimeOffset UtcNow => DateTimeOffset.UtcNow;
     }
 }
diff --git a/HttpClient.Caching/InMemory/MemoryCache.cs b/HttpClient.Caching/InMemory/MemoryCache.cs
@@ -19,15 +19,9 @@ public class MemoryCache : IMemoryCache
         private readonly TimeSpan expirationScanFrequency;
         private DateTimeOffset lastExpirationScan;
 
-        public int Count
-        {
-            get { return this.entries.Count; }
-        }
+        public int Count => this.entries.Count;
 
-        private ICollection<KeyValuePair<object, CacheEntry>> EntriesCollection
-        {
-            get { return this.entries; }
-        }
+        private ICollection<KeyValuePair<object, CacheEntry>> EntriesCollection => this.entries;
 
         public MemoryCache() : this(new MemoryCacheOptions())
         {
@@ -66,12 +60,12 @@ private void SetEntry(CacheEntry entry)
                 return;
             }
 
-            DateTimeOffset utcNow = this.clock.UtcNow;
-            DateTimeOffset? nullable = new DateTimeOffset?();
+            var utcNow = this.clock.UtcNow;
+            var nullable = new DateTimeOffset?();
             if (entry.absoluteExpirationRelativeToNow.HasValue)
             {
-                DateTimeOffset dateTimeOffset = utcNow;
-                TimeSpan? expirationRelativeToNow = entry.absoluteExpirationRelativeToNow;
+                var dateTimeOffset = utcNow;
+                var expirationRelativeToNow = entry.absoluteExpirationRelativeToNow;
                 nullable = expirationRelativeToNow.HasValue ? dateTimeOffset + expirationRelativeToNow.GetValueOrDefault() : new DateTimeOffset?();
             }
             else if (entry.absoluteExpiration.HasValue)
@@ -142,10 +136,9 @@ public bool TryGetValue(object key, out object result)
 
             this.CheckDisposed();
             result = null;
-            DateTimeOffset utcNow = this.clock.UtcNow;
-            bool flag = false;
-            CacheEntry entry;
-            if (this.entries.TryGetValue(key, out entry))
+            var utcNow = this.clock.UtcNow;
+            var flag = false;
+            if (this.entries.TryGetValue(key, out var entry))
             {
                 if (entry.CheckExpired(utcNow) && entry.EvictionReason != EvictionReason.Replaced)
                 {
@@ -172,8 +165,7 @@ public void Remove(object key)
             }
 
             this.CheckDisposed();
-            CacheEntry cacheEntry;
-            if (this.entries.TryRemove(key, out cacheEntry))
+            if (this.entries.TryRemove(key, out var cacheEntry))
             {
                 cacheEntry.SetExpired(EvictionReason.Removed);
                 cacheEntry.InvokeEvictionCallbacks();
@@ -216,22 +208,22 @@ private void EntryExpired(CacheEntry entry)
 
         private void StartScanForExpiredItems()
         {
-            DateTimeOffset utcNow = this.clock.UtcNow;
+            var utcNow = this.clock.UtcNow;
             if (!(this.expirationScanFrequency < utcNow - this.lastExpirationScan))
             {
                 return;
             }
 
             this.lastExpirationScan = utcNow;
-            TaskFactory factory = Task.Factory;
-            CancellationToken none = CancellationToken.None;
-            TaskScheduler scheduler = TaskScheduler.Default;
+            var factory = Task.Factory;
+            var none = CancellationToken.None;
+            var scheduler = TaskScheduler.Default;
             factory.StartNew(state => ScanForExpiredItems((MemoryCache)state), this, none, TaskCreationOptions.DenyChildAttach, scheduler);
         }
 
         private static void ScanForExpiredItems(MemoryCache cache)
         {
-            DateTimeOffset utcNow = cache.clock.UtcNow;
+            var utcNow = cache.clock.UtcNow;
             foreach (var entry in cache.entries.Values)
             {
                 if (entry.CheckExpired(utcNow))
@@ -243,13 +235,13 @@ private static void ScanForExpiredItems(MemoryCache cache)
 
         public void Compact(double percentage)
         {
-            List<CacheEntry> entriesToRemove = new List<CacheEntry>();
-            List<CacheEntry> priorityEntries1 = new List<CacheEntry>();
-            List<CacheEntry> priorityEntries2 = new List<CacheEntry>();
-            List<CacheEntry> priorityEntries3 = new List<CacheEntry>();
-            DateTimeOffset utcNow = this.clock.UtcNow;
+            var entriesToRemove = new List<CacheEntry>();
+            var priorityEntries1 = new List<CacheEntry>();
+            var priorityEntries2 = new List<CacheEntry>();
+            var priorityEntries3 = new List<CacheEntry>();
+            var utcNow = this.clock.UtcNow;
 
-            foreach (CacheEntry cacheEntry in this.entries.Values)
+            foreach (var cacheEntry in this.entries.Values)
             {
                 if (cacheEntry.CheckExpired(utcNow))
                 {
@@ -271,12 +263,12 @@ public void Compact(double percentage)
                         case 3:
                             continue;
                         default:
-                            throw new NotSupportedException("Not implemented: " + (object)cacheEntry.Priority);
+                            throw new NotSupportedException("Not implemented: " + cacheEntry.Priority);
                     }
                 }
             }
 
-            int removalCountTarget = (int)(this.entries.Count * percentage);
+            var removalCountTarget = (int)(this.entries.Count * percentage);
             this.ExpirePriorityBucket(removalCountTarget, entriesToRemove, priorityEntries1);
             this.ExpirePriorityBucket(removalCountTarget, entriesToRemove, priorityEntries2);
             this.ExpirePriorityBucket(removalCountTarget, entriesToRemove, priorityEntries3);
diff --git a/HttpClient.Caching/InMemory/MemoryCacheEntryOptions.cs b/HttpClient.Caching/InMemory/MemoryCacheEntryOptions.cs
@@ -41,8 +41,8 @@ public TimeSpan? AbsoluteExpirationRelativeToNow
             get { return this.absoluteExpirationRelativeToNow; }
             set
             {
-                TimeSpan? nullable = value;
-                TimeSpan zero = TimeSpan.Zero;
+                var nullable = value;
+                var zero = TimeSpan.Zero;
                 if ((nullable.HasValue ? (nullable.GetValueOrDefault() <= zero ? 1 : 0) : 0) != 0)
                 {
                     throw new ArgumentOutOfRangeException(nameof(this.AbsoluteExpirationRelativeToNow), value, "The relative expiration value must be positive.");
@@ -61,8 +61,8 @@ public TimeSpan? SlidingExpiration
             get { return this.slidingExpiration; }
             set
             {
-                TimeSpan? nullable = value;
-                TimeSpan zero = TimeSpan.Zero;
+                var nullable = value;
+                var zero = TimeSpan.Zero;
                 if ((nullable.HasValue ? (nullable.GetValueOrDefault() <= zero ? 1 : 0) : 0) != 0)
                 {
                     throw new ArgumentOutOfRangeException(nameof(this.SlidingExpiration), value, "The sliding expiration value must be positive.");
diff --git a/HttpClient.Caching/Properties/AssemblyConfig.cs b/HttpClient.Caching/Properties/AssemblyConfig.cs
@@ -1,3 +1,3 @@
 ﻿using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("HttpClient.Caching.Tests")]
+[assembly: InternalsVisibleTo("HttpClient.Caching.Tests")] 
diff --git a/Samples/ConsoleAppSample/Program.cs b/Samples/ConsoleAppSample/Program.cs
diff --git a/Tests/HttpClient.Caching.Tests/Abstractions/StatsResultTests.cs b/Tests/HttpClient.Caching.Tests/Abstractions/StatsResultTests.cs
diff --git a/Tests/HttpClient.Caching.Tests/Abstractions/StatusCodeExtensionsTests.cs b/Tests/HttpClient.Caching.Tests/Abstractions/StatusCodeExtensionsTests.cs
diff --git a/Tests/HttpClient.Caching.Tests/InMemory/InMemoryCacheHandlerTests.cs b/Tests/HttpClient.Caching.Tests/InMemory/InMemoryCacheHandlerTests.cs
diff --git a/Tests/HttpClient.Caching.Tests/InMemory/MethodUriHeadersCacheKeysProviderTests.cs b/Tests/HttpClient.Caching.Tests/InMemory/MethodUriHeadersCacheKeysProviderTests.cs

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,8 @@ public static class CacheDataExtensions`
`7`	`7`	`{`
`8`	`8`	`public static byte[] Serialize(this CacheData cacheData)`
`9`	`9`	`{`
`10`		`- string json = JsonConvert.SerializeObject(cacheData);`
`11`		`- byte[] bytes = new byte[json.Length * sizeof(char)];`
	`10`	`+ var json = JsonConvert.SerializeObject(cacheData);`
	`11`	`+ var bytes = new byte[json.Length * sizeof(char)];`
`12`	`12`	`Buffer.BlockCopy(json.ToCharArray(), 0, bytes, 0, bytes.Length);`
`13`	`13`	`return bytes;`
`14`	`14`	`}`
`@@ -17,9 +17,9 @@ public static CacheData Deserialize(this byte[] cacheData)`
`17`	`17`	`{`
`18`	`18`	`try`
`19`	`19`	`{`
`20`		`- char[] chars = new char[cacheData.Length / sizeof(char)];`
	`20`	`+ var chars = new char[cacheData.Length / sizeof(char)];`
`21`	`21`	`Buffer.BlockCopy(cacheData, 0, chars, 0, cacheData.Length);`
`22`		`- string json = new string(chars);`
	`22`	`+ var json = new string(chars);`
`23`	`23`	`var data = JsonConvert.DeserializeObject<CacheData>(json);`
`24`	`24`	`return data;`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,22 +8,19 @@ public static class CacheExtensions`
`8`	`8`	`{`
`9`	`9`	`public static object Get(this IMemoryCache cache, object key)`
`10`	`10`	`{`
`11`		`- object obj = null;`
`12`		`- cache.TryGetValue(key, out obj);`
	`11`	`+ cache.TryGetValue(key, out var obj);`
`13`	`12`	`return obj;`
`14`	`13`	`}`
`15`	`14`
`16`	`15`	`public static TItem Get<TItem>(this IMemoryCache cache, object key)`
`17`	`16`	`{`
`18`		`- TItem obj;`
`19`		`- cache.TryGetValue(key, out obj);`
	`17`	`+ cache.TryGetValue(key, out TItem obj);`
`20`	`18`	`return obj;`
`21`	`19`	`}`
`22`	`20`
`23`	`21`	`public static bool TryGetValue<TItem>(this IMemoryCache cache, object key, out TItem value)`
`24`	`22`	`{`
`25`		`- object obj;`
`26`		`- if (cache.TryGetValue(key, out obj))`
	`23`	`+ if (cache.TryGetValue(key, out var obj))`
`27`	`24`	`{`
`28`	`25`	`value = (TItem)obj;`
`29`	`26`	`return true;`
`@@ -35,15 +32,15 @@ public static bool TryGetValue<TItem>(this IMemoryCache cache, object key, out T`
`35`	`32`
`36`	`33`	`public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value)`
`37`	`34`	`{`
`38`		`- ICacheEntry entry = cache.CreateEntry(key);`
	`35`	`+ var entry = cache.CreateEntry(key);`
`39`	`36`	`entry.Value = value;`
`40`	`37`	`entry.Dispose();`
`41`	`38`	`return value;`
`42`	`39`	`}`
`43`	`40`
`44`	`41`	`public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, DateTimeOffset absoluteExpiration)`
`45`	`42`	`{`
`46`		`- ICacheEntry entry = cache.CreateEntry(key);`
	`43`	`+ var entry = cache.CreateEntry(key);`
`47`	`44`	`DateTimeOffset? nullable = absoluteExpiration;`
`48`	`45`	`entry.AbsoluteExpiration = nullable;`
`49`	`46`	`entry.Value = value;`
`@@ -53,7 +50,7 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,`
`53`	`50`
`54`	`51`	`public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, TimeSpan absoluteExpirationRelativeToNow)`
`55`	`52`	`{`
`56`		`- ICacheEntry entry = cache.CreateEntry(key);`
	`53`	`+ var entry = cache.CreateEntry(key);`
`57`	`54`	`TimeSpan? nullable = absoluteExpirationRelativeToNow;`
`58`	`55`	`entry.AbsoluteExpirationRelativeToNow = nullable;`
`59`	`56`	`entry.Value = value;`
`@@ -63,8 +60,8 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,`
`63`	`60`
`64`	`61`	`public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, IChangeToken expirationToken)`
`65`	`62`	`{`
`66`		`- ICacheEntry entry = cache.CreateEntry(key);`
`67`		`- IChangeToken expirationToken1 = expirationToken;`
	`63`	`+ var entry = cache.CreateEntry(key);`
	`64`	`+ var expirationToken1 = expirationToken;`
`68`	`65`	`entry.AddExpirationToken(expirationToken1);`
`69`	`66`	`entry.Value = value;`
`70`	`67`	`entry.Dispose();`
`@@ -73,7 +70,7 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,`
`73`	`70`
`74`	`71`	`public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value, MemoryCacheEntryOptions options)`
`75`	`72`	`{`
`76`		`- using (ICacheEntry entry = cache.CreateEntry(key))`
	`73`	`+ using (var entry = cache.CreateEntry(key))`
`77`	`74`	`{`
`78`	`75`	`if (options != null)`
`79`	`76`	`{`
`@@ -88,10 +85,9 @@ public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value,`
`88`	`85`
`89`	`86`	`public static TItem GetOrCreate<TItem>(this IMemoryCache cache, object key, Func<ICacheEntry, TItem> factory)`
`90`	`87`	`{`
`91`		`- object obj;`
`92`		`- if (!cache.TryGetValue(key, out obj))`
	`88`	`+ if (!cache.TryGetValue(key, out var obj))`
`93`	`89`	`{`
`94`		`- ICacheEntry entry = cache.CreateEntry(key);`
	`90`	`+ var entry = cache.CreateEntry(key);`
`95`	`91`	`obj = factory(entry);`
`96`	`92`	`entry.SetValue(obj);`
`97`	`93`	`entry.Dispose();`
`@@ -102,10 +98,9 @@ public static TItem GetOrCreate<TItem>(this IMemoryCache cache, object key, Func`
`102`	`98`
`103`	`99`	`public static async Task<TItem> GetOrCreateAsync<TItem>(this IMemoryCache cache, object key, Func<ICacheEntry, Task<TItem>> factory)`
`104`	`100`	`{`
`105`		`- object obj;`
`106`		`- if (!cache.TryGetValue(key, out obj))`
	`101`	`+ if (!cache.TryGetValue(key, out var obj))`
`107`	`102`	`{`
`108`		`- ICacheEntry entry = cache.CreateEntry(key);`
	`103`	`+ var entry = cache.CreateEntry(key);`
`109`	`104`	`obj = await factory(entry);`
`110`	`105`	`entry.SetValue(obj);`
`111`	`106`	`entry.Dispose();`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,10 @@ public static class StatusCodeExtensions`
`17`	`17`	`/// <returns>A TimeSpan that should be used for the given status code when putting it into the cache.</returns>`
`18`	`18`	`public static TimeSpan GetAbsoluteExpirationRelativeToNow(this HttpStatusCode statusCode, IDictionary<HttpStatusCode, TimeSpan> mapping)`
`19`	`19`	`{`
`20`		`- int code = (int)statusCode;`
`21`		`- TimeSpan expiration;`
	`20`	`+ var code = (int)statusCode;`
`22`	`21`
`23`	`22`	`// get the expiration settings for the given status code`
`24`		`- if (mapping.TryGetValue(statusCode, out expiration))`
	`23`	`+ if (mapping.TryGetValue(statusCode, out var expiration))`
`25`	`24`	`{`
`26`	`25`	`return expiration;`
`27`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -159,8 +159,8 @@ private bool CheckForExpiredTime(DateTimeOffset now)`
`159`	`159`
`160`	`160`	`if (this.slidingExpiration.HasValue)`
`161`	`161`	`{`
`162`		`- TimeSpan timeSpan = now - this.LastAccessed;`
`163`		`- TimeSpan? slidingExpiration = this.slidingExpiration;`
	`162`	`+ var timeSpan = now - this.LastAccessed;`
	`163`	`+ var slidingExpiration = this.slidingExpiration;`
`164`	`164`	`if ((slidingExpiration.HasValue ? (timeSpan >= slidingExpiration.GetValueOrDefault() ? 1 : 0) : 0) != 0)`
`165`	`165`	`{`
`166`	`166`	`this.SetExpired(EvictionReason.Expired);`
`@@ -175,7 +175,7 @@ internal bool CheckForExpiredTokens()`
`175`	`175`	`{`
`176`	`176`	`if (this.expirationTokens != null)`
`177`	`177`	`{`
`178`		`- for (int index = 0; index < ((ICollection<IChangeToken>)this.expirationTokens).Count; ++index)`
	`178`	`+ for (var index = 0; index < this.expirationTokens.Count; ++index)`
`179`	`179`	`{`
`180`	`180`	`if (this.expirationTokens[index].HasChanged)`
`181`	`181`	`{`
`@@ -197,9 +197,9 @@ internal void AttachTokens()`
`197`	`197`
`198`	`198`	`lock (this.Lock)`
`199`	`199`	`{`
`200`		`- for (int i = 0; i < this.expirationTokens.Count; ++i)`
	`200`	`+ for (var i = 0; i < this.expirationTokens.Count; ++i)`
`201`	`201`	`{`
`202`		`- IChangeToken expirationToken = this.expirationTokens[i];`
	`202`	`+ var expirationToken = this.expirationTokens[i];`
`203`	`203`	`if (expirationToken.ActiveChangeCallbacks)`
`204`	`204`	`{`
`205`	`205`	`if (this.expirationTokenRegistrations == null)`
`@@ -248,10 +248,10 @@ internal void InvokeEvictionCallbacks()`
`248`	`248`	`return;`
`249`	`249`	`}`
`250`	`250`
`251`		`- TaskFactory factory = Task.Factory;`
`252`		`- CancellationToken none = CancellationToken.None;`
`253`		`- TaskScheduler scheduler = TaskScheduler.Default;`
`254`		`- factory.StartNew((Action<object>)(state => InvokeCallbacks((CacheEntry)state)), (object)this, none, TaskCreationOptions.DenyChildAttach, scheduler);`
	`251`	`+ var factory = Task.Factory;`
	`252`	`+ var none = CancellationToken.None;`
	`253`	`+ var scheduler = TaskScheduler.Default;`
	`254`	`+ factory.StartNew(state => InvokeCallbacks((CacheEntry)state), this, none, TaskCreationOptions.DenyChildAttach, scheduler);`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`private static void InvokeCallbacks(CacheEntry entry)`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public static ICacheEntry RegisterPostEvictionCallback(this ICacheEntry entry, P`
`78`	`78`	`throw new ArgumentNullException("callback");`
`79`	`79`	`}`
`80`	`80`
`81`		`- return entry.RegisterPostEvictionCallback(callback, (object)null);`
	`81`	`+ return entry.RegisterPostEvictionCallback(callback, null);`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,7 @@ public static Task<CacheData> TryGetAsync(this IMemoryCache cache, string key)`
`19`	`19`	`{`
`20`	`20`	`try`
`21`	`21`	`{`
`22`		`- byte[] binaryData = null;`
`23`		`- if (cache.TryGetValue(key, out binaryData))`
	`22`	`+ if (cache.TryGetValue(key, out byte[] binaryData))`
`24`	`23`	`{`
`25`	`24`	`return Task.FromResult(binaryData.Deserialize());`
`26`	`25`	`}`
`@@ -49,7 +48,7 @@ public static Task TrySetAsync(this IMemoryCache cache, string key, CacheData va`
`49`	`48`	`cache.Set(key, value.Serialize(), absoluteExpirationRelativeToNow);`
`50`	`49`	`return Task.FromResult(true);`
`51`	`50`	`}`
`52`		`- catch (Exception ex)`
	`51`	`+ catch (Exception)`
`53`	`52`	`{`
`54`	`53`	`// ignore all exceptions`
`55`	`54`	`return Task.FromResult(false);`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public class InMemoryCacheHandler : DelegatingHandler`
`23`	`23`	`/// Cache key provider being used`
`24`	`24`	`/// </summary>`
`25`	`25`	`public ICacheKeysProvider CacheKeysProvider { get; }`
`26`		`-`
	`26`	`+`
`27`	`27`
`28`	`28`	`/// <summary>`
`29`	`29`	`/// Create a new InMemoryCacheHandler.`
`@@ -93,7 +93,7 @@ public void InvalidateCache(Uri uri, HttpMethod method = null)`
`93`	`93`	`foreach (var m in methods)`
`94`	`94`	`{`
`95`	`95`	`var request = new HttpRequestMessage(m, uri);`
`96`		`- var key = CacheKeysProvider.GetKey(request);`
	`96`	`+ var key = this.CacheKeysProvider.GetKey(request);`
`97`	`97`	`this.responseCache.Remove(key);`
`98`	`98`	`}`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,6 @@ namespace Microsoft.Extensions.Caching.InMemory.Internal`
`8`	`8`	`public class SystemClock : ISystemClock`
`9`	`9`	`{`
`10`	`10`	`/// <summary>Retrieves the current system time in UTC.</summary>`
`11`		`- public DateTimeOffset UtcNow`
`12`		`- {`
`13`		`- get { return DateTimeOffset.UtcNow; }`
`14`		`- }`
	`11`	`+ public DateTimeOffset UtcNow => DateTimeOffset.UtcNow;`
`15`	`12`	`}`
`16`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,9 @@ public class MemoryCache : IMemoryCache`
`19`	`19`	`private readonly TimeSpan expirationScanFrequency;`
`20`	`20`	`private DateTimeOffset lastExpirationScan;`
`21`	`21`
`22`		`- public int Count`
`23`		`- {`
`24`		`- get { return this.entries.Count; }`
`25`		`- }`
	`22`	`+ public int Count => this.entries.Count;`
`26`	`23`
`27`		`- private ICollection<KeyValuePair<object, CacheEntry>> EntriesCollection`
`28`		`- {`
`29`		`- get { return this.entries; }`
`30`		`- }`
	`24`	`+ private ICollection<KeyValuePair<object, CacheEntry>> EntriesCollection => this.entries;`
`31`	`25`
`32`	`26`	`public MemoryCache() : this(new MemoryCacheOptions())`
`33`	`27`	`{`
`@@ -66,12 +60,12 @@ private void SetEntry(CacheEntry entry)`
`66`	`60`	`return;`
`67`	`61`	`}`
`68`	`62`
`69`		`- DateTimeOffset utcNow = this.clock.UtcNow;`
`70`		`- DateTimeOffset? nullable = new DateTimeOffset?();`
	`63`	`+ var utcNow = this.clock.UtcNow;`
	`64`	`+ var nullable = new DateTimeOffset?();`
`71`	`65`	`if (entry.absoluteExpirationRelativeToNow.HasValue)`
`72`	`66`	`{`
`73`		`- DateTimeOffset dateTimeOffset = utcNow;`
`74`		`- TimeSpan? expirationRelativeToNow = entry.absoluteExpirationRelativeToNow;`
	`67`	`+ var dateTimeOffset = utcNow;`
	`68`	`+ var expirationRelativeToNow = entry.absoluteExpirationRelativeToNow;`
`75`	`69`	`nullable = expirationRelativeToNow.HasValue ? dateTimeOffset + expirationRelativeToNow.GetValueOrDefault() : new DateTimeOffset?();`
`76`	`70`	`}`
`77`	`71`	`else if (entry.absoluteExpiration.HasValue)`
`@@ -142,10 +136,9 @@ public bool TryGetValue(object key, out object result)`
`142`	`136`
`143`	`137`	`this.CheckDisposed();`
`144`	`138`	`result = null;`
`145`		`- DateTimeOffset utcNow = this.clock.UtcNow;`
`146`		`- bool flag = false;`
`147`		`- CacheEntry entry;`
`148`		`- if (this.entries.TryGetValue(key, out entry))`
	`139`	`+ var utcNow = this.clock.UtcNow;`
	`140`	`+ var flag = false;`
	`141`	`+ if (this.entries.TryGetValue(key, out var entry))`
`149`	`142`	`{`
`150`	`143`	`if (entry.CheckExpired(utcNow) && entry.EvictionReason != EvictionReason.Replaced)`
`151`	`144`	`{`
`@@ -172,8 +165,7 @@ public void Remove(object key)`
`172`	`165`	`}`
`173`	`166`
`174`	`167`	`this.CheckDisposed();`
`175`		`- CacheEntry cacheEntry;`
`176`		`- if (this.entries.TryRemove(key, out cacheEntry))`
	`168`	`+ if (this.entries.TryRemove(key, out var cacheEntry))`
`177`	`169`	`{`
`178`	`170`	`cacheEntry.SetExpired(EvictionReason.Removed);`
`179`	`171`	`cacheEntry.InvokeEvictionCallbacks();`
`@@ -216,22 +208,22 @@ private void EntryExpired(CacheEntry entry)`
`216`	`208`
`217`	`209`	`private void StartScanForExpiredItems()`
`218`	`210`	`{`
`219`		`- DateTimeOffset utcNow = this.clock.UtcNow;`
	`211`	`+ var utcNow = this.clock.UtcNow;`
`220`	`212`	`if (!(this.expirationScanFrequency < utcNow - this.lastExpirationScan))`
`221`	`213`	`{`
`222`	`214`	`return;`
`223`	`215`	`}`
`224`	`216`
`225`	`217`	`this.lastExpirationScan = utcNow;`
`226`		`- TaskFactory factory = Task.Factory;`
`227`		`- CancellationToken none = CancellationToken.None;`
`228`		`- TaskScheduler scheduler = TaskScheduler.Default;`
	`218`	`+ var factory = Task.Factory;`
	`219`	`+ var none = CancellationToken.None;`
	`220`	`+ var scheduler = TaskScheduler.Default;`
`229`	`221`	`factory.StartNew(state => ScanForExpiredItems((MemoryCache)state), this, none, TaskCreationOptions.DenyChildAttach, scheduler);`
`230`	`222`	`}`
`231`	`223`
`232`	`224`	`private static void ScanForExpiredItems(MemoryCache cache)`
`233`	`225`	`{`
`234`		`- DateTimeOffset utcNow = cache.clock.UtcNow;`
	`226`	`+ var utcNow = cache.clock.UtcNow;`
`235`	`227`	`foreach (var entry in cache.entries.Values)`
`236`	`228`	`{`
`237`	`229`	`if (entry.CheckExpired(utcNow))`
`@@ -243,13 +235,13 @@ private static void ScanForExpiredItems(MemoryCache cache)`
`243`	`235`
`244`	`236`	`public void Compact(double percentage)`
`245`	`237`	`{`
`246`		`- List<CacheEntry> entriesToRemove = new List<CacheEntry>();`
`247`		`- List<CacheEntry> priorityEntries1 = new List<CacheEntry>();`
`248`		`- List<CacheEntry> priorityEntries2 = new List<CacheEntry>();`
`249`		`- List<CacheEntry> priorityEntries3 = new List<CacheEntry>();`
`250`		`- DateTimeOffset utcNow = this.clock.UtcNow;`
	`238`	`+ var entriesToRemove = new List<CacheEntry>();`
	`239`	`+ var priorityEntries1 = new List<CacheEntry>();`
	`240`	`+ var priorityEntries2 = new List<CacheEntry>();`
	`241`	`+ var priorityEntries3 = new List<CacheEntry>();`
	`242`	`+ var utcNow = this.clock.UtcNow;`
`251`	`243`
`252`		`- foreach (CacheEntry cacheEntry in this.entries.Values)`
	`244`	`+ foreach (var cacheEntry in this.entries.Values)`
`253`	`245`	`{`
`254`	`246`	`if (cacheEntry.CheckExpired(utcNow))`
`255`	`247`	`{`
`@@ -271,12 +263,12 @@ public void Compact(double percentage)`
`271`	`263`	`case 3:`
`272`	`264`	`continue;`
`273`	`265`	`default:`
`274`		`- throw new NotSupportedException("Not implemented: " + (object)cacheEntry.Priority);`
	`266`	`+ throw new NotSupportedException("Not implemented: " + cacheEntry.Priority);`
`275`	`267`	`}`
`276`	`268`	`}`
`277`	`269`	`}`
`278`	`270`
`279`		`- int removalCountTarget = (int)(this.entries.Count * percentage);`
	`271`	`+ var removalCountTarget = (int)(this.entries.Count * percentage);`
`280`	`272`	`this.ExpirePriorityBucket(removalCountTarget, entriesToRemove, priorityEntries1);`
`281`	`273`	`this.ExpirePriorityBucket(removalCountTarget, entriesToRemove, priorityEntries2);`
`282`	`274`	`this.ExpirePriorityBucket(removalCountTarget, entriesToRemove, priorityEntries3);`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ public TimeSpan? AbsoluteExpirationRelativeToNow`
`41`	`41`	`get { return this.absoluteExpirationRelativeToNow; }`
`42`	`42`	`set`
`43`	`43`	`{`
`44`		`- TimeSpan? nullable = value;`
`45`		`- TimeSpan zero = TimeSpan.Zero;`
	`44`	`+ var nullable = value;`
	`45`	`+ var zero = TimeSpan.Zero;`
`46`	`46`	`if ((nullable.HasValue ? (nullable.GetValueOrDefault() <= zero ? 1 : 0) : 0) != 0)`
`47`	`47`	`{`
`48`	`48`	`throw new ArgumentOutOfRangeException(nameof(this.AbsoluteExpirationRelativeToNow), value, "The relative expiration value must be positive.");`
`@@ -61,8 +61,8 @@ public TimeSpan? SlidingExpiration`
`61`	`61`	`get { return this.slidingExpiration; }`
`62`	`62`	`set`
`63`	`63`	`{`
`64`		`- TimeSpan? nullable = value;`
`65`		`- TimeSpan zero = TimeSpan.Zero;`
	`64`	`+ var nullable = value;`
	`65`	`+ var zero = TimeSpan.Zero;`
`66`	`66`	`if ((nullable.HasValue ? (nullable.GetValueOrDefault() <= zero ? 1 : 0) : 0) != 0)`
`67`	`67`	`{`
`68`	`68`	`throw new ArgumentOutOfRangeException(nameof(this.SlidingExpiration), value, "The sliding expiration value must be positive.");`