Remove a bunch of X509 PAL closures from FindCore

stephentoub · web-flow · commit 661789255031 · 2021-03-31T17:35:42.000-07:00
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Unix/ManagedCertificateFinder.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Unix/ManagedCertificateFinder.cs
@@ -41,13 +41,14 @@ public string NormalizeOid(string maybeOid, OidGroup expectedGroup)
 
         public void FindByThumbprint(byte[] thumbprint)
         {
-            FindCore(cert => cert.GetCertHash().ContentsEqual(thumbprint));
+            FindCore(thumbprint, static (thumbprint, cert) => cert.GetCertHash().ContentsEqual(thumbprint));
         }
 
         public void FindBySubjectName(string subjectName)
         {
             FindCore(
-                cert =>
+                subjectName,
+                static (subjectName, cert) =>
                 {
                     string formedSubject = X500NameEncoder.X500DistinguishedNameDecode(cert.SubjectName.RawData, false, X500DistinguishedNameFlags.None);
 
@@ -57,13 +58,14 @@ public void FindBySubjectName(string subjectName)
 
         public void FindBySubjectDistinguishedName(string subjectDistinguishedName)
         {
-            FindCore(cert => StringComparer.OrdinalIgnoreCase.Equals(subjectDistinguishedName, cert.Subject));
+            FindCore(subjectDistinguishedName, static (subjectDistinguishedName, cert) => StringComparer.OrdinalIgnoreCase.Equals(subjectDistinguishedName, cert.Subject));
         }
 
         public void FindByIssuerName(string issuerName)
         {
             FindCore(
-                cert =>
+                issuerName,
+                static (issuerName, cert) =>
                 {
                     string formedIssuer = X500NameEncoder.X500DistinguishedNameDecode(cert.IssuerName.RawData, false, X500DistinguishedNameFlags.None);
 
@@ -73,17 +75,18 @@ public void FindByIssuerName(string issuerName)
 
         public void FindByIssuerDistinguishedName(string issuerDistinguishedName)
         {
-            FindCore(cert => StringComparer.OrdinalIgnoreCase.Equals(issuerDistinguishedName, cert.Issuer));
+            FindCore(issuerDistinguishedName, static (issuerDistinguishedName, cert) => StringComparer.OrdinalIgnoreCase.Equals(issuerDistinguishedName, cert.Issuer));
         }
 
         public void FindBySerialNumber(BigInteger hexValue, BigInteger decimalValue)
         {
             FindCore(
-                cert =>
+                (hexValue, decimalValue),
+                static (state, cert) =>
                 {
                     byte[] serialBytes = cert.GetSerialNumber();
                     BigInteger serialNumber = FindPal.PositiveBigIntegerFromByteArray(serialBytes);
-                    bool match = hexValue.Equals(serialNumber) || decimalValue.Equals(serialNumber);
+                    bool match = state.hexValue.Equals(serialNumber) || state.decimalValue.Equals(serialNumber);
 
                     return match;
                 });
@@ -107,27 +110,28 @@ public void FindByTimeValid(DateTime dateTime)
         {
             DateTime normalized = NormalizeDateTime(dateTime);
 
-            FindCore(cert => cert.NotBefore <= normalized && normalized <= cert.NotAfter);
+            FindCore(normalized, static (normalized, cert) => cert.NotBefore <= normalized && normalized <= cert.NotAfter);
         }
 
         public void FindByTimeNotYetValid(DateTime dateTime)
         {
             DateTime normalized = NormalizeDateTime(dateTime);
 
-            FindCore(cert => cert.NotBefore > normalized);
+            FindCore(normalized, static (normalized, cert) => cert.NotBefore > normalized);
         }
 
         public void FindByTimeExpired(DateTime dateTime)
         {
             DateTime normalized = NormalizeDateTime(dateTime);
 
-            FindCore(cert => cert.NotAfter < normalized);
+            FindCore(normalized, static (normalized, cert) => cert.NotAfter < normalized);
         }
 
         public void FindByTemplateName(string templateName)
         {
             FindCore(
-                cert =>
+                templateName,
+                static (templateName, cert) =>
                 {
                     X509Extension? ext = FindExtension(cert, Oids.EnrollCertTypeExtension);
 
@@ -172,7 +176,8 @@ public void FindByTemplateName(string templateName)
         public void FindByApplicationPolicy(string oidValue)
         {
             FindCore(
-                cert =>
+                oidValue,
+                static (oidValue, cert) =>
                 {
                     X509Extension? ext = FindExtension(cert, Oids.EnhancedKeyUsage);
 
@@ -201,7 +206,8 @@ public void FindByApplicationPolicy(string oidValue)
         public void FindByCertificatePolicy(string oidValue)
         {
             FindCore(
-                cert =>
+                oidValue,
+                static (oidValue, cert) =>
                 {
                     X509Extension? ext = FindExtension(cert, Oids.CertPolicies);
 
@@ -218,13 +224,14 @@ public void FindByCertificatePolicy(string oidValue)
 
         public void FindByExtension(string oidValue)
         {
-            FindCore(cert => FindExtension(cert, oidValue) != null);
+            FindCore(oidValue, static (oidValue, cert) => FindExtension(cert, oidValue) != null);
         }
 
         public void FindByKeyUsage(X509KeyUsageFlags keyUsage)
         {
             FindCore(
-                cert =>
+                keyUsage,
+                static (keyUsage, cert) =>
                 {
                     X509Extension? ext = FindExtension(cert, Oids.KeyUsage);
 
@@ -246,7 +253,8 @@ public void FindByKeyUsage(X509KeyUsageFlags keyUsage)
         public void FindBySubjectKeyIdentifier(byte[] keyIdentifier)
         {
             FindCore(
-                cert =>
+                keyIdentifier,
+                (keyIdentifier, cert) =>
                 {
                     X509Extension? ext = FindExtension(cert, Oids.SubjectKeyIdentifier);
                     byte[] certKeyId;
@@ -305,11 +313,14 @@ protected virtual void Dispose(bool disposing)
 
         protected abstract X509Certificate2 CloneCertificate(X509Certificate2 cert);
 
-        private void FindCore(Predicate<X509Certificate2> predicate)
+        private void FindCore<TState>(TState state, Func<TState, X509Certificate2, bool> predicate)
         {
-            foreach (X509Certificate2 cert in _findFrom)
+            X509Certificate2Collection findFrom = _findFrom;
+            int count = findFrom.Count;
+            for (int i = 0; i < count; i++)
             {
-                if (predicate(cert))
+                X509Certificate2 cert = findFrom[i];
+                if (predicate(state, cert))
                 {
                     if (!_validOnly || IsCertValid(cert))
                     {
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Windows/FindPal.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Windows/FindPal.cs
@@ -50,22 +50,23 @@ public unsafe void FindByThumbprint(byte[] thumbPrint)
             fixed (byte* pThumbPrint = thumbPrint)
             {
                 CRYPTOAPI_BLOB blob = new CRYPTOAPI_BLOB(thumbPrint.Length, pThumbPrint);
-                FindCore(CertFindType.CERT_FIND_HASH, &blob);
+                FindCore<object>(CertFindType.CERT_FIND_HASH, &blob);
             }
         }
 
         public unsafe void FindBySubjectName(string subjectName)
         {
             fixed (char* pSubjectName = subjectName)
             {
-                FindCore(CertFindType.CERT_FIND_SUBJECT_STR, pSubjectName);
+                FindCore<object>(CertFindType.CERT_FIND_SUBJECT_STR, pSubjectName);
             }
         }
 
         public void FindBySubjectDistinguishedName(string subjectDistinguishedName)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                subjectDistinguishedName,
+                static (subjectDistinguishedName, pCertContext) =>
                 {
                     string actual = GetCertNameInfo(pCertContext, CertNameType.CERT_NAME_RDN_TYPE, CertNameFlags.None);
                     return subjectDistinguishedName.Equals(actual, StringComparison.OrdinalIgnoreCase);
@@ -76,14 +77,15 @@ public unsafe void FindByIssuerName(string issuerName)
         {
             fixed (char* pIssuerName = issuerName)
             {
-                FindCore(CertFindType.CERT_FIND_ISSUER_STR, pIssuerName);
+                FindCore<object>(CertFindType.CERT_FIND_ISSUER_STR, pIssuerName);
             }
         }
 
         public void FindByIssuerDistinguishedName(string issuerDistinguishedName)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                issuerDistinguishedName,
+                static (issuerDistinguishedName, pCertContext) =>
                 {
                     string actual = GetCertNameInfo(pCertContext, CertNameType.CERT_NAME_RDN_TYPE, CertNameFlags.CERT_NAME_ISSUER_FLAG);
                     return issuerDistinguishedName.Equals(actual, StringComparison.OrdinalIgnoreCase);
@@ -93,15 +95,16 @@ public void FindByIssuerDistinguishedName(string issuerDistinguishedName)
         public unsafe void FindBySerialNumber(BigInteger hexValue, BigInteger decimalValue)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                (hexValue, decimalValue),
+                static (state, pCertContext) =>
                 {
                     byte[] actual = pCertContext.CertContext->pCertInfo->SerialNumber.ToByteArray();
                     GC.KeepAlive(pCertContext);
 
                     // Convert to BigInteger as the comparison must not fail due to spurious leading zeros
                     BigInteger actualAsBigInteger = PositiveBigIntegerFromByteArray(actual);
 
-                    return hexValue.Equals(actualAsBigInteger) || decimalValue.Equals(actualAsBigInteger);
+                    return state.hexValue.Equals(actualAsBigInteger) || state.decimalValue.Equals(actualAsBigInteger);
                 });
         }
 
@@ -125,19 +128,21 @@ private unsafe void FindByTime(DateTime dateTime, int compareResult)
             FILETIME fileTime = FILETIME.FromDateTime(dateTime);
 
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                (fileTime, compareResult),
+                static (state, pCertContext) =>
                 {
-                    int comparison = Interop.crypt32.CertVerifyTimeValidity(ref fileTime,
+                    int comparison = Interop.crypt32.CertVerifyTimeValidity(ref state.fileTime,
                         pCertContext.CertContext->pCertInfo);
                     GC.KeepAlive(pCertContext);
-                    return comparison == compareResult;
+                    return comparison == state.compareResult;
                 });
         }
 
         public unsafe void FindByTemplateName(string templateName)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                templateName,
+                static (templateName, pCertContext) =>
                 {
                     // The template name can have 2 different formats: V1 format (<= Win2K) is just a string
                     // V2 format (XP only) can be a friendly name or an OID.
@@ -203,7 +208,8 @@ public unsafe void FindByTemplateName(string templateName)
         public unsafe void FindByApplicationPolicy(string oidValue)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                oidValue,
+                static (oidValue, pCertContext) =>
                 {
                     int numOids;
                     int cbData = 0;
@@ -234,7 +240,8 @@ public unsafe void FindByApplicationPolicy(string oidValue)
         public unsafe void FindByCertificatePolicy(string oidValue)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                oidValue,
+                static (oidValue, pCertContext) =>
                 {
                     CERT_INFO* pCertInfo = pCertContext.CertContext->pCertInfo;
                     CERT_EXTENSION* pCertExtension = Interop.crypt32.CertFindExtension(Oids.CertPolicies,
@@ -274,7 +281,8 @@ public unsafe void FindByCertificatePolicy(string oidValue)
         public unsafe void FindByExtension(string oidValue)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                oidValue,
+                static (oidValue, pCertContext) =>
                 {
                     CERT_INFO* pCertInfo = pCertContext.CertContext->pCertInfo;
                     CERT_EXTENSION* pCertExtension = Interop.crypt32.CertFindExtension(oidValue, pCertInfo->cExtension, pCertInfo->rgExtension);
@@ -286,7 +294,8 @@ public unsafe void FindByExtension(string oidValue)
         public unsafe void FindByKeyUsage(X509KeyUsageFlags keyUsage)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                keyUsage,
+                static (keyUsage, pCertContext) =>
                 {
                     CERT_INFO* pCertInfo = pCertContext.CertContext->pCertInfo;
                     X509KeyUsageFlags actual;
@@ -300,7 +309,8 @@ public unsafe void FindByKeyUsage(X509KeyUsageFlags keyUsage)
         public void FindBySubjectKeyIdentifier(byte[] keyIdentifier)
         {
             FindCore(
-                delegate (SafeCertContextHandle pCertContext)
+                keyIdentifier,
+                static (keyIdentifier, pCertContext) =>
                 {
                     int cbData = 0;
                     if (!Interop.crypt32.CertGetCertificateContextProperty(pCertContext, CertContextPropId.CERT_KEY_IDENTIFIER_PROP_ID, null, ref cbData))
@@ -319,12 +329,12 @@ public void Dispose()
             _storePal.Dispose();
         }
 
-        private unsafe void FindCore(Func<SafeCertContextHandle, bool> filter)
+        private unsafe void FindCore<TState>(TState state, Func<TState, SafeCertContextHandle, bool> filter)
         {
-            FindCore(CertFindType.CERT_FIND_ANY, null, filter);
+            FindCore(CertFindType.CERT_FIND_ANY, null, state, filter);
         }
 
-        private unsafe void FindCore(CertFindType dwFindType, void* pvFindPara, Func<SafeCertContextHandle, bool>? filter = null)
+        private unsafe void FindCore<TState>(CertFindType dwFindType, void* pvFindPara, TState state = default!, Func<TState, SafeCertContextHandle, bool>? filter = null)
         {
             SafeCertStoreHandle findResults = Interop.crypt32.CertOpenStore(
                 CertStoreProvider.CERT_STORE_PROV_MEMORY,
@@ -338,7 +348,7 @@ private unsafe void FindCore(CertFindType dwFindType, void* pvFindPara, Func<Saf
             SafeCertContextHandle? pCertContext = null;
             while (Interop.crypt32.CertFindCertificateInStore(_storePal.SafeCertStoreHandle, dwFindType, pvFindPara, ref pCertContext))
             {
-                if (filter != null && !filter(pCertContext))
+                if (filter != null && !filter(state, pCertContext))
                     continue;
 
                 if (_validOnly)

Original file line number	Diff line number	Diff line change
`@@ -41,13 +41,14 @@ public string NormalizeOid(string maybeOid, OidGroup expectedGroup)`
`41`	`41`
`42`	`42`	`public void FindByThumbprint(byte[] thumbprint)`
`43`	`43`	`{`
`44`		`- FindCore(cert => cert.GetCertHash().ContentsEqual(thumbprint));`
	`44`	`+ FindCore(thumbprint, static (thumbprint, cert) => cert.GetCertHash().ContentsEqual(thumbprint));`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public void FindBySubjectName(string subjectName)`
`48`	`48`	`{`
`49`	`49`	`FindCore(`
`50`		`- cert =>`
	`50`	`+ subjectName,`
	`51`	`+ static (subjectName, cert) =>`
`51`	`52`	`{`
`52`	`53`	`string formedSubject = X500NameEncoder.X500DistinguishedNameDecode(cert.SubjectName.RawData, false, X500DistinguishedNameFlags.None);`
`53`	`54`
`@@ -57,13 +58,14 @@ public void FindBySubjectName(string subjectName)`
`57`	`58`
`58`	`59`	`public void FindBySubjectDistinguishedName(string subjectDistinguishedName)`
`59`	`60`	`{`
`60`		`- FindCore(cert => StringComparer.OrdinalIgnoreCase.Equals(subjectDistinguishedName, cert.Subject));`
	`61`	`+ FindCore(subjectDistinguishedName, static (subjectDistinguishedName, cert) => StringComparer.OrdinalIgnoreCase.Equals(subjectDistinguishedName, cert.Subject));`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`public void FindByIssuerName(string issuerName)`
`64`	`65`	`{`
`65`	`66`	`FindCore(`
`66`		`- cert =>`
	`67`	`+ issuerName,`
	`68`	`+ static (issuerName, cert) =>`
`67`	`69`	`{`
`68`	`70`	`string formedIssuer = X500NameEncoder.X500DistinguishedNameDecode(cert.IssuerName.RawData, false, X500DistinguishedNameFlags.None);`
`69`	`71`
`@@ -73,17 +75,18 @@ public void FindByIssuerName(string issuerName)`
`73`	`75`
`74`	`76`	`public void FindByIssuerDistinguishedName(string issuerDistinguishedName)`
`75`	`77`	`{`
`76`		`- FindCore(cert => StringComparer.OrdinalIgnoreCase.Equals(issuerDistinguishedName, cert.Issuer));`
	`78`	`+ FindCore(issuerDistinguishedName, static (issuerDistinguishedName, cert) => StringComparer.OrdinalIgnoreCase.Equals(issuerDistinguishedName, cert.Issuer));`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`public void FindBySerialNumber(BigInteger hexValue, BigInteger decimalValue)`
`80`	`82`	`{`
`81`	`83`	`FindCore(`
`82`		`- cert =>`
	`84`	`+ (hexValue, decimalValue),`
	`85`	`+ static (state, cert) =>`
`83`	`86`	`{`
`84`	`87`	`byte[] serialBytes = cert.GetSerialNumber();`
`85`	`88`	`BigInteger serialNumber = FindPal.PositiveBigIntegerFromByteArray(serialBytes);`
`86`		`- bool match = hexValue.Equals(serialNumber) \|\| decimalValue.Equals(serialNumber);`
	`89`	`+ bool match = state.hexValue.Equals(serialNumber) \|\| state.decimalValue.Equals(serialNumber);`
`87`	`90`
`88`	`91`	`return match;`
`89`	`92`	`});`
`@@ -107,27 +110,28 @@ public void FindByTimeValid(DateTime dateTime)`
`107`	`110`	`{`
`108`	`111`	`DateTime normalized = NormalizeDateTime(dateTime);`
`109`	`112`
`110`		`- FindCore(cert => cert.NotBefore <= normalized && normalized <= cert.NotAfter);`
	`113`	`+ FindCore(normalized, static (normalized, cert) => cert.NotBefore <= normalized && normalized <= cert.NotAfter);`
`111`	`114`	`}`
`112`	`115`
`113`	`116`	`public void FindByTimeNotYetValid(DateTime dateTime)`
`114`	`117`	`{`
`115`	`118`	`DateTime normalized = NormalizeDateTime(dateTime);`
`116`	`119`
`117`		`- FindCore(cert => cert.NotBefore > normalized);`
	`120`	`+ FindCore(normalized, static (normalized, cert) => cert.NotBefore > normalized);`
`118`	`121`	`}`
`119`	`122`
`120`	`123`	`public void FindByTimeExpired(DateTime dateTime)`
`121`	`124`	`{`
`122`	`125`	`DateTime normalized = NormalizeDateTime(dateTime);`
`123`	`126`
`124`		`- FindCore(cert => cert.NotAfter < normalized);`
	`127`	`+ FindCore(normalized, static (normalized, cert) => cert.NotAfter < normalized);`
`125`	`128`	`}`
`126`	`129`
`127`	`130`	`public void FindByTemplateName(string templateName)`
`128`	`131`	`{`
`129`	`132`	`FindCore(`
`130`		`- cert =>`
	`133`	`+ templateName,`
	`134`	`+ static (templateName, cert) =>`
`131`	`135`	`{`
`132`	`136`	`X509Extension? ext = FindExtension(cert, Oids.EnrollCertTypeExtension);`
`133`	`137`
`@@ -172,7 +176,8 @@ public void FindByTemplateName(string templateName)`
`172`	`176`	`public void FindByApplicationPolicy(string oidValue)`
`173`	`177`	`{`
`174`	`178`	`FindCore(`
`175`		`- cert =>`
	`179`	`+ oidValue,`
	`180`	`+ static (oidValue, cert) =>`
`176`	`181`	`{`
`177`	`182`	`X509Extension? ext = FindExtension(cert, Oids.EnhancedKeyUsage);`
`178`	`183`
`@@ -201,7 +206,8 @@ public void FindByApplicationPolicy(string oidValue)`
`201`	`206`	`public void FindByCertificatePolicy(string oidValue)`
`202`	`207`	`{`
`203`	`208`	`FindCore(`
`204`		`- cert =>`
	`209`	`+ oidValue,`
	`210`	`+ static (oidValue, cert) =>`
`205`	`211`	`{`
`206`	`212`	`X509Extension? ext = FindExtension(cert, Oids.CertPolicies);`
`207`	`213`
`@@ -218,13 +224,14 @@ public void FindByCertificatePolicy(string oidValue)`
`218`	`224`
`219`	`225`	`public void FindByExtension(string oidValue)`
`220`	`226`	`{`
`221`		`- FindCore(cert => FindExtension(cert, oidValue) != null);`
	`227`	`+ FindCore(oidValue, static (oidValue, cert) => FindExtension(cert, oidValue) != null);`
`222`	`228`	`}`
`223`	`229`
`224`	`230`	`public void FindByKeyUsage(X509KeyUsageFlags keyUsage)`
`225`	`231`	`{`
`226`	`232`	`FindCore(`
`227`		`- cert =>`
	`233`	`+ keyUsage,`
	`234`	`+ static (keyUsage, cert) =>`
`228`	`235`	`{`
`229`	`236`	`X509Extension? ext = FindExtension(cert, Oids.KeyUsage);`
`230`	`237`
`@@ -246,7 +253,8 @@ public void FindByKeyUsage(X509KeyUsageFlags keyUsage)`
`246`	`253`	`public void FindBySubjectKeyIdentifier(byte[] keyIdentifier)`
`247`	`254`	`{`
`248`	`255`	`FindCore(`
`249`		`- cert =>`
	`256`	`+ keyIdentifier,`
	`257`	`+ (keyIdentifier, cert) =>`
`250`	`258`	`{`
`251`	`259`	`X509Extension? ext = FindExtension(cert, Oids.SubjectKeyIdentifier);`
`252`	`260`	`byte[] certKeyId;`
`@@ -305,11 +313,14 @@ protected virtual void Dispose(bool disposing)`
`305`	`313`
`306`	`314`	`protected abstract X509Certificate2 CloneCertificate(X509Certificate2 cert);`
`307`	`315`
`308`		`- private void FindCore(Predicate<X509Certificate2> predicate)`
	`316`	`+ private void FindCore<TState>(TState state, Func<TState, X509Certificate2, bool> predicate)`
`309`	`317`	`{`
`310`		`- foreach (X509Certificate2 cert in _findFrom)`
	`318`	`+ X509Certificate2Collection findFrom = _findFrom;`
	`319`	`+ int count = findFrom.Count;`
	`320`	`+ for (int i = 0; i < count; i++)`
`311`	`321`	`{`
`312`		`- if (predicate(cert))`
	`322`	`+ X509Certificate2 cert = findFrom[i];`
	`323`	`+ if (predicate(state, cert))`
`313`	`324`	`{`
`314`	`325`	`if (!_validOnly \|\| IsCertValid(cert))`
`315`	`326`	`{`
Original file line number	Diff line number	Diff line change
`@@ -50,22 +50,23 @@ public unsafe void FindByThumbprint(byte[] thumbPrint)`
`50`	`50`	`fixed (byte* pThumbPrint = thumbPrint)`
`51`	`51`	`{`
`52`	`52`	`CRYPTOAPI_BLOB blob = new CRYPTOAPI_BLOB(thumbPrint.Length, pThumbPrint);`
`53`		`- FindCore(CertFindType.CERT_FIND_HASH, &blob);`
	`53`	`+ FindCore<object>(CertFindType.CERT_FIND_HASH, &blob);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`public unsafe void FindBySubjectName(string subjectName)`
`58`	`58`	`{`
`59`	`59`	`fixed (char* pSubjectName = subjectName)`
`60`	`60`	`{`
`61`		`- FindCore(CertFindType.CERT_FIND_SUBJECT_STR, pSubjectName);`
	`61`	`+ FindCore<object>(CertFindType.CERT_FIND_SUBJECT_STR, pSubjectName);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public void FindBySubjectDistinguishedName(string subjectDistinguishedName)`
`66`	`66`	`{`
`67`	`67`	`FindCore(`
`68`		`- delegate (SafeCertContextHandle pCertContext)`
	`68`	`+ subjectDistinguishedName,`
	`69`	`+ static (subjectDistinguishedName, pCertContext) =>`
`69`	`70`	`{`
`70`	`71`	`string actual = GetCertNameInfo(pCertContext, CertNameType.CERT_NAME_RDN_TYPE, CertNameFlags.None);`
`71`	`72`	`return subjectDistinguishedName.Equals(actual, StringComparison.OrdinalIgnoreCase);`
`@@ -76,14 +77,15 @@ public unsafe void FindByIssuerName(string issuerName)`
`76`	`77`	`{`
`77`	`78`	`fixed (char* pIssuerName = issuerName)`
`78`	`79`	`{`
`79`		`- FindCore(CertFindType.CERT_FIND_ISSUER_STR, pIssuerName);`
	`80`	`+ FindCore<object>(CertFindType.CERT_FIND_ISSUER_STR, pIssuerName);`
`80`	`81`	`}`
`81`	`82`	`}`
`82`	`83`
`83`	`84`	`public void FindByIssuerDistinguishedName(string issuerDistinguishedName)`
`84`	`85`	`{`
`85`	`86`	`FindCore(`
`86`		`- delegate (SafeCertContextHandle pCertContext)`
	`87`	`+ issuerDistinguishedName,`
	`88`	`+ static (issuerDistinguishedName, pCertContext) =>`
`87`	`89`	`{`
`88`	`90`	`string actual = GetCertNameInfo(pCertContext, CertNameType.CERT_NAME_RDN_TYPE, CertNameFlags.CERT_NAME_ISSUER_FLAG);`
`89`	`91`	`return issuerDistinguishedName.Equals(actual, StringComparison.OrdinalIgnoreCase);`
`@@ -93,15 +95,16 @@ public void FindByIssuerDistinguishedName(string issuerDistinguishedName)`
`93`	`95`	`public unsafe void FindBySerialNumber(BigInteger hexValue, BigInteger decimalValue)`
`94`	`96`	`{`
`95`	`97`	`FindCore(`
`96`		`- delegate (SafeCertContextHandle pCertContext)`
	`98`	`+ (hexValue, decimalValue),`
	`99`	`+ static (state, pCertContext) =>`
`97`	`100`	`{`
`98`	`101`	`byte[] actual = pCertContext.CertContext->pCertInfo->SerialNumber.ToByteArray();`
`99`	`102`	`GC.KeepAlive(pCertContext);`
`100`	`103`
`101`	`104`	`// Convert to BigInteger as the comparison must not fail due to spurious leading zeros`
`102`	`105`	`BigInteger actualAsBigInteger = PositiveBigIntegerFromByteArray(actual);`
`103`	`106`
`104`		`- return hexValue.Equals(actualAsBigInteger) \|\| decimalValue.Equals(actualAsBigInteger);`
	`107`	`+ return state.hexValue.Equals(actualAsBigInteger) \|\| state.decimalValue.Equals(actualAsBigInteger);`
`105`	`108`	`});`
`106`	`109`	`}`
`107`	`110`
`@@ -125,19 +128,21 @@ private unsafe void FindByTime(DateTime dateTime, int compareResult)`
`125`	`128`	`FILETIME fileTime = FILETIME.FromDateTime(dateTime);`
`126`	`129`
`127`	`130`	`FindCore(`
`128`		`- delegate (SafeCertContextHandle pCertContext)`
	`131`	`+ (fileTime, compareResult),`
	`132`	`+ static (state, pCertContext) =>`
`129`	`133`	`{`
`130`		`- int comparison = Interop.crypt32.CertVerifyTimeValidity(ref fileTime,`
	`134`	`+ int comparison = Interop.crypt32.CertVerifyTimeValidity(ref state.fileTime,`
`131`	`135`	`pCertContext.CertContext->pCertInfo);`
`132`	`136`	`GC.KeepAlive(pCertContext);`
`133`		`- return comparison == compareResult;`
	`137`	`+ return comparison == state.compareResult;`
`134`	`138`	`});`
`135`	`139`	`}`
`136`	`140`
`137`	`141`	`public unsafe void FindByTemplateName(string templateName)`
`138`	`142`	`{`
`139`	`143`	`FindCore(`
`140`		`- delegate (SafeCertContextHandle pCertContext)`
	`144`	`+ templateName,`
	`145`	`+ static (templateName, pCertContext) =>`
`141`	`146`	`{`
`142`	`147`	`// The template name can have 2 different formats: V1 format (<= Win2K) is just a string`
`143`	`148`	`// V2 format (XP only) can be a friendly name or an OID.`
`@@ -203,7 +208,8 @@ public unsafe void FindByTemplateName(string templateName)`
`203`	`208`	`public unsafe void FindByApplicationPolicy(string oidValue)`
`204`	`209`	`{`
`205`	`210`	`FindCore(`
`206`		`- delegate (SafeCertContextHandle pCertContext)`
	`211`	`+ oidValue,`
	`212`	`+ static (oidValue, pCertContext) =>`
`207`	`213`	`{`
`208`	`214`	`int numOids;`
`209`	`215`	`int cbData = 0;`
`@@ -234,7 +240,8 @@ public unsafe void FindByApplicationPolicy(string oidValue)`
`234`	`240`	`public unsafe void FindByCertificatePolicy(string oidValue)`
`235`	`241`	`{`
`236`	`242`	`FindCore(`
`237`		`- delegate (SafeCertContextHandle pCertContext)`
	`243`	`+ oidValue,`
	`244`	`+ static (oidValue, pCertContext) =>`
`238`	`245`	`{`
`239`	`246`	`CERT_INFO* pCertInfo = pCertContext.CertContext->pCertInfo;`
`240`	`247`	`CERT_EXTENSION* pCertExtension = Interop.crypt32.CertFindExtension(Oids.CertPolicies,`
`@@ -274,7 +281,8 @@ public unsafe void FindByCertificatePolicy(string oidValue)`
`274`	`281`	`public unsafe void FindByExtension(string oidValue)`
`275`	`282`	`{`
`276`	`283`	`FindCore(`
`277`		`- delegate (SafeCertContextHandle pCertContext)`
	`284`	`+ oidValue,`
	`285`	`+ static (oidValue, pCertContext) =>`
`278`	`286`	`{`
`279`	`287`	`CERT_INFO* pCertInfo = pCertContext.CertContext->pCertInfo;`
`280`	`288`	`CERT_EXTENSION* pCertExtension = Interop.crypt32.CertFindExtension(oidValue, pCertInfo->cExtension, pCertInfo->rgExtension);`
`@@ -286,7 +294,8 @@ public unsafe void FindByExtension(string oidValue)`
`286`	`294`	`public unsafe void FindByKeyUsage(X509KeyUsageFlags keyUsage)`
`287`	`295`	`{`
`288`	`296`	`FindCore(`
`289`		`- delegate (SafeCertContextHandle pCertContext)`
	`297`	`+ keyUsage,`
	`298`	`+ static (keyUsage, pCertContext) =>`
`290`	`299`	`{`
`291`	`300`	`CERT_INFO* pCertInfo = pCertContext.CertContext->pCertInfo;`
`292`	`301`	`X509KeyUsageFlags actual;`
`@@ -300,7 +309,8 @@ public unsafe void FindByKeyUsage(X509KeyUsageFlags keyUsage)`
`300`	`309`	`public void FindBySubjectKeyIdentifier(byte[] keyIdentifier)`
`301`	`310`	`{`
`302`	`311`	`FindCore(`
`303`		`- delegate (SafeCertContextHandle pCertContext)`
	`312`	`+ keyIdentifier,`
	`313`	`+ static (keyIdentifier, pCertContext) =>`
`304`	`314`	`{`
`305`	`315`	`int cbData = 0;`
`306`	`316`	`if (!Interop.crypt32.CertGetCertificateContextProperty(pCertContext, CertContextPropId.CERT_KEY_IDENTIFIER_PROP_ID, null, ref cbData))`
`@@ -319,12 +329,12 @@ public void Dispose()`
`319`	`329`	`_storePal.Dispose();`
`320`	`330`	`}`
`321`	`331`
`322`		`- private unsafe void FindCore(Func<SafeCertContextHandle, bool> filter)`
	`332`	`+ private unsafe void FindCore<TState>(TState state, Func<TState, SafeCertContextHandle, bool> filter)`
`323`	`333`	`{`
`324`		`- FindCore(CertFindType.CERT_FIND_ANY, null, filter);`
	`334`	`+ FindCore(CertFindType.CERT_FIND_ANY, null, state, filter);`
`325`	`335`	`}`
`326`	`336`
`327`		`- private unsafe void FindCore(CertFindType dwFindType, void* pvFindPara, Func<SafeCertContextHandle, bool>? filter = null)`
	`337`	`+ private unsafe void FindCore<TState>(CertFindType dwFindType, void* pvFindPara, TState state = default!, Func<TState, SafeCertContextHandle, bool>? filter = null)`
`328`	`338`	`{`
`329`	`339`	`SafeCertStoreHandle findResults = Interop.crypt32.CertOpenStore(`
`330`	`340`	`CertStoreProvider.CERT_STORE_PROV_MEMORY,`
`@@ -338,7 +348,7 @@ private unsafe void FindCore(CertFindType dwFindType, void* pvFindPara, Func<Saf`
`338`	`348`	`SafeCertContextHandle? pCertContext = null;`
`339`	`349`	`while (Interop.crypt32.CertFindCertificateInStore(_storePal.SafeCertStoreHandle, dwFindType, pvFindPara, ref pCertContext))`
`340`	`350`	`{`
`341`		`- if (filter != null && !filter(pCertContext))`
	`351`	`+ if (filter != null && !filter(state, pCertContext))`
`342`	`352`	`continue;`
`343`	`353`
`344`	`354`	`if (_validOnly)`