First pass (not yet compiling) at removing all the array handling code from Coded*Stream.

Prod code works, but some tests are broken. Obviously those need fixing, then more tests,
and review benchmarks.

12 files changed, 693 insertions, 1920 deletions

diff --git a/csharp/src/AddressBook/Addressbook.cs b/csharp/src/AddressBook/Addressbook.cs
index c88ca424..4fd46471 100644
--- a/csharp/src/AddressBook/Addressbook.cs
+++ b/csharp/src/AddressBook/Addressbook.cs
@@ -131,6 +131,8 @@ namespace Google.Protobuf.Examples.AddressBook {
     }
 
     public const int PhoneFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> _repeated_phone_codec
+        = pb::FieldCodec.ForMessage(34, global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> phone_ = new pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber>();
     public pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> Phone {
       get { return phone_; }
@@ -176,9 +178,7 @@ namespace Google.Protobuf.Examples.AddressBook {
         output.WriteRawTag(26);
         output.WriteString(Email);
       }
-      if (phone_.Count > 0) {
-        output.WriteMessageArray(4, phone_);
-      }
+      phone_.WriteTo(output, _repeated_phone_codec);
     }
 
     public int CalculateSize() {
@@ -192,12 +192,7 @@ namespace Google.Protobuf.Examples.AddressBook {
       if (Email.Length != 0) {
         size += 1 + pb::CodedOutputStream.ComputeStringSize(Email);
       }
-      if (phone_.Count > 0) {
-        foreach (global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber element in phone_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * phone_.Count;
-      }
+      size += phone_.CalculateSize(_repeated_phone_codec);
       return size;
     }
 
@@ -241,7 +236,7 @@ namespace Google.Protobuf.Examples.AddressBook {
             break;
           }
           case 34: {
-            input.ReadMessageArray(phone_, global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber.Parser);
+            phone_.AddEntriesFrom(input, _repeated_phone_codec);
             break;
           }
         }
@@ -437,6 +432,8 @@ namespace Google.Protobuf.Examples.AddressBook {
     }
 
     public const int PersonFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.Examples.AddressBook.Person> _repeated_person_codec
+        = pb::FieldCodec.ForMessage(10, global::Google.Protobuf.Examples.AddressBook.Person.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person> person_ = new pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person>();
     public pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person> Person {
       get { return person_; }
@@ -464,19 +461,12 @@ namespace Google.Protobuf.Examples.AddressBook {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (person_.Count > 0) {
-        output.WriteMessageArray(1, person_);
-      }
+      person_.WriteTo(output, _repeated_person_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (person_.Count > 0) {
-        foreach (global::Google.Protobuf.Examples.AddressBook.Person element in person_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * person_.Count;
-      }
+      size += person_.CalculateSize(_repeated_person_codec);
       return size;
     }
 
@@ -499,7 +489,7 @@ namespace Google.Protobuf.Examples.AddressBook {
             }
             break;
           case 10: {
-            input.ReadMessageArray(person_, global::Google.Protobuf.Examples.AddressBook.Person.Parser);
+            person_.AddEntriesFrom(input, _repeated_person_codec);
             break;
           }
         }
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;
           }
         }
diff --git a/csharp/src/ProtocolBuffers/CodedInputStream.cs b/csharp/src/ProtocolBuffers/CodedInputStream.cs
index dab3e5e3..75178d14 100644
--- a/csharp/src/ProtocolBuffers/CodedInputStream.cs
+++ b/csharp/src/ProtocolBuffers/CodedInputStream.cs
@@ -172,6 +172,12 @@ namespace Google.Protobuf
             }

         }

 

+        /// <summary>

+        /// Returns the last tag read, or 0 if no tags have been read or we've read beyond

+        /// the end of the stream.

+        /// </summary>

+        internal uint LastTag { get { return lastTag; } }

+

         #region Validation

 

         /// <summary>

@@ -435,26 +441,6 @@ namespace Google.Protobuf
             return DecodeZigZag64(ReadRawVarint64());

         }

 

-        private bool BeginArray(uint fieldTag, out bool isPacked, out int oldLimit)

-        {

-            isPacked = WireFormat.GetTagWireType(fieldTag) == WireFormat.WireType.LengthDelimited;

-

-            if (isPacked)

-            {

-                int length = (int) (ReadRawVarint32() & int.MaxValue);

-                if (length > 0)

-                {

-                    oldLimit = PushLimit(length);

-                    return true;

-                }

-                oldLimit = -1;

-                return false; //packed but empty

-            }

-

-            oldLimit = -1;

-            return true;

-        }

-

         /// <summary>

         /// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>,

         /// the tag is consumed and the method returns <c>true</c>; otherwise, the

@@ -474,268 +460,6 @@ namespace Google.Protobuf
             return false;

         }

 

-        /// <summary>

-        /// Returns true if the next tag is also part of the same array, which may or may not be packed.

-        /// </summary>

-        private bool ContinueArray(uint currentTag, bool packed, int oldLimit)

-        {

-            if (packed)

-            {

-                if (ReachedLimit)

-                {

-                    PopLimit(oldLimit);

-                    return false;

-                }

-                return true;

-            }

-            return MaybeConsumeTag(currentTag);

-        }

-

-        /// <summary>

-        /// Reads a string array.

-        /// </summary>

-        /// <remarks>The stream is assumed to be positioned after a tag indicating the field

-        /// repeated string value. A string is read, and then if the next tag is the same,

-        /// the process is repeated, until the next tag is a different one.</remarks>

-        /// <param name="list"></param>

-        public void ReadStringArray(ICollection<string> list)

-        {

-            uint fieldTag = lastTag;

-            do

-            {

-                list.Add(ReadString());

-            } while (MaybeConsumeTag(fieldTag));

-        }

-

-        public void ReadBytesArray(ICollection<ByteString> list)

-        {

-            uint fieldTag = lastTag;

-            do

-            {

-                list.Add(ReadBytes());

-            } while (MaybeConsumeTag(fieldTag));

-        }

-

-        public void ReadBoolArray(ICollection<bool> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadBool());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadInt32Array(ICollection<int> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadInt32());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadSInt32Array(ICollection<int> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadSInt32());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadUInt32Array(ICollection<uint> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadUInt32());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadFixed32Array(ICollection<uint> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadFixed32());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadSFixed32Array(ICollection<int> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadSFixed32());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadInt64Array(ICollection<long> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadInt64());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadSInt64Array(ICollection<long> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadSInt64());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadUInt64Array(ICollection<ulong> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadUInt64());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadFixed64Array(ICollection<ulong> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadFixed64());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadSFixed64Array(ICollection<long> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadSFixed64());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadDoubleArray(ICollection<double> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadDouble());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadFloatArray(ICollection<float> list)

-        {

-            uint fieldTag = lastTag;

-            bool isPacked;

-            int holdLimit;

-            if (BeginArray(fieldTag, out isPacked, out holdLimit))

-            {

-                do

-                {

-                    list.Add(ReadFloat());

-                } while (ContinueArray(fieldTag, isPacked, holdLimit));

-            }

-        }

-

-        public void ReadEnumArray<T>(RepeatedField<T> list)

-            where T : struct, IComparable, IFormattable

-        {

-            uint fieldTag = lastTag;

-            WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag);

-

