Add SingleOrDefaultAsync overload with single key value

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Storage/Prefetch/FetchByKeyWithCachingTest.cs

@@ -327,7 +327,7 @@ public void SingleOrDefaultByExistingIdTest()
     }
 
     [Test]
-    public async Task SingleOrDefaultByExistingIdAsyncTest()
+    public async Task SingleOrDefaultByExistingIdAsyncTest1()
     {
       await RunWithinSessionAsync(async (s) => {
         var existingId = (int) existingKeys[customerType][0].Value.GetValue(0, out var _);
@@ -348,6 +348,28 @@ await RunWithinSessionAsync(async (s) => {
       });
     }
 
+    [Test]
+    public async Task SingleOrDefaultByExistingIdAsyncTest2()
+    {
+      await RunWithinSessionAsync(async (s) => {
+        var existingId = (int) existingKeys[customerType][0].Value.GetValue(0, out var _);
+        var detector = new QueryExecutionDetector();
+        using (detector.Attach(s)) {
+          // Entity is not in cache yet
+          var existingEntity = await s.Query.SingleOrDefaultAsync<Customer>(existingId);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.True);
+        detector.Reset();
+
+        using (detector.Attach(s)) {
+          // now it is in cache
+          var existingEntity = await s.Query.SingleOrDefaultAsync<Customer>(existingId);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.False);
+        detector.Reset();
+      });
+    }
+
     [Test]
     public void SingleOrDefaultByInexistentIdTest()
     {
@@ -372,7 +394,7 @@ public void SingleOrDefaultByInexistentIdTest()
     }
 
     [Test]
-    public async Task SingleOrDefaultByInexistentIdAsyncTest()
+    public async Task SingleOrDefaultByInexistentIdAsyncTest1()
     {
       await RunWithinSessionAsync(async (s) => {
         var inexistentId = 9999;
@@ -395,6 +417,29 @@ await RunWithinSessionAsync(async (s) => {
       });
     }
 
+    [Test]
+    public async Task SingleOrDefaultByInexistentIdAsyncTest2()
+    {
+      await RunWithinSessionAsync(async (s) => {
+        var inexistentId = 9999;
+
+        var detector = new QueryExecutionDetector();
+        using (detector.Attach(s)) {
+          var shouldBeNull = await s.Query.SingleOrDefaultAsync<Customer>(inexistentId);
+          Assert.That(shouldBeNull, Is.Null);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.True);
+        detector.Reset();
+
+        using (detector.Attach(s)) {
+          var shouldBeNull = await s.Query.SingleOrDefaultAsync<Customer>(inexistentId);
+          Assert.That(shouldBeNull, Is.Null);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.False);
+        detector.Reset();
+        await Task.CompletedTask;
+      });
+    }
 
     private void RunWithinSession(Action<Session> testAction)
     {

Orm/Xtensive.Orm/Orm/Query.cs

@@ -385,6 +385,23 @@ public static Task<T> SingleOrDefaultAsync<T>(object[] keyValues, CancellationTo
       return Session.Demand().Query.SingleOrDefaultAsync<T>(keyValues, token);
     }
 
+    /// <summary>
+    /// Resolves (gets) the <see cref="Entity"/> by the specified <paramref name="keyValue"/>
+    /// in the current <see cref="Session"/>.
+    /// </summary>
+    /// <typeparam name="T">Type of the entity.</typeparam>
+    /// <param name="keyValue">Key value.</param>
+    /// <param name="token">The token to cancel this operation.</param>
+    /// <returns>
+    /// The <see cref="Entity"/> specified <paramref name="keyValue"/> identify.
+    /// <see langword="null"/>, if there is no such entity.
+    /// </returns>
+    public static Task<T> SingleOrDefaultAsync<T>(object keyValue, CancellationToken token)
+      where T : class, IEntity
+    {
+      return Session.Demand().Query.SingleOrDefaultAsync<T>(keyValue, token);
+    }
+
     #region Execute
 
     /// <summary>

Orm/Xtensive.Orm/Orm/QueryEndpoint.cs

@@ -496,6 +496,23 @@ public async Task<T> SingleOrDefaultAsync<T>(object[] keyValues, CancellationTok
       return (T) (object) (await SingleOrDefaultAsync(GetKeyByValues<T>(keyValues), token).ConfigureAwait(false));
     }
 
+    /// <summary>
+    /// Resolves (gets) the <see cref="Entity"/> by the specified <paramref name="keyValue"/>
+    /// in the current <see cref="session"/>.
+    /// </summary>
+    /// <typeparam name="T">Type of the entity.</typeparam>
+    /// <param name="keyValue">Key value.</param>
+    /// <param name="token">The token to cancel this operation.</param>
+    /// <returns>
+    /// The <see cref="Entity"/> specified <paramref name="keyValues"/> identify.
+    /// <see langword="null"/>, if there is no such entity.
+    /// </returns>
+    public async Task<T> SingleOrDefaultAsync<T>(object keyValue, CancellationToken token = default)
+      where T : class, IEntity
+    {
+      return (T) (object) (await SingleOrDefaultAsync(GetKeyByValue<T>(keyValue), token).ConfigureAwait(false));
+    }
+
     /// <summary>
     /// Fetches multiple instances of specified type  by provided <paramref name="keys"/>.
     /// </summary>
@@ -970,6 +987,18 @@ private Key GetKeyByValues<T>(object[] keyValues)
       return Key.Create(session.Domain, session.StorageNodeId, typeof(T), TypeReferenceAccuracy.BaseType, keyValues);
     }
 
+    private Key GetKeyByValue<T>(object keyValue)
+    {
+      ArgumentNullException.ThrowIfNull(keyValue);
+      switch (keyValue) {
+        case Key key:
+          return key;
+        case Entity entity:
+          return entity.Key;
+      }
+      return Key.Create(session.Domain, session.StorageNodeId, typeof(T), TypeReferenceAccuracy.BaseType, keyValue);
+    }
+
     private Expression BuildRootExpression(Type elementType)
     {
       return RootBuilder!=null