Merge pull request #560 from jskeet/csharp-repeated

Large changes to repeated field handling

10 files changed, 929 insertions, 1008 deletions

diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamExtensions.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamExtensions.cs
new file mode 100644
index 00000000..408c7cb9
--- /dev/null
+++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamExtensions.cs
@@ -0,0 +1,54 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using NUnit.Framework;
+
+namespace Google.Protobuf
+{
+    internal static class CodedInputStreamExtensions
+    {
+        public static void AssertNextTag(this CodedInputStream input, uint expectedTag)
+        {
+            uint tag;
+            Assert.IsTrue(input.ReadTag(out tag));
+            Assert.AreEqual(expectedTag, tag);
+        }
+
+        public static T ReadMessage<T>(this CodedInputStream stream, MessageParser<T> parser)
+            where T : IMessage<T>
+        {
+            var message = parser.CreateTemplate();
+            stream.ReadMessage(message);
+            return message;
+        }
+    }
+}
diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
index 52757d4d..a64994fd 100644
--- a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
@@ -35,10 +35,8 @@
 #endregion

 

 using System;

-using System.Collections.Generic;

 using System.IO;

 using Google.Protobuf.Collections;

-using Google.Protobuf.Descriptors;

 using Google.Protobuf.TestProtos;

 using NUnit.Framework;

 

@@ -62,7 +60,7 @@ namespace Google.Protobuf
         }

 

         /// <summary>

-        /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and

+        /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64()

         /// </summary>

         private static void AssertReadVarint(byte[] data, ulong value)

         {

@@ -232,66 +230,26 @@ namespace Google.Protobuf
             Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL));

             Assert.AreEqual(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));

         }

-        /*

+        

         [Test]

-        public void ReadWholeMessage()

+        public void ReadWholeMessage_VaryingBlockSizes()

         {

-            TestAllTypes message = TestUtil.GetAllSet();

+            TestAllTypes message = GeneratedMessageTest.GetSampleMessage();

 

             byte[] rawBytes = message.ToByteArray();

-            Assert.AreEqual(rawBytes.Length, message.SerializedSize);

-            TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);

-            TestUtil.AssertAllFieldsSet(message2);

+            Assert.AreEqual(rawBytes.Length, message.CalculateSize());

+            TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(rawBytes);

+            Assert.AreEqual(message, message2);

 

             // Try different block sizes.

             for (int blockSize = 1; blockSize < 256; blockSize *= 2)

             {

-                message2 = TestAllTypes.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));

-                TestUtil.AssertAllFieldsSet(message2);

+                message2 = TestAllTypes.Parser.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));

+                Assert.AreEqual(message, message2);

             }

         }

-

+                

         [Test]

-        public void SkipWholeMessage()

-        {

-            TestAllTypes message = TestUtil.GetAllSet();

-            byte[] rawBytes = message.ToByteArray();

-

-            // Create two parallel inputs.  Parse one as unknown fields while using

-            // skipField() to skip each field on the other.  Expect the same tags.

-            CodedInputStream input1 = CodedInputStream.CreateInstance(rawBytes);

-            CodedInputStream input2 = CodedInputStream.CreateInstance(rawBytes);

-            UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder();

-

-            uint tag;

-            string name;

-            while (input1.ReadTag(out tag, out name))

-            {

-                uint tag2;

-                Assert.IsTrue(input2.ReadTag(out tag2, out name));

-                Assert.AreEqual(tag, tag2);

-

-                unknownFields.MergeFieldFrom(tag, input1);

-                input2.SkipField();

-            }

-        }*/

-

-        /// <summary>

-        /// Test that a bug in SkipRawBytes has been fixed: if the skip

-        /// skips exactly up to a limit, this should bnot break things

-        /// </summary>

-        [Test]

-        public void SkipRawBytesBug()

-        {

-            byte[] rawBytes = new byte[] {1, 2};

-            CodedInputStream input = CodedInputStream.CreateInstance(rawBytes);

-

-            int limit = input.PushLimit(1);

-            input.SkipRawBytes(1);

-            input.PopLimit(limit);

-            Assert.AreEqual(2, input.ReadRawByte());

-        }

-        /*

         public void ReadHugeBlob()

         {

             // Allocate and initialize a 1MB blob.

@@ -302,24 +260,15 @@ namespace Google.Protobuf
             }

 

             // Make a message containing it.

-            TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();

-            TestUtil.SetAllFields(builder);

-            builder.SetOptionalBytes(ByteString.CopyFrom(blob));

-            TestAllTypes message = builder.Build();

+            var message = new TestAllTypes { SingleBytes = ByteString.CopyFrom(blob) };

 

             // Serialize and parse it.  Make sure to parse from an InputStream, not

             // directly from a ByteString, so that CodedInputStream uses buffered

             // reading.

-            TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput());

+            TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(message.ToByteString());

 

-            Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes);

-

-            // Make sure all the other fields were parsed correctly.

-            TestAllTypes message3 = TestAllTypes.CreateBuilder(message2)

-                .SetOptionalBytes(TestUtil.GetAllSet().OptionalBytes)

-                .Build();

-            TestUtil.AssertAllFieldsSet(message3);

-        }*/

+            Assert.AreEqual(message, message2);

+        }

 

         [Test]

         public void ReadMaliciouslyLargeBlob()

@@ -461,66 +410,15 @@ namespace Google.Protobuf
             }

         }

 

-        enum TestNegEnum { None = 0, Value = -2 }

-

         [Test]

         public void TestNegativeEnum()

         {

-            byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };

+            byte[] bytes = { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

-            Assert.AreEqual((int)TestNegEnum.Value, input.ReadEnum());

+            Assert.AreEqual((int)SampleEnum.NegativeValue, input.ReadEnum());

             Assert.IsTrue(input.IsAtEnd);

         }

 

-        [Test]

-        public void TestNegativeEnumPackedArray()

-        {

-            int arraySize = 1 + (10 * 5);

-            int msgSize = 1 + 1 + arraySize;

-            byte[] bytes = new byte[msgSize];

-            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteTag(8, WireFormat.WireType.LengthDelimited);

-            output.WritePackedInt32Array(new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });

-

-            Assert.AreEqual(0, output.SpaceLeft);

-

-            CodedInputStream input = CodedInputStream.CreateInstance(bytes);

-            uint tag;

-            Assert.IsTrue(input.ReadTag(out tag));

-

-            RepeatedField<TestNegEnum> values = new RepeatedField<TestNegEnum>();

-            input.ReadEnumArray(values);

-

-            Assert.AreEqual(6, values.Count);

-            Assert.AreEqual(TestNegEnum.None, values[0]);

-            Assert.AreEqual(TestNegEnum.Value, values[2]);

-            // TODO(jonskeet): Test unknown value preservation

-        }

-

-        [Test]

-        public void TestNegativeEnumArray()

-        {

-            int arraySize = 1 + 1 + (11 * 5);

-            int msgSize = arraySize;

-            byte[] bytes = new byte[msgSize];

-            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteInt32Array(8, new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });

-

-            Assert.AreEqual(0, output.SpaceLeft);

-

-            CodedInputStream input = CodedInputStream.CreateInstance(bytes);

-            uint tag;

-            Assert.IsTrue(input.ReadTag(out tag));

-

-            RepeatedField<TestNegEnum> values = new RepeatedField<TestNegEnum>();

-            input.ReadEnumArray(values);

-

-            Assert.AreEqual(6, values.Count);

-            Assert.AreEqual(TestNegEnum.None, values[0]);

-            Assert.AreEqual(TestNegEnum.Value, values[2]);

-            // TODO(jonskeet): Test unknown value preservation

-        }

-

         //Issue 71:	CodedInputStream.ReadBytes go to slow path unnecessarily

         [Test]

         public void TestSlowPathAvoidance()

diff --git a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
index 223374e0..ab5dcbd6 100644
--- a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
@@ -35,9 +35,8 @@
 #endregion

 

 using System;

-using System.Collections.Generic;

 using System.IO;

-using Google.Protobuf.Collections;

+using Google.Protobuf.TestProtos;

 using NUnit.Framework;

 

 namespace Google.Protobuf

@@ -195,42 +194,24 @@ namespace Google.Protobuf
                 0x9abcdef012345678UL);

         }

 

-        /*

         [Test]

-        public void WriteWholeMessage()

+        public void WriteWholeMessage_VaryingBlockSizes()

         {

-            TestAllTypes message = TestUtil.GetAllSet();

+            TestAllTypes message = GeneratedMessageTest.GetSampleMessage();

 

             byte[] rawBytes = message.ToByteArray();

-            TestUtil.AssertEqualBytes(TestUtil.GoldenMessage.ToByteArray(), rawBytes);

 

             // Try different block sizes.

             for (int blockSize = 1; blockSize < 256; blockSize *= 2)

             {

                 MemoryStream rawOutput = new MemoryStream();

-                CodedOutputStream output =

-                    CodedOutputStream.CreateInstance(rawOutput, blockSize);

+                CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, blockSize);

                 message.WriteTo(output);

                 output.Flush();

-                TestUtil.AssertEqualBytes(rawBytes, rawOutput.ToArray());

+                Assert.AreEqual(rawBytes, rawOutput.ToArray());

             }

         }

-

-        /// <summary>

-        /// Tests writing a whole message with every packed field type. Ensures the

-        /// wire format of packed fields is compatible with C++.

-        /// </summary>

-        [Test]

-        public void WriteWholePackedFieldsMessage()

-        {

-            TestPackedTypes message = TestUtil.GetPackedSet();

-

-            byte[] rawBytes = message.ToByteArray();

-            TestUtil.AssertEqualBytes(TestUtil.GetGoldenPackedFieldsMessage().ToByteArray(),

-                                      rawBytes);

-        }

-        */

-

+        

         [Test]

         public void EncodeZigZag32()

         {

@@ -296,66 +277,16 @@ namespace Google.Protobuf
         public void TestNegativeEnumNoTag()

         {

             Assert.AreEqual(10, CodedOutputStream.ComputeInt32Size(-2));

-            Assert.AreEqual(10, CodedOutputStream.ComputeEnumSize((int) TestNegEnum.Value));

+            Assert.AreEqual(10, CodedOutputStream.ComputeEnumSize((int) SampleEnum.NegativeValue));

 

             byte[] bytes = new byte[10];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteEnum((int) TestNegEnum.Value);

+            output.WriteEnum((int) SampleEnum.NegativeValue);

 

             Assert.AreEqual(0, output.SpaceLeft);

             Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));

         }

 

-        enum TestNegEnum { None = 0, Value = -2 }

-

-        [Test]

-        public void TestNegativeEnumArrayPacked()

-        {

-            int arraySize = 1 + (10 * 5);

-            int msgSize = 1 + 1 + arraySize;

-            byte[] bytes = new byte[msgSize];

-            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteTag(8, WireFormat.WireType.LengthDelimited);

-            output.WritePackedEnumArray(new RepeatedField<TestNegEnum> {

-                0, (TestNegEnum) (-1), TestNegEnum.Value, (TestNegEnum) (-3), (TestNegEnum) (-4), (TestNegEnum) (-5) });

-

-            Assert.AreEqual(0, output.SpaceLeft);

-

-            CodedInputStream input = CodedInputStream.CreateInstance(bytes);

-            uint tag;

-            Assert.IsTrue(input.ReadTag(out tag));

-

-            List<int> values = new List<int>();

-            input.ReadInt32Array(values);

-

-            Assert.AreEqual(6, values.Count);

-            for (int i = 0; i > -6; i--)

-                Assert.AreEqual(i, values[Math.Abs(i)]);

-        }

-

-        [Test]

-        public void TestNegativeEnumArray()

-        {

-            int arraySize = 1 + 1 + (11 * 5);

-            int msgSize = arraySize;

-            byte[] bytes = new byte[msgSize];

-            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteEnumArray(8, new RepeatedField<TestNegEnum> {

-                0, (TestNegEnum) (-1), TestNegEnum.Value, (TestNegEnum) (-3), (TestNegEnum) (-4), (TestNegEnum) (-5) });

-            Assert.AreEqual(0, output.SpaceLeft);

-

-            CodedInputStream input = CodedInputStream.CreateInstance(bytes);

-            uint tag;

-            Assert.IsTrue(input.ReadTag(out tag));

-

-            List<int> values = new List<int>();

-            input.ReadInt32Array(values);

-

-            Assert.AreEqual(6, values.Count);

-            for (int i = 0; i > -6; i--)

-                Assert.AreEqual(i, values[Math.Abs(i)]);

-        }

-

         [Test]

         public void TestCodedInputOutputPosition()

         {

@@ -405,7 +336,7 @@ namespace Google.Protobuf
                 Assert.AreEqual(130, cout.Position);

                 cout.Flush();

             }

-            //Now test Input stream:

+            // Now test Input stream:

             {

                 CodedInputStream cin = CodedInputStream.CreateInstance(new MemoryStream(bytes), new byte[50]);

                 uint tag;

@@ -418,8 +349,8 @@ namespace Google.Protobuf
                 //Field 2:

                 Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 2);

                 Assert.AreEqual(4, cin.Position);

-                uint childlen = cin.ReadRawVarint32();

-                Assert.AreEqual(120u, childlen);

+                int childlen = cin.ReadLength();

+                Assert.AreEqual(120, childlen);

                 Assert.AreEqual(5, cin.Position);

                 int oldlimit = cin.PushLimit((int)childlen);

                 Assert.AreEqual(5, cin.Position);

