Make AsnSerializer resiliant to ILC reflection rules

AsnSerializer had two different paths which checked for ordered fields, one
which used the MetadataToken and one which didn't.  The MetadataToken
method is more reliable, but is not available on ILC.

With this change

* MetadataToken is used when available, and we hope for the best otherwise.
* The two paths now use the same resolution, so future algorithms apply evenly
* The results are cached, so we only sort once per type

Author: bartonjs

src/Common/src/System/Security/Cryptography/Asn1V2.Serializer.cs

@@ -3,11 +3,13 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Buffers;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Numerics;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace System.Security.Cryptography.Asn1
 {
@@ -59,6 +61,9 @@ internal static class AsnSerializer
         private delegate object Deserializer(AsnReader reader);
         private delegate bool TryDeserializer<T>(AsnReader reader, out T value);
 
+        private static readonly ConcurrentDictionary<Type, FieldInfo[]> s_orderedFields =
+            new ConcurrentDictionary<Type, FieldInfo[]>();
+
         private static Deserializer TryOrFail<T>(TryDeserializer<T> tryDeserializer)
         {
             return reader =>
@@ -70,6 +75,53 @@ private static Deserializer TryOrFail<T>(TryDeserializer<T> tryDeserializer)
             };
         }
 
+        private static FieldInfo[] GetOrderedFields(Type typeT)
+        {
+            return s_orderedFields.GetOrAdd(
+                typeT,
+                t =>
+                {
+                    // https://github.com/dotnet/corefx/issues/14606 asserts that ordering by the metadata
+                    // token on a SequentialLayout will produce the fields in their layout order.
+                    //
+                    // Some other alternatives:
+                    // * Add an attribute for controlling the field read order.
+                    //    fieldInfos.Select(fi => (fi, fi.GetCustomAttribute<AsnFieldOrderAttribute>(false)).
+                    //      Where(val => val.Item2 != null).OrderBy(val => val.Item2.OrderWeight).Select(val => val.Item1);
+                    //
+                    // * Use Marshal.OffsetOf as a sort key
+                    //
+                    // * Some sort of interface to return the fields in a declared order, using either
+                    //   an existing object, or Activator.CreateInstance.  It would need to check that
+                    //   any returned fields actually were declared on the type that was queried.
+                    //
+                    // * Invent more alternatives
+                    FieldInfo[] fieldInfos = t.GetFields(FieldFlags);
+
+                    if (fieldInfos.Length == 0)
+                    {
+                        return Array.Empty<FieldInfo>();
+                    }
+
+                    try
+                    {
+                        int token = fieldInfos[0].MetadataToken;
+                    }
+                    catch (InvalidOperationException)
+                    {
+                        // If MetadataToken isn't available (like in ILC) then just hope that
+                        // the fields are returned in declared order.  For the most part that
+                        // will result in data misaligning to fields and deserialization failing,
+                        // thus a CryptographicException.
+                        return fieldInfos;
+                    }
+
+                    Array.Sort(fieldInfos, (x, y) => x.MetadataToken.CompareTo(y.MetadataToken));
+                    return fieldInfos;
+                });
+        }
+
+
         private static ChoiceAttribute GetChoiceAttribute(Type typeT)
         {
             ChoiceAttribute attr = typeT.GetCustomAttribute<ChoiceAttribute>(inherit: false);
@@ -102,20 +154,7 @@ private static void PopulateChoiceLookup(
             Type typeT,
             LinkedList<FieldInfo> currentSet)
         {
-            FieldInfo[] fieldInfos = typeT.GetFields(FieldFlags);
-
-            // https://github.com/dotnet/corefx/issues/14606 asserts that ordering by the metadata
-            // token on a SequentialLayout will produce the fields in their layout order.
-            //
-            // Some other alternatives:
-            // * Add an attribute for controlling the field read order.
-            //    fieldInfos.Select(fi => (fi, fi.GetCustomAttribute<AsnFieldOrderAttribute>(false)).
-            //      Where(val => val.Item2 != null).OrderBy(val => val.Item2.OrderWeight).Select(val => val.Item1);
-            //
-            // * Use Marshal.OffsetOf as a sort key
-            //
-            // * Invent more alternatives
-            foreach (FieldInfo fieldInfo in fieldInfos.OrderBy(fi => fi.MetadataToken))
+            foreach (FieldInfo fieldInfo in GetOrderedFields(typeT))
             {
                 Type fieldType = fieldInfo.FieldType;
 
@@ -211,7 +250,7 @@ private static void SerializeChoice(Type typeT, object value, AsnWriter writer)
             }
             else
             {
-                FieldInfo[] fieldInfos = typeT.GetFields(FieldFlags);
+                FieldInfo[] fieldInfos = GetOrderedFields(typeT);
 
                 for (int i = 0; i < fieldInfos.Length; i++)
                 {