address API review feedback: expose LibraryName via TypeName.AssemblyName

adamsitnik · adamsitnik · commit 261e842048a2 · 2024-05-15T17:54:47.000+02:00
diff --git a/System.Runtime.Serialization.BinaryFormat.Tests/ReadExactTypesTests.cs b/System.Runtime.Serialization.BinaryFormat.Tests/ReadExactTypesTests.cs
@@ -78,7 +78,8 @@ public void CanRead_CustomTypeWithStringFields(string? text)
         Assert.True(classRecord.HasMember(nameof(CustomTypeWithStringField.Text)));
         Assert.Equal(input.Text, classRecord.GetString(nameof(CustomTypeWithStringField.Text)));
         Assert.Equal(typeof(CustomTypeWithStringField).FullName, classRecord.TypeName.FullName);
-        Assert.Equal(typeof(CustomTypeWithStringField).Assembly.FullName, classRecord.LibraryName.FullName);
+        Assert.Equal(typeof(CustomTypeWithStringField).AssemblyQualifiedName, classRecord.TypeName.AssemblyQualifiedName);
+        Assert.Equal(typeof(CustomTypeWithStringField).Assembly.FullName, classRecord.TypeName.AssemblyName!.FullName);
         Assert.False(classRecord.HasMember("NotPresent"));
     }
 
@@ -232,7 +233,7 @@ public void CanRead_ComplexSystemType()
         Assert.True(classRecord.HasMember(nameof(Exception.Message)));
         Assert.Equal(input.Message, classRecord.GetString(nameof(Exception.Message)));
         Assert.Equal(typeof(Exception).FullName, classRecord.TypeName.FullName);
-        Assert.Equal("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", classRecord.LibraryName.FullName);
+        Assert.Equal("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", classRecord.TypeName.AssemblyName!.FullName);
         Assert.False(classRecord.HasMember("NotPresent"));
     }
 
@@ -264,7 +265,7 @@ public void CanRead_ArraysOfComplexTypes()
         ArrayRecord<ClassRecord> arrayRecord = ((ArrayRecord<ClassRecord>)PayloadReader.Read(Serialize(input)));
 
         Assert.Equal(typeof(CustomTypeWithPrimitiveFields).FullName, arrayRecord.ElementTypeName.FullName);
-        Assert.Equal(typeof(CustomTypeWithPrimitiveFields).Assembly.FullName, arrayRecord.ElementTypeLibraryName.FullName);
+        Assert.Equal(typeof(CustomTypeWithPrimitiveFields).Assembly.FullName, arrayRecord.ElementTypeName.AssemblyName!.FullName);
         ClassRecord?[] classRecords = arrayRecord.ToArray();
         for (int i = 0; i < input.Length; i++)
         {
@@ -334,7 +335,7 @@ public void CanRead_ArraysOfObjects()
         ArrayRecord arrayRecord = (ArrayRecord)PayloadReader.Read(Serialize(input));
 
         Assert.Equal(typeof(object).FullName, arrayRecord.ElementTypeName.FullName);
-        Assert.Equal("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", arrayRecord.ElementTypeLibraryName.FullName);
+        Assert.Equal("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", arrayRecord.ElementTypeName.AssemblyName!.FullName);
         Assert.Equal(input, ((ArrayRecord<object>)arrayRecord).ToArray());
     }
 
@@ -437,5 +438,8 @@ public void CanReadStruct()
 
         Assert.Equal(input.Integer, classRecord.GetInt32(nameof(SerializableStruct.Integer)));
         Assert.Equal(input.Text, classRecord.GetString(nameof(SerializableStruct.Text)));
+        Assert.Equal(typeof(SerializableStruct).FullName, classRecord.TypeName.FullName);
+        Assert.Equal(typeof(SerializableStruct).AssemblyQualifiedName, classRecord.TypeName.AssemblyQualifiedName);
+        Assert.Equal(typeof(SerializableStruct).Assembly.FullName, classRecord.TypeName.AssemblyName!.FullName);
     }
 }
