Merge remote-tracking branch 'aubry/master' into ec-aotwarnings

EdwardCooke · EdwardCooke · commit d8f282cd49d7 · 2023-01-28T14:35:50.000-07:00
diff --git a/YamlDotNet.Test/Serialization/DateTimeConverterTests.cs b/YamlDotNet.Test/Serialization/DateTimeConverterTests.cs
@@ -569,7 +569,7 @@ public void Given_Values_WithFormats_WriteYaml_ShouldReturn_Result_WithFirstForm
         public void JsonCompatible_EncaseDateTimesInDoubleQuotes()
         {
             var serializer = new SerializerBuilder().JsonCompatible().Build();
-            var testObject = new TestObject { DateTime = new DateTime(2023, 01, 14, 0, 1, 2) };
+            var testObject = new TestObject { DateTime = new DateTime(2023, 01, 14, 0, 1, 2, DateTimeKind.Utc) };
             var actual = serializer.Serialize(testObject);
 
             actual.TrimNewLines().Should().ContainEquivalentOf("{\"DateTime\": \"01/14/2023 00:01:02\"}");
diff --git a/YamlDotNet.Test/Serialization/DeserializerTest.cs b/YamlDotNet.Test/Serialization/DeserializerTest.cs
@@ -298,7 +298,14 @@ public void DeserializeWithDuplicateKeyChecking_YamlWithDuplicateKeys_ThrowsYaml
                 .Build();
 
             Action act = () => sut.Deserialize<Person>(yaml);
-            act.ShouldThrow<YamlException>("Because there are duplicate name keys");
+            act.ShouldThrow<YamlException>("Because there are duplicate name keys with concrete class");
+            act = () => sut.Deserialize<IDictionary<object, object>>(yaml);
+            act.ShouldThrow<YamlException>("Because there are duplicate name keys with dictionary");
+
+            var stream = Yaml.ReaderFrom("backreference.yaml");
+            var parser = new MergingParser(new Parser(stream));
+            act = () => sut.Deserialize<Dictionary<string, Dictionary<string, string>>>(parser);
+            act.ShouldThrow<YamlException>("Because there are duplicate name keys with merging parser");
         }
 
         [Fact]
@@ -316,6 +323,13 @@ public void DeserializeWithoutDuplicateKeyChecking_YamlWithDuplicateKeys_DoesNot
 
             Action act = () => sut.Deserialize<Person>(yaml);
             act.ShouldNotThrow<YamlException>("Because duplicate key checking is not enabled");
+            act = () => sut.Deserialize<IDictionary<object, object>>(yaml);
+            act.ShouldNotThrow<YamlException>("Because duplicate key checking is not enabled");
+
+            var stream = Yaml.ReaderFrom("backreference.yaml");
+            var parser = new MergingParser(new Parser(stream));
+            act = () => sut.Deserialize<Dictionary<string, Dictionary<string, string>>>(parser);
+            act.ShouldNotThrow<YamlException>("Because duplicate key checking is not enabled");
         }
 
         public class Test
diff --git a/YamlDotNet.Test/Serialization/SerializationTests.cs b/YamlDotNet.Test/Serialization/SerializationTests.cs
@@ -2300,6 +2300,29 @@ public void StringsThatMatchKeywordsAreQuoted(string input)
             Assert.Equal($"text: \"{input}\"{Environment.NewLine}", yaml);
         }
 
+        public static IEnumerable<object[]> Yaml1_1SpecialStringsData = new[]
+        {
+            "-.inf", "-.Inf", "-.INF", "-0", "-0100_200", "-0b101", "-0x30", "-190:20:30", "-23", "-3.14",
+            "._", "._14", ".", ".0", ".1_4", ".14", ".3E-1", ".3e+3", ".inf", ".Inf",
+            ".INF", ".nan", ".NaN", ".NAN", "+.inf", "+.Inf", "+.INF", "+0.3e+3", "+0",
+            "+0100_200", "+0b100", "+190:20:30", "+23", "+3.14", "~", "0.0", "0", "00", "001.23",
+            "0011", "010", "02_0", "07", "0b0", "0b100_101", "0o0", "0o10", "0o7", "0x0",
+            "0x10", "0x2_0", "0x42", "0xa", "100_000", "190:20:30.15", "190:20:30", "23", "3.", "3.14", "3.3e+3",
+            "85_230.15", "85.230_15e+03", "false", "False", "FALSE", "n", "N", "no", "No", "NO",
+            "null", "Null", "NULL", "off", "Off", "OFF", "on", "On", "ON", "true", "True", "TRUE",
+            "y", "Y", "yes", "Yes", "YES"
+        }.Select(v => new object[] { v }).ToList();
+
+        [Theory]
+        [MemberData(nameof(Yaml1_1SpecialStringsData))]
+        public void StringsThatMatchYaml1_1KeywordsAreQuoted(string input)
+        {
+            var serializer = new SerializerBuilder().WithQuotingNecessaryStrings(true).Build();
+            var o = new { text = input };
+            var yaml = serializer.Serialize(o);
+            Assert.Equal($"text: \"{input}\"{Environment.NewLine}", yaml);
+        }
+
         [Fact]
         public void KeysOnConcreteClassDontGetQuoted_TypeStringGetsQuoted()
         {
diff --git a/YamlDotNet/Serialization/DeserializerBuilder.cs b/YamlDotNet/Serialization/DeserializerBuilder.cs
@@ -93,7 +93,7 @@ public DeserializerBuilder()
                 { typeof(NullNodeDeserializer), _ => new NullNodeDeserializer() },
                 { typeof(ScalarNodeDeserializer), _ => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter) },
                 { typeof(ArrayNodeDeserializer), _ => new ArrayNodeDeserializer() },