-            // 2.3 allows packed form even if the field is not declared packed.

-            if (wformat == WireFormat.WireType.LengthDelimited)

-            {

-                int length = (int) (ReadRawVarint32() & int.MaxValue);

-                int limit = PushLimit(length);

-                while (!ReachedLimit)

-                {

-                    // Ghastly hack, but it works...

-                    list.AddInt32(ReadEnum());

-                }

-                PopLimit(limit);

-            }

-            else

-            {

-                do

-                {

-                    list.Add((T)(object) ReadEnum());

-                } while (MaybeConsumeTag(fieldTag));

-            }

-        }

-

-        public void ReadMessageArray<T>(ICollection<T> list, MessageParser<T> messageParser)

-            where T : IMessage<T>

-        {

-            uint fieldTag = lastTag;

-            do

-            {

-                T message = messageParser.CreateTemplate();

-                ReadMessage(message);

-                list.Add(message);

-            } while (MaybeConsumeTag(fieldTag));

-        }

         #endregion

 

         #region Underlying reading primitives

diff --git a/csharp/src/ProtocolBuffers/CodedOutputStream.cs b/csharp/src/ProtocolBuffers/CodedOutputStream.cs
index def874c0..99a99ae2 100644
--- a/csharp/src/ProtocolBuffers/CodedOutputStream.cs
+++ b/csharp/src/ProtocolBuffers/CodedOutputStream.cs
@@ -306,166 +306,6 @@ namespace Google.Protobuf
 

         #endregion

 

-        #region Write array members, with fields.

-        public void WriteMessageArray<T>(int fieldNumber, RepeatedField<T> list)

-            where T : IMessage

-        {

-            foreach (T value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);

-                WriteMessage(value);

-            }

-        }

-

-        public void WriteStringArray(int fieldNumber, RepeatedField<string> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);

-                WriteString(value);

-            }

-        }

-

-        public void WriteBytesArray(int fieldNumber, RepeatedField<ByteString> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);

-                WriteBytes(value);

-            }

-        }

-

-        public void WriteBoolArray(int fieldNumber, RepeatedField<bool> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteBool(value);

-            }

-        }

-

-        public void WriteInt32Array(int fieldNumber, RepeatedField<int> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteInt32(value);

-            }

-        }

-

-        public void WriteSInt32Array(int fieldNumber, RepeatedField<int> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteSInt32(value);

-            }

-        }

-

-        public void WriteUInt32Array(int fieldNumber, RepeatedField<uint> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteUInt32(value);

-            }

-        }

-

-        public void WriteFixed32Array(int fieldNumber, RepeatedField<uint> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed32);

-                WriteFixed32(value);

-            }

-        }

-

-        public void WriteSFixed32Array(int fieldNumber, RepeatedField<int> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed32);

-                WriteSFixed32(value);

-            }

-        }

-

-        public void WriteInt64Array(int fieldNumber, RepeatedField<long> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed64);

-                WriteInt64(value);

-            }

-        }

-

-        public void WriteSInt64Array(int fieldNumber, RepeatedField<long> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteSInt64(value);

-            }

-        }

-

-        public void WriteUInt64Array(int fieldNumber, RepeatedField<ulong> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteUInt64(value);

-            }

-        }

-

-        public void WriteFixed64Array(int fieldNumber, RepeatedField<ulong> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed64);

-                WriteFixed64(value);

-            }

-        }

-

-        public void WriteSFixed64Array(int fieldNumber, RepeatedField<long> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed64);

-                WriteSFixed64(value);

-            }

-        }

-

-        public void WriteDoubleArray(int fieldNumber, RepeatedField<double> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed64);

-                WriteDouble(value);

-            }

-        }

-

-        public void WriteFloatArray(int fieldNumber, RepeatedField<float> list)

-        {

-            foreach (var value in list)

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Fixed32);

-                WriteFloat(value);

-            }

-        }

-

-        public void WriteEnumArray<T>(int fieldNumber, RepeatedField<T> list)

-            where T : struct, IComparable, IFormattable

-        {

-            // Bit of a hack, to access the values as ints

-            var iterator = list.GetInt32Enumerator();

-            while (iterator.MoveNext())

-            {

-                WriteTag(fieldNumber, WireFormat.WireType.Varint);

-                WriteEnum(iterator.Current);

-            }

-        }

-

-        #endregion

-

         #region Raw tag writing

         /// <summary>

         /// Encodes and writes a tag.

@@ -534,171 +374,6 @@ namespace Google.Protobuf
         }

         #endregion

 

-        #region Write packed array members

-        // TODO(jonskeet): A lot of these are really inefficient, due to method group conversions. Fix!

-        // (Alternatively, add extension methods to RepeatedField, accepting the Write* methods via delegates too.)

-        public void WritePackedBoolArray(RepeatedField<bool> list)

-        {

-            uint size = (uint)list.Count;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteBool(value);

-            }

-        }

-

-        public void WritePackedInt32Array(RepeatedField<int> list)

-        {

-            uint size = list.CalculateSize(ComputeInt32Size);

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteInt32(value);

-            }

-        }

-

-        public void WritePackedSInt32Array(RepeatedField<int> list)

-        {

-            uint size = list.CalculateSize(ComputeSInt32Size);

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteSInt32(value);

-            }

-        }

-

-        public void WritePackedUInt32Array(RepeatedField<uint> list)

-        {

-            uint size = list.CalculateSize(ComputeUInt32Size);

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteUInt32(value);

-            }

-        }

-

-        public void WritePackedFixed32Array(RepeatedField<uint> list)

-        {

-            uint size = (uint) list.Count * 4;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteFixed32(value);

-            }

-        }

-

-        public void WritePackedSFixed32Array(RepeatedField<int> list)

-        {

-            uint size = (uint) list.Count * 4;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteSFixed32(value);

-            }

-        }

-

-        public void WritePackedInt64Array(RepeatedField<long> list)

-        {

-            uint size = list.CalculateSize(ComputeInt64Size);

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteInt64(value);

-            }

-        }

-

-        public void WritePackedSInt64Array(RepeatedField<long> list)

-        {

-            uint size = list.CalculateSize(ComputeSInt64Size);

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteSInt64(value);

-            }

-        }

-

-        public void WritePackedUInt64Array(RepeatedField<ulong> list)

-        {

-            if (list.Count == 0)

-            {

-                return;

-            }

-            uint size = list.CalculateSize(ComputeUInt64Size);

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteUInt64(value);

-            }

-        }

-

-        public void WritePackedFixed64Array(RepeatedField<ulong> list)

-        {

-            uint size = (uint) list.Count * 8;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteFixed64(value);

-            }

-        }

-

-        public void WritePackedSFixed64Array(RepeatedField<long> list)

-        {

-            uint size = (uint) list.Count * 8;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteSFixed64(value);

-            }

-        }

-

-        public void WritePackedDoubleArray(RepeatedField<double> list)

-        {

-            uint size = (uint) list.Count * 8;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteDouble(value);

-            }

-        }

-

-        public void WritePackedFloatArray(RepeatedField<float> list)

-        {

-            if (list.Count == 0)

-            {

-                return;

-            }

-            uint size = (uint) list.Count * 4;

-            WriteRawVarint32(size);

-            foreach (var value in list)

-            {

-                WriteFloat(value);

-            }

-        }