diff --git a/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs b/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs
index 29945c36..988801b7 100644
--- a/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs
@@ -1,5 +1,39 @@
-using System;
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using Google.Protobuf.TestProtos;
 using NUnit.Framework;
 
@@ -89,5 +123,260 @@ namespace Google.Protobuf.Collections
             var clone = list.Clone();
             clone[0] = 1;
         }
+
+        [Test]
+        public void AddEntriesFrom_PackedInt32()
+        {
+            uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            var length = CodedOutputStream.ComputeInt32Size(10)
+                + CodedOutputStream.ComputeInt32Size(999)
+                + CodedOutputStream.ComputeInt32Size(-1000);
+            output.WriteTag(packedTag);
+            output.WriteRawVarint32((uint) length);
+            output.WriteInt32(10);
+            output.WriteInt32(999);
+            output.WriteInt32(-1000);
+            output.Flush();
+            stream.Position = 0;
+
+            // Deliberately "expecting" a non-packed tag, but we detect that the data is
+            // actually packed.
+            uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var field = new RepeatedField<int>();
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(packedTag);
+            field.AddEntriesFrom(input, FieldCodec.ForInt32(nonPackedTag));
+            CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field);
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+        [Test]
+        public void AddEntriesFrom_NonPackedInt32()
+        {
+            uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.Varint);
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            output.WriteTag(nonPackedTag);
+            output.WriteInt32(10);
+            output.WriteTag(nonPackedTag);
+            output.WriteInt32(999);
+            output.WriteTag(nonPackedTag);
+            output.WriteInt32(-1000); // Just for variety...
+            output.Flush();
+            stream.Position = 0;
+
+            // Deliberately "expecting" a packed tag, but we detect that the data is
+            // actually not packed.
+            uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var field = new RepeatedField<int>();
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(nonPackedTag);
+            field.AddEntriesFrom(input, FieldCodec.ForInt32(packedTag));
+            CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field);
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+        [Test]
+        public void AddEntriesFrom_String()
+        {
+            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            output.WriteTag(tag);
+            output.WriteString("Foo");
+            output.WriteTag(tag);
+            output.WriteString("");
+            output.WriteTag(tag);
+            output.WriteString("Bar");
+            output.Flush();
+            stream.Position = 0;
+
+            var field = new RepeatedField<string>();
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(tag);
+            field.AddEntriesFrom(input, FieldCodec.ForString(tag));
+            CollectionAssert.AreEqual(new[] { "Foo", "", "Bar" }, field);
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+        [Test]
+        public void AddEntriesFrom_Message()
+        {
+            var message1 = new ForeignMessage { C = 2000 };
+            var message2 = new ForeignMessage { C = -250 };
+
+            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            output.WriteTag(tag);
+            output.WriteMessage(message1);
+            output.WriteTag(tag);
+            output.WriteMessage(message2);
+            output.Flush();
+            stream.Position = 0;
+
+            var field = new RepeatedField<ForeignMessage>();
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(tag);
+            field.AddEntriesFrom(input, FieldCodec.ForMessage(tag, ForeignMessage.Parser));
+            CollectionAssert.AreEqual(new[] { message1, message2}, field);
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+        [Test]
+        public void WriteTo_PackedInt32()
+        {
+            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var field = new RepeatedField<int> { 10, 1000, 1000000 };
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            field.WriteTo(output, FieldCodec.ForInt32(tag));
+            output.Flush();
+            stream.Position = 0;
+
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(tag);
+            var length = input.ReadLength();
+            Assert.AreEqual(10, input.ReadInt32());
+            Assert.AreEqual(1000, input.ReadInt32());
+            Assert.AreEqual(1000000, input.ReadInt32());
+            Assert.IsTrue(input.IsAtEnd);
+            Assert.AreEqual(1 + CodedOutputStream.ComputeLengthSize(length) + length, stream.Length);
+        }
+
+        [Test]
+        public void WriteTo_NonPackedInt32()
+        {
+            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.Varint);
+            var field = new RepeatedField<int> { 10, 1000, 1000000};
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            field.WriteTo(output, FieldCodec.ForInt32(tag));
+            output.Flush();
+            stream.Position = 0;
+
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(tag);
+            Assert.AreEqual(10, input.ReadInt32());
+            input.AssertNextTag(tag);
+            Assert.AreEqual(1000, input.ReadInt32());
+            input.AssertNextTag(tag);
+            Assert.AreEqual(1000000, input.ReadInt32());
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+        [Test]
+        public void WriteTo_String()
+        {
+            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var field = new RepeatedField<string> { "Foo", "", "Bar" };
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            field.WriteTo(output, FieldCodec.ForString(tag));
+            output.Flush();
+            stream.Position = 0;
+
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(tag);
+            Assert.AreEqual("Foo", input.ReadString());
+            input.AssertNextTag(tag);
+            Assert.AreEqual("", input.ReadString());
+            input.AssertNextTag(tag);
+            Assert.AreEqual("Bar", input.ReadString());
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+        [Test]
+        public void WriteTo_Message()
+        {
+            var message1 = new ForeignMessage { C = 20 };
+            var message2 = new ForeignMessage { C = 25 };
+            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
+            var field = new RepeatedField<ForeignMessage> { message1, message2 };
+            var stream = new MemoryStream();
+            var output = CodedOutputStream.CreateInstance(stream);
+            field.WriteTo(output, FieldCodec.ForMessage(tag, ForeignMessage.Parser));
+            output.Flush();
+            stream.Position = 0;
+
+            var input = CodedInputStream.CreateInstance(stream);
+            input.AssertNextTag(tag);
+            Assert.AreEqual(message1, input.ReadMessage(ForeignMessage.Parser));
+            input.AssertNextTag(tag);
+            Assert.AreEqual(message2, input.ReadMessage(ForeignMessage.Parser));
+            Assert.IsTrue(input.IsAtEnd);
+        }
+
+
+        [Test]
+        public void TestNegativeEnumArray()
+        {
+            int arraySize = 1 + 1 + (11 * 5);
+            int msgSize = arraySize;
+            byte[] bytes = new byte[msgSize];
+            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
+            uint tag = WireFormat.MakeTag(8, WireFormat.WireType.Varint);
+            for (int i = 0; i >= -5; i--)
+            {
+                output.WriteTag(tag);
+                output.WriteEnum(i);
+            }
+
+            Assert.AreEqual(0, output.SpaceLeft);
+
+            CodedInputStream input = CodedInputStream.CreateInstance(bytes);
+            Assert.IsTrue(input.ReadTag(out tag));
+
+            RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>();
+            values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x));
+
+            Assert.AreEqual(6, values.Count);
+            Assert.AreEqual(SampleEnum.None, values[0]);
+            Assert.AreEqual(((SampleEnum)(-1)), values[1]);
+            Assert.AreEqual(SampleEnum.NegativeValue, values[2]);
+            Assert.AreEqual(((SampleEnum)(-3)), values[3]);
+            Assert.AreEqual(((SampleEnum)(-4)), values[4]);
+            Assert.AreEqual(((SampleEnum)(-5)), values[5]);
+        }
+
+
+        [Test]
+        public void TestNegativeEnumPackedArray()
+        {
+            int arraySize = 1 + (10 * 5);
+            int msgSize = 1 + 1 + arraySize;
+            byte[] bytes = new byte[msgSize];
+            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
+            // Length-delimited to show we want the packed representation
+            uint tag = WireFormat.MakeTag(8, WireFormat.WireType.LengthDelimited);
+            output.WriteTag(tag);
+            int size = 0;
+            for (int i = 0; i >= -5; i--)
+            {
+                size += CodedOutputStream.ComputeEnumSize(i);
+            }
+            output.WriteRawVarint32((uint)size);
+            for (int i = 0; i >= -5; i--)
+            {
+                output.WriteEnum(i);
+            }
+            Assert.AreEqual(0, output.SpaceLeft);
+
+            CodedInputStream input = CodedInputStream.CreateInstance(bytes);
+            Assert.IsTrue(input.ReadTag(out tag));
+
+            RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>();
+            values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x));
+
+            Assert.AreEqual(6, values.Count);
+            Assert.AreEqual(SampleEnum.None, values[0]);
+            Assert.AreEqual(((SampleEnum)(-1)), values[1]);
+            Assert.AreEqual(SampleEnum.NegativeValue, values[2]);
+            Assert.AreEqual(((SampleEnum)(-3)), values[3]);
+            Assert.AreEqual(((SampleEnum)(-4)), values[4]);
+            Assert.AreEqual(((SampleEnum)(-5)), values[5]);
+        }
     }
 }
diff --git a/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs b/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs
index e2b8e3ef..a14040d1 100644
--- a/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs
@@ -63,15 +63,21 @@ namespace Google.Protobuf
         };
 
         [Test, TestCaseSource("Codecs")]
-        public void RoundTrip(ICodecTestData codec)
+        public void RoundTripWithTag(ICodecTestData codec)
         {
-            codec.TestRoundTrip();
+            codec.TestRoundTripWithTag();
+        }
+
+        [Test, TestCaseSource("Codecs")]
+        public void RoundTripRaw(ICodecTestData codec)
+        {
+            codec.TestRoundTripRaw();
         }
 
         [Test, TestCaseSource("Codecs")]
         public void CalculateSize(ICodecTestData codec)
         {
-            codec.TestCalculateSize();
+            codec.TestCalculateSizeWithTag();
         }
 
         [Test, TestCaseSource("Codecs")]
@@ -82,8 +88,9 @@ namespace Google.Protobuf
 
         public interface ICodecTestData
         {
-            void TestRoundTrip();
-            void TestCalculateSize();
+            void TestRoundTripRaw();
+            void TestRoundTripWithTag();
+            void TestCalculateSizeWithTag();
             void TestDefaultValue();
         }
 
@@ -100,45 +107,67 @@ namespace Google.Protobuf
                 this.name = name;
             }
 
-            public void TestRoundTrip()
+            public void TestRoundTripRaw()
             {
                 var stream = new MemoryStream();
                 var codedOutput = CodedOutputStream.CreateInstance(stream);
-                codec.Write(codedOutput, sampleValue);
+                codec.ValueWriter(codedOutput, sampleValue);
                 codedOutput.Flush();
                 stream.Position = 0;
                 var codedInput = CodedInputStream.CreateInstance(stream);
-                uint tag;
-                Assert.IsTrue(codedInput.ReadTag(out tag));
-                Assert.AreEqual(codec.Tag, tag);
+                Assert.AreEqual(sampleValue, codec.ValueReader(codedInput));
+                Assert.IsTrue(codedInput.IsAtEnd);
+            }
+
+            public void TestRoundTripWithTag()
+            {
+                var stream = new MemoryStream();
+                var codedOutput = CodedOutputStream.CreateInstance(stream);
+                codec.WriteTagAndValue(codedOutput, sampleValue);
+                codedOutput.Flush();
+                stream.Position = 0;
+                var codedInput = CodedInputStream.CreateInstance(stream);
+                codedInput.AssertNextTag(codec.Tag);
                 Assert.AreEqual(sampleValue, codec.Read(codedInput));
                 Assert.IsTrue(codedInput.IsAtEnd);
             }
 
-            public void TestCalculateSize()
+            public void TestCalculateSizeWithTag()
             {
                 var stream = new MemoryStream();
                 var codedOutput = CodedOutputStream.CreateInstance(stream);
-                codec.Write(codedOutput, sampleValue);
+                codec.WriteTagAndValue(codedOutput, sampleValue);
                 codedOutput.Flush();
-                Assert.AreEqual(stream.Position, codec.CalculateSize(sampleValue));
+                Assert.AreEqual(stream.Position, codec.CalculateSizeWithTag(sampleValue));
             }
 
             public void TestDefaultValue()
             {
+                // WriteTagAndValue ignores default values
                 var stream = new MemoryStream();
                 var codedOutput = CodedOutputStream.CreateInstance(stream);
-                codec.Write(codedOutput, codec.DefaultValue);
+                codec.WriteTagAndValue(codedOutput, codec.DefaultValue);
                 codedOutput.Flush();
                 Assert.AreEqual(0, stream.Position);
-                Assert.AreEqual(0, codec.CalculateSize(codec.DefaultValue));
+                Assert.AreEqual(0, codec.CalculateSizeWithTag(codec.DefaultValue));
                 if (typeof(T).IsValueType)
                 {
                     Assert.AreEqual(default(T), codec.DefaultValue);
                 }
-            }
 
