[Perf] Cache key size in CngKey

src/libraries/System.Security.Cryptography.Cng/tests/CngKeyTests.cs

@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace System.Security.Cryptography.Tests
+{
+    public static class CngKeyTests
+    {
+        [Theory]
+        [MemberData(nameof(AllPublicProperties))]
+        public static void AllProperties_ThrowOnDisposal(string propertyName)
+        {
+            // Create a dummy key. Use a fast-ish algorithm.
+            // If we can't query the property even on a fresh key, exclude it from the tests.
+
+            PropertyInfo propInfo = typeof(CngKey).GetProperty(propertyName);
+            CngKey theKey = CngKey.Create(CngAlgorithm.ECDsaP256);
+
+            try
+            {
+                propInfo.GetValue(theKey);
+            }
+            catch
+            {
+                // Property getter threw an exception. It's nonsensical for us to query
+                // whether this same getter throws ObjectDisposedException once the object
+                // is disposed. So we'll just mark this test as success.
+
+                return;
+            }
+
+            // We've queried the property. Now dispose the object and query the property again.
+            // We should see an ObjectDisposedException.
+
+            theKey.Dispose();
+            Assert.ThrowsAny<ObjectDisposedException>(() =>
+                propInfo.GetValue(theKey, BindingFlags.DoNotWrapExceptions, null, null, null));
+        }
+
+        public static IEnumerable<object[]> AllPublicProperties()
+        {
+            foreach (PropertyInfo pi in typeof(CngKey).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
+            {
+                if (pi.GetMethod is not null && !typeof(SafeHandle).IsAssignableFrom(pi.PropertyType))
+                {
+                    yield return new[] { pi.Name };
+                }
+            }
+        }
+    }
+}

src/libraries/System.Security.Cryptography.Cng/tests/System.Security.Cryptography.Cng.Tests.csproj

@@ -82,6 +82,7 @@
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\RSA\TestData.cs" />
     <Compile Include="$(CommonTestPath)System\IO\PositionValueStream.cs"
              Link="CommonTest\System\IO\PositionValueStream.cs" />
+    <Compile Include="CngKeyTests.cs" />
     <Compile Include="CngPkcs8Tests.cs" />
     <Compile Include="DSACngPkcs8Tests.cs" />
     <Compile Include="DSACngProvider.cs" />

src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/CngKey.StandardProperties.cs

@@ -20,6 +20,8 @@ public sealed partial class CngKey : IDisposable
         // Key properties
         //
 
+        private const int CachedKeySizeUninitializedSentinel = -1;
+        private int _cachedKeySize = CachedKeySizeUninitializedSentinel;
 
         /// <summary>
         ///     Algorithm group this key can be used with
@@ -169,6 +171,19 @@ public string? KeyName
         public int KeySize
         {
             get
+            {
+                // Key size lookup is a common operation, and we don't want to incur the
+                // LRPC overhead to query lsass for the information. Since the key size
+                // cannot be changed on an existing key, we'll cache it. For consistency
+                // with other properties, we'll still throw if the underlying handle has
+                // been closed.
+                if (_cachedKeySize == CachedKeySizeUninitializedSentinel || _keyHandle.IsClosed)
+                {
+                    _cachedKeySize = ComputeKeySize();
+                }
+                return _cachedKeySize;
+
+                int ComputeKeySize()
                 {
                     int keySize = 0;
 
@@ -218,6 +233,7 @@ public int KeySize
                     return keySize;
                 }
             }
+        }
 
         /// <summary>
         ///     Usage restrictions on the key