Description

The source generator uses [UnsafeAccessor] (NET8+ non-generic types) or cached reflection delegates (older targets/generic types) to access inaccessible members, enabling three previously unsupported scenarios:

1. Preserve default values for init-only properties

The source generator previously set init-only properties via the constructor delegate's object initializer expression, even when absent from JSON. This replaced C# property initializer defaults with default(T):

public class Foo
{
    public string Name { get; init; } = "DefaultName";
    public int Number { get; init; } = 42;
}
// Previously: static args => new Foo() { Name = (string)args[0], Number = (int)args[1] }
// Deserializing "{}" gave Name=null, Number=0 instead of Name="DefaultName", Number=42

Init-only properties are now removed from the constructor delegate and set post-construction via UnsafeAccessor or reflection, only when present in JSON.

2. Enable [JsonInclude] for inaccessible properties

Previously, [JsonInclude] properties with inaccessible getters or setters generated throwing delegates. They are now fully supported:

public class Bar
{
    [JsonInclude]
    private string Secret { get; set; } = "hidden";
}

3. Enable [JsonConstructor] for inaccessible constructors

Previously, inaccessible constructors marked with [JsonConstructor] were ignored with a SYSLIB1222 warning. They are now invoked via [UnsafeAccessor(UnsafeAccessorKind.Constructor)] or cached ConstructorInfo.Invoke reflection fallback:

public class Baz
{
    [JsonConstructor]
    private Baz(string name) { Name = name; }
    public string Name { get; }
}

Generated Code Samples

UnsafeAccessor path (NET8+ non-generic types)

For a type with a private [JsonInclude] property and an init-only property:

public class MyType
{
    [JsonInclude]
    private string Secret { get; set; } = "default";

    public int Value { get; init; } = 42;
}

The source generator emits [UnsafeAccessor] extern methods that are invoked directly from the getter/setter delegates — no intermediate wrapper methods. JsonPropertyInfoValues<T> is generic on the property type, so the Setter delegate is Action<object, T?> and the Getter is Func<object, T?>. The only cast in each delegate is on the object parameter to the declaring type:

Property getter (inaccessible [JsonInclude])

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_Secret")]
private static extern string __get_MyType_Secret(MyType obj);

// Delegate: Func<object, string?>
Getter = static obj => __get_MyType_Secret((MyType)obj),

Property setter (inaccessible [JsonInclude])

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_Secret")]
private static extern void __set_MyType_Secret(MyType obj, string value);

// Delegate: Action<object, string?>
Setter = static (obj, value) => __set_MyType_Secret((MyType)obj, value!),

Init-only property setter

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_Value")]
private static extern void __set_MyType_Value(MyType obj, int value);

// Delegate: Action<object, int?>
Setter = static (obj, value) => __set_MyType_Value((MyType)obj, value!),

Constructor (inaccessible [JsonConstructor])

[UnsafeAccessor(UnsafeAccessorKind.Constructor)]
private static extern Baz __ctor_Baz(string p0);

// Invoked directly from the parameterized constructor delegate

Value types (structs)

For struct types, the extern uses ref and the delegate passes ref Unsafe.Unbox<T>(obj):

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_Value")]
private static extern void __set_MyStruct_Value(ref MyStruct obj, int value);

Setter = static (obj, value) => __set_MyStruct_Value(ref Unsafe.Unbox<MyStruct>(obj), value!),

Reflection fallback (older targets or generic types)

When [UnsafeAccessor] is not available (e.g., netstandard2.0 targets) or the declaring type is generic (not supported by UnsafeAccessor), the generator falls back to cached reflection with strongly typed wrappers:

Property getter (reflection)

private static Func<MyType, string>? s_get_MyType_Secret;
private static string __get_MyType_Secret(MyType obj) =>
    (s_get_MyType_Secret ??= (Func<MyType, string>)Delegate.CreateDelegate(
        typeof(Func<MyType, string>),
        typeof(MyType).GetProperty("Secret", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)!
            .GetGetMethod(true)!))((MyType)obj);

// Delegate: Func<object, string?>
Getter = static obj => __get_MyType_Secret((MyType)obj),

Property setter (reflection)

private static Action<MyType, string>? s_set_MyType_Secret;
private static void __set_MyType_Secret(MyType obj, string value) =>
    (s_set_MyType_Secret ??= (Action<MyType, string>)Delegate.CreateDelegate(
        typeof(Action<MyType, string>),
        typeof(MyType).GetProperty("Secret", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)!
            .GetSetMethod(true)!))((MyType)obj, value);

