Added field support to JSON serializer #36986

YohDeadfall · 2020-05-25T17:22:34Z

Fixes #876, continues #2192.

@layomia This is reworked version of what I did before. It has no tests (in progress), but I would like to get your comments as soon as possible. And yep, there were unanswered questions in the previous PR. Hope you will find some time to address them (:

layomia · 2020-05-26T22:02:24Z

Addressing questions from #2192:

Should we rename all parameters, fields and properties of type PropertyInfo to something having member as a part of the name?

I think the renaming done in the current PR is fine i.e. using MemberInfo rather thanPropertyInfo. To keep the size of the PR smaller, JsonPropertyInfo and co should not be renamed.

Having a text template to generate class/struct for visibility and fields would improve code coverage and remove duplication.

I'd be supportive of having a template to do this if you want to take this on in this PR, depending on the implementation. However, for the purpose of driving this feature in, I'd be satisfied with interspersing fields in the existing test objects.

Wrt. to coverage for the new code, we should have tests for all serializer features that apply to properties e.g. JsonExtensionData, JsonIgnore (including ignoring per-filed), JsonInclude, JsonConverterAttribute, JsonPropertyName, testing when ctor args map to fields, testing property name collisions etc. This is where the duplication may be more pronounced.

layomia

Thanks for the PR. There are a couple new JsonSerializerOptions properties from #876 (comment) yet to be added. I brought up a few test cases to add. MemberAccessor review is pending on a fix for the CI failures.

src/libraries/System.Text.Json/ref/System.Text.Json.cs

...ies/System.Text.Json/src/System/Text/Json/Serialization/Attributes/JsonConverterAttribute.cs

layomia · 2020-05-26T22:15:25Z

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

@@ -148,6 +154,44 @@ public JsonClassInfo(Type type, JsonSerializerOptions options)
                                    // Non-public properties should not be included for (de)serialization.
                                }
                            }
+
+                            foreach (FieldInfo fieldInfo in currentType.GetFields(binding))


We need to extend the property visibility tests added in #32107 and #36936 to include collisions between field names, and collisions between property and field names.

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonPropertyInfoOfT.cs

...ibraries/System.Text.Json/src/System/Text/Json/Serialization/ReflectionEmitMemberAccessor.cs

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonPropertyInfo.cs

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

layomia · 2020-06-02T16:37:50Z

Ping @YohDeadfall. Marking as ready-for review since we are close to the implementation we want. There's still some feedback above to be addressed.

YohDeadfall · 2020-06-02T16:40:16Z

Already addressed some of them, but not pushed (running tests). Am trying to narrow how the changes cause CI failures.

YohDeadfall · 2020-06-02T19:32:35Z

@layomia could you help me? After rebasing the PR and installing the latest .NET, am unable to build .NET anymore because of:

.nuget\packages\microsoft.dotnet.build.tasks.sharedframework.sdk\5.0.0-beta.20278.4\targets\framework.dependency.targets(445,5): error MSB3073: The command "\dotnet\runtime\artifacts\bin\coreclr\Windows_NT.x64.Debug\sharedFramework\crossgen.exe @\dotnet\runtime\artifacts\obj\netcoreapp\Debug\net5.0\win-x64\crossgen\System.Runtime.WindowsRuntime.rsp" exited with code -2146233031.

This blocks me from fixing the issue with constructors.

YohDeadfall · 2020-06-02T21:06:34Z

Cleaning up artifacts helped.

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

layomia · 2020-06-17T16:50:37Z

@YohDeadfall anything blocking progress on this? I can look into the test failures if needed. Preview 7 snaps on Monday, and we are trying to get this in soon.

YohDeadfall · 2020-06-17T16:52:58Z

Just time blocks it accidentally, nothing more. I aware of the failures and know how to fix them.

layomia · 2020-06-19T16:34:59Z

Looks like CI failures are due to the merge conflicts.

layomia · 2020-06-19T16:36:38Z

Are you holding off for green CI before adding tests?

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonPropertyInfoOfT.cs

steveharter · 2020-06-22T19:34:56Z

Please add the two test classes from the prior PR @ #2192 and be sure to hook them up to TestData.ReadSuccessCases and TestData.WriteSuccessCases. Thanks

layomia

CI is green 👍 We just need the tests now :)

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReflectionMemberAccessor.cs

...ibraries/System.Text.Json/src/System/Text/Json/Serialization/ReflectionEmitMemberAccessor.cs

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonPropertyInfoOfT.cs

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

layomia · 2020-06-24T14:35:52Z

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

+
+            string memberName = memberInfo.Name;
+
+            // The JsonPropertyNameAttribute or naming policy resulted in a collision.


We've made a few changes recently to make sure we have the correct semantics for property name collisions. We should be sure to add tests to cover collisions between field names, and also between property and field names. Basically, we should extend this test suite:

runtime/src/libraries/System.Text.Json/tests/Serialization/PropertyVisibilityTests.cs

Lines 14 to 431 in 8fd5364

[Fact]

public static void Serialize_NewSlotPublicProperty()

{

// Serialize

var obj = new ClassWithNewSlotProperty();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{""MyString"":""NewDefaultValue""}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithNewSlotProperty>(json);

Assert.Equal("NewValue", ((ClassWithNewSlotProperty)obj).MyString);

Assert.Equal("DefaultValue", ((ClassWithInternalProperty)obj).MyString);

}

[Fact]

