Option to disable KeyValuePairSerializer

src/protobuf-net.Test/Serializers/ImplicitTupleOptionTests.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using ProtoBuf.Meta;
+using Xunit;
+
+namespace ProtoBuf.unittest.Serializers
+{
+    public sealed class ImplicitTupleOptionTests
+    {
+        public class ImplicitTupleType
+        {
+            public int Value { get; }
+
+            public ImplicitTupleType(int value)
+            {
+                Value = value;
+            }
+        }
+
+        [Fact]
+        public void ImplicitTupleTypeFailsWhenOptionDisabled()
+        {
+            var model = RuntimeTypeModel.Create();
+            model.AllowImplicitTuples = false;
+            var kv = new KeyValuePair<int, string>(0xdead, "hello");
+            Assert.Throws<InvalidOperationException>(() => model.DeepClone(kv));
+        }
+
+        [Fact]
+        public void DictionaryWorksWithoutImplicitTuples()
+        {
+            var value = new Dictionary<int, string>()
+            {
+                [123] = "abc",
+                [456] = "def"
+            };
+            var model = RuntimeTypeModel.Create();
+            model.AllowImplicitTuples = false;
+            var clone = model.DeepClone(value);
+            Assert.Equal(value.Count, clone.Count); //, "Runtime");
+            Assert.Equal("abc", clone[123]); //, "Runtime");
+            Assert.Equal("def", clone[456]); //, "Runtime");
+
+            model.CompileInPlace();
+            clone = model.DeepClone(value);
+            Assert.Equal(value.Count, clone.Count); //, "CompileInPlace");
+            Assert.Equal("abc", clone[123]); //, "CompileInPlace");
+            Assert.Equal("def", clone[456]); //, "CompileInPlace");
+
+            clone = model.Compile().DeepClone(value);
+            Assert.Equal(value.Count, clone.Count); //, "Compile");
+            Assert.Equal("abc", clone[123]); //, "Compile");
+            Assert.Equal("def", clone[456]); //, "Compile");
+        }
+    }
+}

src/protobuf-net.Test/Serializers/KeyValuePairTests.cs

@@ -4,7 +4,6 @@
 
 namespace ProtoBuf.unittest.Serializers
 {
-
     public class KeyValuePairTests
     {
         [Fact]

src/protobuf-net/Meta/MetaType.cs

@@ -952,8 +952,9 @@ internal static AttributeFamily GetContractFamily(RuntimeTypeModel model, Type t
                         break;
                 }
             }
-            if (family == AttributeFamily.None)
-            { // check for obvious tuples
+            if (family == AttributeFamily.None && model.AllowImplicitTuples)
+            { 
+                // check for obvious tuples
                 if (ResolveTupleConstructor(type, out _) is object)
                 {
                     family |= AttributeFamily.AutoTuple;

src/protobuf-net/Meta/RuntimeTypeModel.cs

@@ -51,6 +51,7 @@ private enum RuntimeTypeModelOptions
             UseImplicitZeroDefaults = 1 << 15,
             AllowParseableTypes = 1 << 16,
             AutoAddProtoContractTypesOnly = 1 << 17,
+            AllowImplicitTuples = 1 << 18,
         }
 
         /// <summary>
@@ -163,6 +164,19 @@ public bool InternStrings
             set { SetOption(RuntimeTypeModelOptions.InternStrings, value); }
         }
 
+        /// <summary>
+        /// Global switch that enables or disables the implicit handling of tuple-like types.
+        /// With this enabled, types that
+        ///     - have a constructor with parameters that are equivalent to all its public members 
+        ///     - has only read-only properties, or whose name includes Tuple
+        /// are serialized even if they are not attributed.
+        /// </summary>
+        public bool AllowImplicitTuples
+        {
+            get { return GetOption(RuntimeTypeModelOptions.AllowImplicitTuples); }
+            set { SetOption(RuntimeTypeModelOptions.AllowImplicitTuples, value); }
+        }
+
         /// <summary>
         /// The default model, used to support ProtoBuf.Serializer
         /// </summary>
@@ -556,6 +570,7 @@ internal RuntimeTypeModel(bool isDefault, string name)
         {
             AutoAddMissingTypes = true;
             UseImplicitZeroDefaults = true;
+            AllowImplicitTuples = true;
             SetOption(RuntimeTypeModelOptions.IsDefaultModel, isDefault);
 #if !DEBUG
             try