diff --git a/System.Runtime.Serialization.BinaryFormat.Tests/TypeMatchTests.cs b/System.Runtime.Serialization.BinaryFormat.Tests/TypeMatchTests.cs
@@ -374,7 +374,7 @@ private static void VerifySZArray<T>(T input) where T : notnull
         ArrayRecord arrayRecord = (ArrayRecord)PayloadReader.Read(Serialize(array));
 
         Assert.Equal(FormatterServices.GetTypeFullNameIncludingTypeForwards(typeof(T)), arrayRecord.ElementTypeName.FullName);
-        Assert.Equal(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)), arrayRecord.ElementTypeLibraryName.FullName);
+        Assert.Equal(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)), arrayRecord.ElementTypeName.AssemblyName!.FullName);
 
         if (PrimitiveTypes.Contains(typeof(T)))
         {
@@ -384,6 +384,7 @@ private static void VerifySZArray<T>(T input) where T : notnull
         {
             Assert.True(arrayRecord is ArrayRecord<ClassRecord>, userMessage: typeof(T).Name);
             Assert.True(arrayRecord.IsTypeNameMatching(typeof(T[])));
+            Assert.Equal(arrayRecord.ElementTypeName.AssemblyName.FullName, FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)));
         }
 
         foreach (Type type in PrimitiveTypes)
diff --git a/System.Runtime.Serialization.BinaryFormat/Infos/MemberTypeInfo.cs b/System.Runtime.Serialization.BinaryFormat/Infos/MemberTypeInfo.cs
@@ -206,20 +206,20 @@ internal bool ShouldBeRepresentedAsArrayOfClassRecords()
         return false;
     }
 
-    internal TypeName GetElementTypeName()
+    internal TypeName GetElementTypeName(RecordMap recordMap)
     {
         (BinaryType binaryType, object? additionalInfo) = Infos[0];
 
         switch (binaryType)
         {
             case BinaryType.String:
-                return TypeName.Parse(typeof(string).FullName.AsSpan());
+                return TypeName.Parse(typeof(string).FullName.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName);
             case BinaryType.StringArray:
-                return TypeName.Parse(typeof(string[]).FullName.AsSpan());
+                return TypeName.Parse(typeof(string[]).FullName.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName); ;
             case BinaryType.Object:
-                return TypeName.Parse(typeof(object).FullName.AsSpan());
+                return TypeName.Parse(typeof(object).FullName.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName); ;
             case BinaryType.ObjectArray:
-                return TypeName.Parse(typeof(object[]).FullName.AsSpan());
+                return TypeName.Parse(typeof(object[]).FullName.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName); ;
             case BinaryType.Primitive:
             case BinaryType.PrimitiveArray:
                 string? name = ((PrimitiveType)additionalInfo!) switch
@@ -243,29 +243,17 @@ internal TypeName GetElementTypeName()
                 };
 
                 return binaryType is BinaryType.PrimitiveArray
-                    ? TypeName.Parse($"{name}[]".AsSpan())
-                    : TypeName.Parse(name.AsSpan());
+                    ? TypeName.Parse($"{name}[], {FormatterServices.CoreLibAssemblyName.FullName}".AsSpan())
+                    : TypeName.Parse(name.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName);
 
             case BinaryType.SystemClass:
-                return (TypeName)additionalInfo!;
+                return ((TypeName)additionalInfo!).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName);
             case BinaryType.Class:
                 ClassTypeInfo typeInfo = (ClassTypeInfo)additionalInfo!;
-                return typeInfo.TypeName;
+                AssemblyNameInfo libraryName = ((BinaryLibraryRecord)recordMap[typeInfo.LibraryId]).LibraryName;
+                return typeInfo.TypeName.WithAssemblyName(libraryName.FullName);
             default:
                 throw new NotSupportedException();
         }
     }
-
-    internal AssemblyNameInfo GetElementLibraryName(RecordMap recordMap)
-    {
-        (BinaryType binaryType, object? additionalInfo) = Infos[0];
-
-        if (binaryType is BinaryType.Class)
-        {
-            ClassTypeInfo typeInfo = (ClassTypeInfo)additionalInfo!;
-            return ((BinaryLibraryRecord)recordMap[typeInfo.LibraryId]).LibraryName;
-        }
-
-        return FormatterServices.CoreLibAssemblyName;
-    }
 }
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ArrayOfClassesRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ArrayOfClassesRecord.cs
@@ -7,14 +7,13 @@ namespace System.Runtime.Serialization.BinaryFormat;
 
 internal sealed class ArrayOfClassesRecord : ArrayRecord<ClassRecord>
 {
-    private AssemblyNameInfo? _elementTypeLibraryName;
+    private TypeName? _elementTypeName;
 
     internal ArrayOfClassesRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo, RecordMap recordMap)
         : base(arrayInfo)
     {
         MemberTypeInfo = memberTypeInfo;
         RecordMap = recordMap;
-        ElementTypeName = MemberTypeInfo.GetElementTypeName();
         Records = [];
     }
 