-                { typeof(DictionaryNodeDeserializer), _ => new DictionaryNodeDeserializer(objectFactory.Value) },
+                { typeof(DictionaryNodeDeserializer), _ => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking) },
                 { typeof(CollectionNodeDeserializer), _ => new CollectionNodeDeserializer(objectFactory.Value) },
                 { typeof(EnumerableNodeDeserializer), _ => new EnumerableNodeDeserializer() },
                 { typeof(ObjectNodeDeserializer), _ => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter) }
diff --git a/YamlDotNet/Serialization/EventEmitters/TypeAssigningEventEmitter.cs b/YamlDotNet/Serialization/EventEmitters/TypeAssigningEventEmitter.cs
@@ -32,21 +32,64 @@ public sealed class TypeAssigningEventEmitter : ChainedEventEmitter
         private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;
         private readonly IDictionary<Type, TagName> tagMappings;
         private readonly bool quoteNecessaryStrings;
-        private static readonly string IsSpecialStringValue_Regex =
+        private readonly Regex? isSpecialStringValue_Regex;
+        private static readonly string SpecialStrings_Pattern =
             @"^("
-                 + @"null|Null|NULL|\~"
-                 + @"|true|True|TRUE|false|False|FALSE"
-                 + @"|[-+]?[0-9]+|0o[0-7]+"
-                 + @"|0x[0-9a-fA-F]+"
-                 + @"|[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?"
-                 + @"|[-+]?(\.inf|\.Inf|\.INF)"
-                 + @"|\.nan|\.NaN|\.NAN"
+                + @"null|Null|NULL|\~"
+                + @"|true|True|TRUE|false|False|FALSE"
+                + @"|[-+]?[0-9]+" // int base 10
+                + @"|0o[0-7]+" // int base 8
+                + @"|0x[0-9a-fA-F]+" // int base 16
+                + @"|[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?" // float number
+                + @"|[-+]?(\.inf|\.Inf|\.INF)"
+                + @"|\.nan|\.NaN|\.NAN"
             + @")$";
 
+        /// <summary>
+        /// This pattern matches strings that are special both in YAML 1.1 and 1.2
+        /// </summary>
+        private static readonly string CombinedYaml1_1SpecialStrings_Pattern =
+            @"^("
+                + @"null|Null|NULL|\~"
+                + @"|true|True|TRUE|false|False|FALSE"
+                + @"|y|Y|yes|Yes|YES|n|N|no|No|NO"
+                + @"|on|On|ON|off|Off|OFF"
+                + @"|[-+]?0b[0-1_]+" // int base 2
+                + @"|[-+]?0o?[0-7_]+" // int base 8 both with and without "o"
+                + @"|[-+]?(0|[1-9][0-9_]*)" // int base 10
+                + @"|[-+]?0x[0-9a-fA-F_]+" // int base 16
+                + @"|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+" // int base 60
+                + @"|[-+]?([0-9][0-9_]*)?\.[0-9_]*([eE][-+][0-9]+)?" // float base 10
+                + @"|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\.[0-9_]*" // float base 60
+                + @"|[-+]?\.(inf|Inf|INF)"
+                + @"|\.(nan|NaN|NAN)"
+            + @")$";
+
+        public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings)
+            : this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings)
+        {
+            this.quoteNecessaryStrings = quoteNecessaryStrings;
+
+            var specialStringValuePattern = quoteYaml1_1Strings
+                ? CombinedYaml1_1SpecialStrings_Pattern
+                : SpecialStrings_Pattern;
+#if NET40
+            isSpecialStringValue_Regex = new Regex(specialStringValuePattern);
+#else
+            isSpecialStringValue_Regex = new Regex(specialStringValuePattern, RegexOptions.Compiled);
+#endif
+        }
+
         public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings)
             : this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings)
         {
             this.quoteNecessaryStrings = quoteNecessaryStrings;
+
+#if NET40
+            isSpecialStringValue_Regex = new Regex(SpecialStrings_Pattern);
+#else
+            isSpecialStringValue_Regex = new Regex(SpecialStrings_Pattern, RegexOptions.Compiled);
+#endif
         }
 
         public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings)