-            public string Description { get { return name; } }
+                // The plain ValueWriter/ValueReader delegates don't.
+                if (codec.DefaultValue != null) // This part isn't appropriate for message types.
+                {
+                    codedOutput = CodedOutputStream.CreateInstance(stream);
+                    codec.ValueWriter(codedOutput, codec.DefaultValue);
+                    codedOutput.Flush();
+                    Assert.AreNotEqual(0, stream.Position);
+                    Assert.AreEqual(stream.Position, codec.ValueSizeCalculator(codec.DefaultValue));
+                    stream.Position = 0;
+                    var codedInput = CodedInputStream.CreateInstance(stream);
+                    Assert.AreEqual(codec.DefaultValue, codec.ValueReader(codedInput));
+                }
+            }
 
             public override string ToString()
             {
diff --git a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs
index f8668662..a094e46b 100644
--- a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs
@@ -10,6 +10,61 @@ namespace Google.Protobuf
     /// </summary>

     public class GeneratedMessageTest

     {

+        /// <summary>

+        /// Returns a sample TestAllTypes with all fields populated

+        /// </summary>

+        public static TestAllTypes GetSampleMessage()

+        {

+            return new TestAllTypes

+            {

+                SingleBool = true,

+                SingleBytes = ByteString.CopyFrom(1, 2, 3, 4),

+                SingleDouble = 23.5,

+                SingleFixed32 = 23,

+                SingleFixed64 = 1234567890123,

+                SingleFloat = 12.25f,

+                SingleForeignEnum = ForeignEnum.FOREIGN_BAR,

+                SingleForeignMessage = new ForeignMessage { C = 10 },

+                SingleImportEnum = ImportEnum.IMPORT_BAZ,

+                SingleImportMessage = new ImportMessage { D = 20 },

+                SingleInt32 = 100,

+                SingleInt64 = 3210987654321,

+                SingleNestedEnum = TestAllTypes.Types.NestedEnum.FOO,

+                SingleNestedMessage = new TestAllTypes.Types.NestedMessage { Bb = 35 },

+                SinglePublicImportMessage = new PublicImportMessage { E = 54 },

+                SingleSfixed32 = -123,

+                SingleSfixed64 = -12345678901234,

+                SingleSint32 = -456,

+                SingleSint64 = -12345678901235,

+                SingleString = "test",

+                SingleUint32 = uint.MaxValue,

+                SingleUint64 = ulong.MaxValue,

+                RepeatedBool = { true, false },

+                RepeatedBytes = { ByteString.CopyFrom(1, 2, 3, 4), ByteString.CopyFrom(5, 6), ByteString.CopyFrom(new byte[1000]) },

+                RepeatedDouble = { -12.25, 23.5 },

+                RepeatedFixed32 = { uint.MaxValue, 23 },

+                RepeatedFixed64 = { ulong.MaxValue, 1234567890123 },

+                RepeatedFloat = { 100f, 12.25f },

+                RepeatedForeignEnum = { ForeignEnum.FOREIGN_FOO, ForeignEnum.FOREIGN_BAR },

+                RepeatedForeignMessage = { new ForeignMessage(), new ForeignMessage { C = 10 } },

+                RepeatedImportEnum = { ImportEnum.IMPORT_BAZ, ImportEnum.IMPORT_ENUM_UNSPECIFIED },

+                RepeatedImportMessage = { new ImportMessage { D = 20 }, new ImportMessage { D = 25 } },

+                RepeatedInt32 = { 100, 200 },

+                RepeatedInt64 = { 3210987654321, long.MaxValue },

+                RepeatedNestedEnum = { TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.NEG },

+                RepeatedNestedMessage = { new TestAllTypes.Types.NestedMessage { Bb = 35 }, new TestAllTypes.Types.NestedMessage { Bb = 10 } },

+                RepeatedPublicImportMessage = { new PublicImportMessage { E = 54 }, new PublicImportMessage { E = -1 } },

+                RepeatedSfixed32 = { -123, 123 },

+                RepeatedSfixed64 = { -12345678901234, 12345678901234 },

+                RepeatedSint32 = { -456, 100 },

+                RepeatedSint64 = { -12345678901235, 123 },

+                RepeatedString = { "foo", "bar" },

+                RepeatedUint32 = { uint.MaxValue, uint.MinValue },

+                RepeatedUint64 = { ulong.MaxValue, uint.MinValue },

+                OneofString = "Oneof string"                

+            };

+        }

+

         [Test]

         public void EmptyMessageFieldDistinctFromMissingMessageField()

         {

@@ -485,5 +540,83 @@ namespace Google.Protobuf
             Assert.Throws<InvalidOperationException>(() => frozen.RepeatedDouble.Add(0.0));

             Assert.Throws<InvalidOperationException>(() => frozen.RepeatedNestedMessage.Add(new TestAllTypes.Types.NestedMessage()));

         }

+

+        [Test]

+        public void OneofProperties()

+        {

+            // Switch the oneof case between each of the different options, and check everything behaves

+            // as expected in each case.

+            var message = new TestAllTypes();

+            Assert.AreEqual("", message.OneofString);

+            Assert.AreEqual(0, message.OneofUint32);

+            Assert.AreEqual(ByteString.Empty, message.OneofBytes);

+            Assert.IsNull(message.OneofNestedMessage);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.None, message.OneofFieldCase);

+

+            message.OneofString = "sample";

+            Assert.AreEqual("sample", message.OneofString);

+            Assert.AreEqual(0, message.OneofUint32);

+            Assert.AreEqual(ByteString.Empty, message.OneofBytes);

+            Assert.IsNull(message.OneofNestedMessage);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofString, message.OneofFieldCase);

+

+            var bytes = ByteString.CopyFrom(1, 2, 3);

+            message.OneofBytes = bytes;

+            Assert.AreEqual("", message.OneofString);

+            Assert.AreEqual(0, message.OneofUint32);

+            Assert.AreEqual(bytes, message.OneofBytes);

+            Assert.IsNull(message.OneofNestedMessage);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofBytes, message.OneofFieldCase);

+

+            message.OneofUint32 = 20;

+            Assert.AreEqual("", message.OneofString);

+            Assert.AreEqual(20, message.OneofUint32);

+            Assert.AreEqual(ByteString.Empty, message.OneofBytes);

+            Assert.IsNull(message.OneofNestedMessage);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, message.OneofFieldCase);

+

+            var nestedMessage = new TestAllTypes.Types.NestedMessage { Bb = 25 };

+            message.OneofNestedMessage = nestedMessage;

+            Assert.AreEqual("", message.OneofString);

+            Assert.AreEqual(0, message.OneofUint32);

+            Assert.AreEqual(ByteString.Empty, message.OneofBytes);

+            Assert.AreEqual(nestedMessage, message.OneofNestedMessage);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofNestedMessage, message.OneofFieldCase);

+

+            message.ClearOneofField();

+            Assert.AreEqual("", message.OneofString);

+            Assert.AreEqual(0, message.OneofUint32);

+            Assert.AreEqual(ByteString.Empty, message.OneofBytes);

+            Assert.IsNull(message.OneofNestedMessage);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.None, message.OneofFieldCase);

+        }

+

+        [Test]

+        public void OneofSerialization_NonDefaultValue()

+        {

+            var message = new TestAllTypes();

+            message.OneofString = "this would take a bit of space";

+            message.OneofUint32 = 10;

+            var bytes = message.ToByteArray();

+            Assert.AreEqual(3, bytes.Length); // 2 bytes for the tag + 1 for the value - no string!

+

+            var message2 = TestAllTypes.Parser.ParseFrom(bytes);

+            Assert.AreEqual(message, message2);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, message2.OneofFieldCase);

+        }

+

+        [Test]

+        public void OneofSerialization_DefaultValue()

+        {

+            var message = new TestAllTypes();

+            message.OneofString = "this would take a bit of space";

+            message.OneofUint32 = 0; // This is the default value for UInt32; normally wouldn't be serialized

+            var bytes = message.ToByteArray();

+            Assert.AreEqual(3, bytes.Length); // 2 bytes for the tag + 1 for the value - it's still serialized

+

+            var message2 = TestAllTypes.Parser.ParseFrom(bytes);

+            Assert.AreEqual(message, message2);

+            Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, message2.OneofFieldCase);

+        }

     }

 }

diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
index 80b504aa..ae7d7575 100644
--- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
+++ b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
@@ -72,6 +72,7 @@
   </ItemGroup>

   <ItemGroup>

     <Compile Include="ByteStringTest.cs" />

+    <Compile Include="CodedInputStreamExtensions.cs" />

     <Compile Include="CodedInputStreamTest.cs" />

     <Compile Include="CodedOutputStreamTest.cs" />

     <Compile Include="EqualityTester.cs" />

@@ -79,6 +80,7 @@
     <Compile Include="GeneratedMessageTest.cs" />

     <Compile Include="Collections\MapFieldTest.cs" />

     <Compile Include="Collections\RepeatedFieldTest.cs" />

+    <Compile Include="SampleEnum.cs" />

     <Compile Include="TestProtos\MapUnittestProto3.cs" />

     <Compile Include="TestProtos\UnittestImportProto3.cs" />

     <Compile Include="TestProtos\UnittestImportPublicProto3.cs" />

diff --git a/csharp/src/ProtocolBuffers.Test/SampleEnum.cs b/csharp/src/ProtocolBuffers.Test/SampleEnum.cs
new file mode 100644
index 00000000..001f9b08
--- /dev/null
+++ b/csharp/src/ProtocolBuffers.Test/SampleEnum.cs
@@ -0,0 +1,42 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+    
+namespace Google.Protobuf
+{
+    // Just a sample enum with positive and negative values to be used in tests.
+    internal enum SampleEnum
+    {
+        NegativeValue = -2,
+        None = 0,
+        PositiveValue = 3
+    }
+}
\ No newline at end of file
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
index 19de87de..16bdb3f2 100644
--- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
@@ -422,13 +422,15 @@ namespace UnitTest.Issues.TestProtos {
     }
 
     public const int ValuesFieldNumber = 2;