public static void Serialize_BasePublicProperty_ConflictWithDerivedPrivate()

{

// Serialize

var obj = new ClassWithNewSlotInternalProperty();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{""MyString"":""DefaultValue""}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithNewSlotInternalProperty>(json);

Assert.Equal("NewValue", ((ClassWithPublicProperty)obj).MyString);

Assert.Equal("NewDefaultValue", ((ClassWithNewSlotInternalProperty)obj).MyString);

}

[Fact]

public static void Serialize_PublicProperty_ConflictWithPrivateDueAttributes()

{

// Serialize

var obj = new ClassWithPropertyNamingConflict();

// Newtonsoft.Json throws JsonSerializationException here because

// non-public properties are included when [JsonProperty] is placed on them.

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{""MyString"":""DefaultValue""}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

// Newtonsoft.Json throws JsonSerializationException here because

// non-public properties are included when [JsonProperty] is placed on them.

obj = JsonSerializer.Deserialize<ClassWithPropertyNamingConflict>(json);

Assert.Equal("NewValue", obj.MyString);

Assert.Equal("ConflictingValue", obj.ConflictingString);

}

[Fact]

public static void Serialize_PublicProperty_ConflictWithPrivateDuePolicy()

{

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

// Serialize

var obj = new ClassWithPropertyPolicyConflict();

string json = JsonSerializer.Serialize(obj, options);

Assert.Equal(@"{""myString"":""DefaultValue""}", json);

// Deserialize

json = @"{""myString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithPropertyPolicyConflict>(json, options);

Assert.Equal("NewValue", obj.MyString);

Assert.Equal("ConflictingValue", obj.myString);

}

[Fact]

public static void Serialize_NewSlotPublicProperty_ConflictWithBasePublicProperty()

{

// Serialize

var obj = new ClassWithNewSlotDecimalProperty();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{""MyNumeric"":1.5}", json);

// Deserialize

json = @"{""MyNumeric"":2.5}";

obj = JsonSerializer.Deserialize<ClassWithNewSlotDecimalProperty>(json);

Assert.Equal(2.5M, obj.MyNumeric);

}

[Fact]

public static void Serialize_NewSlotPublicProperty_SpecifiedJsonPropertyName()

{

// Serialize

var obj = new ClassWithNewSlotAttributedDecimalProperty();

string json = JsonSerializer.Serialize(obj);

Assert.Contains(@"""MyNewNumeric"":1.5", json);

Assert.Contains(@"""MyNumeric"":1", json);

// Deserialize

json = @"{""MyNewNumeric"":2.5,""MyNumeric"":4}";

obj = JsonSerializer.Deserialize<ClassWithNewSlotAttributedDecimalProperty>(json);

Assert.Equal(4, ((ClassWithHiddenByNewSlotIntProperty)obj).MyNumeric);

Assert.Equal(2.5M, ((ClassWithNewSlotAttributedDecimalProperty)obj).MyNumeric);

}

[Fact]

public static void Ignore_NonPublicProperty()

{

// Serialize

var obj = new ClassWithInternalProperty();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithInternalProperty>(json);

Assert.Equal("DefaultValue", obj.MyString);

}

[Fact]

public static void Ignore_NewSlotPublicPropertyIgnored()

{

// Serialize

var obj = new ClassWithIgnoredNewSlotProperty();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithIgnoredNewSlotProperty>(json);

Assert.Equal("NewDefaultValue", ((ClassWithIgnoredNewSlotProperty)obj).MyString);

Assert.Equal("DefaultValue", ((ClassWithInternalProperty)obj).MyString);

}

[Fact]

public static void Ignore_BasePublicPropertyIgnored_ConflictWithDerivedPrivate()

{

// Serialize

var obj = new ClassWithIgnoredPublicPropertyAndNewSlotPrivate();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithIgnoredPublicPropertyAndNewSlotPrivate>(json);

Assert.Equal("DefaultValue", ((ClassWithIgnoredPublicProperty)obj).MyString);

Assert.Equal("NewDefaultValue", ((ClassWithIgnoredPublicPropertyAndNewSlotPrivate)obj).MyString);

}

[Fact]

public static void Ignore_PublicProperty_ConflictWithPrivateDueAttributes()

{

// Serialize

var obj = new ClassWithIgnoredPropertyNamingConflictPrivate();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{}", json);

// Newtonsoft.Json has the following output because non-public properties are included when [JsonProperty] is placed on them.

// {"MyString":"ConflictingValue"}

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyNamingConflictPrivate>(json);

Assert.Equal("DefaultValue", obj.MyString);

Assert.Equal("ConflictingValue", obj.ConflictingString);

// The output for Newtonsoft.Json is:

// obj.ConflictingString = "NewValue"

// obj.MyString still equals "DefaultValue"

}

[Fact]

public static void Ignore_PublicProperty_ConflictWithPrivateDuePolicy()

{

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

// Serialize

var obj = new ClassWithIgnoredPropertyPolicyConflictPrivate();

string json = JsonSerializer.Serialize(obj, options);

Assert.Equal(@"{}", json);

// Deserialize

json = @"{""myString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyPolicyConflictPrivate>(json, options);

Assert.Equal("DefaultValue", obj.MyString);

Assert.Equal("ConflictingValue", obj.myString);

}

[Fact]

public static void Ignore_PublicProperty_ConflictWithPublicDueAttributes()

{

// Serialize

var obj = new ClassWithIgnoredPropertyNamingConflictPublic();

string json = JsonSerializer.Serialize(obj);

Assert.Equal(@"{""MyString"":""ConflictingValue""}", json);

// Deserialize

json = @"{""MyString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyNamingConflictPublic>(json);

Assert.Equal("DefaultValue", obj.MyString);

Assert.Equal("NewValue", obj.ConflictingString);

}

[Fact]

public static void Ignore_PublicProperty_ConflictWithPublicDuePolicy()

{

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

// Serialize

var obj = new ClassWithIgnoredPropertyPolicyConflictPublic();

string json = JsonSerializer.Serialize(obj, options);

Assert.Equal(@"{""myString"":""ConflictingValue""}", json);

// Deserialize

json = @"{""myString"":""NewValue""}";

obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyPolicyConflictPublic>(json, options);

Assert.Equal("DefaultValue", obj.MyString);

Assert.Equal("NewValue", obj.myString);

}

[Fact]

public static void Throw_PublicProperty_ConflictDueAttributes()

{

// Serialize

var obj = new ClassWithPropertyNamingConflictWhichThrows();

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Serialize(obj));

// Deserialize

string json = @"{""MyString"":""NewValue""}";

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Deserialize<ClassWithPropertyNamingConflictWhichThrows>(json));

}

