From ad68ea8780b2cbb63908bff68d4d6464e2967088 Mon Sep 17 00:00:00 2001 From: James Newton-King Date: Sat, 3 Oct 2015 14:10:39 +1300 Subject: [PATCH] -Added JsonConstructorAttribute support for lists and dictionaries --- .../Linq/QueryJsonSelectTokenEscaped.aml | 2 +- Doc/SerializationAttributes.aml | 1 + .../Serialization/ContractResolverTests.cs | 10 +- .../JsonSerializerCollectionsTests.cs | 242 ++++++++++++++++++ .../DynamicReflectionDelegateFactoryTests.cs | 6 +- ...xpressionReflectionDelegateFactoryTests.cs | 6 +- ...LateboundReflectionDelegateFactoryTests.cs | 6 +- .../Serialization/DefaultContractResolver.cs | 58 ++++- .../Serialization/JsonArrayContract.cs | 64 +++-- .../Serialization/JsonContainerContract.cs | 7 +- .../Serialization/JsonDictionaryContract.cs | 46 +++- .../Serialization/JsonObjectContract.cs | 25 +- .../JsonSerializerInternalReader.cs | 65 ++++- .../Serialization/JsonTypeReflector.cs | 2 +- .../Utilities/CollectionUtils.cs | 2 + .../DynamicReflectionDelegateFactory.cs | 2 +- .../ExpressionReflectionDelegateFactory.cs | 2 +- Src/Newtonsoft.Json/Utilities/FSharpUtils.cs | 4 +- .../Utilities/ImmutableCollectionsUtils.cs | 4 +- .../LateBoundReflectionDelegateFactory.cs | 2 +- .../Utilities/ReflectionDelegateFactory.cs | 2 +- .../Utilities/ReflectionObject.cs | 2 +- 22 files changed, 477 insertions(+), 83 deletions(-) diff --git a/Doc/Samples/Linq/QueryJsonSelectTokenEscaped.aml b/Doc/Samples/Linq/QueryJsonSelectTokenEscaped.aml index 4ddbb41b..c92645a9 100644 --- a/Doc/Samples/Linq/QueryJsonSelectTokenEscaped.aml +++ b/Doc/Samples/Linq/QueryJsonSelectTokenEscaped.aml @@ -2,7 +2,7 @@ - This sample loads JSON with properties that required escaped queries using M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String). + This sample loads JSON with properties that need to be escaped when queried with M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String).
Sample diff --git a/Doc/SerializationAttributes.aml b/Doc/SerializationAttributes.aml index ca4558df..3fe7ed53 100644 --- a/Doc/SerializationAttributes.aml +++ b/Doc/SerializationAttributes.aml @@ -146,6 +146,7 @@ T:Newtonsoft.Json.JsonPropertyAttribute T:Newtonsoft.Json.JsonConverterAttribute T:Newtonsoft.Json.JsonExtensionDataAttribute + T:Newtonsoft.Json.JsonConstructorAttribute \ No newline at end of file diff --git a/Src/Newtonsoft.Json.Tests/Serialization/ContractResolverTests.cs b/Src/Newtonsoft.Json.Tests/Serialization/ContractResolverTests.cs index 6aeae522..a6e16db3 100644 --- a/Src/Newtonsoft.Json.Tests/Serialization/ContractResolverTests.cs +++ b/Src/Newtonsoft.Json.Tests/Serialization/ContractResolverTests.cs @@ -203,7 +203,7 @@ namespace Newtonsoft.Json.Tests.Serialization Assert.IsFalse(contract.IsInstantiable); Assert.IsNull(contract.DefaultCreator); - Assert.IsFalse(contract.HasParametrizedCreator); + Assert.IsFalse(contract.HasParameterizedCreatorInternal); ExceptionAssert.Throws(() => JsonConvert.DeserializeObject>(@"[1,2]", new JsonSerializerSettings { @@ -283,7 +283,7 @@ namespace Newtonsoft.Json.Tests.Serialization Assert.IsFalse(contract.IsInstantiable); Assert.IsNull(contract.DefaultCreator); - Assert.IsFalse(contract.HasParametrizedCreator); + Assert.IsFalse(contract.HasParameterizedCreatorInternal); ExceptionAssert.Throws(() => JsonConvert.DeserializeObject>(@"{key1:1,key2:2}", new JsonSerializerSettings { @@ -436,13 +436,13 @@ namespace Newtonsoft.Json.Tests.Serialization } [Test] - public void ParametrizedCreator() + public void ParameterizedCreator() { var resolver = new DefaultContractResolver(); var contract = (JsonObjectContract)resolver.ResolveContract(typeof(PublicParametizedConstructorWithPropertyNameConflictWithAttribute)); Assert.IsNull(contract.DefaultCreator); - Assert.IsNotNull(contract.ParametrizedCreator); + Assert.IsNotNull(contract.ParameterizedCreator); #pragma warning disable 618 Assert.AreEqual(contract.ParametrizedConstructor, typeof(PublicParametizedConstructorWithPropertyNameConflictWithAttribute).GetConstructor(new[] { typeof(string) })); #pragma warning restore 618 @@ -452,7 +452,7 @@ namespace Newtonsoft.Json.Tests.Serialization #pragma warning disable 618 contract.ParametrizedConstructor = null; #pragma warning restore 618 - Assert.IsNull(contract.ParametrizedCreator); + Assert.IsNull(contract.ParameterizedCreator); } [Test] diff --git a/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerCollectionsTests.cs b/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerCollectionsTests.cs index 369c0fb9..e50dfdac 100644 --- a/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerCollectionsTests.cs +++ b/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerCollectionsTests.cs @@ -59,6 +59,248 @@ namespace Newtonsoft.Json.Tests.Serialization [TestFixture] public class JsonSerializerCollectionsTests : TestFixtureBase { + public class TestCollectionPrivateParameterized : IEnumerable + { + private readonly List _bars; + + public TestCollectionPrivateParameterized() + { + _bars = new List(); + } + + [JsonConstructor] + private TestCollectionPrivateParameterized(IEnumerable bars) + { + _bars = new List(bars); + } + + public void Add(int bar) + { + _bars.Add(bar); + } + + public IEnumerator GetEnumerator() => _bars.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } + + [Test] + public void CollectionJsonConstructorPrivateParameterized() + { + TestCollectionPrivateParameterized c1 = new TestCollectionPrivateParameterized(); + c1.Add(0); + c1.Add(1); + c1.Add(2); + string json = JsonConvert.SerializeObject(c1); + TestCollectionPrivateParameterized c2 = JsonConvert.DeserializeObject(json); + + List values = c2.ToList(); + + Assert.AreEqual(3, values.Count); + Assert.AreEqual(0, values[0]); + Assert.AreEqual(1, values[1]); + Assert.AreEqual(2, values[2]); + } + + public class TestCollectionPrivate : List + { + [JsonConstructor] + private TestCollectionPrivate() + { + } + + public static TestCollectionPrivate Create() + { + return new TestCollectionPrivate(); + } + } + + [Test] + public void CollectionJsonConstructorPrivate() + { + TestCollectionPrivate c1 = TestCollectionPrivate.Create(); + c1.Add(0); + c1.Add(1); + c1.Add(2); + string json = JsonConvert.SerializeObject(c1); + TestCollectionPrivate c2 = JsonConvert.DeserializeObject(json); + + List values = c2.ToList(); + + Assert.AreEqual(3, values.Count); + Assert.AreEqual(0, values[0]); + Assert.AreEqual(1, values[1]); + Assert.AreEqual(2, values[2]); + } + + public class TestCollectionMultipleParameters : List + { + [JsonConstructor] + public TestCollectionMultipleParameters(string s1, string s2) + { + } + } + + [Test] + public void CollectionJsonConstructorMultipleParameters() + { + ExceptionAssert.Throws( + () => JsonConvert.SerializeObject(new TestCollectionMultipleParameters(null, null)), + "Constructor for 'Newtonsoft.Json.Tests.Serialization.JsonSerializerCollectionsTests+TestCollectionMultipleParameters' must have no parameters or a single parameter that implements 'System.Collections.Generic.IEnumerable`1[System.Int32]'."); + } + + public class TestCollectionBadIEnumerableParameter : List + { + [JsonConstructor] + public TestCollectionBadIEnumerableParameter(List l) + { + } + } + + [Test] + public void CollectionJsonConstructorBadIEnumerableParameter() + { + ExceptionAssert.Throws( + () => JsonConvert.SerializeObject(new TestCollectionBadIEnumerableParameter(null)), + "Constructor for 'Newtonsoft.Json.Tests.Serialization.JsonSerializerCollectionsTests+TestCollectionBadIEnumerableParameter' must have no parameters or a single parameter that implements 'System.Collections.Generic.IEnumerable`1[System.Int32]'."); + } + +#if !(DNXCORE50 || PORTABLE) + public class TestCollectionNonGeneric : ArrayList + { + [JsonConstructor] + public TestCollectionNonGeneric(IEnumerable l) + : base(l.Cast().ToList()) + { + } + } + + [Test] + public void CollectionJsonConstructorNonGeneric() + { + string json = @"[1,2,3]"; + TestCollectionNonGeneric l = JsonConvert.DeserializeObject(json); + + Assert.AreEqual(3, l.Count); + Assert.AreEqual(1, l[0]); + Assert.AreEqual(2, l[1]); + Assert.AreEqual(3, l[2]); + } +#endif + + public class TestDictionaryPrivateParameterized : Dictionary + { + public TestDictionaryPrivateParameterized() + { + } + + [JsonConstructor] + private TestDictionaryPrivateParameterized(IEnumerable> bars) + : base(bars.ToDictionary(k => k.Key, k => k.Value)) + { + } + } + + [Test] + public void DictionaryJsonConstructorPrivateParameterized() + { + TestDictionaryPrivateParameterized c1 = new TestDictionaryPrivateParameterized(); + c1.Add("zero", 0); + c1.Add("one", 1); + c1.Add("two", 2); + string json = JsonConvert.SerializeObject(c1); + TestDictionaryPrivateParameterized c2 = JsonConvert.DeserializeObject(json); + + Assert.AreEqual(3, c2.Count); + Assert.AreEqual(0, c2["zero"]); + Assert.AreEqual(1, c2["one"]); + Assert.AreEqual(2, c2["two"]); + } + + public class TestDictionaryPrivate : Dictionary + { + [JsonConstructor] + private TestDictionaryPrivate() + { + } + + public static TestDictionaryPrivate Create() + { + return new TestDictionaryPrivate(); + } + } + + [Test] + public void DictionaryJsonConstructorPrivate() + { + TestDictionaryPrivate c1 = TestDictionaryPrivate.Create(); + c1.Add("zero", 0); + c1.Add("one", 1); + c1.Add("two", 2); + string json = JsonConvert.SerializeObject(c1); + TestDictionaryPrivate c2 = JsonConvert.DeserializeObject(json); + + Assert.AreEqual(3, c2.Count); + Assert.AreEqual(0, c2["zero"]); + Assert.AreEqual(1, c2["one"]); + Assert.AreEqual(2, c2["two"]); + } + + public class TestDictionaryMultipleParameters : Dictionary + { + [JsonConstructor] + public TestDictionaryMultipleParameters(string s1, string s2) + { + } + } + + [Test] + public void DictionaryJsonConstructorMultipleParameters() + { + ExceptionAssert.Throws( + () => JsonConvert.SerializeObject(new TestDictionaryMultipleParameters(null, null)), + "Constructor for 'Newtonsoft.Json.Tests.Serialization.JsonSerializerCollectionsTests+TestDictionaryMultipleParameters' must have no parameters or a single parameter that implements 'System.Collections.Generic.IEnumerable`1[System.Collections.Generic.KeyValuePair`2[System.String,System.Int32]]'."); + } + + public class TestDictionaryBadIEnumerableParameter : Dictionary + { + [JsonConstructor] + public TestDictionaryBadIEnumerableParameter(Dictionary l) + { + } + } + + [Test] + public void DictionaryJsonConstructorBadIEnumerableParameter() + { + ExceptionAssert.Throws( + () => JsonConvert.SerializeObject(new TestDictionaryBadIEnumerableParameter(null)), + "Constructor for 'Newtonsoft.Json.Tests.Serialization.JsonSerializerCollectionsTests+TestDictionaryBadIEnumerableParameter' must have no parameters or a single parameter that implements 'System.Collections.Generic.IEnumerable`1[System.Collections.Generic.KeyValuePair`2[System.String,System.Int32]]'."); + } + +#if !(DNXCORE50 || PORTABLE) + public class TestDictionaryNonGeneric : Hashtable + { + [JsonConstructor] + public TestDictionaryNonGeneric(IDictionary d) + : base(d) + { + } + } + + [Test] + public void DictionaryJsonConstructorNonGeneric() + { + string json = @"{'zero':0,'one':1,'two':2}"; + TestDictionaryNonGeneric d = JsonConvert.DeserializeObject(json); + + Assert.AreEqual(3, d.Count); + Assert.AreEqual(0, d["zero"]); + Assert.AreEqual(1, d["one"]); + Assert.AreEqual(2, d["two"]); + } +#endif + #if !(NETFX_CORE || DNXCORE50) public class NameValueCollectionTestClass { diff --git a/Src/Newtonsoft.Json.Tests/Utilities/DynamicReflectionDelegateFactoryTests.cs b/Src/Newtonsoft.Json.Tests/Utilities/DynamicReflectionDelegateFactoryTests.cs index 949ffb5e..50fd200e 100644 --- a/Src/Newtonsoft.Json.Tests/Utilities/DynamicReflectionDelegateFactoryTests.cs +++ b/Src/Newtonsoft.Json.Tests/Utilities/DynamicReflectionDelegateFactoryTests.cs @@ -58,7 +58,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = typeof(OutAndRefTestClass).GetConstructors().Single(c => c.GetParameters().Count() == 1); - var creator = DynamicReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = DynamicReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input" }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); @@ -71,7 +71,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = typeof(OutAndRefTestClass).GetConstructors().Single(c => c.GetParameters().Count() == 2); - var creator = DynamicReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = DynamicReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input", false }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); @@ -85,7 +85,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = typeof(OutAndRefTestClass).GetConstructors().Single(c => c.GetParameters().Count() == 3); - var creator = DynamicReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = DynamicReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input", true, null }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); diff --git a/Src/Newtonsoft.Json.Tests/Utilities/ExpressionReflectionDelegateFactoryTests.cs b/Src/Newtonsoft.Json.Tests/Utilities/ExpressionReflectionDelegateFactoryTests.cs index de998c2d..ebe70c69 100644 --- a/Src/Newtonsoft.Json.Tests/Utilities/ExpressionReflectionDelegateFactoryTests.cs +++ b/Src/Newtonsoft.Json.Tests/Utilities/ExpressionReflectionDelegateFactoryTests.cs @@ -55,7 +55,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = TestReflectionUtils.GetConstructors(typeof(OutAndRefTestClass)).Single(c => c.GetParameters().Count() == 1); - var creator = ExpressionReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = ExpressionReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input" }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); @@ -68,7 +68,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = TestReflectionUtils.GetConstructors(typeof(OutAndRefTestClass)).Single(c => c.GetParameters().Count() == 2); - var creator = ExpressionReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = ExpressionReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input", null }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); @@ -81,7 +81,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = TestReflectionUtils.GetConstructors(typeof(OutAndRefTestClass)).Single(c => c.GetParameters().Count() == 3); - var creator = ExpressionReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = ExpressionReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input", true, null }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); diff --git a/Src/Newtonsoft.Json.Tests/Utilities/LateboundReflectionDelegateFactoryTests.cs b/Src/Newtonsoft.Json.Tests/Utilities/LateboundReflectionDelegateFactoryTests.cs index 84e47e32..bd85c1b3 100644 --- a/Src/Newtonsoft.Json.Tests/Utilities/LateboundReflectionDelegateFactoryTests.cs +++ b/Src/Newtonsoft.Json.Tests/Utilities/LateboundReflectionDelegateFactoryTests.cs @@ -54,7 +54,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = TestReflectionUtils.GetConstructors(typeof(OutAndRefTestClass)).Single(c => c.GetParameters().Count() == 1); - var creator = LateBoundReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = LateBoundReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input" }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); @@ -67,7 +67,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = TestReflectionUtils.GetConstructors(typeof(OutAndRefTestClass)).Single(c => c.GetParameters().Count() == 2); - var creator = LateBoundReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = LateBoundReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input", null }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); @@ -80,7 +80,7 @@ namespace Newtonsoft.Json.Tests.Utilities { ConstructorInfo constructor = TestReflectionUtils.GetConstructors(typeof(OutAndRefTestClass)).Single(c => c.GetParameters().Count() == 3); - var creator = LateBoundReflectionDelegateFactory.Instance.CreateParametrizedConstructor(constructor); + var creator = LateBoundReflectionDelegateFactory.Instance.CreateParameterizedConstructor(constructor); object[] args = new object[] { "Input", true, null }; OutAndRefTestClass o = (OutAndRefTestClass)creator(args); diff --git a/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs b/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs index 466e22ca..30a73960 100644 --- a/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs +++ b/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs @@ -398,7 +398,7 @@ namespace Newtonsoft.Json.Serialization } else if (contract.DefaultCreator == null || contract.DefaultCreatorNonPublic) { - ConstructorInfo constructor = GetParametrizedConstructor(contract.NonNullableUnderlyingType); + ConstructorInfo constructor = GetParameterizedConstructor(contract.NonNullableUnderlyingType); if (constructor != null) { #pragma warning disable 618 @@ -511,7 +511,7 @@ namespace Newtonsoft.Json.Serialization Type enumerableWrapper = typeof(DictionaryEnumerator<,>).MakeGenericType(keyType, valueType); ConstructorInfo constructors = enumerableWrapper.GetConstructors().First(); - ObjectConstructor createEnumerableWrapper = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(constructors); + ObjectConstructor createEnumerableWrapper = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(constructors); ExtensionDataGetter extensionDataGetter = o => { @@ -591,7 +591,7 @@ namespace Newtonsoft.Json.Serialization return null; } - private ConstructorInfo GetParametrizedConstructor(Type objectType) + private ConstructorInfo GetParameterizedConstructor(Type objectType) { IList constructors = objectType.GetConstructors(BindingFlags.Public | BindingFlags.Instance).ToList(); @@ -878,6 +878,31 @@ namespace Newtonsoft.Json.Serialization contract.DictionaryKeyResolver = ResolveDictionaryKey; + ConstructorInfo overrideConstructor = GetAttributeConstructor(contract.NonNullableUnderlyingType); + + if (overrideConstructor != null) + { + ParameterInfo[] parameters = overrideConstructor.GetParameters(); + Type expectedParameterType = (contract.DictionaryKeyType != null && contract.DictionaryValueType != null) + ? typeof(IEnumerable<>).MakeGenericType(typeof(KeyValuePair<,>).MakeGenericType(contract.DictionaryKeyType, contract.DictionaryValueType)) + : typeof(IDictionary); + + if (parameters.Length == 0) + { + contract.HasParameterizedCreator = false; + } + else if (parameters.Length == 1 && expectedParameterType.IsAssignableFrom(parameters[0].ParameterType)) + { + contract.HasParameterizedCreator = true; + } + else + { + throw new JsonException("Constructor for '{0}' must have no parameters or a single parameter that implements '{1}'.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType, expectedParameterType)); + } + + contract.OverrideCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(overrideConstructor); + } + return contract; } @@ -891,6 +916,31 @@ namespace Newtonsoft.Json.Serialization JsonArrayContract contract = new JsonArrayContract(objectType); InitializeContract(contract); + ConstructorInfo overrideConstructor = GetAttributeConstructor(contract.NonNullableUnderlyingType); + + if (overrideConstructor != null) + { + ParameterInfo[] parameters = overrideConstructor.GetParameters(); + Type expectedParameterType = (contract.CollectionItemType != null) + ? typeof(IEnumerable<>).MakeGenericType(contract.CollectionItemType) + : typeof(IEnumerable); + + if (parameters.Length == 0) + { + contract.HasParameterizedCreator = false; + } + else if (parameters.Length == 1 && expectedParameterType.IsAssignableFrom(parameters[0].ParameterType)) + { + contract.HasParameterizedCreator = true; + } + else + { + throw new JsonException("Constructor for '{0}' must have no parameters or a single parameter that implements '{1}'.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType, expectedParameterType)); + } + + contract.OverrideCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(overrideConstructor); + } + return contract; } @@ -934,7 +984,7 @@ namespace Newtonsoft.Json.Serialization ConstructorInfo constructorInfo = contract.NonNullableUnderlyingType.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(SerializationInfo), typeof(StreamingContext) }, null); if (constructorInfo != null) { - ObjectConstructor creator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(constructorInfo); + ObjectConstructor creator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(constructorInfo); contract.ISerializableCreator = creator; } diff --git a/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs b/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs index 736abdc3..a60f1491 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs @@ -67,23 +67,46 @@ namespace Newtonsoft.Json.Serialization internal bool ShouldCreateWrapper { get; private set; } internal bool CanDeserialize { get; private set; } - private readonly ConstructorInfo _parametrizedConstructor; + private readonly ConstructorInfo _parameterizedConstructor; - private ObjectConstructor _parametrizedCreator; - internal ObjectConstructor ParametrizedCreator + private ObjectConstructor _parameterizedCreator; + private ObjectConstructor _overrideCreator; + + internal ObjectConstructor ParameterizedCreator { get { - if (_parametrizedCreator == null) - _parametrizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(_parametrizedConstructor); + if (_parameterizedCreator == null) + _parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(_parameterizedConstructor); - return _parametrizedCreator; + return _parameterizedCreator; } } - internal bool HasParametrizedCreator + /// + /// Gets or sets the function used to create the object. When set this function will override . + /// + /// The function used to create the object. + public ObjectConstructor OverrideCreator { - get { return _parametrizedCreator != null || _parametrizedConstructor != null; } + get { return _overrideCreator; } + set + { + _overrideCreator = value; + // hacky + CanDeserialize = true; + } + } + + /// + /// Gets a value indicating whether the creator has a parameter with the collection values. + /// + /// true if the creator has a parameter with the collection values; otherwise, false. + public bool HasParameterizedCreator { get; set; } + + internal bool HasParameterizedCreatorInternal + { + get { return (HasParameterizedCreator || _parameterizedCreator != null || _parameterizedConstructor != null); } } /// @@ -119,7 +142,7 @@ namespace Newtonsoft.Json.Serialization CreatedType = typeof(List); if (CollectionItemType != null) - _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); + _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyCollection<>)); canDeserialize = true; @@ -137,7 +160,7 @@ namespace Newtonsoft.Json.Serialization CreatedType = typeof(HashSet<>).MakeGenericType(CollectionItemType); #endif - _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); + _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); canDeserialize = true; ShouldCreateWrapper = true; } @@ -151,9 +174,9 @@ namespace Newtonsoft.Json.Serialization CreatedType = typeof(ReadOnlyCollection<>).MakeGenericType(CollectionItemType); _genericCollectionDefinitionType = typeof(List<>).MakeGenericType(CollectionItemType); - _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, CollectionItemType); + _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, CollectionItemType); IsReadOnlyOrFixedSize = true; - canDeserialize = HasParametrizedCreator; + canDeserialize = HasParameterizedCreatorInternal; } #endif else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IEnumerable<>), out tempCollectionType)) @@ -163,13 +186,13 @@ namespace Newtonsoft.Json.Serialization if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IEnumerable<>))) CreatedType = typeof(List<>).MakeGenericType(CollectionItemType); - _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); + _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); #if !(NET35 || NET20) - if (!HasParametrizedCreator && underlyingType.Name == FSharpUtils.FSharpListTypeName) + if (!HasParameterizedCreatorInternal && underlyingType.Name == FSharpUtils.FSharpListTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); - _parametrizedCreator = FSharpUtils.CreateSeq(CollectionItemType); + _parameterizedCreator = FSharpUtils.CreateSeq(CollectionItemType); } #endif @@ -187,7 +210,7 @@ namespace Newtonsoft.Json.Serialization IsReadOnlyOrFixedSize = true; ShouldCreateWrapper = true; - canDeserialize = HasParametrizedCreator; + canDeserialize = HasParameterizedCreatorInternal; } } else @@ -218,7 +241,7 @@ namespace Newtonsoft.Json.Serialization if (ImmutableCollectionsUtils.TryBuildImmutableForArrayContract(underlyingType, CollectionItemType, out immutableCreatedType, out immutableParameterizedCreator)) { CreatedType = immutableCreatedType; - _parametrizedCreator = immutableParameterizedCreator; + _parameterizedCreator = immutableParameterizedCreator; IsReadOnlyOrFixedSize = true; CanDeserialize = true; } @@ -240,7 +263,7 @@ namespace Newtonsoft.Json.Serialization constructorArgument = _genericCollectionDefinitionType; ConstructorInfo genericWrapperConstructor = _genericWrapperType.GetConstructor(new[] { constructorArgument }); - _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(genericWrapperConstructor); + _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(genericWrapperConstructor); } return (IWrappedCollection)_genericWrapperCreator(list); @@ -251,7 +274,10 @@ namespace Newtonsoft.Json.Serialization if (_genericTemporaryCollectionCreator == null) { // multidimensional array will also have array instances in it - Type collectionItemType = (IsMultidimensionalArray) ? typeof(object) : CollectionItemType; + Type collectionItemType = (IsMultidimensionalArray || CollectionItemType == null) + ? typeof(object) + : CollectionItemType; + Type temporaryListType = typeof(List<>).MakeGenericType(collectionItemType); _genericTemporaryCollectionCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor(temporaryListType); } diff --git a/Src/Newtonsoft.Json/Serialization/JsonContainerContract.cs b/Src/Newtonsoft.Json/Serialization/JsonContainerContract.cs index cb904462..ef917439 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonContainerContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonContainerContract.cs @@ -105,8 +105,11 @@ namespace Newtonsoft.Json.Serialization if (jsonContainerAttribute != null) { if (jsonContainerAttribute.ItemConverterType != null) - ItemConverter = JsonTypeReflector.CreateJsonConverterInstance(jsonContainerAttribute.ItemConverterType, - jsonContainerAttribute.ItemConverterParameters); + { + ItemConverter = JsonTypeReflector.CreateJsonConverterInstance( + jsonContainerAttribute.ItemConverterType, + jsonContainerAttribute.ItemConverterParameters); + } ItemIsReference = jsonContainerAttribute._itemIsReference; ItemReferenceLoopHandling = jsonContainerAttribute._itemReferenceLoopHandling; diff --git a/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs b/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs index b79d48bf..10bfbc7e 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs @@ -81,23 +81,41 @@ namespace Newtonsoft.Json.Serialization internal bool ShouldCreateWrapper { get; private set; } - private readonly ConstructorInfo _parametrizedConstructor; + private readonly ConstructorInfo _parameterizedConstructor; - private ObjectConstructor _parametrizedCreator; - internal ObjectConstructor ParametrizedCreator + private ObjectConstructor _overrideCreator; + private ObjectConstructor _parameterizedCreator; + + internal ObjectConstructor ParameterizedCreator { get { - if (_parametrizedCreator == null) - _parametrizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(_parametrizedConstructor); + if (_parameterizedCreator == null) + _parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(_parameterizedConstructor); - return _parametrizedCreator; + return _parameterizedCreator; } } - internal bool HasParametrizedCreator + /// + /// Gets or sets the function used to create the object. When set this function will override . + /// + /// The function used to create the object. + public ObjectConstructor OverrideCreator { - get { return _parametrizedCreator != null || _parametrizedConstructor != null; } + get { return _overrideCreator; } + set { _overrideCreator = value; } + } + + /// + /// Gets a value indicating whether the creator has a parameter with the dictionary values. + /// + /// true if the creator has a parameter with the dictionary values; otherwise, false. + public bool HasParameterizedCreator { get; set; } + + internal bool HasParameterizedCreatorInternal + { + get { return (HasParameterizedCreator || _parameterizedCreator != null || _parameterizedConstructor != null); } } /// @@ -146,13 +164,13 @@ namespace Newtonsoft.Json.Serialization if (keyType != null && valueType != null) { - _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, typeof(KeyValuePair<,>).MakeGenericType(keyType, valueType)); + _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, typeof(KeyValuePair<,>).MakeGenericType(keyType, valueType)); #if !(NET35 || NET20) - if (!HasParametrizedCreator && underlyingType.Name == FSharpUtils.FSharpMapTypeName) + if (!HasParameterizedCreatorInternal && underlyingType.Name == FSharpUtils.FSharpMapTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); - _parametrizedCreator = FSharpUtils.CreateMap(keyType, valueType); + _parameterizedCreator = FSharpUtils.CreateMap(keyType, valueType); } #endif } @@ -182,7 +200,7 @@ namespace Newtonsoft.Json.Serialization if (ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(underlyingType, DictionaryKeyType, DictionaryValueType, out immutableCreatedType, out immutableParameterizedCreator)) { CreatedType = immutableCreatedType; - _parametrizedCreator = immutableParameterizedCreator; + _parameterizedCreator = immutableParameterizedCreator; IsReadOnlyOrFixedSize = true; } #endif @@ -195,7 +213,7 @@ namespace Newtonsoft.Json.Serialization _genericWrapperType = typeof(DictionaryWrapper<,>).MakeGenericType(DictionaryKeyType, DictionaryValueType); ConstructorInfo genericWrapperConstructor = _genericWrapperType.GetConstructor(new[] { _genericCollectionDefinitionType }); - _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(genericWrapperConstructor); + _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(genericWrapperConstructor); } return (IWrappedDictionary)_genericWrapperCreator(dictionary); @@ -205,7 +223,7 @@ namespace Newtonsoft.Json.Serialization { if (_genericTemporaryDictionaryCreator == null) { - Type temporaryDictionaryType = typeof(Dictionary<,>).MakeGenericType(DictionaryKeyType, DictionaryValueType); + Type temporaryDictionaryType = typeof(Dictionary<,>).MakeGenericType(DictionaryKeyType ?? typeof(object), DictionaryValueType ?? typeof(object)); _genericTemporaryDictionaryCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor(temporaryDictionaryType); } diff --git a/Src/Newtonsoft.Json/Serialization/JsonObjectContract.cs b/Src/Newtonsoft.Json/Serialization/JsonObjectContract.cs index bcb00099..8edb688c 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonObjectContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonObjectContract.cs @@ -69,7 +69,18 @@ namespace Newtonsoft.Json.Serialization /// /// Gets a collection of instances that define the parameters used with . /// - public JsonPropertyCollection CreatorParameters { get; private set; } + public JsonPropertyCollection CreatorParameters + { + get + { + if (_creatorParameters == null) + { + _creatorParameters = new JsonPropertyCollection(UnderlyingType); + } + + return _creatorParameters; + } + } /// /// Gets or sets the override constructor used to create the object. @@ -84,7 +95,7 @@ namespace Newtonsoft.Json.Serialization set { _overrideConstructor = value; - _overrideCreator = (value != null) ? JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(value) : null; + _overrideCreator = (value != null) ? JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(value) : null; } } @@ -99,7 +110,7 @@ namespace Newtonsoft.Json.Serialization set { _parametrizedConstructor = value; - _parametrizedCreator = (value != null) ? JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(value) : null; + _parameterizedCreator = (value != null) ? JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(value) : null; } } @@ -118,9 +129,9 @@ namespace Newtonsoft.Json.Serialization } } - internal ObjectConstructor ParametrizedCreator + internal ObjectConstructor ParameterizedCreator { - get { return _parametrizedCreator; } + get { return _parameterizedCreator; } } /// @@ -137,7 +148,8 @@ namespace Newtonsoft.Json.Serialization private ConstructorInfo _parametrizedConstructor; private ConstructorInfo _overrideConstructor; private ObjectConstructor _overrideCreator; - private ObjectConstructor _parametrizedCreator; + private ObjectConstructor _parameterizedCreator; + private JsonPropertyCollection _creatorParameters; internal bool HasRequiredOrDefaultValueProperties { @@ -178,7 +190,6 @@ namespace Newtonsoft.Json.Serialization ContractType = JsonContractType.Object; Properties = new JsonPropertyCollection(UnderlyingType); - CreatorParameters = new JsonPropertyCollection(UnderlyingType); } #if !(DOTNET || PORTABLE40 || PORTABLE) diff --git a/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs b/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs index eef3bfcf..3487ea12 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs @@ -484,7 +484,7 @@ namespace Newtonsoft.Json.Serialization if (contract.OnErrorCallbacks.Count > 0) throw JsonSerializationException.Create(reader, "Cannot call OnError on readonly list, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)); - if (!dictionaryContract.HasParametrizedCreator) + if (!dictionaryContract.HasParameterizedCreatorInternal) throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size dictionary: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)); } @@ -492,7 +492,9 @@ namespace Newtonsoft.Json.Serialization if (createdFromNonDefaultCreator) { - return dictionaryContract.ParametrizedCreator(dictionary); + ObjectConstructor creator = dictionaryContract.OverrideCreator ?? dictionaryContract.ParameterizedCreator; + + return creator(dictionary); } else if (dictionary is IWrappedDictionary) { @@ -786,14 +788,18 @@ namespace Newtonsoft.Json.Serialization if (contract.OnErrorCallbacks.Count > 0) throw JsonSerializationException.Create(reader, "Cannot call OnError on an array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)); - if (!arrayContract.HasParametrizedCreator && !arrayContract.IsArray) + if (!arrayContract.HasParameterizedCreatorInternal && !arrayContract.IsArray) throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size list: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)); } if (!arrayContract.IsMultidimensionalArray) + { PopulateList(list, reader, arrayContract, member, id); + } else + { PopulateMultidimensionalArray(list, reader, arrayContract, member, id); + } if (createdFromNonDefaultCreator) { @@ -809,8 +815,9 @@ namespace Newtonsoft.Json.Serialization } else { - // call constructor that takes IEnumerable - return arrayContract.ParametrizedCreator(list); + ObjectConstructor creator = arrayContract.OverrideCreator ?? arrayContract.ParameterizedCreator; + + return creator(list); } } else if (list is IWrappedCollection) @@ -823,7 +830,9 @@ namespace Newtonsoft.Json.Serialization else { if (!arrayContract.CanDeserialize) + { throw JsonSerializationException.Create(reader, "Cannot populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.CreatedType)); + } value = PopulateList((arrayContract.ShouldCreateWrapper) ? arrayContract.CreateWrapper(existingValue) : (IList)existingValue, reader, arrayContract, member, id); } @@ -1037,15 +1046,32 @@ namespace Newtonsoft.Json.Serialization { // some types like non-generic IEnumerable can be serialized but not deserialized if (!contract.CanDeserialize) + { throw JsonSerializationException.Create(reader, "Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.CreatedType)); + } - if (contract.IsReadOnlyOrFixedSize) + if (contract.OverrideCreator != null) + { + if (contract.HasParameterizedCreator) + { + createdFromNonDefaultCreator = true; + return contract.CreateTemporaryCollection(); + } + else + { + createdFromNonDefaultCreator = false; + return (IList)contract.OverrideCreator(); + } + } + else if (contract.IsReadOnlyOrFixedSize) { createdFromNonDefaultCreator = true; IList list = contract.CreateTemporaryCollection(); if (contract.ShouldCreateWrapper) + { list = contract.CreateWrapper(list); + } return list; } @@ -1054,12 +1080,14 @@ namespace Newtonsoft.Json.Serialization object list = contract.DefaultCreator(); if (contract.ShouldCreateWrapper) + { list = contract.CreateWrapper(list); + } createdFromNonDefaultCreator = false; return (IList)list; } - else if (contract.HasParametrizedCreator) + else if (contract.HasParameterizedCreatorInternal) { createdFromNonDefaultCreator = true; return contract.CreateTemporaryCollection(); @@ -1075,7 +1103,20 @@ namespace Newtonsoft.Json.Serialization private IDictionary CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract, out bool createdFromNonDefaultCreator) { - if (contract.IsReadOnlyOrFixedSize) + if (contract.OverrideCreator != null) + { + if (contract.HasParameterizedCreator) + { + createdFromNonDefaultCreator = true; + return contract.CreateTemporaryDictionary(); + } + else + { + createdFromNonDefaultCreator = false; + return (IDictionary)contract.OverrideCreator(); + } + } + else if (contract.IsReadOnlyOrFixedSize) { createdFromNonDefaultCreator = true; return contract.CreateTemporaryDictionary(); @@ -1090,7 +1131,7 @@ namespace Newtonsoft.Json.Serialization createdFromNonDefaultCreator = false; return (IDictionary)dictionary; } - else if (contract.HasParametrizedCreator) + else if (contract.HasParameterizedCreatorInternal) { createdFromNonDefaultCreator = true; return contract.CreateTemporaryDictionary(); @@ -1937,7 +1978,7 @@ namespace Newtonsoft.Json.Serialization newObject = objectContract.OverrideCreator(new object[0]); } else if (objectContract.DefaultCreator != null && - (!objectContract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor || objectContract.ParametrizedCreator == null)) + (!objectContract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor || objectContract.ParameterizedCreator == null)) { // use the default constructor if it is... // public @@ -1945,10 +1986,10 @@ namespace Newtonsoft.Json.Serialization // non-public and there is no other creator newObject = objectContract.DefaultCreator(); } - else if (objectContract.ParametrizedCreator != null) + else if (objectContract.ParameterizedCreator != null) { createdFromNonDefaultCreator = true; - return CreateObjectUsingCreatorWithParameters(reader, objectContract, containerMember, objectContract.ParametrizedCreator, id); + return CreateObjectUsingCreatorWithParameters(reader, objectContract, containerMember, objectContract.ParameterizedCreator, id); } if (newObject == null) diff --git a/Src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs b/Src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs index ebc79511..2d86b89a 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs @@ -193,7 +193,7 @@ namespace Newtonsoft.Json.Serialization if (null != parameterizedConstructorInfo) { - parameterizedConstructor = ReflectionDelegateFactory.CreateParametrizedConstructor(parameterizedConstructorInfo); + parameterizedConstructor = ReflectionDelegateFactory.CreateParameterizedConstructor(parameterizedConstructorInfo); return (JsonConverter)parameterizedConstructor(parameters); } else diff --git a/Src/Newtonsoft.Json/Utilities/CollectionUtils.cs b/Src/Newtonsoft.Json/Utilities/CollectionUtils.cs index f82c098d..ca755bf2 100644 --- a/Src/Newtonsoft.Json/Utilities/CollectionUtils.cs +++ b/Src/Newtonsoft.Json/Utilities/CollectionUtils.cs @@ -124,7 +124,9 @@ namespace Newtonsoft.Json.Utilities if (match == null) { if (genericEnumerable.IsAssignableFrom(parameters[0].ParameterType)) + { match = constructor; + } } } } diff --git a/Src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs b/Src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs index 7533af34..4aaded13 100644 --- a/Src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs +++ b/Src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs @@ -49,7 +49,7 @@ namespace Newtonsoft.Json.Utilities return dynamicMethod; } - public override ObjectConstructor CreateParametrizedConstructor(MethodBase method) + public override ObjectConstructor CreateParameterizedConstructor(MethodBase method) { DynamicMethod dynamicMethod = CreateDynamicMethod(method.ToString(), typeof(object), new[] { typeof(object[]) }, method.DeclaringType); ILGenerator generator = dynamicMethod.GetILGenerator(); diff --git a/Src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs b/Src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs index 6cb95a37..0e56ca33 100644 --- a/Src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs +++ b/Src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs @@ -43,7 +43,7 @@ namespace Newtonsoft.Json.Utilities get { return _instance; } } - public override ObjectConstructor CreateParametrizedConstructor(MethodBase method) + public override ObjectConstructor CreateParameterizedConstructor(MethodBase method) { ValidationUtils.ArgumentNotNull(method, "method"); diff --git a/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs b/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs index 72cf2e83..a2c76417 100644 --- a/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs +++ b/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs @@ -144,7 +144,7 @@ namespace Newtonsoft.Json.Utilities { MethodInfo seqType = _ofSeq.MakeGenericMethod(t); - return JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(seqType); + return JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(seqType); } public static ObjectConstructor CreateMap(Type keyType, Type valueType) @@ -160,7 +160,7 @@ namespace Newtonsoft.Json.Utilities { Type genericMapType = _mapType.MakeGenericType(typeof(TKey), typeof(TValue)); ConstructorInfo ctor = genericMapType.GetConstructor(new[] { typeof(IEnumerable>) }); - ObjectConstructor ctorDelegate = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(ctor); + ObjectConstructor ctorDelegate = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(ctor); ObjectConstructor creator = args => { diff --git a/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs b/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs index 2a438199..f1c0e81b 100644 --- a/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs +++ b/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs @@ -122,7 +122,7 @@ namespace Newtonsoft.Json.Utilities { createdType = createdTypeDefinition.MakeGenericType(collectionItemType); MethodInfo method = mb.MakeGenericMethod(collectionItemType); - parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(method); + parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(method); return true; } } @@ -159,7 +159,7 @@ namespace Newtonsoft.Json.Utilities { createdType = createdTypeDefinition.MakeGenericType(keyItemType, valueItemType); MethodInfo method = mb.MakeGenericMethod(keyItemType, valueItemType); - parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParametrizedConstructor(method); + parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(method); return true; } } diff --git a/Src/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs b/Src/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs index 51876ada..4945a271 100644 --- a/Src/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs +++ b/Src/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs @@ -42,7 +42,7 @@ namespace Newtonsoft.Json.Utilities get { return _instance; } } - public override ObjectConstructor CreateParametrizedConstructor(MethodBase method) + public override ObjectConstructor CreateParameterizedConstructor(MethodBase method) { ValidationUtils.ArgumentNotNull(method, "method"); diff --git a/Src/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs b/Src/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs index 1d9ffc57..b2b19fe7 100644 --- a/Src/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs +++ b/Src/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs @@ -63,7 +63,7 @@ namespace Newtonsoft.Json.Utilities } public abstract MethodCall CreateMethodCall(MethodBase method); - public abstract ObjectConstructor CreateParametrizedConstructor(MethodBase method); + public abstract ObjectConstructor CreateParameterizedConstructor(MethodBase method); public abstract Func CreateDefaultConstructor(Type type); public abstract Func CreateGet(PropertyInfo propertyInfo); public abstract Func CreateGet(FieldInfo fieldInfo); diff --git a/Src/Newtonsoft.Json/Utilities/ReflectionObject.cs b/Src/Newtonsoft.Json/Utilities/ReflectionObject.cs index 0a175538..9023f85a 100644 --- a/Src/Newtonsoft.Json/Utilities/ReflectionObject.cs +++ b/Src/Newtonsoft.Json/Utilities/ReflectionObject.cs @@ -84,7 +84,7 @@ namespace Newtonsoft.Json.Utilities if (creator != null) { - d.Creator = delegateFactory.CreateParametrizedConstructor(creator); + d.Creator = delegateFactory.CreateParameterizedConstructor(creator); } else {