-

-        public void WritePackedEnumArray<T>(RepeatedField<T> list)

-            where T : struct, IComparable, IFormattable

-        {

-            if (list.Count == 0)

-            {

-                return;

-            }

-            // Bit of a hack, to access the values as ints

-            var iterator = list.GetInt32Enumerator();

-            uint size = 0;

-            while (iterator.MoveNext())

-            {

-                size += (uint) ComputeEnumSize(iterator.Current);

-            }

-            iterator.Reset();

-            WriteRawVarint32(size);

-            while (iterator.MoveNext())

-            {

-                WriteEnum(iterator.Current);

-            }

-        }

-

-        #endregion

-

         #region Underlying writing primitives

         /// <summary>

         /// Writes a 32 bit value as a varint. The fast route is taken when

diff --git a/csharp/src/ProtocolBuffers/Collections/MapField.cs b/csharp/src/ProtocolBuffers/Collections/MapField.cs
index 9eed833f..6d1097a6 100644
--- a/csharp/src/ProtocolBuffers/Collections/MapField.cs
+++ b/csharp/src/ProtocolBuffers/Collections/MapField.cs
@@ -334,6 +334,10 @@ namespace Google.Protobuf.Collections
 
         public int CalculateSize(Codec codec)
         {
+            if (Count == 0)
+            {
+                return 0;
+            }
             var message = new Codec.MessageAdapter(codec);
             int size = 0;
             foreach (var entry in list)
@@ -419,13 +423,13 @@ namespace Google.Protobuf.Collections
 
                 public void WriteTo(CodedOutputStream output)
                 {
-                    codec.keyCodec.Write(output, Key);
-                    codec.valueCodec.Write(output, Value);
+                    codec.keyCodec.WriteTagAndValue(output, Key);
+                    codec.valueCodec.WriteTagAndValue(output, Value);
                 }
 
                 public int CalculateSize()
                 {
-                    return codec.keyCodec.CalculateSize(Key) + codec.valueCodec.CalculateSize(Value);
+                    return codec.keyCodec.CalculateSizeWithTag(Key) + codec.valueCodec.CalculateSizeWithTag(Value);
                 }
             }
         }
diff --git a/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs b/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
index 39d4f351..588f66a4 100644
--- a/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
+++ b/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
@@ -49,6 +49,112 @@ namespace Google.Protobuf.Collections
             return clone;
         }
 
+        public void AddEntriesFrom(CodedInputStream input, FieldCodec<T> codec)
+        {
+            uint tag = input.LastTag;
+            var reader = codec.ValueReader;
+            // Value types can be packed or not.
+            if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
+            {
+                int length = (int)(input.ReadRawVarint32() & int.MaxValue);
+                if (length > 0)
+                {
+                    int oldLimit = input.PushLimit(length);
+                    while (!input.ReachedLimit)
+                    {
+                        Add(reader(input));
+                    }
+                    input.PopLimit(oldLimit);
+                }
+                // Empty packed field. Odd, but valid - just ignore.
+            }
+            else
+            {
+                // Not packed... (possibly not packable)
+                do
+                {
+                    Add(reader(input));
+                } while (input.MaybeConsumeTag(tag));
+            }
+        }
+
+        public int CalculateSize(FieldCodec<T> codec)
+        {
+            if (count == 0)
+            {
+                return 0;
+            }
+            uint tag = codec.Tag;
+            if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
+            {
+                int dataSize = CalculatePackedDataSize(codec);
+                return CodedOutputStream.ComputeRawVarint32Size(tag) +
+                    CodedOutputStream.ComputeRawVarint32Size((uint)dataSize) +
+                    dataSize;
+            }
+            else
+            {
+                var sizeCalculator = codec.ValueSizeCalculator;
+                int size = count * CodedOutputStream.ComputeRawVarint32Size(tag);
+                for (int i = 0; i < count; i++)
+                {
+                    size += sizeCalculator(array[i]);
+                }
+                return size;
+            }
+        }
+
+        private int CalculatePackedDataSize(FieldCodec<T> codec)
+        {
+            int fixedSize = codec.FixedSize;
+            if (fixedSize == 0)
+            {
+                var calculator = codec.ValueSizeCalculator;
+                int tmp = 0;
+                for (int i = 0; i < count; i++)
+                {
+                    tmp += calculator(array[i]);
+                }
+                return tmp;
+            }
+            else
+            {
+                return fixedSize * Count;
+            }
+        }
+
+        public void WriteTo(CodedOutputStream output, FieldCodec<T> codec)
+        {
+            // TODO: Assert that T is a value type, and that codec.Tag is packed?
+            if (count == 0)
+            {
+                return;
+            }
+            var writer = codec.ValueWriter;
+            var tag = codec.Tag;
+            if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
+            {
+                // Packed primitive type
+                uint size = (uint)CalculatePackedDataSize(codec);
+                output.WriteTag(tag);
+                output.WriteRawVarint32(size);
+                for (int i = 0; i < count; i++)
+                {
+                    writer(output, array[i]);
+                }
+            }
+            else
+            {
+                // Not packed: a simple tag/value pair for each value.
+                // Can't use codec.WriteTagAndValue, as that omits default values.
+                for (int i = 0; i < count; i++)
+                {
+                    output.WriteTag(tag);
+                    writer(output, array[i]);
+                }
+            }
+        }
+
         public bool IsFrozen { get { return frozen; } }
 
         public void Freeze()
@@ -87,18 +193,6 @@ namespace Google.Protobuf.Collections
             array[count++] = item;
         }
 
-        /// <summary>
-        /// Hack to allow us to add enums easily... will only work with int-based types.
-        /// </summary>
-        /// <param name="readEnum"></param>
-        internal void AddInt32(int item)
-        {
-            this.CheckMutable();
-            EnsureSize(count + 1);
-            int[] castArray = (int[]) (object) array;
-            castArray[count++] = item;
-        }
-
         public void Clear()
         {
             this.CheckMutable();
@@ -180,16 +274,7 @@ namespace Google.Protobuf.Collections
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
-        }
-
-        /// <summary>
-        /// Returns an enumerator of the values in this list as integers.
-        /// Used for enum types.
-        /// </summary>
-        internal Int32Enumerator GetInt32Enumerator()
-        {
-            return new Int32Enumerator((int[])(object)array, count);
-        }
+        }        
 
         public override int GetHashCode()
         {
@@ -297,17 +382,7 @@ namespace Google.Protobuf.Collections
                 array[index] = value;
             }
         }
-
-        internal uint CalculateSize(Func<T, int> sizeComputer)
-        {
-            int size = 0;
-            for (int i = 0; i < count; i++)
-            {
-                size += sizeComputer(array[i]);
-            }
-            return (uint)size;
-        }
-
+        
         public struct Enumerator : IEnumerator<T>
         {
             private int index;
@@ -355,46 +430,5 @@ namespace Google.Protobuf.Collections
             {
             }
         }