-    private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
+    private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.NegativeEnum> _repeated_values_codec
+        = pb::FieldCodec.ForEnum(16, x => (int) x, x => (global::UnitTest.Issues.TestProtos.NegativeEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
     public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> Values {
       get { return values_; }
     }
 
     public const int PackedValuesFieldNumber = 3;
-    private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
+    private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.NegativeEnum> _repeated_packedValues_codec
+        = pb::FieldCodec.ForEnum(26, x => (int) x, x => (global::UnitTest.Issues.TestProtos.NegativeEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
     public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> PackedValues {
       get { return packedValues_; }
     }
@@ -463,13 +465,8 @@ namespace UnitTest.Issues.TestProtos {
         output.WriteRawTag(8);
         output.WriteEnum((int) Value);
       }
-      if (values_.Count > 0) {
-        output.WriteEnumArray(2, values_);
-      }
-      if (packedValues_.Count > 0) {
-        output.WriteRawTag(26);
-        output.WritePackedEnumArray(packedValues_);
-      }
+      values_.WriteTo(output, _repeated_values_codec);
+      packedValues_.WriteTo(output, _repeated_packedValues_codec);
     }
 
     public int CalculateSize() {
@@ -477,22 +474,8 @@ namespace UnitTest.Issues.TestProtos {
       if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) {
         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value);
       }
-      if (values_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in values_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 1 * values_.Count;
-      }
-      if (packedValues_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in packedValues_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
+      size += values_.CalculateSize(_repeated_values_codec);
+      size += packedValues_.CalculateSize(_repeated_packedValues_codec);
       return size;
     }
 
@@ -524,12 +507,12 @@ namespace UnitTest.Issues.TestProtos {
           }
           case 18:
           case 16: {
-            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(values_);
+            values_.AddEntriesFrom(input, _repeated_values_codec);
             break;
           }
           case 26:
           case 24: {
-            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(packedValues_);
+            packedValues_.AddEntriesFrom(input, _repeated_packedValues_codec);
             break;
           }
         }
@@ -678,6 +661,8 @@ namespace UnitTest.Issues.TestProtos {
     }
 
     public const int PrimitiveArrayFieldNumber = 2;
+    private static readonly pb::FieldCodec<int> _repeated_primitiveArray_codec
+        = pb::FieldCodec.ForInt32(18);
     private readonly pbc::RepeatedField<int> primitiveArray_ = new pbc::RepeatedField<int>();
     [global::System.ObsoleteAttribute()]
     public pbc::RepeatedField<int> PrimitiveArray {
@@ -696,6 +681,8 @@ namespace UnitTest.Issues.TestProtos {
     }
 
     public const int MessageArrayFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.DeprecatedChild> _repeated_messageArray_codec
+        = pb::FieldCodec.ForMessage(34, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser);
     private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> messageArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild>();
     [global::System.ObsoleteAttribute()]
     public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> MessageArray {
@@ -714,7 +701,8 @@ namespace UnitTest.Issues.TestProtos {
     }
 
     public const int EnumArrayFieldNumber = 6;
-    private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>();
+    private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.DeprecatedEnum> _repeated_enumArray_codec
+        = pb::FieldCodec.ForEnum(50, x => (int) x, x => (global::UnitTest.Issues.TestProtos.DeprecatedEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>();
     [global::System.ObsoleteAttribute()]
     public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> EnumArray {
       get { return enumArray_; }
@@ -756,25 +744,17 @@ namespace UnitTest.Issues.TestProtos {
         output.WriteRawTag(8);
         output.WriteInt32(PrimitiveValue);
       }
-      if (primitiveArray_.Count > 0) {
-        output.WriteRawTag(18);
-        output.WritePackedInt32Array(primitiveArray_);
-      }
+      primitiveArray_.WriteTo(output, _repeated_primitiveArray_codec);
       if (messageValue_ != null) {
         output.WriteRawTag(26);
         output.WriteMessage(MessageValue);
       }
-      if (messageArray_.Count > 0) {
-        output.WriteMessageArray(4, messageArray_);
-      }
+      messageArray_.WriteTo(output, _repeated_messageArray_codec);
       if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) {
         output.WriteRawTag(40);
         output.WriteEnum((int) EnumValue);
       }
-      if (enumArray_.Count > 0) {
-        output.WriteRawTag(50);
-        output.WritePackedEnumArray(enumArray_);
-      }
+      enumArray_.WriteTo(output, _repeated_enumArray_codec);
     }
 
     public int CalculateSize() {
@@ -782,34 +762,15 @@ namespace UnitTest.Issues.TestProtos {
       if (PrimitiveValue != 0) {
         size += 1 + pb::CodedOutputStream.ComputeInt32Size(PrimitiveValue);
       }
-      if (primitiveArray_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in primitiveArray_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
+      size += primitiveArray_.CalculateSize(_repeated_primitiveArray_codec);
       if (messageValue_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageValue);
       }
-      if (messageArray_.Count > 0) {
-        foreach (global::UnitTest.Issues.TestProtos.DeprecatedChild element in messageArray_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * messageArray_.Count;
-      }
+      size += messageArray_.CalculateSize(_repeated_messageArray_codec);
       if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) {
         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) EnumValue);
       }
-      if (enumArray_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::UnitTest.Issues.TestProtos.DeprecatedEnum element in enumArray_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
+      size += enumArray_.CalculateSize(_repeated_enumArray_codec);
       return size;
     }
 
@@ -851,7 +812,7 @@ namespace UnitTest.Issues.TestProtos {
           }
           case 18:
           case 16: {
-            input.ReadInt32Array(primitiveArray_);
+            primitiveArray_.AddEntriesFrom(input, _repeated_primitiveArray_codec);
             break;
           }
           case 26: {
@@ -862,7 +823,7 @@ namespace UnitTest.Issues.TestProtos {
             break;
           }
           case 34: {
-            input.ReadMessageArray(messageArray_, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser);
+            messageArray_.AddEntriesFrom(input, _repeated_messageArray_codec);
             break;
           }
           case 40: {
@@ -871,7 +832,7 @@ namespace UnitTest.Issues.TestProtos {
           }
           case 50:
           case 48: {
-            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(enumArray_);
+            enumArray_.AddEntriesFrom(input, _repeated_enumArray_codec);
             break;
           }
         }
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
index 1ae2d9a9..ea486fcc 100644
--- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
@@ -742,132 +742,173 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int RepeatedInt32FieldNumber = 31;
+    private static readonly pb::FieldCodec<int> _repeated_repeatedInt32_codec
+        = pb::FieldCodec.ForInt32(250);
     private readonly pbc::RepeatedField<int> repeatedInt32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> RepeatedInt32 {
       get { return repeatedInt32_; }
     }
 
     public const int RepeatedInt64FieldNumber = 32;
+    private static readonly pb::FieldCodec<long> _repeated_repeatedInt64_codec
+        = pb::FieldCodec.ForInt64(258);
     private readonly pbc::RepeatedField<long> repeatedInt64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> RepeatedInt64 {
       get { return repeatedInt64_; }
     }
 
     public const int RepeatedUint32FieldNumber = 33;
+    private static readonly pb::FieldCodec<uint> _repeated_repeatedUint32_codec
+        = pb::FieldCodec.ForUInt32(266);
     private readonly pbc::RepeatedField<uint> repeatedUint32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> RepeatedUint32 {
       get { return repeatedUint32_; }
     }
 
     public const int RepeatedUint64FieldNumber = 34;
+    private static readonly pb::FieldCodec<ulong> _repeated_repeatedUint64_codec
+        = pb::FieldCodec.ForUInt64(274);
     private readonly pbc::RepeatedField<ulong> repeatedUint64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> RepeatedUint64 {
       get { return repeatedUint64_; }
     }
 
     public const int RepeatedSint32FieldNumber = 35;
+    private static readonly pb::FieldCodec<int> _repeated_repeatedSint32_codec
+        = pb::FieldCodec.ForSInt32(282);
     private readonly pbc::RepeatedField<int> repeatedSint32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> RepeatedSint32 {
       get { return repeatedSint32_; }
     }
 
     public const int RepeatedSint64FieldNumber = 36;
+    private static readonly pb::FieldCodec<long> _repeated_repeatedSint64_codec
+        = pb::FieldCodec.ForSInt64(290);
     private readonly pbc::RepeatedField<long> repeatedSint64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> RepeatedSint64 {
       get { return repeatedSint64_; }
     }
 
     public const int RepeatedFixed32FieldNumber = 37;
+    private static readonly pb::FieldCodec<uint> _repeated_repeatedFixed32_codec
+        = pb::FieldCodec.ForFixed32(298);
     private readonly pbc::RepeatedField<uint> repeatedFixed32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> RepeatedFixed32 {
       get { return repeatedFixed32_; }
     }
 
     public const int RepeatedFixed64FieldNumber = 38;
+    private static readonly pb::FieldCodec<ulong> _repeated_repeatedFixed64_codec
+        = pb::FieldCodec.ForFixed64(306);
     private readonly pbc::RepeatedField<ulong> repeatedFixed64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> RepeatedFixed64 {
       get { return repeatedFixed64_; }
     }
 
     public const int RepeatedSfixed32FieldNumber = 39;
+    private static readonly pb::FieldCodec<int> _repeated_repeatedSfixed32_codec
+        = pb::FieldCodec.ForSFixed32(314);
     private readonly pbc::RepeatedField<int> repeatedSfixed32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> RepeatedSfixed32 {
       get { return repeatedSfixed32_; }
     }
 
     public const int RepeatedSfixed64FieldNumber = 40;
+    private static readonly pb::FieldCodec<long> _repeated_repeatedSfixed64_codec
+        = pb::FieldCodec.ForSFixed64(322);
     private readonly pbc::RepeatedField<long> repeatedSfixed64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> RepeatedSfixed64 {
       get { return repeatedSfixed64_; }
     }
 
     public const int RepeatedFloatFieldNumber = 41;
+    private static readonly pb::FieldCodec<float> _repeated_repeatedFloat_codec
+        = pb::FieldCodec.ForFloat(330);
     private readonly pbc::RepeatedField<float> repeatedFloat_ = new pbc::RepeatedField<float>();
     public pbc::RepeatedField<float> RepeatedFloat {
       get { return repeatedFloat_; }
     }
 
     public const int RepeatedDoubleFieldNumber = 42;
+    private static readonly pb::FieldCodec<double> _repeated_repeatedDouble_codec
+        = pb::FieldCodec.ForDouble(338);
     private readonly pbc::RepeatedField<double> repeatedDouble_ = new pbc::RepeatedField<double>();
     public pbc::RepeatedField<double> RepeatedDouble {
       get { return repeatedDouble_; }
     }
 
     public const int RepeatedBoolFieldNumber = 43;
+    private static readonly pb::FieldCodec<bool> _repeated_repeatedBool_codec
+        = pb::FieldCodec.ForBool(346);
     private readonly pbc::RepeatedField<bool> repeatedBool_ = new pbc::RepeatedField<bool>();
     public pbc::RepeatedField<bool> RepeatedBool {
       get { return repeatedBool_; }
     }
 
     public const int RepeatedStringFieldNumber = 44;
+    private static readonly pb::FieldCodec<string> _repeated_repeatedString_codec
+        = pb::FieldCodec.ForString(354);
     private readonly pbc::RepeatedField<string> repeatedString_ = new pbc::RepeatedField<string>();
     public pbc::RepeatedField<string> RepeatedString {
       get { return repeatedString_; }
     }
 
     public const int RepeatedBytesFieldNumber = 45;
+    private static readonly pb::FieldCodec<pb::ByteString> _repeated_repeatedBytes_codec
+        = pb::FieldCodec.ForBytes(362);
     private readonly pbc::RepeatedField<pb::ByteString> repeatedBytes_ = new pbc::RepeatedField<pb::ByteString>();
     public pbc::RepeatedField<pb::ByteString> RepeatedBytes {
       get { return repeatedBytes_; }
     }
 
     public const int RepeatedNestedMessageFieldNumber = 48;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage> _repeated_repeatedNestedMessage_codec
+        = pb::FieldCodec.ForMessage(386, global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage> repeatedNestedMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage> RepeatedNestedMessage {
       get { return repeatedNestedMessage_; }
     }
 
     public const int RepeatedForeignMessageFieldNumber = 49;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignMessage> _repeated_repeatedForeignMessage_codec
+        = pb::FieldCodec.ForMessage(394, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> repeatedForeignMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> RepeatedForeignMessage {
       get { return repeatedForeignMessage_; }
     }
 
     public const int RepeatedImportMessageFieldNumber = 50;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ImportMessage> _repeated_repeatedImportMessage_codec
+        = pb::FieldCodec.ForMessage(402, global::Google.Protobuf.TestProtos.ImportMessage.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage> repeatedImportMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage> RepeatedImportMessage {
       get { return repeatedImportMessage_; }
     }
 
     public const int RepeatedNestedEnumFieldNumber = 51;
-    private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> repeatedNestedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>();
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> _repeated_repeatedNestedEnum_codec
+        = pb::FieldCodec.ForEnum(410, x => (int) x, x => (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> repeatedNestedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> RepeatedNestedEnum {
       get { return repeatedNestedEnum_; }
     }
 
     public const int RepeatedForeignEnumFieldNumber = 52;
-    private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedForeignEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_repeatedForeignEnum_codec
+        = pb::FieldCodec.ForEnum(418, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedForeignEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> RepeatedForeignEnum {
       get { return repeatedForeignEnum_; }
     }
 
     public const int RepeatedImportEnumFieldNumber = 53;
-    private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> repeatedImportEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum>();
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ImportEnum> _repeated_repeatedImportEnum_codec
+        = pb::FieldCodec.ForEnum(426, x => (int) x, x => (global::Google.Protobuf.TestProtos.ImportEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> repeatedImportEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> RepeatedImportEnum {
       get { return repeatedImportEnum_; }
     }
 
     public const int RepeatedPublicImportMessageFieldNumber = 54;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.PublicImportMessage> _repeated_repeatedPublicImportMessage_codec
+        = pb::FieldCodec.ForMessage(434, global::Google.Protobuf.TestProtos.PublicImportMessage.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMessage> repeatedPublicImportMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMessage>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMessage> RepeatedPublicImportMessage {
       get { return repeatedPublicImportMessage_; }
@@ -1136,88 +1177,28 @@ namespace Google.Protobuf.TestProtos {
         output.WriteRawTag(210, 1);
         output.WriteMessage(SinglePublicImportMessage);
       }
-      if (repeatedInt32_.Count > 0) {
-        output.WriteRawTag(250, 1);
-        output.WritePackedInt32Array(repeatedInt32_);
-      }
-      if (repeatedInt64_.Count > 0) {
-        output.WriteRawTag(130, 2);
-        output.WritePackedInt64Array(repeatedInt64_);
-      }
-      if (repeatedUint32_.Count > 0) {
-        output.WriteRawTag(138, 2);
-        output.WritePackedUInt32Array(repeatedUint32_);
-      }
-      if (repeatedUint64_.Count > 0) {
-        output.WriteRawTag(146, 2);
-        output.WritePackedUInt64Array(repeatedUint64_);
-      }
-      if (repeatedSint32_.Count > 0) {
-        output.WriteRawTag(154, 2);
-        output.WritePackedSInt32Array(repeatedSint32_);
-      }
-      if (repeatedSint64_.Count > 0) {
-        output.WriteRawTag(162, 2);
-        output.WritePackedSInt64Array(repeatedSint64_);
-      }
-      if (repeatedFixed32_.Count > 0) {
-        output.WriteRawTag(170, 2);
-        output.WritePackedFixed32Array(repeatedFixed32_);
-      }
-      if (repeatedFixed64_.Count > 0) {
-        output.WriteRawTag(178, 2);
-        output.WritePackedFixed64Array(repeatedFixed64_);
-      }
-      if (repeatedSfixed32_.Count > 0) {
-        output.WriteRawTag(186, 2);
-        output.WritePackedSFixed32Array(repeatedSfixed32_);
-      }
-      if (repeatedSfixed64_.Count > 0) {
-        output.WriteRawTag(194, 2);
-        output.WritePackedSFixed64Array(repeatedSfixed64_);
-      }
-      if (repeatedFloat_.Count > 0) {
-        output.WriteRawTag(202, 2);
-        output.WritePackedFloatArray(repeatedFloat_);
-      }
-      if (repeatedDouble_.Count > 0) {
-        output.WriteRawTag(210, 2);
-        output.WritePackedDoubleArray(repeatedDouble_);
-      }
-      if (repeatedBool_.Count > 0) {
-        output.WriteRawTag(218, 2);
-        output.WritePackedBoolArray(repeatedBool_);
-      }
-      if (repeatedString_.Count > 0) {
-        output.WriteStringArray(44, repeatedString_);
-      }
-      if (repeatedBytes_.Count > 0) {
-        output.WriteBytesArray(45, repeatedBytes_);
-      }
-      if (repeatedNestedMessage_.Count > 0) {
-        output.WriteMessageArray(48, repeatedNestedMessage_);
-      }
-      if (repeatedForeignMessage_.Count > 0) {
-        output.WriteMessageArray(49, repeatedForeignMessage_);
-      }
-      if (repeatedImportMessage_.Count > 0) {
-        output.WriteMessageArray(50, repeatedImportMessage_);
-      }
-      if (repeatedNestedEnum_.Count > 0) {
-        output.WriteRawTag(154, 3);
-        output.WritePackedEnumArray(repeatedNestedEnum_);
-      }
-      if (repeatedForeignEnum_.Count > 0) {
-        output.WriteRawTag(162, 3);
-        output.WritePackedEnumArray(repeatedForeignEnum_);
-      }
-      if (repeatedImportEnum_.Count > 0) {
-        output.WriteRawTag(170, 3);
-        output.WritePackedEnumArray(repeatedImportEnum_);
-      }
-      if (repeatedPublicImportMessage_.Count > 0) {
-        output.WriteMessageArray(54, repeatedPublicImportMessage_);
-      }
+      repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec);
+      repeatedInt64_.WriteTo(output, _repeated_repeatedInt64_codec);
+      repeatedUint32_.WriteTo(output, _repeated_repeatedUint32_codec);
+      repeatedUint64_.WriteTo(output, _repeated_repeatedUint64_codec);
+      repeatedSint32_.WriteTo(output, _repeated_repeatedSint32_codec);
+      repeatedSint64_.WriteTo(output, _repeated_repeatedSint64_codec);
+      repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec);
+      repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec);
+      repeatedSfixed32_.WriteTo(output, _repeated_repeatedSfixed32_codec);
+      repeatedSfixed64_.WriteTo(output, _repeated_repeatedSfixed64_codec);
+      repeatedFloat_.WriteTo(output, _repeated_repeatedFloat_codec);
+      repeatedDouble_.WriteTo(output, _repeated_repeatedDouble_codec);
+      repeatedBool_.WriteTo(output, _repeated_repeatedBool_codec);
+      repeatedString_.WriteTo(output, _repeated_repeatedString_codec);
+      repeatedBytes_.WriteTo(output, _repeated_repeatedBytes_codec);
+      repeatedNestedMessage_.WriteTo(output, _repeated_repeatedNestedMessage_codec);
+      repeatedForeignMessage_.WriteTo(output, _repeated_repeatedForeignMessage_codec);
+      repeatedImportMessage_.WriteTo(output, _repeated_repeatedImportMessage_codec);
+      repeatedNestedEnum_.WriteTo(output, _repeated_repeatedNestedEnum_codec);
+      repeatedForeignEnum_.WriteTo(output, _repeated_repeatedForeignEnum_codec);
+      repeatedImportEnum_.WriteTo(output, _repeated_repeatedImportEnum_codec);
+      repeatedPublicImportMessage_.WriteTo(output, _repeated_repeatedPublicImportMessage_codec);
       if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {
         output.WriteRawTag(248, 6);
         output.WriteUInt32(OneofUint32);
@@ -1304,160 +1285,28 @@ namespace Google.Protobuf.TestProtos {
       if (singlePublicImportMessage_ != null) {
         size += 2 + pb::CodedOutputStream.ComputeMessageSize(SinglePublicImportMessage);
       }
-      if (repeatedInt32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in repeatedInt32_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedInt64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in repeatedInt64_) {
-          dataSize += pb::CodedOutputStream.ComputeInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedUint32_.Count > 0) {
-        int dataSize = 0;
-        foreach (uint element in repeatedUint32_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedUint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (ulong element in repeatedUint64_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedSint32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in repeatedSint32_) {
-          dataSize += pb::CodedOutputStream.ComputeSInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedSint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in repeatedSint64_) {
-          dataSize += pb::CodedOutputStream.ComputeSInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedFixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * repeatedFixed32_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedFixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * repeatedFixed64_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedSfixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * repeatedSfixed32_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedSfixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * repeatedSfixed64_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedFloat_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * repeatedFloat_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedDouble_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * repeatedDouble_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedBool_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 1 * repeatedBool_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedString_.Count > 0) {
-        int dataSize = 0;
-        foreach (string element in repeatedString_) {
-          dataSize += pb::CodedOutputStream.ComputeStringSize(element);
-        }
-        size += dataSize;
-        size += 2 * repeatedString_.Count;
-      }
-      if (repeatedBytes_.Count > 0) {
-        int dataSize = 0;
-        foreach (pb::ByteString element in repeatedBytes_) {
-          dataSize += pb::CodedOutputStream.ComputeBytesSize(element);
-        }
-        size += dataSize;
-        size += 2 * repeatedBytes_.Count;
-      }
-      if (repeatedNestedMessage_.Count > 0) {
-        foreach (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage element in repeatedNestedMessage_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * repeatedNestedMessage_.Count;
-      }
-      if (repeatedForeignMessage_.Count > 0) {
-        foreach (global::Google.Protobuf.TestProtos.ForeignMessage element in repeatedForeignMessage_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * repeatedForeignMessage_.Count;
-      }
-      if (repeatedImportMessage_.Count > 0) {
-        foreach (global::Google.Protobuf.TestProtos.ImportMessage element in repeatedImportMessage_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * repeatedImportMessage_.Count;
-      }
-      if (repeatedNestedEnum_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum element in repeatedNestedEnum_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
-      if (repeatedForeignEnum_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in repeatedForeignEnum_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
-      if (repeatedImportEnum_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::Google.Protobuf.TestProtos.ImportEnum element in repeatedImportEnum_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
-      if (repeatedPublicImportMessage_.Count > 0) {
-        foreach (global::Google.Protobuf.TestProtos.PublicImportMessage element in repeatedPublicImportMessage_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * repeatedPublicImportMessage_.Count;
-      }
+      size += repeatedInt32_.CalculateSize(_repeated_repeatedInt32_codec);
+      size += repeatedInt64_.CalculateSize(_repeated_repeatedInt64_codec);
+      size += repeatedUint32_.CalculateSize(_repeated_repeatedUint32_codec);
+      size += repeatedUint64_.CalculateSize(_repeated_repeatedUint64_codec);
+      size += repeatedSint32_.CalculateSize(_repeated_repeatedSint32_codec);
+      size += repeatedSint64_.CalculateSize(_repeated_repeatedSint64_codec);
+      size += repeatedFixed32_.CalculateSize(_repeated_repeatedFixed32_codec);
+      size += repeatedFixed64_.CalculateSize(_repeated_repeatedFixed64_codec);
+      size += repeatedSfixed32_.CalculateSize(_repeated_repeatedSfixed32_codec);
+      size += repeatedSfixed64_.CalculateSize(_repeated_repeatedSfixed64_codec);
+      size += repeatedFloat_.CalculateSize(_repeated_repeatedFloat_codec);
+      size += repeatedDouble_.CalculateSize(_repeated_repeatedDouble_codec);
+      size += repeatedBool_.CalculateSize(_repeated_repeatedBool_codec);
+      size += repeatedString_.CalculateSize(_repeated_repeatedString_codec);
+      size += repeatedBytes_.CalculateSize(_repeated_repeatedBytes_codec);
+      size += repeatedNestedMessage_.CalculateSize(_repeated_repeatedNestedMessage_codec);
+      size += repeatedForeignMessage_.CalculateSize(_repeated_repeatedForeignMessage_codec);
+      size += repeatedImportMessage_.CalculateSize(_repeated_repeatedImportMessage_codec);
+      size += repeatedNestedEnum_.CalculateSize(_repeated_repeatedNestedEnum_codec);
+      size += repeatedForeignEnum_.CalculateSize(_repeated_repeatedForeignEnum_codec);
+      size += repeatedImportEnum_.CalculateSize(_repeated_repeatedImportEnum_codec);
+      size += repeatedPublicImportMessage_.CalculateSize(_repeated_repeatedPublicImportMessage_codec);
       if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {
         size += 2 + pb::CodedOutputStream.ComputeUInt32Size(OneofUint32);
       }
@@ -1707,106 +1556,106 @@ namespace Google.Protobuf.TestProtos {
           }
           case 250:
           case 248: {
-            input.ReadInt32Array(repeatedInt32_);
+            repeatedInt32_.AddEntriesFrom(input, _repeated_repeatedInt32_codec);
             break;
           }
           case 258:
           case 256: {
-            input.ReadInt64Array(repeatedInt64_);
+            repeatedInt64_.AddEntriesFrom(input, _repeated_repeatedInt64_codec);
             break;
           }
           case 266:
           case 264: {
-            input.ReadUInt32Array(repeatedUint32_);
+            repeatedUint32_.AddEntriesFrom(input, _repeated_repeatedUint32_codec);
             break;
           }
           case 274:
           case 272: {
-            input.ReadUInt64Array(repeatedUint64_);
+            repeatedUint64_.AddEntriesFrom(input, _repeated_repeatedUint64_codec);
             break;
           }
           case 282:
           case 280: {
-            input.ReadSInt32Array(repeatedSint32_);
+            repeatedSint32_.AddEntriesFrom(input, _repeated_repeatedSint32_codec);
             break;
           }
           case 290:
           case 288: {
-            input.ReadSInt64Array(repeatedSint64_);
+            repeatedSint64_.AddEntriesFrom(input, _repeated_repeatedSint64_codec);
             break;
           }
           case 298:
           case 301: {
-            input.ReadFixed32Array(repeatedFixed32_);
+            repeatedFixed32_.AddEntriesFrom(input, _repeated_repeatedFixed32_codec);
             break;
           }
           case 306:
           case 305: {
-            input.ReadFixed64Array(repeatedFixed64_);
+            repeatedFixed64_.AddEntriesFrom(input, _repeated_repeatedFixed64_codec);
             break;
           }
           case 314:
           case 317: {
-            input.ReadSFixed32Array(repeatedSfixed32_);
+            repeatedSfixed32_.AddEntriesFrom(input, _repeated_repeatedSfixed32_codec);
             break;
           }
           case 322:
           case 321: {
-            input.ReadSFixed64Array(repeatedSfixed64_);
+            repeatedSfixed64_.AddEntriesFrom(input, _repeated_repeatedSfixed64_codec);
             break;
           }
           case 330:
           case 333: {
-            input.ReadFloatArray(repeatedFloat_);
+            repeatedFloat_.AddEntriesFrom(input, _repeated_repeatedFloat_codec);
             break;
           }
           case 338:
           case 337: {
-            input.ReadDoubleArray(repeatedDouble_);
+            repeatedDouble_.AddEntriesFrom(input, _repeated_repeatedDouble_codec);
             break;
           }
           case 346:
           case 344: {
-            input.ReadBoolArray(repeatedBool_);
+            repeatedBool_.AddEntriesFrom(input, _repeated_repeatedBool_codec);
             break;
           }
           case 354: {
-            input.ReadStringArray(repeatedString_);
+            repeatedString_.AddEntriesFrom(input, _repeated_repeatedString_codec);
             break;
           }
           case 362: {
-            input.ReadBytesArray(repeatedBytes_);
+            repeatedBytes_.AddEntriesFrom(input, _repeated_repeatedBytes_codec);
             break;
           }
           case 386: {
-            input.ReadMessageArray(repeatedNestedMessage_, global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage.Parser);
+            repeatedNestedMessage_.AddEntriesFrom(input, _repeated_repeatedNestedMessage_codec);
             break;
           }
           case 394: {
-            input.ReadMessageArray(repeatedForeignMessage_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
+            repeatedForeignMessage_.AddEntriesFrom(input, _repeated_repeatedForeignMessage_codec);
             break;
           }
           case 402: {
-            input.ReadMessageArray(repeatedImportMessage_, global::Google.Protobuf.TestProtos.ImportMessage.Parser);
+            repeatedImportMessage_.AddEntriesFrom(input, _repeated_repeatedImportMessage_codec);
             break;
           }
           case 410:
           case 408: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>(repeatedNestedEnum_);
+            repeatedNestedEnum_.AddEntriesFrom(input, _repeated_repeatedNestedEnum_codec);
             break;
           }
           case 418:
           case 416: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(repeatedForeignEnum_);
+            repeatedForeignEnum_.AddEntriesFrom(input, _repeated_repeatedForeignEnum_codec);
             break;
           }
           case 426:
           case 424: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ImportEnum>(repeatedImportEnum_);
+            repeatedImportEnum_.AddEntriesFrom(input, _repeated_repeatedImportEnum_codec);
             break;
           }
           case 434: {
-            input.ReadMessageArray(repeatedPublicImportMessage_, global::Google.Protobuf.TestProtos.PublicImportMessage.Parser);
+            repeatedPublicImportMessage_.AddEntriesFrom(input, _repeated_repeatedPublicImportMessage_codec);
             break;
           }
           case 888: {
@@ -2022,6 +1871,8 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int RepeatedChildFieldNumber = 3;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.NestedTestAllTypes> _repeated_repeatedChild_codec
+        = pb::FieldCodec.ForMessage(26, global::Google.Protobuf.TestProtos.NestedTestAllTypes.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTypes> repeatedChild_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTypes>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTypes> RepeatedChild {
       get { return repeatedChild_; }
@@ -2061,9 +1912,7 @@ namespace Google.Protobuf.TestProtos {
         output.WriteRawTag(18);
         output.WriteMessage(Payload);
       }
-      if (repeatedChild_.Count > 0) {
-        output.WriteMessageArray(3, repeatedChild_);
-      }
+      repeatedChild_.WriteTo(output, _repeated_repeatedChild_codec);
     }
 
     public int CalculateSize() {
@@ -2074,12 +1923,7 @@ namespace Google.Protobuf.TestProtos {
       if (payload_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Payload);
       }
-      if (repeatedChild_.Count > 0) {
-        foreach (global::Google.Protobuf.TestProtos.NestedTestAllTypes element in repeatedChild_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * repeatedChild_.Count;
-      }
+      size += repeatedChild_.CalculateSize(_repeated_repeatedChild_codec);
       return size;
     }
 
@@ -2128,7 +1972,7 @@ namespace Google.Protobuf.TestProtos {
             break;
           }
           case 26: {
-            input.ReadMessageArray(repeatedChild_, global::Google.Protobuf.TestProtos.NestedTestAllTypes.Parser);
+            repeatedChild_.AddEntriesFrom(input, _repeated_repeatedChild_codec);
             break;
           }
         }
@@ -3196,24 +3040,31 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int RepeatedPrimitiveFieldFieldNumber = 7;
+    private static readonly pb::FieldCodec<int> _repeated_repeatedPrimitiveField_codec
+        = pb::FieldCodec.ForInt32(58);
     private readonly pbc::RepeatedField<int> repeatedPrimitiveField_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> RepeatedPrimitiveField {
       get { return repeatedPrimitiveField_; }
     }
 
     public const int RepeatedStringFieldFieldNumber = 8;
+    private static readonly pb::FieldCodec<string> _repeated_repeatedStringField_codec
+        = pb::FieldCodec.ForString(66);
     private readonly pbc::RepeatedField<string> repeatedStringField_ = new pbc::RepeatedField<string>();
     public pbc::RepeatedField<string> RepeatedStringField {
       get { return repeatedStringField_; }
     }
 
     public const int RepeatedEnumFieldFieldNumber = 9;
-    private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedEnumField_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_repeatedEnumField_codec
+        = pb::FieldCodec.ForEnum(74, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedEnumField_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> RepeatedEnumField {
       get { return repeatedEnumField_; }
     }
 
     public const int RepeatedMessageFieldFieldNumber = 10;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignMessage> _repeated_repeatedMessageField_codec
+        = pb::FieldCodec.ForMessage(82, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> repeatedMessageField_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> RepeatedMessageField {
       get { return repeatedMessageField_; }
@@ -3271,20 +3122,10 @@ namespace Google.Protobuf.TestProtos {
         output.WriteRawTag(34);
         output.WriteMessage(MessageField);
       }
-      if (repeatedPrimitiveField_.Count > 0) {
-        output.WriteRawTag(58);
-        output.WritePackedInt32Array(repeatedPrimitiveField_);
-      }
-      if (repeatedStringField_.Count > 0) {
-        output.WriteStringArray(8, repeatedStringField_);
-      }
-      if (repeatedEnumField_.Count > 0) {
-        output.WriteRawTag(74);
-        output.WritePackedEnumArray(repeatedEnumField_);
-      }
-      if (repeatedMessageField_.Count > 0) {
-        output.WriteMessageArray(10, repeatedMessageField_);
-      }
+      repeatedPrimitiveField_.WriteTo(output, _repeated_repeatedPrimitiveField_codec);
+      repeatedStringField_.WriteTo(output, _repeated_repeatedStringField_codec);
+      repeatedEnumField_.WriteTo(output, _repeated_repeatedEnumField_codec);
+      repeatedMessageField_.WriteTo(output, _repeated_repeatedMessageField_codec);
     }
 
     public int CalculateSize() {
@@ -3301,36 +3142,10 @@ namespace Google.Protobuf.TestProtos {
       if (messageField_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageField);
       }
-      if (repeatedPrimitiveField_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in repeatedPrimitiveField_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedStringField_.Count > 0) {
-        int dataSize = 0;
-        foreach (string element in repeatedStringField_) {
-          dataSize += pb::CodedOutputStream.ComputeStringSize(element);
-        }
-        size += dataSize;
-        size += 1 * repeatedStringField_.Count;
-      }
-      if (repeatedEnumField_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in repeatedEnumField_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
-      if (repeatedMessageField_.Count > 0) {
-        foreach (global::Google.Protobuf.TestProtos.ForeignMessage element in repeatedMessageField_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * repeatedMessageField_.Count;
-      }
+      size += repeatedPrimitiveField_.CalculateSize(_repeated_repeatedPrimitiveField_codec);
+      size += repeatedStringField_.CalculateSize(_repeated_repeatedStringField_codec);
+      size += repeatedEnumField_.CalculateSize(_repeated_repeatedEnumField_codec);
+      size += repeatedMessageField_.CalculateSize(_repeated_repeatedMessageField_codec);
       return size;
     }
 
@@ -3391,20 +3206,20 @@ namespace Google.Protobuf.TestProtos {
           }
           case 58:
           case 56: {
-            input.ReadInt32Array(repeatedPrimitiveField_);
+            repeatedPrimitiveField_.AddEntriesFrom(input, _repeated_repeatedPrimitiveField_codec);
             break;
           }
           case 66: {
-            input.ReadStringArray(repeatedStringField_);
+            repeatedStringField_.AddEntriesFrom(input, _repeated_repeatedStringField_codec);
             break;
           }
           case 74:
           case 72: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(repeatedEnumField_);
+            repeatedEnumField_.AddEntriesFrom(input, _repeated_repeatedEnumField_codec);
             break;
           }
           case 82: {
-            input.ReadMessageArray(repeatedMessageField_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
+            repeatedMessageField_.AddEntriesFrom(input, _repeated_repeatedMessageField_codec);
             break;
           }
         }
@@ -4015,6 +3830,8 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int DataFieldNumber = 1;
+    private static readonly pb::FieldCodec<string> _repeated_data_codec
+        = pb::FieldCodec.ForString(10);
     private readonly pbc::RepeatedField<string> data_ = new pbc::RepeatedField<string>();
     public pbc::RepeatedField<string> Data {
       get { return data_; }
@@ -4042,21 +3859,12 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (data_.Count > 0) {
-        output.WriteStringArray(1, data_);
-      }
+      data_.WriteTo(output, _repeated_data_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (data_.Count > 0) {
-        int dataSize = 0;
-        foreach (string element in data_) {
-          dataSize += pb::CodedOutputStream.ComputeStringSize(element);
-        }
-        size += dataSize;
-        size += 1 * data_.Count;
-      }
+      size += data_.CalculateSize(_repeated_data_codec);
       return size;
     }
 
@@ -4079,7 +3887,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 10: {
-            input.ReadStringArray(data_);
+            data_.AddEntriesFrom(input, _repeated_data_codec);
             break;
           }
         }
@@ -5129,85 +4937,112 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int PackedInt32FieldNumber = 90;
+    private static readonly pb::FieldCodec<int> _repeated_packedInt32_codec
+        = pb::FieldCodec.ForInt32(722);
     private readonly pbc::RepeatedField<int> packedInt32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> PackedInt32 {
       get { return packedInt32_; }
     }
 
     public const int PackedInt64FieldNumber = 91;
+    private static readonly pb::FieldCodec<long> _repeated_packedInt64_codec
+        = pb::FieldCodec.ForInt64(730);
     private readonly pbc::RepeatedField<long> packedInt64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> PackedInt64 {
       get { return packedInt64_; }
     }
 
     public const int PackedUint32FieldNumber = 92;
+    private static readonly pb::FieldCodec<uint> _repeated_packedUint32_codec
+        = pb::FieldCodec.ForUInt32(738);
     private readonly pbc::RepeatedField<uint> packedUint32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> PackedUint32 {
       get { return packedUint32_; }
     }
 
     public const int PackedUint64FieldNumber = 93;
+    private static readonly pb::FieldCodec<ulong> _repeated_packedUint64_codec
+        = pb::FieldCodec.ForUInt64(746);
     private readonly pbc::RepeatedField<ulong> packedUint64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> PackedUint64 {
       get { return packedUint64_; }
     }
 
     public const int PackedSint32FieldNumber = 94;
+    private static readonly pb::FieldCodec<int> _repeated_packedSint32_codec
+        = pb::FieldCodec.ForSInt32(754);
     private readonly pbc::RepeatedField<int> packedSint32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> PackedSint32 {
       get { return packedSint32_; }
     }
 
     public const int PackedSint64FieldNumber = 95;
+    private static readonly pb::FieldCodec<long> _repeated_packedSint64_codec
+        = pb::FieldCodec.ForSInt64(762);
     private readonly pbc::RepeatedField<long> packedSint64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> PackedSint64 {
       get { return packedSint64_; }
     }
 
     public const int PackedFixed32FieldNumber = 96;
+    private static readonly pb::FieldCodec<uint> _repeated_packedFixed32_codec
+        = pb::FieldCodec.ForFixed32(770);
     private readonly pbc::RepeatedField<uint> packedFixed32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> PackedFixed32 {
       get { return packedFixed32_; }
     }
 
     public const int PackedFixed64FieldNumber = 97;
+    private static readonly pb::FieldCodec<ulong> _repeated_packedFixed64_codec
+        = pb::FieldCodec.ForFixed64(778);
     private readonly pbc::RepeatedField<ulong> packedFixed64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> PackedFixed64 {
       get { return packedFixed64_; }
     }
 
     public const int PackedSfixed32FieldNumber = 98;
+    private static readonly pb::FieldCodec<int> _repeated_packedSfixed32_codec
+        = pb::FieldCodec.ForSFixed32(786);
     private readonly pbc::RepeatedField<int> packedSfixed32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> PackedSfixed32 {
       get { return packedSfixed32_; }
     }
 
     public const int PackedSfixed64FieldNumber = 99;
+    private static readonly pb::FieldCodec<long> _repeated_packedSfixed64_codec
+        = pb::FieldCodec.ForSFixed64(794);
     private readonly pbc::RepeatedField<long> packedSfixed64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> PackedSfixed64 {
       get { return packedSfixed64_; }
     }
 
     public const int PackedFloatFieldNumber = 100;
+    private static readonly pb::FieldCodec<float> _repeated_packedFloat_codec
+        = pb::FieldCodec.ForFloat(802);
     private readonly pbc::RepeatedField<float> packedFloat_ = new pbc::RepeatedField<float>();
     public pbc::RepeatedField<float> PackedFloat {
       get { return packedFloat_; }
     }
 
     public const int PackedDoubleFieldNumber = 101;
+    private static readonly pb::FieldCodec<double> _repeated_packedDouble_codec
+        = pb::FieldCodec.ForDouble(810);
     private readonly pbc::RepeatedField<double> packedDouble_ = new pbc::RepeatedField<double>();
     public pbc::RepeatedField<double> PackedDouble {
       get { return packedDouble_; }
     }
 
     public const int PackedBoolFieldNumber = 102;
+    private static readonly pb::FieldCodec<bool> _repeated_packedBool_codec
+        = pb::FieldCodec.ForBool(818);
     private readonly pbc::RepeatedField<bool> packedBool_ = new pbc::RepeatedField<bool>();
     public pbc::RepeatedField<bool> PackedBool {
       get { return packedBool_; }
     }
 
     public const int PackedEnumFieldNumber = 103;
-    private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> packedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_packedEnum_codec
+        = pb::FieldCodec.ForEnum(826, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> packedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> PackedEnum {
       get { return packedEnum_; }
     }
@@ -5260,164 +5095,38 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (packedInt32_.Count > 0) {
-        output.WriteRawTag(210, 5);
-        output.WritePackedInt32Array(packedInt32_);
-      }
-      if (packedInt64_.Count > 0) {
-        output.WriteRawTag(218, 5);
-        output.WritePackedInt64Array(packedInt64_);
-      }
-      if (packedUint32_.Count > 0) {
-        output.WriteRawTag(226, 5);
-        output.WritePackedUInt32Array(packedUint32_);
-      }
-      if (packedUint64_.Count > 0) {
-        output.WriteRawTag(234, 5);
-        output.WritePackedUInt64Array(packedUint64_);
-      }
-      if (packedSint32_.Count > 0) {
-        output.WriteRawTag(242, 5);
-        output.WritePackedSInt32Array(packedSint32_);
-      }
-      if (packedSint64_.Count > 0) {
-        output.WriteRawTag(250, 5);
-        output.WritePackedSInt64Array(packedSint64_);
-      }
-      if (packedFixed32_.Count > 0) {
-        output.WriteRawTag(130, 6);
-        output.WritePackedFixed32Array(packedFixed32_);
-      }
-      if (packedFixed64_.Count > 0) {
-        output.WriteRawTag(138, 6);
-        output.WritePackedFixed64Array(packedFixed64_);
-      }
-      if (packedSfixed32_.Count > 0) {
-        output.WriteRawTag(146, 6);
-        output.WritePackedSFixed32Array(packedSfixed32_);
-      }
-      if (packedSfixed64_.Count > 0) {
-        output.WriteRawTag(154, 6);
-        output.WritePackedSFixed64Array(packedSfixed64_);
-      }
-      if (packedFloat_.Count > 0) {
-        output.WriteRawTag(162, 6);
-        output.WritePackedFloatArray(packedFloat_);
-      }
-      if (packedDouble_.Count > 0) {
-        output.WriteRawTag(170, 6);
-        output.WritePackedDoubleArray(packedDouble_);
-      }
-      if (packedBool_.Count > 0) {
-        output.WriteRawTag(178, 6);
-        output.WritePackedBoolArray(packedBool_);
-      }
-      if (packedEnum_.Count > 0) {
-        output.WriteRawTag(186, 6);
-        output.WritePackedEnumArray(packedEnum_);
-      }
+      packedInt32_.WriteTo(output, _repeated_packedInt32_codec);
+      packedInt64_.WriteTo(output, _repeated_packedInt64_codec);
+      packedUint32_.WriteTo(output, _repeated_packedUint32_codec);
+      packedUint64_.WriteTo(output, _repeated_packedUint64_codec);
+      packedSint32_.WriteTo(output, _repeated_packedSint32_codec);
+      packedSint64_.WriteTo(output, _repeated_packedSint64_codec);
+      packedFixed32_.WriteTo(output, _repeated_packedFixed32_codec);
+      packedFixed64_.WriteTo(output, _repeated_packedFixed64_codec);
+      packedSfixed32_.WriteTo(output, _repeated_packedSfixed32_codec);
+      packedSfixed64_.WriteTo(output, _repeated_packedSfixed64_codec);
+      packedFloat_.WriteTo(output, _repeated_packedFloat_codec);
+      packedDouble_.WriteTo(output, _repeated_packedDouble_codec);
+      packedBool_.WriteTo(output, _repeated_packedBool_codec);
+      packedEnum_.WriteTo(output, _repeated_packedEnum_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (packedInt32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in packedInt32_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedInt64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in packedInt64_) {
-          dataSize += pb::CodedOutputStream.ComputeInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedUint32_.Count > 0) {
-        int dataSize = 0;
-        foreach (uint element in packedUint32_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedUint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (ulong element in packedUint64_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedSint32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in packedSint32_) {
-          dataSize += pb::CodedOutputStream.ComputeSInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedSint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in packedSint64_) {
-          dataSize += pb::CodedOutputStream.ComputeSInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedFixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * packedFixed32_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedFixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * packedFixed64_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedSfixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * packedSfixed32_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedSfixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * packedSfixed64_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedFloat_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * packedFloat_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedDouble_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * packedDouble_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedBool_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 1 * packedBool_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (packedEnum_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in packedEnum_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
-      }
+      size += packedInt32_.CalculateSize(_repeated_packedInt32_codec);
+      size += packedInt64_.CalculateSize(_repeated_packedInt64_codec);
+      size += packedUint32_.CalculateSize(_repeated_packedUint32_codec);
+      size += packedUint64_.CalculateSize(_repeated_packedUint64_codec);
+      size += packedSint32_.CalculateSize(_repeated_packedSint32_codec);
+      size += packedSint64_.CalculateSize(_repeated_packedSint64_codec);
+      size += packedFixed32_.CalculateSize(_repeated_packedFixed32_codec);
+      size += packedFixed64_.CalculateSize(_repeated_packedFixed64_codec);
+      size += packedSfixed32_.CalculateSize(_repeated_packedSfixed32_codec);
+      size += packedSfixed64_.CalculateSize(_repeated_packedSfixed64_codec);
+      size += packedFloat_.CalculateSize(_repeated_packedFloat_codec);
+      size += packedDouble_.CalculateSize(_repeated_packedDouble_codec);
+      size += packedBool_.CalculateSize(_repeated_packedBool_codec);
+      size += packedEnum_.CalculateSize(_repeated_packedEnum_codec);
       return size;
     }
 
@@ -5454,72 +5163,72 @@ namespace Google.Protobuf.TestProtos {
             break;
           case 722:
           case 720: {
-            input.ReadInt32Array(packedInt32_);
+            packedInt32_.AddEntriesFrom(input, _repeated_packedInt32_codec);
             break;
           }
           case 730:
           case 728: {
-            input.ReadInt64Array(packedInt64_);
+            packedInt64_.AddEntriesFrom(input, _repeated_packedInt64_codec);
             break;
           }
           case 738:
           case 736: {
-            input.ReadUInt32Array(packedUint32_);
+            packedUint32_.AddEntriesFrom(input, _repeated_packedUint32_codec);
             break;
           }
           case 746:
           case 744: {
-            input.ReadUInt64Array(packedUint64_);
+            packedUint64_.AddEntriesFrom(input, _repeated_packedUint64_codec);
             break;
           }
           case 754:
           case 752: {
-            input.ReadSInt32Array(packedSint32_);
+            packedSint32_.AddEntriesFrom(input, _repeated_packedSint32_codec);
             break;
           }
           case 762:
           case 760: {
-            input.ReadSInt64Array(packedSint64_);
+            packedSint64_.AddEntriesFrom(input, _repeated_packedSint64_codec);
             break;
           }
           case 770:
           case 773: {
-            input.ReadFixed32Array(packedFixed32_);
+            packedFixed32_.AddEntriesFrom(input, _repeated_packedFixed32_codec);
             break;
           }
           case 778:
           case 777: {
-            input.ReadFixed64Array(packedFixed64_);
+            packedFixed64_.AddEntriesFrom(input, _repeated_packedFixed64_codec);
             break;
           }
           case 786:
           case 789: {
-            input.ReadSFixed32Array(packedSfixed32_);
+            packedSfixed32_.AddEntriesFrom(input, _repeated_packedSfixed32_codec);
             break;
           }
           case 794:
           case 793: {
-            input.ReadSFixed64Array(packedSfixed64_);
+            packedSfixed64_.AddEntriesFrom(input, _repeated_packedSfixed64_codec);
             break;
           }
           case 802:
           case 805: {
-            input.ReadFloatArray(packedFloat_);
+            packedFloat_.AddEntriesFrom(input, _repeated_packedFloat_codec);
             break;
           }
           case 810:
           case 809: {
-            input.ReadDoubleArray(packedDouble_);
+            packedDouble_.AddEntriesFrom(input, _repeated_packedDouble_codec);
             break;
           }
           case 818:
           case 816: {
-            input.ReadBoolArray(packedBool_);
+            packedBool_.AddEntriesFrom(input, _repeated_packedBool_codec);
             break;
           }
           case 826:
           case 824: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(packedEnum_);
+            packedEnum_.AddEntriesFrom(input, _repeated_packedEnum_codec);
             break;
           }
         }
@@ -5591,85 +5300,112 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int UnpackedInt32FieldNumber = 90;
+    private static readonly pb::FieldCodec<int> _repeated_unpackedInt32_codec
+        = pb::FieldCodec.ForInt32(720);
     private readonly pbc::RepeatedField<int> unpackedInt32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> UnpackedInt32 {
       get { return unpackedInt32_; }
     }
 
     public const int UnpackedInt64FieldNumber = 91;
+    private static readonly pb::FieldCodec<long> _repeated_unpackedInt64_codec
+        = pb::FieldCodec.ForInt64(728);
     private readonly pbc::RepeatedField<long> unpackedInt64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> UnpackedInt64 {
       get { return unpackedInt64_; }
     }
 
     public const int UnpackedUint32FieldNumber = 92;
+    private static readonly pb::FieldCodec<uint> _repeated_unpackedUint32_codec
+        = pb::FieldCodec.ForUInt32(736);
     private readonly pbc::RepeatedField<uint> unpackedUint32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> UnpackedUint32 {
       get { return unpackedUint32_; }
     }
 
     public const int UnpackedUint64FieldNumber = 93;
+    private static readonly pb::FieldCodec<ulong> _repeated_unpackedUint64_codec
+        = pb::FieldCodec.ForUInt64(744);
     private readonly pbc::RepeatedField<ulong> unpackedUint64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> UnpackedUint64 {
       get { return unpackedUint64_; }
     }
 
     public const int UnpackedSint32FieldNumber = 94;
+    private static readonly pb::FieldCodec<int> _repeated_unpackedSint32_codec
+        = pb::FieldCodec.ForSInt32(752);
     private readonly pbc::RepeatedField<int> unpackedSint32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> UnpackedSint32 {
       get { return unpackedSint32_; }
     }
 
     public const int UnpackedSint64FieldNumber = 95;
+    private static readonly pb::FieldCodec<long> _repeated_unpackedSint64_codec
+        = pb::FieldCodec.ForSInt64(760);
     private readonly pbc::RepeatedField<long> unpackedSint64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> UnpackedSint64 {
       get { return unpackedSint64_; }
     }
 
     public const int UnpackedFixed32FieldNumber = 96;
+    private static readonly pb::FieldCodec<uint> _repeated_unpackedFixed32_codec
+        = pb::FieldCodec.ForFixed32(773);
     private readonly pbc::RepeatedField<uint> unpackedFixed32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> UnpackedFixed32 {
       get { return unpackedFixed32_; }
     }
 
     public const int UnpackedFixed64FieldNumber = 97;
+    private static readonly pb::FieldCodec<ulong> _repeated_unpackedFixed64_codec
+        = pb::FieldCodec.ForFixed64(777);
     private readonly pbc::RepeatedField<ulong> unpackedFixed64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> UnpackedFixed64 {
       get { return unpackedFixed64_; }
     }
 
     public const int UnpackedSfixed32FieldNumber = 98;
+    private static readonly pb::FieldCodec<int> _repeated_unpackedSfixed32_codec
+        = pb::FieldCodec.ForSFixed32(789);
     private readonly pbc::RepeatedField<int> unpackedSfixed32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> UnpackedSfixed32 {
       get { return unpackedSfixed32_; }
     }
 
     public const int UnpackedSfixed64FieldNumber = 99;
+    private static readonly pb::FieldCodec<long> _repeated_unpackedSfixed64_codec
+        = pb::FieldCodec.ForSFixed64(793);
     private readonly pbc::RepeatedField<long> unpackedSfixed64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> UnpackedSfixed64 {
       get { return unpackedSfixed64_; }
     }
 
     public const int UnpackedFloatFieldNumber = 100;
+    private static readonly pb::FieldCodec<float> _repeated_unpackedFloat_codec
+        = pb::FieldCodec.ForFloat(805);
     private readonly pbc::RepeatedField<float> unpackedFloat_ = new pbc::RepeatedField<float>();
     public pbc::RepeatedField<float> UnpackedFloat {
       get { return unpackedFloat_; }
     }
 
     public const int UnpackedDoubleFieldNumber = 101;
+    private static readonly pb::FieldCodec<double> _repeated_unpackedDouble_codec
+        = pb::FieldCodec.ForDouble(809);
     private readonly pbc::RepeatedField<double> unpackedDouble_ = new pbc::RepeatedField<double>();
     public pbc::RepeatedField<double> UnpackedDouble {
       get { return unpackedDouble_; }
     }
 
     public const int UnpackedBoolFieldNumber = 102;
+    private static readonly pb::FieldCodec<bool> _repeated_unpackedBool_codec
+        = pb::FieldCodec.ForBool(816);
     private readonly pbc::RepeatedField<bool> unpackedBool_ = new pbc::RepeatedField<bool>();
     public pbc::RepeatedField<bool> UnpackedBool {
       get { return unpackedBool_; }
     }
 
     public const int UnpackedEnumFieldNumber = 103;
-    private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> unpackedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
+    private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_unpackedEnum_codec
+        = pb::FieldCodec.ForEnum(824, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> unpackedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>();
     public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> UnpackedEnum {
       get { return unpackedEnum_; }
     }
@@ -5722,150 +5458,38 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (unpackedInt32_.Count > 0) {
-        output.WriteInt32Array(90, unpackedInt32_);
-      }
-      if (unpackedInt64_.Count > 0) {
-        output.WriteInt64Array(91, unpackedInt64_);
-      }
-      if (unpackedUint32_.Count > 0) {
-        output.WriteUInt32Array(92, unpackedUint32_);
-      }
-      if (unpackedUint64_.Count > 0) {
-        output.WriteUInt64Array(93, unpackedUint64_);
-      }
-      if (unpackedSint32_.Count > 0) {
-        output.WriteSInt32Array(94, unpackedSint32_);
-      }
-      if (unpackedSint64_.Count > 0) {
-        output.WriteSInt64Array(95, unpackedSint64_);
-      }
-      if (unpackedFixed32_.Count > 0) {
-        output.WriteFixed32Array(96, unpackedFixed32_);
-      }
-      if (unpackedFixed64_.Count > 0) {
-        output.WriteFixed64Array(97, unpackedFixed64_);
-      }
-      if (unpackedSfixed32_.Count > 0) {
-        output.WriteSFixed32Array(98, unpackedSfixed32_);
-      }
-      if (unpackedSfixed64_.Count > 0) {
-        output.WriteSFixed64Array(99, unpackedSfixed64_);
-      }
-      if (unpackedFloat_.Count > 0) {
-        output.WriteFloatArray(100, unpackedFloat_);
-      }
-      if (unpackedDouble_.Count > 0) {
-        output.WriteDoubleArray(101, unpackedDouble_);
-      }
-      if (unpackedBool_.Count > 0) {
-        output.WriteBoolArray(102, unpackedBool_);
-      }
-      if (unpackedEnum_.Count > 0) {
-        output.WriteEnumArray(103, unpackedEnum_);
-      }
+      unpackedInt32_.WriteTo(output, _repeated_unpackedInt32_codec);
+      unpackedInt64_.WriteTo(output, _repeated_unpackedInt64_codec);
+      unpackedUint32_.WriteTo(output, _repeated_unpackedUint32_codec);
+      unpackedUint64_.WriteTo(output, _repeated_unpackedUint64_codec);
+      unpackedSint32_.WriteTo(output, _repeated_unpackedSint32_codec);
+      unpackedSint64_.WriteTo(output, _repeated_unpackedSint64_codec);
+      unpackedFixed32_.WriteTo(output, _repeated_unpackedFixed32_codec);
+      unpackedFixed64_.WriteTo(output, _repeated_unpackedFixed64_codec);
+      unpackedSfixed32_.WriteTo(output, _repeated_unpackedSfixed32_codec);
+      unpackedSfixed64_.WriteTo(output, _repeated_unpackedSfixed64_codec);
+      unpackedFloat_.WriteTo(output, _repeated_unpackedFloat_codec);
+      unpackedDouble_.WriteTo(output, _repeated_unpackedDouble_codec);
+      unpackedBool_.WriteTo(output, _repeated_unpackedBool_codec);
+      unpackedEnum_.WriteTo(output, _repeated_unpackedEnum_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (unpackedInt32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in unpackedInt32_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 * unpackedInt32_.Count;
-      }
-      if (unpackedInt64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in unpackedInt64_) {
-          dataSize += pb::CodedOutputStream.ComputeInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 * unpackedInt64_.Count;
-      }
-      if (unpackedUint32_.Count > 0) {
-        int dataSize = 0;
-        foreach (uint element in unpackedUint32_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 * unpackedUint32_.Count;
-      }
-      if (unpackedUint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (ulong element in unpackedUint64_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 * unpackedUint64_.Count;
-      }
-      if (unpackedSint32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in unpackedSint32_) {
-          dataSize += pb::CodedOutputStream.ComputeSInt32Size(element);
-        }
-        size += dataSize;
-        size += 2 * unpackedSint32_.Count;
-      }
-      if (unpackedSint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in unpackedSint64_) {
-          dataSize += pb::CodedOutputStream.ComputeSInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 * unpackedSint64_.Count;
-      }
-      if (unpackedFixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * unpackedFixed32_.Count;
-        size += dataSize;
-        size += 2 * unpackedFixed32_.Count;
-      }
-      if (unpackedFixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * unpackedFixed64_.Count;
-        size += dataSize;
-        size += 2 * unpackedFixed64_.Count;
-      }
-      if (unpackedSfixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * unpackedSfixed32_.Count;
-        size += dataSize;
-        size += 2 * unpackedSfixed32_.Count;
-      }
-      if (unpackedSfixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * unpackedSfixed64_.Count;
-        size += dataSize;
-        size += 2 * unpackedSfixed64_.Count;
-      }
-      if (unpackedFloat_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * unpackedFloat_.Count;
-        size += dataSize;
-        size += 2 * unpackedFloat_.Count;
-      }
-      if (unpackedDouble_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * unpackedDouble_.Count;
-        size += dataSize;
-        size += 2 * unpackedDouble_.Count;
-      }
-      if (unpackedBool_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 1 * unpackedBool_.Count;
-        size += dataSize;
-        size += 2 * unpackedBool_.Count;
-      }
-      if (unpackedEnum_.Count > 0) {
-        int dataSize = 0;
-        foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in unpackedEnum_) {
-          dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
-        }
-        size += dataSize;
-        size += 2 * unpackedEnum_.Count;
-      }
+      size += unpackedInt32_.CalculateSize(_repeated_unpackedInt32_codec);
+      size += unpackedInt64_.CalculateSize(_repeated_unpackedInt64_codec);
+      size += unpackedUint32_.CalculateSize(_repeated_unpackedUint32_codec);
+      size += unpackedUint64_.CalculateSize(_repeated_unpackedUint64_codec);
+      size += unpackedSint32_.CalculateSize(_repeated_unpackedSint32_codec);
+      size += unpackedSint64_.CalculateSize(_repeated_unpackedSint64_codec);
+      size += unpackedFixed32_.CalculateSize(_repeated_unpackedFixed32_codec);
+      size += unpackedFixed64_.CalculateSize(_repeated_unpackedFixed64_codec);
+      size += unpackedSfixed32_.CalculateSize(_repeated_unpackedSfixed32_codec);
+      size += unpackedSfixed64_.CalculateSize(_repeated_unpackedSfixed64_codec);
+      size += unpackedFloat_.CalculateSize(_repeated_unpackedFloat_codec);
+      size += unpackedDouble_.CalculateSize(_repeated_unpackedDouble_codec);
+      size += unpackedBool_.CalculateSize(_repeated_unpackedBool_codec);
+      size += unpackedEnum_.CalculateSize(_repeated_unpackedEnum_codec);
       return size;
     }
 
@@ -5902,72 +5526,72 @@ namespace Google.Protobuf.TestProtos {
             break;
           case 722:
           case 720: {
-            input.ReadInt32Array(unpackedInt32_);
+            unpackedInt32_.AddEntriesFrom(input, _repeated_unpackedInt32_codec);
             break;
           }
           case 730:
           case 728: {
-            input.ReadInt64Array(unpackedInt64_);
+            unpackedInt64_.AddEntriesFrom(input, _repeated_unpackedInt64_codec);
             break;
           }
           case 738:
           case 736: {
-            input.ReadUInt32Array(unpackedUint32_);
+            unpackedUint32_.AddEntriesFrom(input, _repeated_unpackedUint32_codec);
             break;
           }
           case 746:
           case 744: {
-            input.ReadUInt64Array(unpackedUint64_);
+            unpackedUint64_.AddEntriesFrom(input, _repeated_unpackedUint64_codec);
             break;
           }
           case 754:
           case 752: {
-            input.ReadSInt32Array(unpackedSint32_);
+            unpackedSint32_.AddEntriesFrom(input, _repeated_unpackedSint32_codec);
             break;
           }
           case 762:
           case 760: {
-            input.ReadSInt64Array(unpackedSint64_);
+            unpackedSint64_.AddEntriesFrom(input, _repeated_unpackedSint64_codec);
             break;
           }
           case 770:
           case 773: {
-            input.ReadFixed32Array(unpackedFixed32_);
+            unpackedFixed32_.AddEntriesFrom(input, _repeated_unpackedFixed32_codec);
             break;
           }
           case 778:
           case 777: {
-            input.ReadFixed64Array(unpackedFixed64_);
+            unpackedFixed64_.AddEntriesFrom(input, _repeated_unpackedFixed64_codec);
             break;
           }
           case 786:
           case 789: {
-            input.ReadSFixed32Array(unpackedSfixed32_);
+            unpackedSfixed32_.AddEntriesFrom(input, _repeated_unpackedSfixed32_codec);
             break;
           }
           case 794:
           case 793: {
-            input.ReadSFixed64Array(unpackedSfixed64_);
+            unpackedSfixed64_.AddEntriesFrom(input, _repeated_unpackedSfixed64_codec);
             break;
           }
           case 802:
           case 805: {
-            input.ReadFloatArray(unpackedFloat_);
+            unpackedFloat_.AddEntriesFrom(input, _repeated_unpackedFloat_codec);
             break;
           }
           case 810:
           case 809: {
-            input.ReadDoubleArray(unpackedDouble_);
+            unpackedDouble_.AddEntriesFrom(input, _repeated_unpackedDouble_codec);
             break;
           }
           case 818:
           case 816: {
-            input.ReadBoolArray(unpackedBool_);
+            unpackedBool_.AddEntriesFrom(input, _repeated_unpackedBool_codec);
             break;
           }
           case 826:
           case 824: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(unpackedEnum_);
+            unpackedEnum_.AddEntriesFrom(input, _repeated_unpackedEnum_codec);
             break;
           }
         }
@@ -6023,36 +5647,48 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public const int RepeatedFixed32FieldNumber = 12;
+    private static readonly pb::FieldCodec<uint> _repeated_repeatedFixed32_codec
+        = pb::FieldCodec.ForFixed32(98);
     private readonly pbc::RepeatedField<uint> repeatedFixed32_ = new pbc::RepeatedField<uint>();
     public pbc::RepeatedField<uint> RepeatedFixed32 {
       get { return repeatedFixed32_; }
     }
 
     public const int RepeatedInt32FieldNumber = 13;
+    private static readonly pb::FieldCodec<int> _repeated_repeatedInt32_codec
+        = pb::FieldCodec.ForInt32(106);
     private readonly pbc::RepeatedField<int> repeatedInt32_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> RepeatedInt32 {
       get { return repeatedInt32_; }
     }
 
     public const int RepeatedFixed64FieldNumber = 2046;
+    private static readonly pb::FieldCodec<ulong> _repeated_repeatedFixed64_codec
+        = pb::FieldCodec.ForFixed64(16370);
     private readonly pbc::RepeatedField<ulong> repeatedFixed64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> RepeatedFixed64 {
       get { return repeatedFixed64_; }
     }
 
     public const int RepeatedInt64FieldNumber = 2047;
+    private static readonly pb::FieldCodec<long> _repeated_repeatedInt64_codec
+        = pb::FieldCodec.ForInt64(16378);
     private readonly pbc::RepeatedField<long> repeatedInt64_ = new pbc::RepeatedField<long>();
     public pbc::RepeatedField<long> RepeatedInt64 {
       get { return repeatedInt64_; }
     }
 
     public const int RepeatedFloatFieldNumber = 262142;
+    private static readonly pb::FieldCodec<float> _repeated_repeatedFloat_codec
+        = pb::FieldCodec.ForFloat(2097138);
     private readonly pbc::RepeatedField<float> repeatedFloat_ = new pbc::RepeatedField<float>();
     public pbc::RepeatedField<float> RepeatedFloat {
       get { return repeatedFloat_; }
     }
 
     public const int RepeatedUint64FieldNumber = 262143;
+    private static readonly pb::FieldCodec<ulong> _repeated_repeatedUint64_codec
+        = pb::FieldCodec.ForUInt64(2097146);
     private readonly pbc::RepeatedField<ulong> repeatedUint64_ = new pbc::RepeatedField<ulong>();
     public pbc::RepeatedField<ulong> RepeatedUint64 {
       get { return repeatedUint64_; }
@@ -6090,76 +5726,22 @@ namespace Google.Protobuf.TestProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (repeatedFixed32_.Count > 0) {
-        output.WriteRawTag(98);
-        output.WritePackedFixed32Array(repeatedFixed32_);
-      }
-      if (repeatedInt32_.Count > 0) {
-        output.WriteRawTag(106);
-        output.WritePackedInt32Array(repeatedInt32_);
-      }
-      if (repeatedFixed64_.Count > 0) {
-        output.WriteRawTag(242, 127);
-        output.WritePackedFixed64Array(repeatedFixed64_);
-      }
-      if (repeatedInt64_.Count > 0) {
-        output.WriteRawTag(250, 127);
-        output.WritePackedInt64Array(repeatedInt64_);
-      }
-      if (repeatedFloat_.Count > 0) {
-        output.WriteRawTag(242, 255, 127);
-        output.WritePackedFloatArray(repeatedFloat_);
-      }
-      if (repeatedUint64_.Count > 0) {
-        output.WriteRawTag(250, 255, 127);
-        output.WritePackedUInt64Array(repeatedUint64_);
-      }
+      repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec);
+      repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec);
+      repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec);
+      repeatedInt64_.WriteTo(output, _repeated_repeatedInt64_codec);
+      repeatedFloat_.WriteTo(output, _repeated_repeatedFloat_codec);
+      repeatedUint64_.WriteTo(output, _repeated_repeatedUint64_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (repeatedFixed32_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * repeatedFixed32_.Count;
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedInt32_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in repeatedInt32_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedFixed64_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 8 * repeatedFixed64_.Count;
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedInt64_.Count > 0) {
-        int dataSize = 0;
-        foreach (long element in repeatedInt64_) {
-          dataSize += pb::CodedOutputStream.ComputeInt64Size(element);
-        }
-        size += dataSize;
-        size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedFloat_.Count > 0) {
-        int dataSize = 0;
-        dataSize = 4 * repeatedFloat_.Count;
-        size += dataSize;
-        size += 3 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
-      if (repeatedUint64_.Count > 0) {
-        int dataSize = 0;
-        foreach (ulong element in repeatedUint64_) {
-          dataSize += pb::CodedOutputStream.ComputeUInt64Size(element);
-        }
-        size += dataSize;
-        size += 3 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-      }
+      size += repeatedFixed32_.CalculateSize(_repeated_repeatedFixed32_codec);
+      size += repeatedInt32_.CalculateSize(_repeated_repeatedInt32_codec);
+      size += repeatedFixed64_.CalculateSize(_repeated_repeatedFixed64_codec);
+      size += repeatedInt64_.CalculateSize(_repeated_repeatedInt64_codec);
+      size += repeatedFloat_.CalculateSize(_repeated_repeatedFloat_codec);
+      size += repeatedUint64_.CalculateSize(_repeated_repeatedUint64_codec);
       return size;
     }
 
@@ -6188,32 +5770,32 @@ namespace Google.Protobuf.TestProtos {
             break;
           case 98:
           case 101: {
-            input.ReadFixed32Array(repeatedFixed32_);
+            repeatedFixed32_.AddEntriesFrom(input, _repeated_repeatedFixed32_codec);
             break;
           }
           case 106:
           case 104: {
-            input.ReadInt32Array(repeatedInt32_);
+            repeatedInt32_.AddEntriesFrom(input, _repeated_repeatedInt32_codec);
             break;
           }
           case 16370:
           case 16369: {
-            input.ReadFixed64Array(repeatedFixed64_);
+            repeatedFixed64_.AddEntriesFrom(input, _repeated_repeatedFixed64_codec);
             break;
           }
           case 16378:
           case 16376: {
-            input.ReadInt64Array(repeatedInt64_);
+            repeatedInt64_.AddEntriesFrom(input, _repeated_repeatedInt64_codec);
             break;
           }
           case 2097138:
           case 2097141: {
-            input.ReadFloatArray(repeatedFloat_);
+            repeatedFloat_.AddEntriesFrom(input, _repeated_repeatedFloat_codec);
             break;
           }
           case 2097146:
           case 2097144: {
-            input.ReadUInt64Array(repeatedUint64_);
+            repeatedUint64_.AddEntriesFrom(input, _repeated_repeatedUint64_codec);
             break;
           }
         }