NonBlockingAsyncCache: Fixes lambda func capturing the outer context (memory optimization) (#4470)

# Pull Request Template

## Description

Set createValueFunc to null once the Func delegate is not needed.
Without breaking the reference, the lambda function will keep capturing
of any outer variables, in #4345, DocumentServiceRequest was captured,
which prevent GC from recycling the request object, cause memory leak.

Below code, the request object will be captured by singleValueInitFunc
delegate.

```
addresses = await this.serverPartitionAddressCache.GetAsync( 
                         key: partitionKeyRangeIdentity, 
                         singleValueInitFunc: (_) => this.GetAddressesForRangeIdAsync( 
                             request, 
                             cachedAddresses: null, 
                             partitionKeyRangeIdentity.CollectionRid, 
                             partitionKeyRangeIdentity.PartitionKeyRangeId, 
                             forceRefresh: false), 
                         forceRefresh: (_) => false); 
```

## Type of change

Please delete options that are not relevant.

- [] Bug fix (non-breaking change which fixes an issue)

## Closing issues

To automatically close an issue: closes #4345

---------

Co-authored-by: Guiyong Yang (from Dev Box) <[email protected]>
Co-authored-by: Kiran Kumar Kolli <[email protected]>

Author: 3 people

Microsoft.Azure.Cosmos/src/Routing/AsyncCacheNonBlocking.cs

@@ -95,7 +95,7 @@ public async Task<TValue> GetAsync(
             {
                 try
                 {
-                    TValue cachedResult = await initialLazyValue.GetValueAsync();
+                    TValue cachedResult = await initialLazyValue.GetValueAsync(singleValueInitFunc);
                     if (forceRefresh == null || !forceRefresh(cachedResult))
                     {
                         return cachedResult;
@@ -129,23 +129,23 @@ public async Task<TValue> GetAsync(
             // The AsyncLazyWithRefreshTask is lazy and won't create the task until GetValue is called.
             // It's possible multiple threads will call the GetOrAdd for the same key. The current asyncLazy may
             // not be used if another thread adds it first.
-            AsyncLazyWithRefreshTask<TValue> asyncLazy = new AsyncLazyWithRefreshTask<TValue>(singleValueInitFunc, this.cancellationTokenSource.Token);
+            AsyncLazyWithRefreshTask<TValue> asyncLazy = new AsyncLazyWithRefreshTask<TValue>(this.cancellationTokenSource.Token);
             AsyncLazyWithRefreshTask<TValue> result = this.values.GetOrAdd(
                 key,
                 asyncLazy);
 
             // Another thread async lazy was inserted. Just await on the inserted lazy object.
             if (!object.ReferenceEquals(asyncLazy, result))
             {
-                return await result.GetValueAsync();
+                return await result.GetValueAsync(singleValueInitFunc);
             }
 
             // This means the current caller async lazy was inserted into the concurrent dictionary.
             // The task is now awaited on so if an exception occurs it can be removed from
             // the concurrent dictionary.
             try
             {
-                return await result.GetValueAsync();
+                return await result.GetValueAsync(singleValueInitFunc);
             }
             catch (Exception e)
             {
@@ -253,7 +253,6 @@ private async Task<TValue> UpdateCacheAndGetValueFromBackgroundTaskAsync(
         private sealed class AsyncLazyWithRefreshTask<T>
         {
             private readonly CancellationToken cancellationToken;
-            private readonly Func<T, Task<T>> createValueFunc;
             private readonly object valueLock = new ();
             private readonly object removedFromCacheLock = new ();
 
@@ -266,24 +265,22 @@ public AsyncLazyWithRefreshTask(
                 CancellationToken cancellationToken)
             {
                 this.cancellationToken = cancellationToken;
-                this.createValueFunc = null;
                 this.value = Task.FromResult(value);
                 this.refreshInProgress = null;
             }
 
             public AsyncLazyWithRefreshTask(
-                Func<T, Task<T>> taskFactory,
                 CancellationToken cancellationToken)
             {
                 this.cancellationToken = cancellationToken;
-                this.createValueFunc = taskFactory;
                 this.value = null;
                 this.refreshInProgress = null;
             }
 
             public bool IsValueCreated => this.value != null;
 
-            public Task<T> GetValueAsync()
+            public Task<T> GetValueAsync(
+                Func<T, Task<T>> createValueFunc)
             {
                 // The task was already created so just return it.
                 Task<T> valueSnapshot = this.value;
@@ -303,7 +300,7 @@ public Task<T> GetValueAsync()
                     }
 
                     this.cancellationToken.ThrowIfCancellationRequested();
-                    this.value = this.createValueFunc(default);
+                    this.value = createValueFunc(default);
                     return this.value;
                 }
             }