[Fact]

public static void Throw_PublicProperty_ConflictDueAttributes_SingleInheritance()

{

// Serialize

var obj = new ClassInheritedWithPropertyNamingConflictWhichThrows();

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Serialize(obj));

// The output for Newtonsoft.Json is:

// {"MyString":"ConflictingValue"}

// Conflicts at different type-hierarchy levels that are not caused by

// deriving or the new keyword are allowed. Properties on more derived types win.

// Deserialize

string json = @"{""MyString"":""NewValue""}";

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Deserialize<ClassInheritedWithPropertyNamingConflictWhichThrows>(json));

// The output for Newtonsoft.Json is:

// obj.ConflictingString = "NewValue"

// obj.MyString still equals "DefaultValue"

}

[Fact]

public static void Throw_PublicProperty_ConflictDueAttributes_DoubleInheritance()

{

// Serialize

var obj = new ClassTwiceInheritedWithPropertyNamingConflictWhichThrows();

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Serialize(obj));

// The output for Newtonsoft.Json is:

// {"MyString":"ConflictingValue"}

// Conflicts at different type-hierarchy levels that are not caused by

// deriving or the new keyword are allowed. Properties on more derived types win.

// Deserialize

string json = @"{""MyString"":""NewValue""}";

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Deserialize<ClassTwiceInheritedWithPropertyNamingConflictWhichThrows>(json));

// The output for Newtonsoft.Json is:

// obj.ConflictingString = "NewValue"

// obj.MyString still equals "DefaultValue"

}

[Fact]

public static void Throw_PublicProperty_ConflictDuePolicy()

{

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

// Serialize

var obj = new ClassWithPropertyPolicyConflictWhichThrows();

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Serialize(obj, options));

// Deserialize

string json = @"{""MyString"":""NewValue""}";

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Deserialize<ClassWithPropertyPolicyConflictWhichThrows>(json, options));

}

[Fact]

public static void Throw_PublicProperty_ConflictDuePolicy_SingleInheritance()

{

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

// Serialize

var obj = new ClassInheritedWithPropertyPolicyConflictWhichThrows();

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Serialize(obj, options));

// The output for Newtonsoft.Json is:

// {"myString":"ConflictingValue"}

// Conflicts at different type-hierarchy levels that are not caused by

// deriving or the new keyword are allowed. Properties on more derived types win.

// Deserialize

string json = @"{""MyString"":""NewValue""}";

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Deserialize<ClassInheritedWithPropertyPolicyConflictWhichThrows>(json, options));

// The output for Newtonsoft.Json is:

// obj.myString = "NewValue"

// obj.MyString still equals "DefaultValue"

}

[Fact]

public static void Throw_PublicProperty_ConflictDuePolicy_DobuleInheritance()

{

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

// Serialize

var obj = new ClassTwiceInheritedWithPropertyPolicyConflictWhichThrows();

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Serialize(obj, options));

// The output for Newtonsoft.Json is:

// {"myString":"ConflictingValue"}

// Conflicts at different type-hierarchy levels that are not caused by

// deriving or the new keyword are allowed. Properties on more derived types win.

// Deserialize

string json = @"{""MyString"":""NewValue""}";

Assert.Throws<InvalidOperationException>(

() => JsonSerializer.Deserialize<ClassTwiceInheritedWithPropertyPolicyConflictWhichThrows>(json, options));

// The output for Newtonsoft.Json is:

// obj.myString = "NewValue"

// obj.MyString still equals "DefaultValue"

}

[Fact]

public static void HiddenPropertiesIgnored_WhenOverridesIgnored()