// Delegate: Action<object, string?>
Setter = static (obj, value) => __set_MyType_Secret((MyType)obj, value!),

Value type setter (reflection, struct)

For value type property setters, a bespoke ValueTypeSetter<TDeclaringType, TValue> delegate with ref parameter is emitted once in the context class and used with Unsafe.Unbox to mutate the boxed value in-place:

// Defined once per context class
private delegate void ValueTypeSetter<TDeclaringType, TValue>(ref TDeclaringType obj, TValue value);

private static ValueTypeSetter<MyStruct, int>? s_set_MyStruct_Value;
private static void __set_MyStruct_Value(object obj, int value) =>
    (s_set_MyStruct_Value ??= (ValueTypeSetter<MyStruct, int>)Delegate.CreateDelegate(
        typeof(ValueTypeSetter<MyStruct, int>),
        typeof(MyStruct).GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)!
            .GetSetMethod(true)!))(ref Unsafe.Unbox<MyStruct>(obj), value);

Constructor (reflection)

Note: Unlike PropertyInfo, ConstructorInfo cannot be wrapped in a Func<> delegate, so the ConstructorInfo itself is cached:

private static ConstructorInfo? s_ctor_Baz;
private static Baz __ctor_Baz(string p0) =>
    (Baz)(s_ctor_Baz ??= typeof(Baz).GetConstructor(
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
        binder: null, new Type[] { typeof(string) }, modifiers: null)!)
    .Invoke(new object?[] { p0 });

Changes

• Parser: Non-required init-only properties removed from PropertyInitializerSpecs (renamed memberInitializerNames to requiredMemberNames). Inaccessible [JsonInclude] properties no longer flagged as HasInvalidConfigurationForFastPath. Inaccessible [JsonConstructor] constructors no longer nulled out — tracked as inaccessible for the emitter to handle.

• PropertyGenerationSpec: Added CanUseUnsafeAccessors (per-property, checks UnsafeAccessorAttribute availability and non-generic declaring type), NeedsAccessorForGetter, and NeedsAccessorForSetter.

• TypeGenerationSpec: Added ConstructorIsInaccessible and CanUseUnsafeAccessorForConstructor for inaccessible constructor support.

• Emitter: Unified accessor pattern — both UnsafeAccessor and reflection fallback generate wrapper methods with identical names and strongly typed signatures, so call sites don't need to differentiate between the two paths. UnsafeAccessor externs are implementation details wrapped by the unified method.

  • Property accessors: [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_X")] / "set_X" with ref Unsafe.Unbox<T>(obj) for value types, or cached Func<TDeclaringType, TValue> / Action<TDeclaringType, TValue> delegates via Delegate.CreateDelegate on MethodInfo. For struct setters, a bespoke ValueTypeSetter<TDeclaringType, TValue> delegate with ref parameter is emitted.
  • Constructor accessors: [UnsafeAccessor(UnsafeAccessorKind.Constructor)] or cached ConstructorInfo.Invoke (note: ConstructorInfo cannot be wrapped in a delegate unlike MethodInfo, so the ConstructorInfo itself is cached).
  • Fast-path serialization: Inaccessible [JsonInclude] properties included in the fast path using UnsafeAccessor-generated getters.

• KnownTypeSymbols: Detect UnsafeAccessorAttribute availability in the target compilation.

• Runtime validation (JsonMetadataServices.Helpers.cs): PopulateProperties now allows non-public [JsonInclude] properties when getter or setter delegates are provided. Only throws when both are null (backward-compatible with older generators).

• Diagnostics: InaccessibleJsonIncludePropertiesNotSupported (SYSLIB1038) no longer emitted. Inaccessible [JsonConstructor] no longer triggers SYSLIB1222.

• Tests:

  • Updated existing source gen test overrides to expect success instead of InvalidOperationException for private/protected [JsonInclude] members and inaccessible [JsonConstructor] constructors.
  • Added new test types: ClassWithPrivateJsonIncludeProperties_Roundtrip, ClassWithProtectedJsonIncludeProperties_Roundtrip, ClassWithMixedAccessibilityJsonIncludeProperties, ClassWithJsonIncludePrivateInitOnlyProperties, ClassWithJsonIncludePrivateGetterProperties, StructWithJsonIncludePrivateProperties.
  • Added new test methods for roundtrip, default preservation, mixed accessibility, and struct scenarios.
  • Updated MetadataTests to reflect that init-only properties no longer have an AssociatedParameter.
  • All 7779 source gen tests pass.

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.