@@ -26,9 +25,7 @@ internal ArrayOfClassesRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo
 
     private RecordMap RecordMap { get; }
 
-    public override TypeName ElementTypeName { get; }
-
-    public override AssemblyNameInfo ElementTypeLibraryName => _elementTypeLibraryName ??= MemberTypeInfo.GetElementLibraryName(RecordMap);
+    public override TypeName ElementTypeName => _elementTypeName ??= MemberTypeInfo.GetElementTypeName(RecordMap);
 
     protected override ClassRecord?[] ToArrayOfT(bool allowNulls)
     {
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ArrayRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ArrayRecord.cs
@@ -32,8 +32,6 @@ private protected ArrayRecord(ArrayInfo arrayInfo)
 
     public abstract TypeName ElementTypeName { get; }
 
-    public abstract AssemblyNameInfo ElementTypeLibraryName { get; }
-
     public override int ObjectId => ArrayInfo.ObjectId;
 
     internal long ValuesToRead { get; private protected set; }
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ArraySingleObjectRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ArraySingleObjectRecord.cs
@@ -23,9 +23,8 @@ internal sealed class ArraySingleObjectRecord : ArrayRecord<object?>
 
     public override RecordType RecordType => RecordType.ArraySingleObject;
 
-    public override TypeName ElementTypeName => s_elementTypeName ??= TypeName.Parse(typeof(object).FullName.AsSpan());
-
-    public override AssemblyNameInfo ElementTypeLibraryName => FormatterServices.CoreLibAssemblyName;
+    public override TypeName ElementTypeName
+        => s_elementTypeName ??= TypeName.Parse(typeof(object).FullName.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName);
 
     private List<SerializationRecord> Records { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ArraySinglePrimitiveRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ArraySinglePrimitiveRecord.cs
@@ -21,7 +21,6 @@ internal sealed class ArraySinglePrimitiveRecord<T> : ArrayRecord<T>
     where T : unmanaged
 {
     private static TypeName? s_elementTypeName;
-    private static AssemblyNameInfo? s_elementTypeLibraryName;
 
     internal ArraySinglePrimitiveRecord(ArrayInfo arrayInfo, IReadOnlyList<T> values) : base(arrayInfo)
     {
@@ -31,9 +30,8 @@ internal ArraySinglePrimitiveRecord(ArrayInfo arrayInfo, IReadOnlyList<T> values
 
     public override RecordType RecordType => RecordType.ArraySinglePrimitive;
 
-    public override TypeName ElementTypeName => s_elementTypeName ??= TypeName.Parse(typeof(T).FullName.AsSpan());
-
-    public override AssemblyNameInfo ElementTypeLibraryName => s_elementTypeLibraryName ??= AssemblyNameInfo.Parse(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)).AsSpan());
+    public override TypeName ElementTypeName
+        => s_elementTypeName ??= TypeName.Parse(typeof(T).FullName.AsSpan()).WithAssemblyName(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)));
 
     internal IReadOnlyList<T> Values { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ArraySingleStringRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ArraySingleStringRecord.cs
@@ -23,9 +23,8 @@ internal sealed class ArraySingleStringRecord : ArrayRecord<string?>
 
     public override RecordType RecordType => RecordType.ArraySingleString;
 
-    public override TypeName ElementTypeName => s_elementTypeName ??= TypeName.Parse(typeof(string).FullName.AsSpan());
-
-    public override AssemblyNameInfo ElementTypeLibraryName => FormatterServices.CoreLibAssemblyName;
+    public override TypeName ElementTypeName
+        => s_elementTypeName ??= TypeName.Parse(typeof(string).FullName.AsSpan()).WithAssemblyName(FormatterServices.CoreLibAssemblyName.FullName);
 
     private List<SerializationRecord> Records { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/BinaryArrayRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/BinaryArrayRecord.cs
@@ -16,22 +16,20 @@ internal sealed class BinaryArrayRecord : ArrayRecord
         typeof(TimeSpan), typeof(string), typeof(object)
     ];
 
-    private AssemblyNameInfo? _elementTypeLibraryName;
+    private TypeName? _elementTypeName;
 
     private BinaryArrayRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo, RecordMap recordMap)
         : base(arrayInfo)
     {
         MemberTypeInfo = memberTypeInfo;
         RecordMap = recordMap;
-        ElementTypeName = memberTypeInfo.GetElementTypeName();
         Values = [];
     }
 
     public override RecordType RecordType => RecordType.BinaryArray;
 
-    public override TypeName ElementTypeName { get; }
-
-    public override AssemblyNameInfo ElementTypeLibraryName => _elementTypeLibraryName ??= MemberTypeInfo.GetElementLibraryName(RecordMap);
+    public override TypeName ElementTypeName
+        => _elementTypeName ??= MemberTypeInfo.GetElementTypeName(RecordMap);
 
     private MemberTypeInfo MemberTypeInfo { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ClassRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ClassRecord.cs
@@ -20,15 +20,17 @@ public abstract class ClassRecord : SerializationRecord
 {
     private const int MaxLength = ArrayRecord.DefaultMaxArrayLength;
 
+    private TypeName? _typeName;
+
     private protected ClassRecord(ClassInfo classInfo)
     {
         ClassInfo = classInfo;
         MemberValues = [];
     }
 
-    public TypeName TypeName => ClassInfo.Name;
+    public TypeName TypeName => _typeName ??= ClassInfo.Name.WithAssemblyName(LibraryName.FullName);
 
-    public abstract AssemblyNameInfo LibraryName { get; }
+    internal abstract AssemblyNameInfo LibraryName { get; }
 
     // Currently we don't expose raw values, so we are not preserving the order here.
     public IEnumerable<string> MemberNames => ClassInfo.MemberNames.Keys;
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ClassWithIdRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ClassWithIdRecord.cs
@@ -25,7 +25,7 @@ private ClassWithIdRecord(int objectId, ClassRecord metadataClass) : base(metada
 
     public override RecordType RecordType => RecordType.ClassWithId;
 
-    public override AssemblyNameInfo LibraryName => MetadataClass.LibraryName;
+    internal override AssemblyNameInfo LibraryName => MetadataClass.LibraryName;
 
     public override int ObjectId { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/ClassWithMembersAndTypesRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/ClassWithMembersAndTypesRecord.cs
@@ -26,7 +26,7 @@ private ClassWithMembersAndTypesRecord(ClassInfo classInfo, BinaryLibraryRecord
 
     public override RecordType RecordType => RecordType.ClassWithMembersAndTypes;
 
-    public override AssemblyNameInfo LibraryName => Library.LibraryName;
+    internal override AssemblyNameInfo LibraryName => Library.LibraryName;
 
     internal BinaryLibraryRecord Library { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/RectangularOrCustomOffsetArrayRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/RectangularOrCustomOffsetArrayRecord.cs
@@ -9,7 +9,7 @@ namespace System.Runtime.Serialization.BinaryFormat;
 
 internal sealed class RectangularOrCustomOffsetArrayRecord : ArrayRecord
 {
-    private AssemblyNameInfo? _elementTypeLibraryName;
+    private TypeName? _elementTypeName;
 
     private RectangularOrCustomOffsetArrayRecord(Type elementType, ArrayInfo arrayInfo,
         MemberTypeInfo memberTypeInfo, int[] lengths, int[] offsets, RecordMap recordMap) : base(arrayInfo)
@@ -19,15 +19,13 @@ private RectangularOrCustomOffsetArrayRecord(Type elementType, ArrayInfo arrayIn
         Lengths = lengths;
         Offsets = offsets;
         RecordMap = recordMap;
-        ElementTypeName = memberTypeInfo.GetElementTypeName();
         Values = new();
     }
 
     public override RecordType RecordType => RecordType.BinaryArray;
 
-    public override TypeName ElementTypeName { get; }
-
-    public override AssemblyNameInfo ElementTypeLibraryName => _elementTypeLibraryName ??= MemberTypeInfo.GetElementLibraryName(RecordMap);
+    public override TypeName ElementTypeName
+        => _elementTypeName ??= MemberTypeInfo.GetElementTypeName(RecordMap);
 
     private Type ElementType { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Records/SystemClassWithMembersAndTypesRecord.cs b/System.Runtime.Serialization.BinaryFormat/Records/SystemClassWithMembersAndTypesRecord.cs
@@ -15,7 +15,7 @@ private SystemClassWithMembersAndTypesRecord(ClassInfo classInfo, MemberTypeInfo
 
     public override RecordType RecordType => RecordType.SystemClassWithMembersAndTypes;
 
-    public override AssemblyNameInfo LibraryName => FormatterServices.CoreLibAssemblyName;
+    internal override AssemblyNameInfo LibraryName => FormatterServices.CoreLibAssemblyName;
 
     internal MemberTypeInfo MemberTypeInfo { get; }
 
diff --git a/System.Runtime.Serialization.BinaryFormat/Utils/TypeNameExtensions.cs b/System.Runtime.Serialization.BinaryFormat/Utils/TypeNameExtensions.cs
@@ -0,0 +1,32 @@
+﻿using System.Buffers;
+using System.Reflection.Metadata;
+
+namespace System.Runtime.Serialization.BinaryFormat;
+
+internal static class TypeNameExtensions
+{
+    internal static TypeName WithAssemblyName(this TypeName typeName, string assemblyName)
+    {
+        // For ClassWithMembersAndTypesRecord, the TypeName and LibraryName and provided separately,
+        // and the LibraryName may not be known when parsing TypeName.
+        // For SystemClassWithMembersAndTypesRecord, the LibraryName is not provided, it's always mscorlib.
+        // Ideally, we would just create TypeName with new AssemblyNameInfo.
+        // This will be possible once https://github.com/dotnet/runtime/issues/102263 is done.
+
+        int length = typeName.FullName.Length + 1 + assemblyName.Length;
+        char[] rented = ArrayPool<char>.Shared.Rent(length);
+
+        try
+        {
+            typeName.FullName.AsSpan().CopyTo(rented);
+            rented[typeName.FullName.Length] = ',';
+            assemblyName.AsSpan().CopyTo(rented.AsSpan(typeName.FullName.Length + 1));
+
+            return TypeName.Parse(rented.AsSpan(0, length));
+        }
+        finally
+        {
+            ArrayPool<char>.Shared.Return(rented);
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -374,7 +374,7 @@ private static void VerifySZArray<T>(T input) where T : notnull`
`374`	`374`	`ArrayRecord arrayRecord = (ArrayRecord)PayloadReader.Read(Serialize(array));`
`375`	`375`
`376`	`376`	`Assert.Equal(FormatterServices.GetTypeFullNameIncludingTypeForwards(typeof(T)), arrayRecord.ElementTypeName.FullName);`
`377`		`- Assert.Equal(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)), arrayRecord.ElementTypeLibraryName.FullName);`
	`377`	`+ Assert.Equal(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)), arrayRecord.ElementTypeName.AssemblyName!.FullName);`
`378`	`378`
`379`	`379`	`if (PrimitiveTypes.Contains(typeof(T)))`
`380`	`380`	`{`
`@@ -384,6 +384,7 @@ private static void VerifySZArray<T>(T input) where T : notnull`
`384`	`384`	`{`
`385`	`385`	`Assert.True(arrayRecord is ArrayRecord<ClassRecord>, userMessage: typeof(T).Name);`
`386`	`386`	`Assert.True(arrayRecord.IsTypeNameMatching(typeof(T[])));`
	`387`	`+ Assert.Equal(arrayRecord.ElementTypeName.AssemblyName.FullName, FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)));`
`387`	`388`	`}`
`388`	`389`
`389`	`390`	`foreach (Type type in PrimitiveTypes)`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,13 @@ namespace System.Runtime.Serialization.BinaryFormat;`
`7`	`7`
`8`	`8`	`internal sealed class ArrayOfClassesRecord : ArrayRecord<ClassRecord>`
`9`	`9`	`{`
`10`		`- private AssemblyNameInfo? _elementTypeLibraryName;`
	`10`	`+ private TypeName? _elementTypeName;`
`11`	`11`
`12`	`12`	`internal ArrayOfClassesRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo, RecordMap recordMap)`
`13`	`13`	`: base(arrayInfo)`
`14`	`14`	`{`
`15`	`15`	`MemberTypeInfo = memberTypeInfo;`
`16`	`16`	`RecordMap = recordMap;`
`17`		`- ElementTypeName = MemberTypeInfo.GetElementTypeName();`
`18`	`17`	`Records = [];`
`19`	`18`	`}`
`20`	`19`
`@@ -26,9 +25,7 @@ internal ArrayOfClassesRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo`
`26`	`25`
`27`	`26`	`private RecordMap RecordMap { get; }`
`28`	`27`
`29`		`- public override TypeName ElementTypeName { get; }`
`30`		`-`
`31`		`- public override AssemblyNameInfo ElementTypeLibraryName => _elementTypeLibraryName ??= MemberTypeInfo.GetElementLibraryName(RecordMap);`
	`28`	`+ public override TypeName ElementTypeName => _elementTypeName ??= MemberTypeInfo.GetElementTypeName(RecordMap);`
`32`	`29`
`33`	`30`	`protected override ClassRecord?[] ToArrayOfT(bool allowNulls)`
`34`	`31`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ internal sealed class ArraySinglePrimitiveRecord<T> : ArrayRecord<T>`
`21`	`21`	`where T : unmanaged`
`22`	`22`	`{`
`23`	`23`	`private static TypeName? s_elementTypeName;`
`24`		`- private static AssemblyNameInfo? s_elementTypeLibraryName;`
`25`	`24`
`26`	`25`	`internal ArraySinglePrimitiveRecord(ArrayInfo arrayInfo, IReadOnlyList<T> values) : base(arrayInfo)`
`27`	`26`	`{`
`@@ -31,9 +30,8 @@ internal ArraySinglePrimitiveRecord(ArrayInfo arrayInfo, IReadOnlyList<T> values`
`31`	`30`
`32`	`31`	`public override RecordType RecordType => RecordType.ArraySinglePrimitive;`
`33`	`32`
`34`		`- public override TypeName ElementTypeName => s_elementTypeName ??= TypeName.Parse(typeof(T).FullName.AsSpan());`
`35`		`-`
`36`		`- public override AssemblyNameInfo ElementTypeLibraryName => s_elementTypeLibraryName ??= AssemblyNameInfo.Parse(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)).AsSpan());`
	`33`	`+ public override TypeName ElementTypeName`
	`34`	`+ => s_elementTypeName ??= TypeName.Parse(typeof(T).FullName.AsSpan()).WithAssemblyName(FormatterServices.GetAssemblyNameIncludingTypeForwards(typeof(T)));`
`37`	`35`
`38`	`36`	`internal IReadOnlyList<T> Values { get; }`
`39`	`37`
Original file line number	Diff line number	Diff line change
`@@ -20,15 +20,17 @@ public abstract class ClassRecord : SerializationRecord`
`20`	`20`	`{`
`21`	`21`	`private const int MaxLength = ArrayRecord.DefaultMaxArrayLength;`
`22`	`22`
	`23`	`+ private TypeName? _typeName;`
	`24`	`+`
`23`	`25`	`private protected ClassRecord(ClassInfo classInfo)`
`24`	`26`	`{`
`25`	`27`	`ClassInfo = classInfo;`
`26`	`28`	`MemberValues = [];`
`27`	`29`	`}`
`28`	`30`
`29`		`- public TypeName TypeName => ClassInfo.Name;`
	`31`	`+ public TypeName TypeName => _typeName ??= ClassInfo.Name.WithAssemblyName(LibraryName.FullName);`
`30`	`32`
`31`		`- public abstract AssemblyNameInfo LibraryName { get; }`
	`33`	`+ internal abstract AssemblyNameInfo LibraryName { get; }`
`32`	`34`
`33`	`35`	`// Currently we don't expose raw values, so we are not preserving the order here.`
`34`	`36`	`public IEnumerable<string> MemberNames => ClassInfo.MemberNames.Keys;`