@@ -204,9 +247,7 @@ private bool IsSpecialStringValue(string value)
                 return true;
             }
 
-            return Regex.IsMatch(
-                value,
-                IsSpecialStringValue_Regex);
+            return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
         }
     }
 }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/DictionaryDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/DictionaryDeserializer.cs
@@ -28,9 +28,25 @@ namespace YamlDotNet.Serialization.NodeDeserializers
 {
     public abstract class DictionaryDeserializer
     {
-        protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result)
+        private readonly bool duplicateKeyChecking;
+
+        public DictionaryDeserializer(bool duplicateKeyChecking)
+        {
+            this.duplicateKeyChecking = duplicateKeyChecking;
+        }
+
+        private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
+        {
+            if (duplicateKeyChecking && result.Contains(key))
+            {
+                throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {key}");
+            }
+            result[key] = value!;
+        }
+
+        protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result)
         {
-            parser.Consume<MappingStart>();
+            var property = parser.Consume<MappingStart>();
             while (!parser.TryConsume<MappingEnd>(out var _))
             {
                 var key = nestedObjectDeserializer(parser, tKey);
@@ -53,7 +69,7 @@ protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser,
                         {
                             if (hasFirstPart)
                             {
-                                result[v!] = value!;
+                                TryAssign(result, v!, value!, property);
                             }
                             else
                             {
@@ -66,7 +82,7 @@ protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser,
                         {
                             if (hasFirstPart)
                             {
-                                result[key] = v!;
+                                TryAssign(result, key, v!, property);
                             }
                             else
                             {
@@ -86,7 +102,7 @@ protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser,
                     if (valuePromise == null)
                     {
                         // Happy path: both key and value are known
-                        result[key] = value!;
+                        TryAssign(result, key, value!, property);
                     }
                     else
                     {
diff --git a/YamlDotNet/Serialization/NodeDeserializers/DictionaryNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/DictionaryNodeDeserializer.cs
@@ -33,7 +33,8 @@ public class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeseriali
     {
         private readonly IObjectFactory objectFactory;
 
-        public DictionaryNodeDeserializer(IObjectFactory objectFactory)
+        public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking) :
+            base(duplicateKeyChecking)
         {
             this.objectFactory = objectFactory ?? throw new ArgumentNullException(nameof(objectFactory));
         }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/ObjectNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/ObjectNodeDeserializer.cs
@@ -57,17 +57,16 @@ public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, o
             var implementationType = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
 
             value = objectFactory.Create(implementationType);
-            var consumedProperties = new List<string>();
+            var consumedProperties = new HashSet<string>(StringComparer.Ordinal);
             while (!parser.TryConsume<MappingEnd>(out var _))
             {
                 var propertyName = parser.Consume<Scalar>();
-                if (duplicateKeyChecking && consumedProperties.Contains(propertyName.Value))
+                if (duplicateKeyChecking && !consumedProperties.Add(propertyName.Value))
                 {
                     throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {propertyName.Value}");
                 }
                 try
                 {
-                    consumedProperties.Add(propertyName.Value);
                     var property = typeDescriptor.GetProperty(implementationType, null, propertyName.Value, ignoreUnmatched);
                     if (property == null)
                     {
diff --git a/YamlDotNet/Serialization/NodeDeserializers/StaticDictionaryNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/StaticDictionaryNodeDeserializer.cs
@@ -29,7 +29,8 @@ public class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDes
     {
         private readonly ObjectFactories.StaticObjectFactory _objectFactory;
 
-        public StaticDictionaryNodeDeserializer(ObjectFactories.StaticObjectFactory objectFactory)
+        public StaticDictionaryNodeDeserializer(ObjectFactories.StaticObjectFactory objectFactory, bool duplicateKeyChecking)
+            : base(duplicateKeyChecking)
         {
             _objectFactory = objectFactory ?? throw new ArgumentNullException(nameof(objectFactory));
         }
diff --git a/YamlDotNet/Serialization/SerializerBuilder.cs b/YamlDotNet/Serialization/SerializerBuilder.cs
@@ -60,6 +60,7 @@ public sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
         private EmitterSettings emitterSettings = EmitterSettings.Default;
         private DefaultValuesHandling defaultValuesHandlingConfiguration = DefaultValuesHandling.Preserve;
         private bool quoteNecessaryStrings;
+        private bool quoteYaml1_1Strings;
 
         public SerializerBuilder()
             : base(new DynamicTypeResolver())
@@ -96,7 +97,7 @@ public SerializerBuilder()
 
             eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter>
             {
-                { typeof(TypeAssigningEventEmitter), inner => new TypeAssigningEventEmitter(inner, false, tagMappings, quoteNecessaryStrings) }
+                { typeof(TypeAssigningEventEmitter), inner => new TypeAssigningEventEmitter(inner, false, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings) }
             };
 
             objectFactory = new DefaultObjectFactory();
@@ -110,9 +111,11 @@ public SerializerBuilder()
         /// <summary>
         /// Put double quotes around strings that need it, for example Null, True, False, a number. This should be called before any other "With" methods if you want this feature enabled.
         /// </summary>
-        public SerializerBuilder WithQuotingNecessaryStrings()
+        /// <param name="quoteYaml1_1Strings">Also quote strings that are valid scalars in the YAML 1.1 specification (which includes boolean Yes/No/On/Off, base 60 numbers and more)</param>
+        public SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
         {
             quoteNecessaryStrings = true;
+            this.quoteYaml1_1Strings = quoteYaml1_1Strings;
             return this;
         }
 
@@ -269,7 +272,7 @@ public SerializerBuilder EnsureRoundtrip()
                 settings,
                 objectFactory
             );
-            WithEventEmitter(inner => new TypeAssigningEventEmitter(inner, true, tagMappings, quoteNecessaryStrings), loc => loc.InsteadOf<TypeAssigningEventEmitter>());
+            WithEventEmitter(inner => new TypeAssigningEventEmitter(inner, true, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings), loc => loc.InsteadOf<TypeAssigningEventEmitter>());
             return WithTypeInspector(inner => new ReadableAndWritablePropertiesTypeInspector(inner), loc => loc.OnBottom());
         }
 
diff --git a/YamlDotNet/Serialization/StaticDeserializerBuilder.cs b/YamlDotNet/Serialization/StaticDeserializerBuilder.cs
@@ -88,7 +88,7 @@ public StaticDeserializerBuilder(StaticContext context)
                 { typeof(NullNodeDeserializer), _ => new NullNodeDeserializer() },
                 { typeof(ScalarNodeDeserializer), _ => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter) },
                 { typeof(StaticArrayNodeDeserializer), _ => new StaticArrayNodeDeserializer(factory) },
-                { typeof(StaticDictionaryNodeDeserializer), _ => new StaticDictionaryNodeDeserializer(factory) },
+                { typeof(StaticDictionaryNodeDeserializer), _ => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking) },
                 { typeof(StaticCollectionNodeDeserializer), _ => new StaticCollectionNodeDeserializer(factory) },
                 { typeof(ObjectNodeDeserializer), _ => new ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter) },
             };

Original file line number	Diff line number	Diff line change
`@@ -569,7 +569,7 @@ public void Given_Values_WithFormats_WriteYaml_ShouldReturn_Result_WithFirstForm`
`569`	`569`	`public void JsonCompatible_EncaseDateTimesInDoubleQuotes()`
`570`	`570`	`{`
`571`	`571`	`var serializer = new SerializerBuilder().JsonCompatible().Build();`
`572`		`- var testObject = new TestObject { DateTime = new DateTime(2023, 01, 14, 0, 1, 2) };`
	`572`	`+ var testObject = new TestObject { DateTime = new DateTime(2023, 01, 14, 0, 1, 2, DateTimeKind.Utc) };`
`573`	`573`	`var actual = serializer.Serialize(testObject);`
`574`	`574`
`575`	`575`	`actual.TrimNewLines().Should().ContainEquivalentOf("{\"DateTime\": \"01/14/2023 00:01:02\"}");`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,25 @@ namespace YamlDotNet.Serialization.NodeDeserializers`
`28`	`28`	`{`
`29`	`29`	`public abstract class DictionaryDeserializer`
`30`	`30`	`{`
`31`		`- protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result)`
	`31`	`+ private readonly bool duplicateKeyChecking;`
	`32`	`+`
	`33`	`+ public DictionaryDeserializer(bool duplicateKeyChecking)`
	`34`	`+ {`
	`35`	`+ this.duplicateKeyChecking = duplicateKeyChecking;`
	`36`	`+ }`
	`37`	`+`
	`38`	`+ private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)`
	`39`	`+ {`
	`40`	`+ if (duplicateKeyChecking && result.Contains(key))`
	`41`	`+ {`
	`42`	`+ throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {key}");`
	`43`	`+ }`
	`44`	`+ result[key] = value!;`
	`45`	`+ }`
	`46`	`+`
	`47`	`+ protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result)`
`32`	`48`	`{`
`33`		`- parser.Consume<MappingStart>();`
	`49`	`+ var property = parser.Consume<MappingStart>();`
`34`	`50`	`while (!parser.TryConsume<MappingEnd>(out var _))`
`35`	`51`	`{`
`36`	`52`	`var key = nestedObjectDeserializer(parser, tKey);`
`@@ -53,7 +69,7 @@ protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser,`
`53`	`69`	`{`
`54`	`70`	`if (hasFirstPart)`
`55`	`71`	`{`
`56`		`- result[v!] = value!;`
	`72`	`+ TryAssign(result, v!, value!, property);`
`57`	`73`	`}`
`58`	`74`	`else`
`59`	`75`	`{`
`@@ -66,7 +82,7 @@ protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser,`
`66`	`82`	`{`
`67`	`83`	`if (hasFirstPart)`
`68`	`84`	`{`
`69`		`- result[key] = v!;`
	`85`	`+ TryAssign(result, key, v!, property);`
`70`	`86`	`}`
`71`	`87`	`else`
`72`	`88`	`{`
`@@ -86,7 +102,7 @@ protected void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser,`
`86`	`102`	`if (valuePromise == null)`
`87`	`103`	`{`
`88`	`104`	`// Happy path: both key and value are known`
`89`		`- result[key] = value!;`
	`105`	`+ TryAssign(result, key, value!, property);`
`90`	`106`	`}`
`91`	`107`	`else`
`92`	`108`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,8 @@ public class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeseriali`
`33`	`33`	`{`
`34`	`34`	`private readonly IObjectFactory objectFactory;`
`35`	`35`
`36`		`- public DictionaryNodeDeserializer(IObjectFactory objectFactory)`
	`36`	`+ public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking) :`
	`37`	`+ base(duplicateKeyChecking)`
`37`	`38`	`{`
`38`	`39`	`this.objectFactory = objectFactory ?? throw new ArgumentNullException(nameof(objectFactory));`
`39`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,17 +57,16 @@ public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, o`
`57`	`57`	`var implementationType = Nullable.GetUnderlyingType(expectedType) ?? expectedType;`
`58`	`58`
`59`	`59`	`value = objectFactory.Create(implementationType);`
`60`		`- var consumedProperties = new List<string>();`
	`60`	`+ var consumedProperties = new HashSet<string>(StringComparer.Ordinal);`
`61`	`61`	`while (!parser.TryConsume<MappingEnd>(out var _))`
`62`	`62`	`{`
`63`	`63`	`var propertyName = parser.Consume<Scalar>();`
`64`		`- if (duplicateKeyChecking && consumedProperties.Contains(propertyName.Value))`
	`64`	`+ if (duplicateKeyChecking && !consumedProperties.Add(propertyName.Value))`
`65`	`65`	`{`
`66`	`66`	`throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {propertyName.Value}");`
`67`	`67`	`}`
`68`	`68`	`try`
`69`	`69`	`{`
`70`		`- consumedProperties.Add(propertyName.Value);`
`71`	`70`	`var property = typeDescriptor.GetProperty(implementationType, null, propertyName.Value, ignoreUnmatched);`
`72`	`71`	`if (property == null)`
`73`	`72`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,8 @@ public class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDes`
`29`	`29`	`{`
`30`	`30`	`private readonly ObjectFactories.StaticObjectFactory _objectFactory;`
`31`	`31`
`32`		`- public StaticDictionaryNodeDeserializer(ObjectFactories.StaticObjectFactory objectFactory)`
	`32`	`+ public StaticDictionaryNodeDeserializer(ObjectFactories.StaticObjectFactory objectFactory, bool duplicateKeyChecking)`
	`33`	`+ : base(duplicateKeyChecking)`
`33`	`34`	`{`
`34`	`35`	`_objectFactory = objectFactory ?? throw new ArgumentNullException(nameof(objectFactory));`
`35`	`36`	`}`