Add serializer support for required members

src/Orleans.CodeGenerator/Model/SerializableTypeDescription.cs

@@ -158,6 +158,21 @@ public bool IsEmptyConstructable
                     return true;
                 }
 
+                // Types which have required members are not empty constructable for Orleans, at least not yet.
+                var t = Type;
+                while (t != null)
+                {
+                    foreach (var member in t.GetMembers())
+                    {
+                        if (member is IPropertySymbol { IsRequired: true } or IFieldSymbol { IsRequired: true })
+                        {
+                            return false;
+                        }
+                    }
+
+                    t = t.BaseType;
+                }
+
                 foreach (var ctor in Type.Constructors)
                 {
                     if (ctor.Parameters.Length != 0)

src/Orleans.Runtime/Catalog/GrainTypeSharedContext.cs

@@ -83,7 +83,7 @@ private TimeSpan GetCollectionAgeLimit(GrainType grainType, Type grainClass, Gra
                 }
             }
 
-            if (collectionOptions.ClassSpecificCollectionAge.TryGetValue(grainClass.FullName, out var specified))
+            if (collectionOptions.ClassSpecificCollectionAge.TryGetValue(grainClass.FullName!, out var specified))
             {
                 return specified;
             }

test/Orleans.Serialization.UnitTests/GeneratedSerializerTests.cs

@@ -105,6 +105,34 @@ public void GeneratedRecordWithPCtorSerializersRoundTripThroughCodec()
         Assert.Equal(original.StarSign, result.StarSign);
     }
 
+#if NET6_0_OR_GREATER
+    [Fact]
+    public void RequiredMembersAreSupported()
+    {
+        var original = new ClassWithRequiredMembers
+        {
+            IntProperty = 1,
+            StringField = "foo",
+        };
+
+        var result = RoundTripThroughCodec(original);
+
+        Assert.Equal(original.IntProperty, result.IntProperty);
+        Assert.Equal(original.StringField, result.StringField);
+
+        var subOriginal = new SubClassWithRequiredMembersInBase
+        {
+            IntProperty = 1,
+            StringField = "foo",
+        };
+
+        var subResult = RoundTripThroughCodec(subOriginal);
+
+        Assert.Equal(subOriginal.IntProperty, subResult.IntProperty);
+        Assert.Equal(subOriginal.StringField, subResult.StringField);
+    }
+#endif
+
     [Fact]
     public void GeneratedRecordWithExcludedPCtorSerializersRoundTripThroughCodec()
     {

test/Orleans.Serialization.UnitTests/Models.cs

@@ -486,6 +486,23 @@ public class SerializableClassWithCompiledBase : List<int>
         public int IntProperty { get; set; }
     }
 
+#if NET6_0_OR_GREATER
+    [GenerateSerializer]
+    public class ClassWithRequiredMembers
+    {
+        [Id(0)]
+        public required int IntProperty { get; set; }
+
+        [Id(1)]
+        public required string StringField;
+    }
+
+    [GenerateSerializer]
+    public class SubClassWithRequiredMembersInBase : ClassWithRequiredMembers
+    {
+    }
+#endif
+
     [GenerateSerializer]
     public sealed class DerivedFromDictionary<TKey, TValue> : Dictionary<TKey, TValue>
     {

test/Orleans.Serialization.UnitTests/Properties/IsExternalInit.cs

@@ -1,4 +1,4 @@
-namespace System.Runtime.CompilerServices
+namespace System.Runtime.CompilerServices
 {
     internal static class IsExternalInit {}
 }

test/Orleans.Serialization.UnitTests/Properties/RequiredMemberAttribute.cs

@@ -0,0 +1,5 @@
+namespace System.Runtime.CompilerServices
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+    internal sealed class RequiredMemberAttribute : Attribute { }
+}