{

string serialized = JsonSerializer.Serialize(new DerivedClass_With_IgnoredOverride());

Assert.Equal(@"{}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_WithVisibleProperty_Of_DerivedClass_With_IgnoredOverride());

Assert.Equal(@"{""MyProp"":false}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_IgnoredOverride_And_ConflictingPropertyName());

Assert.Equal(@"{""MyProp"":null}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_NewProperty());

Assert.Equal(@"{""MyProp"":false}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_WithConflictingNewMember());

Assert.Equal(@"{""MyProp"":false}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_WithConflictingNewMember_Of_DifferentType());

Assert.Equal(@"{""MyProp"":0}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_ConflictingNewMember());

Assert.Equal(@"{""MyProp"":false}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_ConflictingNewMember_Of_DifferentType());

Assert.Equal(@"{""MyProp"":false}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_NewProperty_And_ConflictingPropertyName());

Assert.Equal(@"{""MyProp"":null}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_NewProperty_Of_DifferentType());

Assert.Equal(@"{""MyProp"":false}", serialized);

serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_NewProperty_Of_DifferentType_And_ConflictingPropertyName());

Assert.Equal(@"{""MyProp"":null}", serialized);

serialized = JsonSerializer.Serialize(new FurtherDerivedClass_With_ConflictingPropertyName());

Assert.Equal(@"{""MyProp"":null}", serialized);

// Here we differ from Newtonsoft.Json, where the output would be

// {"MyProp":null}

// Conflicts at different type-hierarchy levels that are not caused by

// deriving or the new keyword are allowed. Properties on more derived types win.

// This is invalid in System.Text.Json.

Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(new DerivedClass_WithConflictingPropertyName()));

serialized = JsonSerializer.Serialize(new FurtherDerivedClass_With_IgnoredOverride());

Assert.Equal(@"{""MyProp"":null}", serialized);

}

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

src/libraries/System.Text.Json/src/System/Text/Json/JsonHelpers.cs

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

layomia · 2020-07-06T07:59:06Z

@YohDeadfall, will you have some time soon to check on the failures here?

YohDeadfall · 2020-07-06T08:39:05Z

Am on vacation till Saturday, so on Sunday will return back and finish the feature.

layomia

LGTM when these comments are addressed.

layomia · 2020-07-12T01:28:56Z

...System.Text.Json/src/System/Text/Json/Serialization/Attributes/JsonExtensionDataAttribute.cs

@@ -14,13 +14,13 @@ namespace System.Text.Json.Serialization
    /// During deserializing, when using <see cref="object"/> a "null" JSON value is treated as a <c>null</c> object reference, and when using
    /// <see cref="JsonElement"/> a "null" is treated as a JsonElement with <see cref="JsonElement.ValueKind"/> set to <see cref="JsonValueKind.Null"/>.
    ///
-    /// During serializing, the name of the extension data property is not included in the JSON;
+    /// During serializing, the name of the extension data member is not included in the JSON;


member

change to property or field here and below.

layomia · 2020-07-12T01:29:10Z

...raries/System.Text.Json/src/System/Text/Json/Serialization/Attributes/JsonIgnoreAttribute.cs

    public sealed class JsonIgnoreAttribute : JsonAttribute
    {
        /// <summary>
-        /// Specifies the condition that must be met before a property will be ignored.
+        /// Specifies the condition that must be met before a member will be ignored.


property or field

layomia · 2020-07-12T01:35:25Z

src/libraries/System.Text.Json/tests/Serialization/SpanTests.cs

@@ -30,9 +31,11 @@ public static void Read(Type classType, byte[] data)
        public static void ReadFromStream(Type classType, byte[] data)
        {
            MemoryStream stream = new MemoryStream(data);
+            var options = new JsonSerializerOptions { IncludeFields = true };


We also need IncludeFields on line 48. This is the cause of the CI failures.

Yeah, I pushed tests as is before going to vacation. Thought that would have some time, but had other interests there.

layomia · 2020-07-12T01:36:51Z

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

                                    {
-                                        ThrowHelper.ThrowInvalidOperationException_JsonIncludeOnNonPublicInvalid(propertyInfo, currentType);
+                                        ThrowHelper.ThrowInvalidOperationException_JsonIncludeOnNonPublicInvalid(fieldInfo, currentType);


Please test this code path by extending these tests:

runtime/src/libraries/System.Text.Json/tests/Serialization/PropertyVisibilityTests.NonPublicAccessors.cs

Lines 295 to 331 in 3aa66d4

[Theory]

[InlineData(typeof(ClassWithPrivateProperty_WithJsonIncludeProperty))]

[InlineData(typeof(ClassWithInternalProperty_WithJsonIncludeProperty))]

[InlineData(typeof(ClassWithProtectedProperty_WithJsonIncludeProperty))]

public static void NonPublicProperty_WithJsonInclude_Invalid(Type type)

{

InvalidOperationException ex = Assert.Throws<InvalidOperationException>(() => JsonSerializer.Deserialize("", type));

string exAsStr = ex.ToString();

Assert.Contains("MyString", exAsStr);

Assert.Contains(type.ToString(), exAsStr);

Assert.Contains("JsonIncludeAttribute", exAsStr);

ex = Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(Activator.CreateInstance(type), type));

exAsStr = ex.ToString();

Assert.Contains("MyString", exAsStr);

Assert.Contains(type.ToString(), exAsStr);

Assert.Contains("JsonIncludeAttribute", exAsStr);

}

private class ClassWithPrivateProperty_WithJsonIncludeProperty

{

[JsonInclude]

private string MyString { get; set; }

}

private class ClassWithInternalProperty_WithJsonIncludeProperty

{

[JsonInclude]

internal string MyString { get; }

}

private class ClassWithProtectedProperty_WithJsonIncludeProperty

{

[JsonInclude]

protected string MyString { get; private set; }

}

}

layomia · 2020-07-12T01:39:44Z

src/libraries/System.Text.Json/ref/System.Text.Json.cs

@@ -218,6 +218,8 @@ public sealed partial class JsonSerializerOptions
        public System.Text.Encodings.Web.JavaScriptEncoder? Encoder { get { throw null; } set { } }
        public bool IgnoreNullValues { get { throw null; } set { } }
        public bool IgnoreReadOnlyProperties { get { throw null; } set { } }
+        public bool IgnoreReadOnlyFields { get { throw null; } set { } }


Please add a test using this option.

layomia · 2020-07-12T01:39:59Z

src/libraries/System.Text.Json/ref/System.Text.Json.cs

@@ -479,7 +481,7 @@ public abstract partial class JsonConverter
        internal JsonConverter() { }
        public abstract bool CanConvert(System.Type typeToConvert);
    }
-    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Enum | System.AttributeTargets.Property | System.AttributeTargets.Struct, AllowMultiple=false)]
+    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Struct | System.AttributeTargets.Enum | System.AttributeTargets.Property | System.AttributeTargets.Field, AllowMultiple=false)]


Please add a test using the attribute on a field, along with JsonIgnoreAttribute, JsonIncludeAttribute, JsonExtensionDataAttribute & JsonPropertyName.

Added some new tests, but not finished yet. For naming they already exist.

layomia

LGTM - thanks for your contribution, @YohDeadfall.

...ies/System.Text.Json/src/System/Text/Json/Serialization/Attributes/JsonConverterAttribute.cs

src/libraries/System.Text.Json/tests/Serialization/ExtensionDataTests.cs

layomia · 2020-07-14T00:31:53Z

Will address minor clean up.

By default the AspNet.Core Serializer on 3.0+ is the System.Text.Json, the current implementation of the library doesn't support Fields only Properties even public fields. There is a change that will be part of .net 5.0 that will provide a option to change this behaviour dotnet/runtime#36986

Dotnet-GitSync-Bot added the area-System.Text.Json label May 25, 2020

layomia added this to the 5.0 milestone May 26, 2020

layomia assigned YohDeadfall May 26, 2020

layomia reviewed May 26, 2020

View reviewed changes

layomia mentioned this pull request May 28, 2020

Support for overriding enum field name in JsonConverterEnum (#31081) #37113

Closed

layomia marked this pull request as ready for review June 2, 2020 16:37

layomia requested review from jozkee and steveharter as code owners June 2, 2020 16:37

YohDeadfall force-pushed the json-field-support branch from 7a018ec to 457b22e Compare June 2, 2020 16:58

YohDeadfall commented Jun 8, 2020

View reviewed changes

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs Outdated Show resolved Hide resolved

YohDeadfall force-pushed the json-field-support branch from b84b565 to 4786151 Compare June 9, 2020 17:53

YohDeadfall force-pushed the json-field-support branch from 17650a4 to ee5ef0d Compare June 17, 2020 18:44

steveharter reviewed Jun 22, 2020

View reviewed changes

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonPropertyInfoOfT.cs Show resolved Hide resolved

YohDeadfall force-pushed the json-field-support branch from ee5ef0d to e528a0a Compare June 23, 2020 21:50

Added field support to JSON serializer

70813da

YohDeadfall force-pushed the json-field-support branch from e528a0a to 70813da Compare June 24, 2020 11:47

layomia reviewed Jun 24, 2020

View reviewed changes

YohDeadfall commented Jun 25, 2020

View reviewed changes

src/libraries/System.Text.Json/src/System/Text/Json/JsonHelpers.cs Outdated Show resolved Hide resolved

Addressed issues

c45c32e

YohDeadfall force-pushed the json-field-support branch from 9a4f40e to c45c32e Compare June 25, 2020 17:27

layomia reviewed Jun 25, 2020

View reviewed changes

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs Show resolved Hide resolved

Added tests

3aa66d4

layomia reviewed Jul 12, 2020

View reviewed changes

Addressed issues

735f6f7

YohDeadfall force-pushed the json-field-support branch from 2c58c23 to 735f6f7 Compare July 13, 2020 18:33

layomia approved these changes Jul 14, 2020

View reviewed changes

...ies/System.Text.Json/src/System/Text/Json/Serialization/Attributes/JsonConverterAttribute.cs Show resolved Hide resolved

src/libraries/System.Text.Json/tests/Serialization/ExtensionDataTests.cs Show resolved Hide resolved

layomia merged commit 8892364 into dotnet:master Jul 14, 2020

YohDeadfall deleted the json-field-support branch July 14, 2020 07:54

NGL321 mentioned this pull request Jul 15, 2020

Add support for serializing fields to Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer aws/aws-lambda-dotnet#696

Closed

1 task

layomia mentioned this pull request Jul 21, 2020

Clean up code following JSON number handling and field support PRs #39716

Merged

layomia mentioned this pull request Aug 7, 2020

Add code to preserve public fields of input types to JsonSerializer #40508

Merged

ghost locked as resolved and limited conversation to collaborators Dec 9, 2020

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Added field support to JSON serializer #36986

Added field support to JSON serializer #36986

YohDeadfall commented May 25, 2020

layomia commented May 26, 2020 •

edited

Loading

layomia left a comment

layomia May 26, 2020

layomia commented Jun 2, 2020

YohDeadfall commented Jun 2, 2020

YohDeadfall commented Jun 2, 2020

YohDeadfall commented Jun 2, 2020

layomia commented Jun 17, 2020

YohDeadfall commented Jun 17, 2020

layomia commented Jun 19, 2020

layomia commented Jun 19, 2020

steveharter commented Jun 22, 2020

layomia left a comment

layomia Jun 24, 2020

layomia commented Jul 6, 2020

YohDeadfall commented Jul 6, 2020

layomia left a comment

layomia Jul 12, 2020

layomia Jul 12, 2020

layomia Jul 12, 2020

YohDeadfall Jul 13, 2020

layomia Jul 12, 2020

layomia Jul 12, 2020

layomia Jul 12, 2020

YohDeadfall Jul 13, 2020

layomia left a comment

layomia commented Jul 14, 2020


		string memberName = memberInfo.Name;

		// The JsonPropertyNameAttribute or naming policy resulted in a collision.

	[Fact]
	public static void Serialize_NewSlotPublicProperty()
	{
	// Serialize
	var obj = new ClassWithNewSlotProperty();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{""MyString"":""NewDefaultValue""}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithNewSlotProperty>(json);

	Assert.Equal("NewValue", ((ClassWithNewSlotProperty)obj).MyString);
	Assert.Equal("DefaultValue", ((ClassWithInternalProperty)obj).MyString);
	}

	[Fact]
	public static void Serialize_BasePublicProperty_ConflictWithDerivedPrivate()
	{
	// Serialize
	var obj = new ClassWithNewSlotInternalProperty();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{""MyString"":""DefaultValue""}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithNewSlotInternalProperty>(json);

	Assert.Equal("NewValue", ((ClassWithPublicProperty)obj).MyString);
	Assert.Equal("NewDefaultValue", ((ClassWithNewSlotInternalProperty)obj).MyString);
	}

	[Fact]
	public static void Serialize_PublicProperty_ConflictWithPrivateDueAttributes()
	{
	// Serialize
	var obj = new ClassWithPropertyNamingConflict();

	// Newtonsoft.Json throws JsonSerializationException here because
	// non-public properties are included when [JsonProperty] is placed on them.
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{""MyString"":""DefaultValue""}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";

	// Newtonsoft.Json throws JsonSerializationException here because
	// non-public properties are included when [JsonProperty] is placed on them.
	obj = JsonSerializer.Deserialize<ClassWithPropertyNamingConflict>(json);

	Assert.Equal("NewValue", obj.MyString);
	Assert.Equal("ConflictingValue", obj.ConflictingString);
	}

	[Fact]
	public static void Serialize_PublicProperty_ConflictWithPrivateDuePolicy()
	{
	var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

	// Serialize
	var obj = new ClassWithPropertyPolicyConflict();
	string json = JsonSerializer.Serialize(obj, options);

	Assert.Equal(@"{""myString"":""DefaultValue""}", json);

	// Deserialize
	json = @"{""myString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithPropertyPolicyConflict>(json, options);

	Assert.Equal("NewValue", obj.MyString);
	Assert.Equal("ConflictingValue", obj.myString);
	}

	[Fact]
	public static void Serialize_NewSlotPublicProperty_ConflictWithBasePublicProperty()
	{
	// Serialize
	var obj = new ClassWithNewSlotDecimalProperty();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{""MyNumeric"":1.5}", json);

	// Deserialize
	json = @"{""MyNumeric"":2.5}";
	obj = JsonSerializer.Deserialize<ClassWithNewSlotDecimalProperty>(json);

	Assert.Equal(2.5M, obj.MyNumeric);
	}

	[Fact]
	public static void Serialize_NewSlotPublicProperty_SpecifiedJsonPropertyName()
	{
	// Serialize
	var obj = new ClassWithNewSlotAttributedDecimalProperty();
	string json = JsonSerializer.Serialize(obj);

	Assert.Contains(@"""MyNewNumeric"":1.5", json);
	Assert.Contains(@"""MyNumeric"":1", json);

	// Deserialize
	json = @"{""MyNewNumeric"":2.5,""MyNumeric"":4}";
	obj = JsonSerializer.Deserialize<ClassWithNewSlotAttributedDecimalProperty>(json);

	Assert.Equal(4, ((ClassWithHiddenByNewSlotIntProperty)obj).MyNumeric);
	Assert.Equal(2.5M, ((ClassWithNewSlotAttributedDecimalProperty)obj).MyNumeric);
	}

	[Fact]
	public static void Ignore_NonPublicProperty()
	{
	// Serialize
	var obj = new ClassWithInternalProperty();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithInternalProperty>(json);

	Assert.Equal("DefaultValue", obj.MyString);
	}

	[Fact]
	public static void Ignore_NewSlotPublicPropertyIgnored()
	{
	// Serialize
	var obj = new ClassWithIgnoredNewSlotProperty();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithIgnoredNewSlotProperty>(json);

	Assert.Equal("NewDefaultValue", ((ClassWithIgnoredNewSlotProperty)obj).MyString);
	Assert.Equal("DefaultValue", ((ClassWithInternalProperty)obj).MyString);
	}

	[Fact]
	public static void Ignore_BasePublicPropertyIgnored_ConflictWithDerivedPrivate()
	{
	// Serialize
	var obj = new ClassWithIgnoredPublicPropertyAndNewSlotPrivate();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithIgnoredPublicPropertyAndNewSlotPrivate>(json);

	Assert.Equal("DefaultValue", ((ClassWithIgnoredPublicProperty)obj).MyString);
	Assert.Equal("NewDefaultValue", ((ClassWithIgnoredPublicPropertyAndNewSlotPrivate)obj).MyString);
	}

	[Fact]
	public static void Ignore_PublicProperty_ConflictWithPrivateDueAttributes()
	{
	// Serialize
	var obj = new ClassWithIgnoredPropertyNamingConflictPrivate();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{}", json);

	// Newtonsoft.Json has the following output because non-public properties are included when [JsonProperty] is placed on them.
	// {"MyString":"ConflictingValue"}

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyNamingConflictPrivate>(json);

	Assert.Equal("DefaultValue", obj.MyString);
	Assert.Equal("ConflictingValue", obj.ConflictingString);

	// The output for Newtonsoft.Json is:
	// obj.ConflictingString = "NewValue"
	// obj.MyString still equals "DefaultValue"
	}

	[Fact]
	public static void Ignore_PublicProperty_ConflictWithPrivateDuePolicy()
	{
	var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

	// Serialize
	var obj = new ClassWithIgnoredPropertyPolicyConflictPrivate();
	string json = JsonSerializer.Serialize(obj, options);

	Assert.Equal(@"{}", json);

	// Deserialize
	json = @"{""myString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyPolicyConflictPrivate>(json, options);

	Assert.Equal("DefaultValue", obj.MyString);
	Assert.Equal("ConflictingValue", obj.myString);
	}

	[Fact]
	public static void Ignore_PublicProperty_ConflictWithPublicDueAttributes()
	{
	// Serialize
	var obj = new ClassWithIgnoredPropertyNamingConflictPublic();
	string json = JsonSerializer.Serialize(obj);

	Assert.Equal(@"{""MyString"":""ConflictingValue""}", json);

	// Deserialize
	json = @"{""MyString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyNamingConflictPublic>(json);

	Assert.Equal("DefaultValue", obj.MyString);
	Assert.Equal("NewValue", obj.ConflictingString);
	}

	[Fact]
	public static void Ignore_PublicProperty_ConflictWithPublicDuePolicy()
	{
	var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

	// Serialize
	var obj = new ClassWithIgnoredPropertyPolicyConflictPublic();
	string json = JsonSerializer.Serialize(obj, options);

	Assert.Equal(@"{""myString"":""ConflictingValue""}", json);

	// Deserialize
	json = @"{""myString"":""NewValue""}";
	obj = JsonSerializer.Deserialize<ClassWithIgnoredPropertyPolicyConflictPublic>(json, options);

	Assert.Equal("DefaultValue", obj.MyString);
	Assert.Equal("NewValue", obj.myString);
	}

	[Fact]
	public static void Throw_PublicProperty_ConflictDueAttributes()
	{
	// Serialize
	var obj = new ClassWithPropertyNamingConflictWhichThrows();
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Serialize(obj));

	// Deserialize
	string json = @"{""MyString"":""NewValue""}";
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Deserialize<ClassWithPropertyNamingConflictWhichThrows>(json));
	}

	[Fact]
	public static void Throw_PublicProperty_ConflictDueAttributes_SingleInheritance()
	{
	// Serialize
	var obj = new ClassInheritedWithPropertyNamingConflictWhichThrows();
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Serialize(obj));

	// The output for Newtonsoft.Json is:
	// {"MyString":"ConflictingValue"}
	// Conflicts at different type-hierarchy levels that are not caused by
	// deriving or the new keyword are allowed. Properties on more derived types win.

	// Deserialize
	string json = @"{""MyString"":""NewValue""}";
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Deserialize<ClassInheritedWithPropertyNamingConflictWhichThrows>(json));

	// The output for Newtonsoft.Json is:
	// obj.ConflictingString = "NewValue"
	// obj.MyString still equals "DefaultValue"
	}

	[Fact]
	public static void Throw_PublicProperty_ConflictDueAttributes_DoubleInheritance()
	{
	// Serialize
	var obj = new ClassTwiceInheritedWithPropertyNamingConflictWhichThrows();
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Serialize(obj));

	// The output for Newtonsoft.Json is:
	// {"MyString":"ConflictingValue"}
	// Conflicts at different type-hierarchy levels that are not caused by
	// deriving or the new keyword are allowed. Properties on more derived types win.

	// Deserialize
	string json = @"{""MyString"":""NewValue""}";

	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Deserialize<ClassTwiceInheritedWithPropertyNamingConflictWhichThrows>(json));

	// The output for Newtonsoft.Json is:
	// obj.ConflictingString = "NewValue"
	// obj.MyString still equals "DefaultValue"
	}

	[Fact]
	public static void Throw_PublicProperty_ConflictDuePolicy()
	{
	var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

	// Serialize
	var obj = new ClassWithPropertyPolicyConflictWhichThrows();
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Serialize(obj, options));

	// Deserialize
	string json = @"{""MyString"":""NewValue""}";
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Deserialize<ClassWithPropertyPolicyConflictWhichThrows>(json, options));
	}

	[Fact]
	public static void Throw_PublicProperty_ConflictDuePolicy_SingleInheritance()
	{
	var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

	// Serialize
	var obj = new ClassInheritedWithPropertyPolicyConflictWhichThrows();

	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Serialize(obj, options));

	// The output for Newtonsoft.Json is:
	// {"myString":"ConflictingValue"}
	// Conflicts at different type-hierarchy levels that are not caused by
	// deriving or the new keyword are allowed. Properties on more derived types win.

	// Deserialize
	string json = @"{""MyString"":""NewValue""}";
	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Deserialize<ClassInheritedWithPropertyPolicyConflictWhichThrows>(json, options));

	// The output for Newtonsoft.Json is:
	// obj.myString = "NewValue"
	// obj.MyString still equals "DefaultValue"
	}

	[Fact]
	public static void Throw_PublicProperty_ConflictDuePolicy_DobuleInheritance()
	{
	var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };

	// Serialize
	var obj = new ClassTwiceInheritedWithPropertyPolicyConflictWhichThrows();

	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Serialize(obj, options));

	// The output for Newtonsoft.Json is:
	// {"myString":"ConflictingValue"}
	// Conflicts at different type-hierarchy levels that are not caused by
	// deriving or the new keyword are allowed. Properties on more derived types win.

	// Deserialize
	string json = @"{""MyString"":""NewValue""}";

	Assert.Throws<InvalidOperationException>(
	() => JsonSerializer.Deserialize<ClassTwiceInheritedWithPropertyPolicyConflictWhichThrows>(json, options));

	// The output for Newtonsoft.Json is:
	// obj.myString = "NewValue"
	// obj.MyString still equals "DefaultValue"
	}

	[Fact]
	public static void HiddenPropertiesIgnored_WhenOverridesIgnored()
	{
	string serialized = JsonSerializer.Serialize(new DerivedClass_With_IgnoredOverride());
	Assert.Equal(@"{}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_WithVisibleProperty_Of_DerivedClass_With_IgnoredOverride());
	Assert.Equal(@"{""MyProp"":false}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_IgnoredOverride_And_ConflictingPropertyName());
	Assert.Equal(@"{""MyProp"":null}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_NewProperty());
	Assert.Equal(@"{""MyProp"":false}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_WithConflictingNewMember());
	Assert.Equal(@"{""MyProp"":false}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_WithConflictingNewMember_Of_DifferentType());
	Assert.Equal(@"{""MyProp"":0}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_ConflictingNewMember());
	Assert.Equal(@"{""MyProp"":false}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_ConflictingNewMember_Of_DifferentType());
	Assert.Equal(@"{""MyProp"":false}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_NewProperty_And_ConflictingPropertyName());
	Assert.Equal(@"{""MyProp"":null}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_NewProperty_Of_DifferentType());
	Assert.Equal(@"{""MyProp"":false}", serialized);

	serialized = JsonSerializer.Serialize(new DerivedClass_With_Ignored_NewProperty_Of_DifferentType_And_ConflictingPropertyName());
	Assert.Equal(@"{""MyProp"":null}", serialized);

	serialized = JsonSerializer.Serialize(new FurtherDerivedClass_With_ConflictingPropertyName());
	Assert.Equal(@"{""MyProp"":null}", serialized);

	// Here we differ from Newtonsoft.Json, where the output would be
	// {"MyProp":null}
	// Conflicts at different type-hierarchy levels that are not caused by
	// deriving or the new keyword are allowed. Properties on more derived types win.
	// This is invalid in System.Text.Json.
	Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(new DerivedClass_WithConflictingPropertyName()));

	serialized = JsonSerializer.Serialize(new FurtherDerivedClass_With_IgnoredOverride());
	Assert.Equal(@"{""MyProp"":null}", serialized);
	}

	[Theory]
	[InlineData(typeof(ClassWithPrivateProperty_WithJsonIncludeProperty))]
	[InlineData(typeof(ClassWithInternalProperty_WithJsonIncludeProperty))]
	[InlineData(typeof(ClassWithProtectedProperty_WithJsonIncludeProperty))]
	public static void NonPublicProperty_WithJsonInclude_Invalid(Type type)
	{
	InvalidOperationException ex = Assert.Throws<InvalidOperationException>(() => JsonSerializer.Deserialize("", type));
	string exAsStr = ex.ToString();
	Assert.Contains("MyString", exAsStr);
	Assert.Contains(type.ToString(), exAsStr);
	Assert.Contains("JsonIncludeAttribute", exAsStr);

	ex = Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(Activator.CreateInstance(type), type));
	exAsStr = ex.ToString();
	Assert.Contains("MyString", exAsStr);
	Assert.Contains(type.ToString(), exAsStr);
	Assert.Contains("JsonIncludeAttribute", exAsStr);
	}

	private class ClassWithPrivateProperty_WithJsonIncludeProperty
	{
	[JsonInclude]
	private string MyString { get; set; }
	}

	private class ClassWithInternalProperty_WithJsonIncludeProperty
	{
	[JsonInclude]
	internal string MyString { get; }
	}

	private class ClassWithProtectedProperty_WithJsonIncludeProperty
	{
	[JsonInclude]
	protected string MyString { get; private set; }
	}
	}

Added field support to JSON serializer #36986

Added field support to JSON serializer #36986

Conversation

YohDeadfall commented May 25, 2020

layomia commented May 26, 2020 • edited Loading

layomia left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

layomia commented Jun 2, 2020

YohDeadfall commented Jun 2, 2020

YohDeadfall commented Jun 2, 2020

YohDeadfall commented Jun 2, 2020

layomia commented Jun 17, 2020

YohDeadfall commented Jun 17, 2020

layomia commented Jun 19, 2020

layomia commented Jun 19, 2020

steveharter commented Jun 22, 2020

layomia left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

layomia commented Jul 6, 2020

YohDeadfall commented Jul 6, 2020

layomia left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

layomia left a comment

Choose a reason for hiding this comment

layomia commented Jul 14, 2020

layomia commented May 26, 2020 •

edited

Loading