-
-        internal struct Int32Enumerator : IEnumerator<int>
-        {
-            private int index;
-            private readonly int[] array;
-            private readonly int count;
-
-            public Int32Enumerator(int[] array, int count)
-            {
-                this.array = array;
-                this.index = -1;
-                this.count = count;
-            }
-
-            public bool MoveNext()
-            {
-                if (index + 1 >= count)
-                {
-                    return false;
-                }
-                index++;
-                return true;
-            }
-
-            public void Reset()
-            {
-                index = -1;
-            }
-
-            // No guard here, as we're only going to use this internally...
-            public int Current { get { return array[index]; } }
-
-            object IEnumerator.Current
-            {
-                get { return Current; }
-            }
-
-            public void Dispose()
-            {
-            }
-        }
     }
 }
diff --git a/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs b/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
index bc0419b0..80166a34 100644
--- a/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
+++ b/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
@@ -314,6 +314,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int FileFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> _repeated_file_codec
+        = pb::FieldCodec.ForMessage(10, global::Google.Protobuf.DescriptorProtos.FileDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> file_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> File {
       get { return file_; }
@@ -341,19 +343,12 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (file_.Count > 0) {
-        output.WriteMessageArray(1, file_);
-      }
+      file_.WriteTo(output, _repeated_file_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (file_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.FileDescriptorProto element in file_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * file_.Count;
-      }
+      size += file_.CalculateSize(_repeated_file_codec);
       return size;
     }
 
@@ -376,7 +371,7 @@ namespace Google.Protobuf.DescriptorProtos {
             }
             break;
           case 10: {
-            input.ReadMessageArray(file_, global::Google.Protobuf.DescriptorProtos.FileDescriptorProto.Parser);
+            file_.AddEntriesFrom(input, _repeated_file_codec);
             break;
           }
         }
@@ -461,42 +456,56 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int DependencyFieldNumber = 3;
+    private static readonly pb::FieldCodec<string> _repeated_dependency_codec
+        = pb::FieldCodec.ForString(26);
     private readonly pbc::RepeatedField<string> dependency_ = new pbc::RepeatedField<string>();
     public pbc::RepeatedField<string> Dependency {
       get { return dependency_; }
     }
 
     public const int PublicDependencyFieldNumber = 10;
+    private static readonly pb::FieldCodec<int> _repeated_publicDependency_codec
+        = pb::FieldCodec.ForInt32(80);
     private readonly pbc::RepeatedField<int> publicDependency_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> PublicDependency {
       get { return publicDependency_; }
     }
 
     public const int WeakDependencyFieldNumber = 11;
+    private static readonly pb::FieldCodec<int> _repeated_weakDependency_codec
+        = pb::FieldCodec.ForInt32(88);
     private readonly pbc::RepeatedField<int> weakDependency_ = new pbc::RepeatedField<int>();
     public pbc::RepeatedField<int> WeakDependency {
       get { return weakDependency_; }
     }
 
     public const int MessageTypeFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto> _repeated_messageType_codec
+        = pb::FieldCodec.ForMessage(34, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> messageType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> MessageType {
       get { return messageType_; }
     }
 
     public const int EnumTypeFieldNumber = 5;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> _repeated_enumType_codec
+        = pb::FieldCodec.ForMessage(42, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> EnumType {
       get { return enumType_; }
     }
 
     public const int ServiceFieldNumber = 6;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> _repeated_service_codec
+        = pb::FieldCodec.ForMessage(50, global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> service_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> Service {
       get { return service_; }
     }
 
     public const int ExtensionFieldNumber = 7;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_extension_codec
+        = pb::FieldCodec.ForMessage(58, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Extension {
       get { return extension_; }
@@ -584,21 +593,11 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(18);
         output.WriteString(Package);
       }
-      if (dependency_.Count > 0) {
-        output.WriteStringArray(3, dependency_);
-      }
-      if (messageType_.Count > 0) {
-        output.WriteMessageArray(4, messageType_);
-      }
-      if (enumType_.Count > 0) {
-        output.WriteMessageArray(5, enumType_);
-      }
-      if (service_.Count > 0) {
-        output.WriteMessageArray(6, service_);
-      }
-      if (extension_.Count > 0) {
-        output.WriteMessageArray(7, extension_);
-      }
+      dependency_.WriteTo(output, _repeated_dependency_codec);
+      messageType_.WriteTo(output, _repeated_messageType_codec);
+      enumType_.WriteTo(output, _repeated_enumType_codec);
+      service_.WriteTo(output, _repeated_service_codec);
+      extension_.WriteTo(output, _repeated_extension_codec);
       if (options_ != null) {
         output.WriteRawTag(66);
         output.WriteMessage(Options);
@@ -607,12 +606,8 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(74);
         output.WriteMessage(SourceCodeInfo);
       }
-      if (publicDependency_.Count > 0) {
-        output.WriteInt32Array(10, publicDependency_);
-      }
-      if (weakDependency_.Count > 0) {
-        output.WriteInt32Array(11, weakDependency_);
-      }
+      publicDependency_.WriteTo(output, _repeated_publicDependency_codec);
+      weakDependency_.WriteTo(output, _repeated_weakDependency_codec);
       if (Syntax.Length != 0) {
         output.WriteRawTag(98);
         output.WriteString(Syntax);
@@ -627,54 +622,13 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Package.Length != 0) {
         size += 1 + pb::CodedOutputStream.ComputeStringSize(Package);
       }
-      if (dependency_.Count > 0) {
-        int dataSize = 0;
-        foreach (string element in dependency_) {
-          dataSize += pb::CodedOutputStream.ComputeStringSize(element);
-        }
-        size += dataSize;
-        size += 1 * dependency_.Count;
-      }
-      if (publicDependency_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in publicDependency_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 1 * publicDependency_.Count;
-      }
-      if (weakDependency_.Count > 0) {
-        int dataSize = 0;
-        foreach (int element in weakDependency_) {
-          dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-        }
-        size += dataSize;
-        size += 1 * weakDependency_.Count;
-      }
-      if (messageType_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto element in messageType_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * messageType_.Count;
-      }
-      if (enumType_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto element in enumType_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * enumType_.Count;
-      }
-      if (service_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto element in service_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * service_.Count;
-      }
-      if (extension_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in extension_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * extension_.Count;
-      }
+      size += dependency_.CalculateSize(_repeated_dependency_codec);
+      size += publicDependency_.CalculateSize(_repeated_publicDependency_codec);
+      size += weakDependency_.CalculateSize(_repeated_weakDependency_codec);
+      size += messageType_.CalculateSize(_repeated_messageType_codec);
+      size += enumType_.CalculateSize(_repeated_enumType_codec);
+      size += service_.CalculateSize(_repeated_service_codec);
+      size += extension_.CalculateSize(_repeated_extension_codec);
       if (options_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
       }
@@ -741,23 +695,23 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 26: {
-            input.ReadStringArray(dependency_);
+            dependency_.AddEntriesFrom(input, _repeated_dependency_codec);
             break;
           }
           case 34: {
-            input.ReadMessageArray(messageType_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
+            messageType_.AddEntriesFrom(input, _repeated_messageType_codec);
             break;
           }
           case 42: {
-            input.ReadMessageArray(enumType_, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
+            enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
             break;
           }
           case 50: {
-            input.ReadMessageArray(service_, global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto.Parser);
+            service_.AddEntriesFrom(input, _repeated_service_codec);
             break;
           }
           case 58: {
-            input.ReadMessageArray(extension_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
+            extension_.AddEntriesFrom(input, _repeated_extension_codec);
             break;
           }
           case 66: {
@@ -776,12 +730,12 @@ namespace Google.Protobuf.DescriptorProtos {
           }
           case 82:
           case 80: {
-            input.ReadInt32Array(publicDependency_);
+            publicDependency_.AddEntriesFrom(input, _repeated_publicDependency_codec);
             break;
           }
           case 90:
           case 88: {
-            input.ReadInt32Array(weakDependency_);
+            weakDependency_.AddEntriesFrom(input, _repeated_weakDependency_codec);
             break;
           }
           case 98: {
@@ -858,36 +812,48 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int FieldFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_field_codec
+        = pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> field_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Field {
       get { return field_; }
     }
 
     public const int ExtensionFieldNumber = 6;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_extension_codec
+        = pb::FieldCodec.ForMessage(50, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Extension {
       get { return extension_; }
     }
 
     public const int NestedTypeFieldNumber = 3;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto> _repeated_nestedType_codec
+        = pb::FieldCodec.ForMessage(26, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> nestedType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> NestedType {
       get { return nestedType_; }
     }
 
     public const int EnumTypeFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> _repeated_enumType_codec
+        = pb::FieldCodec.ForMessage(34, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> EnumType {
       get { return enumType_; }
     }
 
     public const int ExtensionRangeFieldNumber = 5;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> _repeated_extensionRange_codec
+        = pb::FieldCodec.ForMessage(42, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> extensionRange_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRange {
       get { return extensionRange_; }
     }
 
     public const int OneofDeclFieldNumber = 8;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> _repeated_oneofDecl_codec
+        = pb::FieldCodec.ForMessage(66, global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> oneofDecl_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> OneofDecl {
       get { return oneofDecl_; }
@@ -904,12 +870,16 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int ReservedRangeFieldNumber = 9;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> _repeated_reservedRange_codec
+        = pb::FieldCodec.ForMessage(74, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> reservedRange_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> ReservedRange {
       get { return reservedRange_; }
     }
 
     public const int ReservedNameFieldNumber = 10;
+    private static readonly pb::FieldCodec<string> _repeated_reservedName_codec
+        = pb::FieldCodec.ForString(82);
     private readonly pbc::RepeatedField<string> reservedName_ = new pbc::RepeatedField<string>();
     public pbc::RepeatedField<string> ReservedName {
       get { return reservedName_; }
@@ -959,34 +929,18 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(10);
         output.WriteString(Name);
       }
-      if (field_.Count > 0) {
-        output.WriteMessageArray(2, field_);
-      }
-      if (nestedType_.Count > 0) {
-        output.WriteMessageArray(3, nestedType_);
-      }
-      if (enumType_.Count > 0) {
-        output.WriteMessageArray(4, enumType_);
-      }
-      if (extensionRange_.Count > 0) {
-        output.WriteMessageArray(5, extensionRange_);
-      }
-      if (extension_.Count > 0) {
-        output.WriteMessageArray(6, extension_);
-      }
+      field_.WriteTo(output, _repeated_field_codec);
+      nestedType_.WriteTo(output, _repeated_nestedType_codec);
+      enumType_.WriteTo(output, _repeated_enumType_codec);
+      extensionRange_.WriteTo(output, _repeated_extensionRange_codec);
+      extension_.WriteTo(output, _repeated_extension_codec);
       if (options_ != null) {
         output.WriteRawTag(58);
         output.WriteMessage(Options);
       }
-      if (oneofDecl_.Count > 0) {
-        output.WriteMessageArray(8, oneofDecl_);
-      }
-      if (reservedRange_.Count > 0) {
-        output.WriteMessageArray(9, reservedRange_);
-      }
-      if (reservedName_.Count > 0) {
-        output.WriteStringArray(10, reservedName_);
-      }
+      oneofDecl_.WriteTo(output, _repeated_oneofDecl_codec);
+      reservedRange_.WriteTo(output, _repeated_reservedRange_codec);
+      reservedName_.WriteTo(output, _repeated_reservedName_codec);
     }
 
     public int CalculateSize() {
@@ -994,59 +948,17 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Name.Length != 0) {
         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
       }
-      if (field_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in field_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * field_.Count;
-      }
-      if (extension_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in extension_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * extension_.Count;
-      }
-      if (nestedType_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto element in nestedType_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * nestedType_.Count;
-      }
-      if (enumType_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto element in enumType_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * enumType_.Count;
-      }
-      if (extensionRange_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in extensionRange_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * extensionRange_.Count;
-      }
-      if (oneofDecl_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto element in oneofDecl_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * oneofDecl_.Count;
-      }
+      size += field_.CalculateSize(_repeated_field_codec);
+      size += extension_.CalculateSize(_repeated_extension_codec);
+      size += nestedType_.CalculateSize(_repeated_nestedType_codec);
+      size += enumType_.CalculateSize(_repeated_enumType_codec);
+      size += extensionRange_.CalculateSize(_repeated_extensionRange_codec);
+      size += oneofDecl_.CalculateSize(_repeated_oneofDecl_codec);
       if (options_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
       }
-      if (reservedRange_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange element in reservedRange_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * reservedRange_.Count;
-      }
-      if (reservedName_.Count > 0) {
-        int dataSize = 0;
-        foreach (string element in reservedName_) {
-          dataSize += pb::CodedOutputStream.ComputeStringSize(element);
-        }
-        size += dataSize;
-        size += 1 * reservedName_.Count;
-      }
+      size += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
+      size += reservedName_.CalculateSize(_repeated_reservedName_codec);
       return size;
     }
 
@@ -1089,23 +1001,23 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 18: {
-            input.ReadMessageArray(field_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
+            field_.AddEntriesFrom(input, _repeated_field_codec);
             break;
           }
           case 26: {
-            input.ReadMessageArray(nestedType_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
+            nestedType_.AddEntriesFrom(input, _repeated_nestedType_codec);
             break;
           }
           case 34: {
-            input.ReadMessageArray(enumType_, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
+            enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
             break;
           }
           case 42: {
-            input.ReadMessageArray(extensionRange_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Parser);
+            extensionRange_.AddEntriesFrom(input, _repeated_extensionRange_codec);
             break;
           }
           case 50: {
-            input.ReadMessageArray(extension_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
+            extension_.AddEntriesFrom(input, _repeated_extension_codec);
             break;
           }
           case 58: {
@@ -1116,15 +1028,15 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 66: {
-            input.ReadMessageArray(oneofDecl_, global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto.Parser);
+            oneofDecl_.AddEntriesFrom(input, _repeated_oneofDecl_codec);
             break;
           }
           case 74: {
-            input.ReadMessageArray(reservedRange_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange.Parser);
+            reservedRange_.AddEntriesFrom(input, _repeated_reservedRange_codec);
             break;
           }
           case 82: {
-            input.ReadStringArray(reservedName_);
+            reservedName_.AddEntriesFrom(input, _repeated_reservedName_codec);
             break;
           }
         }
@@ -1943,6 +1855,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int ValueFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> _repeated_value_codec
+        = pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> value_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> Value {
       get { return value_; }
@@ -1988,9 +1902,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(10);
         output.WriteString(Name);
       }
-      if (value_.Count > 0) {
-        output.WriteMessageArray(2, value_);
-      }
+      value_.WriteTo(output, _repeated_value_codec);
       if (options_ != null) {
         output.WriteRawTag(26);
         output.WriteMessage(Options);
@@ -2002,12 +1914,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Name.Length != 0) {
         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
       }
-      if (value_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto element in value_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * value_.Count;
-      }
+      size += value_.CalculateSize(_repeated_value_codec);
       if (options_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
       }
@@ -2046,7 +1953,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 18: {
-            input.ReadMessageArray(value_, global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto.Parser);
+            value_.AddEntriesFrom(input, _repeated_value_codec);
             break;
           }
           case 26: {
@@ -2284,6 +2191,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int MethodFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> _repeated_method_codec
+        = pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> method_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> Method {
       get { return method_; }
@@ -2329,9 +2238,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(10);
         output.WriteString(Name);
       }
-      if (method_.Count > 0) {
-        output.WriteMessageArray(2, method_);
-      }
+      method_.WriteTo(output, _repeated_method_codec);
       if (options_ != null) {
         output.WriteRawTag(26);
         output.WriteMessage(Options);
@@ -2343,12 +2250,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Name.Length != 0) {
         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
       }
-      if (method_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto element in method_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * method_.Count;
-      }
+      size += method_.CalculateSize(_repeated_method_codec);
       if (options_ != null) {
         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
       }
@@ -2387,7 +2289,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 18: {
-            input.ReadMessageArray(method_, global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto.Parser);
+            method_.AddEntriesFrom(input, _repeated_method_codec);
             break;
           }
           case 26: {
@@ -2847,6 +2749,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -2958,9 +2862,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(170, 2);
         output.WriteString(CsharpNamespace);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -3007,12 +2909,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (CsharpNamespace.Length != 0) {
         size += 2 + pb::CodedOutputStream.ComputeStringSize(CsharpNamespace);
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -3133,7 +3030,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -3235,6 +3132,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -3286,9 +3185,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(56);
         output.WriteBool(MapEntry);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -3305,12 +3202,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (MapEntry != false) {
         size += 1 + 1;
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -3361,7 +3253,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -3473,6 +3365,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -3536,9 +3430,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(80);
         output.WriteBool(Weak);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -3561,12 +3453,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Weak != false) {
         size += 1 + 1;
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -3631,7 +3518,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -3717,6 +3604,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -3756,9 +3645,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(24);
         output.WriteBool(Deprecated);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -3769,12 +3656,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Deprecated != false) {
         size += 1 + 1;
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -3811,7 +3693,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -3868,6 +3750,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -3901,9 +3785,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(8);
         output.WriteBool(Deprecated);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -3911,12 +3793,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Deprecated != false) {
         size += 1 + 1;
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -3946,7 +3823,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -4003,6 +3880,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -4036,9 +3915,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(136, 2);
         output.WriteBool(Deprecated);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -4046,12 +3923,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Deprecated != false) {
         size += 2 + 1;
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -4081,7 +3953,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -4138,6 +4010,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
       get { return uninterpretedOption_; }
@@ -4171,9 +4045,7 @@ namespace Google.Protobuf.DescriptorProtos {
         output.WriteRawTag(136, 2);
         output.WriteBool(Deprecated);
       }
-      if (uninterpretedOption_.Count > 0) {
-        output.WriteMessageArray(999, uninterpretedOption_);
-      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
     }
 
     public int CalculateSize() {
@@ -4181,12 +4053,7 @@ namespace Google.Protobuf.DescriptorProtos {
       if (Deprecated != false) {
         size += 2 + 1;
       }
-      if (uninterpretedOption_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 2 * uninterpretedOption_.Count;
-      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
       return size;
     }
 
@@ -4216,7 +4083,7 @@ namespace Google.Protobuf.DescriptorProtos {
             break;
           }
           case 7994: {
-            input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
             break;
           }
         }
@@ -4268,6 +4135,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int NameFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> _repeated_name_codec
+        = pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> name_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> Name {
       get { return name_; }
@@ -4367,9 +4236,7 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (name_.Count > 0) {
-        output.WriteMessageArray(2, name_);
-      }
+      name_.WriteTo(output, _repeated_name_codec);
       if (IdentifierValue.Length != 0) {
         output.WriteRawTag(26);
         output.WriteString(IdentifierValue);
@@ -4398,12 +4265,7 @@ namespace Google.Protobuf.DescriptorProtos {
 
     public int CalculateSize() {
       int size = 0;
-      if (name_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart element in name_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * name_.Count;
-      }
+      size += name_.CalculateSize(_repeated_name_codec);
       if (IdentifierValue.Length != 0) {
         size += 1 + pb::CodedOutputStream.ComputeStringSize(IdentifierValue);
       }
@@ -4462,7 +4324,7 @@ namespace Google.Protobuf.DescriptorProtos {
             }
             break;
           case 18: {
-            input.ReadMessageArray(name_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart.Parser);
+            name_.AddEntriesFrom(input, _repeated_name_codec);
             break;
           }
           case 26: {
@@ -4676,6 +4538,8 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public const int LocationFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> _repeated_location_codec
+        = pb::FieldCodec.ForMessage(10, global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location.Parser);
     private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> location_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location>();
     public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> Location {
       get { return location_; }
@@ -4703,19 +4567,12 @@ namespace Google.Protobuf.DescriptorProtos {
     }
 
     public void WriteTo(pb::CodedOutputStream output) {
-      if (location_.Count > 0) {
-        output.WriteMessageArray(1, location_);
-      }
+      location_.WriteTo(output, _repeated_location_codec);
     }
 
     public int CalculateSize() {
       int size = 0;
-      if (location_.Count > 0) {
-        foreach (global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location element in location_) {
-          size += pb::CodedOutputStream.ComputeMessageSize(element);
-        }
-        size += 1 * location_.Count;
-      }
+      size += location_.CalculateSize(_repeated_location_codec);
       return size;
     }
 
@@ -4738,7 +4595,7 @@ namespace Google.Protobuf.DescriptorProtos {
             }
             break;
           case 10: {
-            input.ReadMessageArray(location_, global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location.Parser);
+            location_.AddEntriesFrom(input, _repeated_location_codec);
             break;
           }
         }
@@ -4791,12 +4648,16 @@ namespace Google.Protobuf.DescriptorProtos {
         }
 
         public const int PathFieldNumber = 1;
+        private static readonly pb::FieldCodec<int> _repeated_path_codec
+            = pb::FieldCodec.ForInt32(10);
         private readonly pbc::RepeatedField<int> path_ = new pbc::RepeatedField<int>();
         public pbc::RepeatedField<int> Path {
           get { return path_; }
         }
 
         public const int SpanFieldNumber = 2;
+        private static readonly pb::FieldCodec<int> _repeated_span_codec
+            = pb::FieldCodec.ForInt32(18);
         private readonly pbc::RepeatedField<int> span_ = new pbc::RepeatedField<int>();
         public pbc::RepeatedField<int> Span {
           get { return span_; }
@@ -4823,6 +4684,8 @@ namespace Google.Protobuf.DescriptorProtos {
         }
 
         public const int LeadingDetachedCommentsFieldNumber = 6;
+        private static readonly pb::FieldCodec<string> _repeated_leadingDetachedComments_codec
+            = pb::FieldCodec.ForString(50);
         private readonly pbc::RepeatedField<string> leadingDetachedComments_ = new pbc::RepeatedField<string>();
         public pbc::RepeatedField<string> LeadingDetachedComments {
           get { return leadingDetachedComments_; }
@@ -4858,14 +4721,8 @@ namespace Google.Protobuf.DescriptorProtos {
         }
 
         public void WriteTo(pb::CodedOutputStream output) {
-          if (path_.Count > 0) {
-            output.WriteRawTag(10);
-            output.WritePackedInt32Array(path_);
-          }
-          if (span_.Count > 0) {
-            output.WriteRawTag(18);
-            output.WritePackedInt32Array(span_);
-          }
+          path_.WriteTo(output, _repeated_path_codec);
+          span_.WriteTo(output, _repeated_span_codec);
           if (LeadingComments.Length != 0) {
             output.WriteRawTag(26);
             output.WriteString(LeadingComments);
@@ -4874,43 +4731,20 @@ namespace Google.Protobuf.DescriptorProtos {
             output.WriteRawTag(34);
             output.WriteString(TrailingComments);
           }
-          if (leadingDetachedComments_.Count > 0) {
-            output.WriteStringArray(6, leadingDetachedComments_);
-          }
+          leadingDetachedComments_.WriteTo(output, _repeated_leadingDetachedComments_codec);
         }
 
         public int CalculateSize() {
           int size = 0;
-          if (path_.Count > 0) {
-            int dataSize = 0;
-            foreach (int element in path_) {
-              dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-            }
-            size += dataSize;
-            size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-          }
-          if (span_.Count > 0) {
-            int dataSize = 0;
-            foreach (int element in span_) {
-              dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
-            }
-            size += dataSize;
-            size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
-          }
+          size += path_.CalculateSize(_repeated_path_codec);
+          size += span_.CalculateSize(_repeated_span_codec);
           if (LeadingComments.Length != 0) {
             size += 1 + pb::CodedOutputStream.ComputeStringSize(LeadingComments);
           }
           if (TrailingComments.Length != 0) {
             size += 1 + pb::CodedOutputStream.ComputeStringSize(TrailingComments);
           }
-          if (leadingDetachedComments_.Count > 0) {
-            int dataSize = 0;
-            foreach (string element in leadingDetachedComments_) {
-              dataSize += pb::CodedOutputStream.ComputeStringSize(element);
-            }
-            size += dataSize;
-            size += 1 * leadingDetachedComments_.Count;
-          }
+          size += leadingDetachedComments_.CalculateSize(_repeated_leadingDetachedComments_codec);
           return size;
         }
 
@@ -4942,12 +4776,12 @@ namespace Google.Protobuf.DescriptorProtos {
                 break;
               case 10:
               case 8: {
-                input.ReadInt32Array(path_);
+                path_.AddEntriesFrom(input, _repeated_path_codec);
                 break;
               }
               case 18:
               case 16: {
-                input.ReadInt32Array(span_);
+                span_.AddEntriesFrom(input, _repeated_span_codec);
                 break;
               }
               case 26: {
@@ -4959,7 +4793,7 @@ namespace Google.Protobuf.DescriptorProtos {
                 break;
               }
               case 50: {
-                input.ReadStringArray(leadingDetachedComments_);
+                leadingDetachedComments_.AddEntriesFrom(input, _repeated_leadingDetachedComments_codec);
                 break;
               }
             }
diff --git a/csharp/src/ProtocolBuffers/FieldCodec.cs b/csharp/src/ProtocolBuffers/FieldCodec.cs
index 4cab9cc4..d3fc2f71 100644
--- a/csharp/src/ProtocolBuffers/FieldCodec.cs
+++ b/csharp/src/ProtocolBuffers/FieldCodec.cs
@@ -145,28 +145,68 @@ namespace Google.Protobuf
 
         private readonly Func<CodedInputStream, T> reader;
         private readonly Action<CodedOutputStream, T> writer;
-        private readonly Func<T, int> sizeComputer;
+        private readonly Func<T, int> sizeCalculator;
         private readonly uint tag;
         private readonly int tagSize;
+        private readonly int fixedSize;
 
         internal FieldCodec(
             Func<CodedInputStream, T> reader,
             Action<CodedOutputStream, T> writer,
-            Func<T, int> sizeComputer,
+            Func<T, int> sizeCalculator,
             uint tag)
         {
             this.reader = reader;
             this.writer = writer;
-            this.sizeComputer = sizeComputer;
+            this.sizeCalculator = sizeCalculator;
+            this.fixedSize = 0;
             this.tag = tag;
             tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
         }
 
+        internal FieldCodec(
+            Func<CodedInputStream, T> reader,
+            Action<CodedOutputStream, T> writer,
+            int fixedSize,
+            uint tag)
+        {
+            this.reader = reader;
+            this.writer = writer;
+            this.sizeCalculator = _ => fixedSize;
+            this.fixedSize = fixedSize;
+            this.tag = tag;
+            tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
+        }
+
+        /// <summary>
+        /// Returns the size calculator for just a value.
+        /// </summary>
+        internal Func<T, int> ValueSizeCalculator { get { return sizeCalculator; } }
+
+        /// <summary>
+        /// Returns a delegate to write a value (unconditionally) to a coded output stream.
+        /// </summary>
+        internal Action<CodedOutputStream, T> ValueWriter { get { return writer; } }
+
+        /// <summary>
+        /// Returns a delegate to read a value from a coded input stream. It is assumed that
+        /// the stream is already positioned on the appropriate tag.
+        /// </summary>
+        internal Func<CodedInputStream, T> ValueReader { get { return reader; } }
+
+        /// <summary>
+        /// Returns the fixed size for an entry, or 0 if sizes vary.
+        /// </summary>
+        internal int FixedSize { get { return fixedSize; } }
+
         public uint Tag { get { return tag; } }
 
         public T DefaultValue { get { return Default; } }
 
-        public void Write(CodedOutputStream output, T value)
+        /// <summary>
+        /// Write a tag and the given value, *if* the value is not the default.
+        /// </summary>
+        public void WriteTagAndValue(CodedOutputStream output, T value)
         {
             if (!IsDefault(value))
             {
@@ -180,9 +220,13 @@ namespace Google.Protobuf
             return reader(input);
         }
 
-        public int CalculateSize(T value)
+        /// <summary>
+        /// Calculates the size required to write the given value, with a tag,
+        /// if the value is not the default.
+        /// </summary>
+        public int CalculateSizeWithTag(T value)
         {
-            return IsDefault(value) ? 0 : sizeComputer(value) + CodedOutputStream.ComputeRawVarint32Size(tag);
+            return IsDefault(value) ? 0 : sizeCalculator(value) + tagSize;
         }        
     }
 }
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
index d223273c..4445c281 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
@@ -49,7 +49,6 @@ namespace csharp {
 RepeatedEnumFieldGenerator::RepeatedEnumFieldGenerator(
     const FieldDescriptor* descriptor, int fieldOrdinal)
     : FieldGeneratorBase(descriptor, fieldOrdinal) {
-  variables_["packed"] = descriptor->is_packed() ? "Packed" : "";
 }
 
 RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {
@@ -57,6 +56,10 @@ RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {
 }
 
 void RepeatedEnumFieldGenerator::GenerateMembers(io::Printer* printer) {
+  printer->Print(
+    variables_,
+    "private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
+    "    = pb::FieldCodec.ForEnum($tag$, x => (int) x, x => ($type_name$) x);");
   printer->Print(variables_,
     "private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
   AddDeprecatedFlag(printer);
@@ -76,53 +79,19 @@ void RepeatedEnumFieldGenerator::GenerateMergingCode(io::Printer* printer) {
 void RepeatedEnumFieldGenerator::GenerateParsingCode(io::Printer* printer) {
   printer->Print(
     variables_,
-    "input.ReadEnumArray<$type_name$>($name$_);\n");
+    "$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
 }
 
 void RepeatedEnumFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
   printer->Print(
     variables_,
-    "if ($name$_.Count > 0) {\n");
-  printer->Indent();
-  if (descriptor_->is_packed()) {
-    printer->Print(
-      variables_,
-      "output.WriteRawTag($tag_bytes$);\n"
-      "output.WritePackedEnumArray($name$_);\n");
-  } else {
-    printer->Print(
-      variables_,
-      "output.Write$capitalized_type_name$Array($number$, $name$_);\n");
-  }
-  printer->Outdent();
-  printer->Print("}\n");
+    "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
 }
 
-void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
-  // TODO(jonskeet): Move all this code into CodedOutputStream? It's a lot to repeat everywhere...
-  printer->Print(
-    variables_,
-    "if ($name$_.Count > 0) {\n");
-  printer->Indent();
-  printer->Print("int dataSize = 0;\n");
+void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {  
   printer->Print(
     variables_,
-    "foreach ($type_name$ element in $name$_) {\n"
-    "  dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);\n"
-    "}\n"
-    "size += dataSize;\n");
-  int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
-  if (descriptor_->is_packed()) {
-    printer->Print(
-      "size += $tag_size$ + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);\n",
-      "tag_size", SimpleItoa(tagSize));
-  } else {
-    printer->Print(
-      "size += $tag_size$ * $name$_.Count;\n",
-      "tag_size", SimpleItoa(tagSize), "name", name());
-  }
-  printer->Outdent();
-  printer->Print("}\n");
+    "size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
 }
 
 void RepeatedEnumFieldGenerator::WriteHash(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
index 400f0e4f..c74e5d0d 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
@@ -57,6 +57,10 @@ RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {
 void RepeatedMessageFieldGenerator::GenerateMembers(io::Printer* printer) {
   printer->Print(
     variables_,
+    "private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
+    "    = pb::FieldCodec.ForMessage($tag$, $type_name$.Parser);\n");
+  printer->Print(
+    variables_,
     "private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
   AddDeprecatedFlag(printer);
   printer->Print(
@@ -75,28 +79,19 @@ void RepeatedMessageFieldGenerator::GenerateMergingCode(io::Printer* printer) {
 void RepeatedMessageFieldGenerator::GenerateParsingCode(io::Printer* printer) {
   printer->Print(
     variables_,
-    "input.ReadMessageArray($name$_, $type_name$.Parser);\n");
+    "$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
 }
 
 void RepeatedMessageFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
-  // TODO(jonskeet): Bake the foreach loop into the generated code? We lose the
-  // advantage of knowing the tag bytes this way :(
   printer->Print(
     variables_,
-    "if ($name$_.Count > 0) {\n"
-    "  output.WriteMessageArray($number$, $name$_);\n"
-    "}\n");
+    "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
 }
 
 void RepeatedMessageFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
   printer->Print(
     variables_,
-    "if ($name$_.Count > 0) {\n"
-    "  foreach ($type_name$ element in $name$_) {\n"
-    "    size += pb::CodedOutputStream.ComputeMessageSize(element);\n"
-    "  }\n"
-    "  size += $tag_size$ * $name$_.Count;\n"
-    "}\n");
+    "size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
 }
 
 void RepeatedMessageFieldGenerator::WriteHash(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
index a78a74c0..a3014da8 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
@@ -49,7 +49,6 @@ namespace csharp {
 RepeatedPrimitiveFieldGenerator::RepeatedPrimitiveFieldGenerator(
     const FieldDescriptor* descriptor, int fieldOrdinal)
     : FieldGeneratorBase(descriptor, fieldOrdinal) {
-  variables_["packed"] = descriptor->is_packed() ? "Packed" : "";
 }
 
 RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {
@@ -57,6 +56,10 @@ RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {
 }
 
 void RepeatedPrimitiveFieldGenerator::GenerateMembers(io::Printer* printer) {
+  printer->Print(
+    variables_,
+    "private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
+    "    = pb::FieldCodec.For$capitalized_type_name$($tag$);\n");
   printer->Print(variables_,
     "private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
   AddDeprecatedFlag(printer);
@@ -74,63 +77,21 @@ void RepeatedPrimitiveFieldGenerator::GenerateMergingCode(io::Printer* printer)
 }
 
 void RepeatedPrimitiveFieldGenerator::GenerateParsingCode(io::Printer* printer) {
-  printer->Print(variables_,
-    "input.Read$capitalized_type_name$Array($name$_);\n");
+  printer->Print(
+    variables_,
+    "$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
 }
 
-void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(
-    io::Printer* printer) {
+void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
   printer->Print(
     variables_,
-    "if ($name$_.Count > 0) {\n");
-  printer->Indent();
-  if (descriptor_->is_packed()) {
-    printer->Print(
-      variables_,
-      "output.WriteRawTag($tag_bytes$);\n"
-      "output.WritePacked$capitalized_type_name$Array($name$_);\n");
-  } else {
-    printer->Print(
-      variables_,
-      "output.Write$capitalized_type_name$Array($number$, $name$_);\n");
-  }
-  printer->Outdent();
-  printer->Print("}\n");
+    "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
 }
 
-void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(
-    io::Printer* printer) {
-  // TODO(jonskeet): Do this in the runtime if possible. It's a pain, but it must be feasible...
+void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
   printer->Print(
-    "if ($name$_.Count > 0) {\n",
-    "name", name());
-  printer->Indent();
-  printer->Print("int dataSize = 0;\n");
-  int fixedSize = GetFixedSize(descriptor_->type());
-  if (fixedSize == -1) {
-    printer->Print(
-      variables_,
-      "foreach ($type_name$ element in $name$_) {\n"
-      "  dataSize += pb::CodedOutputStream.Compute$capitalized_type_name$Size(element);\n"
-      "}\n");
-  } else {
-    printer->Print(
-      "dataSize = $size$ * $name$_.Count;\n",
-      "size", SimpleItoa(fixedSize), "name", name());
-  }
-  printer->Print("size += dataSize;\n");
-  int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
-  if (descriptor_->is_packed()) {
-    printer->Print(
-      "size += $tag_size$ + pb::CodedOutputStream.ComputeInt32Size(dataSize);\n",
-      "tag_size", SimpleItoa(tagSize));
-  } else {
-    printer->Print(
-      "size += $tag_size$ * $name$_.Count;\n",
-      "tag_size", SimpleItoa(tagSize), "name", name());
-  }
-  printer->Outdent();
-  printer->Print("}\n");
+    variables_,
+    "size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
 }
 
 void RepeatedPrimitiveFieldGenerator::WriteHash(io::Printer* printer) {