Merged local fix for Issue 50

CHANGES.txt

@@ -1,99 +1,99 @@
-===============================================================================
-Welcome to the C# port of Google Protocol Buffers, written by Jon Skeet
-(skeet@pobox.com) based on the work of many talented people.
-
-For more information about this port, visit its homepage:
-http://protobuf-csharp-port.googlecode.com
-
-For more information about Protocol Buffers in general, visit the project page 
-for the C++, Java and Python project:
-http://protobuf.googlecode.com
-===============================================================================
-RELEASE NOTES - Version 2.4.1.TBD
-===============================================================================
-
-Features:
-- Added option service_generator_type to control service generation with
-  NONE, GENERIC, INTERFACE, or IRPCDISPATCH
-- Added interfaces IRpcDispatch and IRpcServerStub to provide for blocking
-  services and implementations.
-- Added ProtoGen.exe command-line argument "--protoc_dir=" to specify the 
-  location of protoc.exe.
-- Extracted interfaces for ICodedInputStream and ICodedOutputStream to allow
-  custom implementation of writers with both speed and size optimizations.
-- Addition of the "Google.ProtoBuffers.Serialization" assembly to support
-  reading and writing messages to/from XML, JSON, IDictionary<,> and others.
-- Several performance related fixes and tweeks
-- Issue 3:	Add option to mark generated code with attribute
-- Issue 20:	Support for decorating classes [Serializable]
-- Issue 21:	Decorate fields with [deprecated=true] as [System.Obsolete]
-- Issue 22:	Reusable Builder classes
-- Issue 24:	Support for using Json/Xml formats with ICodedInputStream
-- Issue 25: Added support for NuGet packages
-- Issue 31: Upgraded protoc.exe and descriptor to 2.4.1
-
-Fixes:
-- Issue 13:	Message with Field same name as message causes uncompilable .cs
-- Issue 16:	Does not integrate well with other tooling
-- Issue 19:	Support for negative enum values
-- Issue 26:	AddRange in GeneratedBuilder iterates twice.
-- Issue 27:	Remove XML documentation output from test projects to clear 
-  warnings/errors.
-- Issue 28: Circular message dependencies result in null default values for 
-  Message fields.
-- Issue 29: Message classes generated have a public default constructor.  You
-  can disable private ctor generation with the option generate_private_ctor.
-- Issue 35: Fixed a bug in ProtoGen handling of arguments with trailing \
-- Big-endian support for float, and double on Silverlight
-- Packed and Unpacked parsing allow for all repeated, as per version 2.3
-- Fix for leaving Builder a public ctor on internal classes for use with
-  generic "where T: new()" constraints.
-
-Other:
-- Changed the code signing key to a privately held key
-- Reformatted all code and line-endings to C# defaults
-- Reworking of performance benchmarks to produce reliable results, option /v2
-- Issue 34: Silverlight assemblies are now unit tested
-
-===============================================================================
-RELEASE NOTES - Version 2.3.0.277
-===============================================================================
-
-Features:
-- Added cls_compliance option to generate attributes indicating 
-  non-CLS-compliance.
-- Added file_extension option to control the generated output file's extension.
-- Added umbrella_namespace option to place the umbrella class into a nested
-  namespace to address issues with proto files having the same name as a 
-  message it contains.
-- Added output_directory option to set the output path for the source file(s).
-- Added ignore_google_protobuf option to avoid generating code for includes 
-  from the google.protobuf package.
-- Added the LITE framework (Google.ProtoBuffersLite.dll) and the ability to
-  generate code with "option optimize_for = LITE_RUNTIME;".
-- Added ability to invoke protoc.exe from within ProtoGen.exe.
-- Upgraded to protoc.exe (2.3) compiler.
-
-Fixes:
-- Issue 9:	Class cannot be static and sealed error
-- Issue 12:	default value for enumerate fields must be filled out
-
-Other:
-- Rewrite of build using MSBbuild instead of NAnt
-- Moved to NUnit Version 2.2.8.0
-- Changed to using secure .snk for releases
-
-===============================================================================
-RELEASE NOTES - Version 0.9.1
-===============================================================================
-
-Fixes:
-- issue 10:	Incorrect encoding of packed fields when serialized
-
-===============================================================================
-RELEASE NOTES - Version 0.9.0
-===============================================================================
-
-- Initial release
-
+===============================================================================
+Welcome to the C# port of Google Protocol Buffers, written by Jon Skeet
+(skeet@pobox.com) based on the work of many talented people.
+
+For more information about this port, visit its homepage:
+http://protobuf-csharp-port.googlecode.com
+
+For more information about Protocol Buffers in general, visit the project page 
+for the C++, Java and Python project:
+http://protobuf.googlecode.com
+===============================================================================
+RELEASE NOTES - Version 2.4.1.473
+===============================================================================
+
+Features:
+- Added option service_generator_type to control service generation with
+  NONE, GENERIC, INTERFACE, or IRPCDISPATCH
+- Added interfaces IRpcDispatch and IRpcServerStub to provide for blocking
+  services and implementations.
+- Added ProtoGen.exe command-line argument "--protoc_dir=" to specify the 
+  location of protoc.exe.
+- Extracted interfaces for ICodedInputStream and ICodedOutputStream to allow
+  custom implementation of writers with both speed and size optimizations.
+- Addition of the "Google.ProtoBuffers.Serialization" assembly to support
+  reading and writing messages to/from XML, JSON, IDictionary<,> and others.
+- Several performance related fixes and tweeks
+- Issue 3:	Add option to mark generated code with attribute
+- Issue 20:	Support for decorating classes [Serializable]
+- Issue 21:	Decorate fields with [deprecated=true] as [System.Obsolete]
+- Issue 22:	Reusable Builder classes
+- Issue 24:	Support for using Json/Xml formats with ICodedInputStream
+- Issue 25: Added support for NuGet packages
+- Issue 31: Upgraded protoc.exe and descriptor to 2.4.1
+
+Fixes:
+- Issue 13:	Message with Field same name as message causes uncompilable .cs
+- Issue 16:	Does not integrate well with other tooling
+- Issue 19:	Support for negative enum values
+- Issue 26:	AddRange in GeneratedBuilder iterates twice.
+- Issue 27:	Remove XML documentation output from test projects to clear 
+  warnings/errors.
+- Issue 28: Circular message dependencies result in null default values for 
+  Message fields.
+- Issue 29: Message classes generated have a public default constructor.  You
+  can disable private ctor generation with the option generate_private_ctor.
+- Issue 35: Fixed a bug in ProtoGen handling of arguments with trailing \
+- Big-endian support for float, and double on Silverlight
+- Packed and Unpacked parsing allow for all repeated, as per version 2.3
+- Fix for leaving Builder a public ctor on internal classes for use with
+  generic "where T: new()" constraints.
+
+Other:
+- Changed the code signing key to a privately held key
+- Reformatted all code and line-endings to C# defaults
+- Reworking of performance benchmarks to produce reliable results, option /v2
+- Issue 34: Silverlight assemblies are now unit tested
+
+===============================================================================
+RELEASE NOTES - Version 2.3.0.277
+===============================================================================
+
+Features:
+- Added cls_compliance option to generate attributes indicating 
+  non-CLS-compliance.
+- Added file_extension option to control the generated output file's extension.
+- Added umbrella_namespace option to place the umbrella class into a nested
+  namespace to address issues with proto files having the same name as a 
+  message it contains.
+- Added output_directory option to set the output path for the source file(s).
+- Added ignore_google_protobuf option to avoid generating code for includes 
+  from the google.protobuf package.
+- Added the LITE framework (Google.ProtoBuffersLite.dll) and the ability to
+  generate code with "option optimize_for = LITE_RUNTIME;".
+- Added ability to invoke protoc.exe from within ProtoGen.exe.
+- Upgraded to protoc.exe (2.3) compiler.
+
+Fixes:
+- Issue 9:	Class cannot be static and sealed error
+- Issue 12:	default value for enumerate fields must be filled out
+
+Other:
+- Rewrite of build using MSBbuild instead of NAnt
+- Moved to NUnit Version 2.2.8.0
+- Changed to using secure .snk for releases
+
+===============================================================================
+RELEASE NOTES - Version 0.9.1
+===============================================================================
+
+Fixes:
+- issue 10:	Incorrect encoding of packed fields when serialized
+
+===============================================================================
+RELEASE NOTES - Version 0.9.0
+===============================================================================
+
+- Initial release
+
 ===============================================================================

protos/extest/unittest_issues.proto

@@ -129,4 +129,9 @@ message DeprecatedFieldsMessage {
 
     optional DeprecatedEnum EnumValue = 5 [deprecated = true];
     repeated DeprecatedEnum EnumArray = 6 [deprecated = true];
-}
+}
+
+// Issue 45: http://code.google.com/p/protobuf-csharp-port/issues/detail?id=45
+message ItemField {
+  optional int32 item = 1;
+}

src/ProtoGen.Test/TestPreprocessing.cs

@@ -112,7 +112,7 @@ message MyMessage {
                 args.Add(String.Format(@"""/out:{0}""", tempDll.TempPath));
                 args.Add("/r:System.dll");
                 args.Add(String.Format(@"""/r:{0}""",
-                                       typeof (Google.ProtocolBuffers.DescriptorProtos.DescriptorProto).Assembly.
+                                       typeof(Google.ProtocolBuffers.DescriptorProtos.DescriptorProto).Assembly.
                                            Location));
                 args.AddRange(sources);
 
@@ -162,7 +162,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -188,7 +188,7 @@ message " +
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple." + test, true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple.Proto." + test, true, true);
             }
@@ -206,7 +206,7 @@ message " +
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("MyNewNamespace." + test, true, true);
             }
@@ -224,7 +224,7 @@ message " +
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple.MyUmbrellaClassname", true, true);
             }
@@ -242,7 +242,7 @@ message " +
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -260,7 +260,7 @@ message " +
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -290,7 +290,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath, "/warnaserror+");
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -308,7 +308,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -326,7 +326,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple.MyUmbrella.Namespace." + test, true, true);
             }
@@ -344,7 +344,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -387,7 +387,7 @@ message " +
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -421,7 +421,7 @@ option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace"";
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("MyNewNamespace." + test, true, true);
             }
@@ -493,7 +493,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("MyNewNamespace." + test, true, true);
             }
@@ -532,7 +532,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("MyNewNamespace." + test, true, true);
             }
@@ -560,7 +560,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -580,7 +580,7 @@ message MyMessage {
                 Assembly a = RunCsc(0, source.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple." + test, true, true);
             }
@@ -620,10 +620,10 @@ message MyMessageList {
                 Assembly a = RunCsc(0, source1.TempPath, source2.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t1 = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t1), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage");
                 //assert that the message type is in the expected namespace
                 Type t2 = a.GetType("nunit.simple.MyMessageList", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t2), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple.Proto.MyMessage", true, true);
                 a.GetType("nunit.simple.Proto.MyMessageList", true, true);
@@ -664,10 +664,10 @@ message MyMessageList {
                 Assembly a = RunCsc(0, source1.TempPath, source2.TempPath);
                 //assert that the message type is in the expected namespace
                 Type t1 = a.GetType("nunit.simple.MyMessage", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t1), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage");
                 //assert that the message type is in the expected namespace
                 Type t2 = a.GetType("nunit.simple.MyMessageList", true, true);
-                Assert.IsTrue(typeof (IMessage).IsAssignableFrom(t2), "Expect an IMessage");
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage");
                 //assert that we can find the static descriptor type
                 a.GetType("nunit.simple.Proto.MyMessage", true, true);
                 a.GetType("nunit.simple.Proto.MyMessageList", true, true);

src/ProtoGen/SourceGenerators.cs

@@ -47,12 +47,12 @@ namespace Google.ProtocolBuffers.ProtoGen
         private static readonly Dictionary<Type, Func<IDescriptor, ISourceGenerator>> GeneratorFactories =
             new Dictionary<Type, Func<IDescriptor, ISourceGenerator>>
                 {
-                    {typeof (FileDescriptor), descriptor => new UmbrellaClassGenerator((FileDescriptor) descriptor)},
-                    {typeof (EnumDescriptor), descriptor => new EnumGenerator((EnumDescriptor) descriptor)},
-                    {typeof (ServiceDescriptor), descriptor => new ServiceGenerator((ServiceDescriptor) descriptor)},
-                    {typeof (MessageDescriptor), descriptor => new MessageGenerator((MessageDescriptor) descriptor)},
+                    {typeof(FileDescriptor), descriptor => new UmbrellaClassGenerator((FileDescriptor) descriptor)},
+                    {typeof(EnumDescriptor), descriptor => new EnumGenerator((EnumDescriptor) descriptor)},
+                    {typeof(ServiceDescriptor), descriptor => new ServiceGenerator((ServiceDescriptor) descriptor)},
+                    {typeof(MessageDescriptor), descriptor => new MessageGenerator((MessageDescriptor) descriptor)},
                     // For other fields, we have IFieldSourceGenerators.
-                    {typeof (FieldDescriptor), descriptor => new ExtensionGenerator((FieldDescriptor) descriptor)}
+                    {typeof(FieldDescriptor), descriptor => new ExtensionGenerator((FieldDescriptor) descriptor)}
                 };
 
         public static IFieldSourceGenerator CreateFieldGenerator(FieldDescriptor field, int fieldOrdinal)
@@ -77,9 +77,9 @@ namespace Google.ProtocolBuffers.ProtoGen
         public static ISourceGenerator CreateGenerator<T>(T descriptor) where T : IDescriptor
         {
             Func<IDescriptor, ISourceGenerator> factory;
-            if (!GeneratorFactories.TryGetValue(typeof (T), out factory))
+            if (!GeneratorFactories.TryGetValue(typeof(T), out factory))
             {
-                throw new ArgumentException("No generator registered for " + typeof (T).Name);
+                throw new ArgumentException("No generator registered for " + typeof(T).Name);
             }
             return factory(descriptor);
         }

src/ProtocolBuffers.Serialization/AbstractReader.cs

@@ -468,7 +468,7 @@ namespace Google.ProtocolBuffers.Serialization
             rawValue = null;
             if (ReadEnum(ref rawValue))
             {
-                if (Enum.IsDefined(typeof (T), rawValue))
+                if (Enum.IsDefined(typeof(T), rawValue))
                 {
                     if (rawValue is int)
                     {
@@ -476,7 +476,7 @@ namespace Google.ProtocolBuffers.Serialization
                     }
                     else if (rawValue is string)
                     {
-                        value = (T) Enum.Parse(typeof (T), (string) rawValue, false);
+                        value = (T) Enum.Parse(typeof(T), (string) rawValue, false);
                     }
                     else
                     {
@@ -565,7 +565,7 @@ namespace Google.ProtocolBuffers.Serialization
                     }
                     else if (rawValue is string)
                     {
-                        list.Add((T) Enum.Parse(typeof (T), (string) rawValue, false));
+                        list.Add((T) Enum.Parse(typeof(T), (string) rawValue, false));
                     }
                     else
                     {

src/ProtocolBuffers.Serialization/AbstractTextReader.cs

@@ -23,7 +23,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref string value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (string)))
+            if (ReadAsText(ref text, typeof(string)))
             {
                 value = text;
                 return true;
@@ -37,7 +37,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref bool value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (bool)))
+            if (ReadAsText(ref text, typeof(bool)))
             {
                 value = XmlConvert.ToBoolean(text);
                 return true;
@@ -51,7 +51,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref int value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (int)))
+            if (ReadAsText(ref text, typeof(int)))
             {
                 value = XmlConvert.ToInt32(text);
                 return true;
@@ -66,7 +66,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref uint value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (uint)))
+            if (ReadAsText(ref text, typeof(uint)))
             {
                 value = XmlConvert.ToUInt32(text);
                 return true;
@@ -80,7 +80,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref long value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (long)))
+            if (ReadAsText(ref text, typeof(long)))
             {
                 value = XmlConvert.ToInt64(text);
                 return true;
@@ -95,7 +95,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref ulong value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (ulong)))
+            if (ReadAsText(ref text, typeof(ulong)))
             {
                 value = XmlConvert.ToUInt64(text);
                 return true;
@@ -109,7 +109,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref float value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (float)))
+            if (ReadAsText(ref text, typeof(float)))
             {
                 value = XmlConvert.ToSingle(text);
                 return true;
@@ -123,7 +123,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref double value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (double)))
+            if (ReadAsText(ref text, typeof(double)))
             {
                 value = XmlConvert.ToDouble(text);
                 return true;
@@ -145,7 +145,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool Read(ref ByteString value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (ByteString)))
+            if (ReadAsText(ref text, typeof(ByteString)))
             {
                 value = DecodeBytes(text);
                 return true;
@@ -160,7 +160,7 @@ namespace Google.ProtocolBuffers.Serialization
         protected override bool ReadEnum(ref object value)
         {
             string text = null;
-            if (ReadAsText(ref text, typeof (Enum)))
+            if (ReadAsText(ref text, typeof(Enum)))
             {
                 int number;
                 if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out number))

src/ProtocolBuffers.Serialization/DictionaryReader.cs

@@ -82,7 +82,7 @@ namespace Google.ProtocolBuffers.Serialization
                 {
                     if (obj is IConvertible)
                     {
-                        value = (T) Convert.ChangeType(obj, typeof (T), CultureInfo.InvariantCulture);
+                        value = (T) Convert.ChangeType(obj, typeof(T), CultureInfo.InvariantCulture);
                     }
                     else
                     {
@@ -207,7 +207,7 @@ namespace Google.ProtocolBuffers.Serialization
             object[] array = null;
             if (GetValue(ref array))
             {
-                if (typeof (T) == typeof (ByteString))
+                if (typeof(T) == typeof(ByteString))
                 {
                     ICollection<ByteString> output = (ICollection<ByteString>) items;
                     foreach (byte[] item in array)

src/ProtocolBuffers.Serialization/JsonFormatReader.cs

@@ -207,7 +207,7 @@ namespace Google.ProtocolBuffers.Serialization
 
             //exponent representation of integer number:
             if (value != null && type == JsonCursor.JsType.Number &&
-                (typeInfo != typeof (double) && typeInfo != typeof (float)) &&
+                (typeInfo != typeof(double) && typeInfo != typeof(float)) &&
                 value.IndexOf("e", StringComparison.OrdinalIgnoreCase) > 0)
             {
                 value = XmlConvert.ToString((long) Math.Round(XmlConvert.ToDouble(value), 0));

src/ProtocolBuffers.Test/ExtendableMessageTest.cs

@@ -45,7 +45,7 @@ namespace Google.ProtocolBuffers
     [TestClass]
     public class ExtendableMessageTest
     {
-        [TestMethod, ExpectedException(typeof (ArgumentException))]
+        [TestMethod, ExpectedException(typeof(ArgumentException))]
         public void ExtensionWriterInvalidExtension()
         {
             TestPackedExtensions.CreateBuilder()[UnitTestProtoFile.OptionalForeignMessageExtension.Descriptor] =

src/ProtocolBuffers.Test/IssuesTest.cs

@@ -0,0 +1,59 @@
+#region Copyright notice and license
+
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://github.com/jskeet/dotnet-protobufs/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#endregion
+
+using Google.ProtocolBuffers.Descriptors;
+using NUnit.Framework;
+using UnitTest.Issues.TestProtos;
+
+namespace Google.ProtocolBuffers
+{
+    /// <summary>
+    /// Tests for issues which aren't easily compartmentalized into other unit tests.
+    /// </summary>
+    [TestFixture]
+    public class IssuesTest
+    {
+        // Issue 45
+        [Test]
+        public void FieldCalledItem()
+        {
+            ItemField message = new ItemField.Builder { Item = 3 }.Build();
+            FieldDescriptor field = ItemField.Descriptor.FindFieldByName("item");
+            Assert.IsNotNull(field);
+            Assert.AreEqual(3, message[field]);
+        }
+    }
+}

src/ProtocolBuffers.Test/MessageUtilTest.cs

@@ -44,14 +44,14 @@ namespace Google.ProtocolBuffers
     public class MessageUtilTest
     {
         [TestMethod]
-        [ExpectedException(typeof (ArgumentNullException))]
+        [ExpectedException(typeof(ArgumentNullException))]
         public void NullTypeName()
         {
             MessageUtil.GetDefaultMessage((string) null);
         }
 
         [TestMethod]
-        [ExpectedException(typeof (ArgumentException))]
+        [ExpectedException(typeof(ArgumentException))]
         public void InvalidTypeName()
         {
             MessageUtil.GetDefaultMessage("invalidtypename");
@@ -61,27 +61,27 @@ namespace Google.ProtocolBuffers
         public void ValidTypeName()
         {
             Assert.AreSame(TestAllTypes.DefaultInstance,
-                           MessageUtil.GetDefaultMessage(typeof (TestAllTypes).AssemblyQualifiedName));
+                           MessageUtil.GetDefaultMessage(typeof(TestAllTypes).AssemblyQualifiedName));
         }
 
         [TestMethod]
-        [ExpectedException(typeof (ArgumentNullException))]
+        [ExpectedException(typeof(ArgumentNullException))]
         public void NullType()
         {
             MessageUtil.GetDefaultMessage((Type) null);
         }
 
         [TestMethod]
-        [ExpectedException(typeof (ArgumentException))]
+        [ExpectedException(typeof(ArgumentException))]
         public void NonMessageType()
         {
-            MessageUtil.GetDefaultMessage(typeof (string));
+            MessageUtil.GetDefaultMessage(typeof(string));
         }
 
         [TestMethod]
         public void ValidType()
         {
-            Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof (TestAllTypes)));
+            Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes)));
         }
     }
 }

src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj

@@ -94,6 +94,7 @@
     <Compile Include="ExtendableMessageTest.cs" />
     <Compile Include="GeneratedBuilderTest.cs" />
     <Compile Include="GeneratedMessageTest.cs" />
+    <Compile Include="IssuesTest.cs" />
     <Compile Include="MessageStreamIteratorTest.cs" />
     <Compile Include="MessageStreamWriterTest.cs" />
     <Compile Include="MessageTest.cs" />

src/ProtocolBuffers.Test/TestProtos/UnitTestExtrasIssuesProtoFile.cs

@@ -36,6 +36,8 @@ namespace UnitTest.Issues.TestProtos {
     internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedChild, global::UnitTest.Issues.TestProtos.DeprecatedChild.Builder> internal__static_unittest_issues_DeprecatedChild__FieldAccessorTable;
     internal static pbd::MessageDescriptor internal__static_unittest_issues_DeprecatedFieldsMessage__Descriptor;
     internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedFieldsMessage, global::UnitTest.Issues.TestProtos.DeprecatedFieldsMessage.Builder> internal__static_unittest_issues_DeprecatedFieldsMessage__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_unittest_issues_ItemField__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.ItemField, global::UnitTest.Issues.TestProtos.ItemField.Builder> internal__static_unittest_issues_ItemField__FieldAccessorTable;
     #endregion
     #region Descriptor
     public static pbd::FileDescriptor Descriptor {
@@ -63,11 +65,11 @@ namespace UnitTest.Issues.TestProtos {
           "eRgEIAMoCzIgLnVuaXR0ZXN0X2lzc3Vlcy5EZXByZWNhdGVkQ2hpbGRCAhgB" + 
           "EjYKCUVudW1WYWx1ZRgFIAEoDjIfLnVuaXR0ZXN0X2lzc3Vlcy5EZXByZWNh" + 
           "dGVkRW51bUICGAESNgoJRW51bUFycmF5GAYgAygOMh8udW5pdHRlc3RfaXNz" + 
-          "dWVzLkRlcHJlY2F0ZWRFbnVtQgIYASpHCgxOZWdhdGl2ZUVudW0SFgoJRml2" + 
-          "ZUJlbG93EPv//////////wESFQoITWludXNPbmUQ////////////ARIICgRa" + 
-          "ZXJvEAAqGQoORGVwcmVjYXRlZEVudW0SBwoDb25lEAFCQEgBwj47ChpVbml0" + 
-          "VGVzdC5Jc3N1ZXMuVGVzdFByb3RvcxIdVW5pdFRlc3RFeHRyYXNJc3N1ZXNQ" + 
-          "cm90b0ZpbGU=");
+          "dWVzLkRlcHJlY2F0ZWRFbnVtQgIYASIZCglJdGVtRmllbGQSDAoEaXRlbRgB" + 
+          "IAEoBSpHCgxOZWdhdGl2ZUVudW0SFgoJRml2ZUJlbG93EPv//////////wES" + 
+          "FQoITWludXNPbmUQ////////////ARIICgRaZXJvEAAqGQoORGVwcmVjYXRl" + 
+          "ZEVudW0SBwoDb25lEAFCQEgBwj47ChpVbml0VGVzdC5Jc3N1ZXMuVGVzdFBy" + 
+          "b3RvcxIdVW5pdFRlc3RFeHRyYXNJc3N1ZXNQcm90b0ZpbGU=");
       pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
         descriptor = root;
         internal__static_unittest_issues_A__Descriptor = Descriptor.MessageTypes[0];
@@ -106,6 +108,10 @@ namespace UnitTest.Issues.TestProtos {
         internal__static_unittest_issues_DeprecatedFieldsMessage__FieldAccessorTable = 
             new pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedFieldsMessage, global::UnitTest.Issues.TestProtos.DeprecatedFieldsMessage.Builder>(internal__static_unittest_issues_DeprecatedFieldsMessage__Descriptor,
                 new string[] { "PrimitiveValue", "PrimitiveArray", "MessageValue", "MessageArray", "EnumValue", "EnumArray", });
+        internal__static_unittest_issues_ItemField__Descriptor = Descriptor.MessageTypes[9];
+        internal__static_unittest_issues_ItemField__FieldAccessorTable = 
+            new pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.ItemField, global::UnitTest.Issues.TestProtos.ItemField.Builder>(internal__static_unittest_issues_ItemField__Descriptor,
+                new string[] { "Item", });
         pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance();
         RegisterAllExtensions(registry);
         global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry);
@@ -3151,6 +3157,280 @@ namespace UnitTest.Issues.TestProtos {
     }
   }
   
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.4.1.473")]
+  public sealed partial class ItemField : pb::GeneratedMessage<ItemField, ItemField.Builder> {
+    private ItemField() { }
+    private static readonly ItemField defaultInstance = new ItemField().MakeReadOnly();
+    private static readonly string[] _itemFieldFieldNames = new string[] { "item" };
+    private static readonly uint[] _itemFieldFieldTags = new uint[] { 8 };
+    public static ItemField DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override ItemField DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override ItemField ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::UnitTest.Issues.TestProtos.UnitTestExtrasIssuesProtoFile.internal__static_unittest_issues_ItemField__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<ItemField, ItemField.Builder> InternalFieldAccessors {
+      get { return global::UnitTest.Issues.TestProtos.UnitTestExtrasIssuesProtoFile.internal__static_unittest_issues_ItemField__FieldAccessorTable; }
+    }
+    
+    public const int ItemFieldNumber = 1;
+    private bool hasItem;
+    private int item_;
+    public bool HasItem {
+      get { return hasItem; }
+    }
+    public int Item {
+      get { return item_; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _itemFieldFieldNames;
+      if (hasItem) {
+        output.WriteInt32(1, field_names[0], Item);
+      }
+      UnknownFields.WriteTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        if (hasItem) {
+          size += pb::CodedOutputStream.ComputeInt32Size(1, Item);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static ItemField ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static ItemField ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static ItemField ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static ItemField ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static ItemField ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static ItemField ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static ItemField ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static ItemField ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static ItemField ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static ItemField ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private ItemField MakeReadOnly() {
+      return this;
+    }
+    
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(ItemField prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.4.1.473")]
+    public sealed partial class Builder : pb::GeneratedBuilder<ItemField, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(ItemField cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private ItemField result;
+      
+      private ItemField PrepareBuilder() {
+        if (resultIsReadOnly) {
+          ItemField original = result;
+          result = new ItemField();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override ItemField MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::UnitTest.Issues.TestProtos.ItemField.Descriptor; }
+      }
+      
+      public override ItemField DefaultInstanceForType {
+        get { return global::UnitTest.Issues.TestProtos.ItemField.DefaultInstance; }
+      }
+      
+      public override ItemField BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is ItemField) {
+          return MergeFrom((ItemField) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(ItemField other) {
+        if (other == global::UnitTest.Issues.TestProtos.ItemField.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasItem) {
+          Item = other.Item;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_itemFieldFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _itemFieldFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 8: {
+              result.hasItem = input.ReadInt32(ref result.item_);
+              break;
+            }
+          }
+        }
+        
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+      
+      
+      public bool HasItem {
+        get { return result.hasItem; }
+      }
+      public int Item {
+        get { return result.Item; }
+        set { SetItem(value); }
+      }
+      public Builder SetItem(int value) {
+        PrepareBuilder();
+        result.hasItem = true;
+        result.item_ = value;
+        return this;
+      }
+      public Builder ClearItem() {
+        PrepareBuilder();
+        result.hasItem = false;
+        result.item_ = 0;
+        return this;
+      }
+    }
+    static ItemField() {
+      object.ReferenceEquals(global::UnitTest.Issues.TestProtos.UnitTestExtrasIssuesProtoFile.Descriptor, null);
+    }
+  }
+  
   #endregion
   
 }

src/ProtocolBuffers.Test/WireFormatTest.cs

@@ -51,11 +51,11 @@ namespace Google.ProtocolBuffers
         [TestMethod]
         public void FieldTypeToWireTypeMapping()
         {
-            foreach (FieldInfo field in typeof (FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))
+            foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))
             {
                 FieldType fieldType = (FieldType) field.GetValue(null);
                 FieldMappingAttribute mapping =
-                    (FieldMappingAttribute) field.GetCustomAttributes(typeof (FieldMappingAttribute), false)[0];
+                    (FieldMappingAttribute) field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
                 Assert.AreEqual(mapping.WireType, WireFormat.GetWireType(fieldType));
             }
         }

src/ProtocolBuffers/CodedInputStream.cs

@@ -467,7 +467,7 @@ namespace Google.ProtocolBuffers
             where T : struct, IComparable, IFormattable, IConvertible
         {
             int number = (int) ReadRawVarint32();
-            if (Enum.IsDefined(typeof (T), number))
+            if (Enum.IsDefined(typeof(T), number))
             {
                 unknown = null;
                 value = (T) (object) number;

src/ProtocolBuffers/Descriptors/FieldDescriptor.cs

@@ -441,11 +441,11 @@ namespace Google.ProtocolBuffers.Descriptors
         private static IDictionary<FieldType, MappedType> MapFieldTypes()
         {
             var map = new Dictionary<FieldType, MappedType>();
-            foreach (FieldInfo field in typeof (FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))
+            foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))
             {
                 FieldType fieldType = (FieldType) field.GetValue(null);
                 FieldMappingAttribute mapping =
-                    (FieldMappingAttribute) field.GetCustomAttributes(typeof (FieldMappingAttribute), false)[0];
+                    (FieldMappingAttribute) field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
                 map[fieldType] = mapping.MappedType;
             }
             return Dictionaries.AsReadOnly(map);

src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs

@@ -63,11 +63,11 @@ namespace Google.ProtocolBuffers.Descriptors
         private static IDictionary<FieldType, FieldMappingAttribute> MapFieldTypes()
         {
             var map = new Dictionary<FieldType, FieldMappingAttribute>();
-            foreach (FieldInfo field in typeof (FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))
+            foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))
             {
                 FieldType fieldType = (FieldType) field.GetValue(null);
                 FieldMappingAttribute mapping =
-                    (FieldMappingAttribute) field.GetCustomAttributes(typeof (FieldMappingAttribute), false)[0];
+                    (FieldMappingAttribute) field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
                 map[fieldType] = mapping;
             }
             return Dictionaries.AsReadOnly(map);

src/ProtocolBuffers/EnumLite.cs

@@ -107,7 +107,7 @@ namespace Google.ProtocolBuffers
                 items.Add(Convert.ToInt32(evalue), new EnumValue(evalue));
             }
 #else
-            foreach (TEnum evalue in Enum.GetValues(typeof (TEnum)))
+            foreach (TEnum evalue in Enum.GetValues(typeof(TEnum)))
             {
                 items.Add(Convert.ToInt32(evalue), new EnumValue(evalue));
             }
@@ -128,9 +128,9 @@ namespace Google.ProtocolBuffers
         public IEnumLite FindValueByName(string name)
         {
             IEnumLite val;
-            if (Enum.IsDefined(typeof (TEnum), name))
+            if (Enum.IsDefined(typeof(TEnum), name))
             {
-                return items.TryGetValue((int) Enum.Parse(typeof (TEnum), name, false), out val) ? val : null;
+                return items.TryGetValue((int) Enum.Parse(typeof(TEnum), name, false), out val) ? val : null;
             }
             return null;
         }

src/ProtocolBuffers/FieldAccess/ReflectionUtil.cs

@@ -44,6 +44,11 @@ namespace Google.ProtocolBuffers.FieldAccess
     /// </summary>
     internal static class ReflectionUtil
     {
+        /// <summary>
+        /// Empty Type[] used when calling GetProperty to force property instead of indexer fetching.
+        /// </summary>
+        internal static readonly Type[] EmptyTypes = new Type[0];
+
         /// <summary>
         /// Creates a delegate which will execute the given method and then return
         /// the result as an object.
@@ -51,8 +56,8 @@ namespace Google.ProtocolBuffers.FieldAccess
         public static Func<T, object> CreateUpcastDelegate<T>(MethodInfo method)
         {
             // The tricky bit is invoking CreateCreateUpcastDelegateImpl with the right type parameters
-            MethodInfo openImpl = typeof (ReflectionUtil).GetMethod("CreateUpcastDelegateImpl");
-            MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof (T), method.ReturnType);
+            MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateUpcastDelegateImpl");
+            MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof(T), method.ReturnType);
             return (Func<T, object>) closedImpl.Invoke(null, new object[] {method});
         }
 
@@ -66,7 +71,7 @@ namespace Google.ProtocolBuffers.FieldAccess
             // Convert the reflection call into an open delegate, i.e. instead of calling x.Method()
             // we'll call getter(x).
             Func<TSource, TResult> getter =
-                (Func<TSource, TResult>) Delegate.CreateDelegate(typeof (Func<TSource, TResult>), null, method);
+                (Func<TSource, TResult>) Delegate.CreateDelegate(typeof(Func<TSource, TResult>), null, method);
 
             // Implicit upcast to object (within the delegate)
             return delegate(TSource source) { return getter(source); };
@@ -78,8 +83,8 @@ namespace Google.ProtocolBuffers.FieldAccess
         /// </summary>
         public static Action<T, object> CreateDowncastDelegate<T>(MethodInfo method)
         {
-            MethodInfo openImpl = typeof (ReflectionUtil).GetMethod("CreateDowncastDelegateImpl");
-            MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof (T), method.GetParameters()[0].ParameterType);
+            MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateDowncastDelegateImpl");
+            MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof(T), method.GetParameters()[0].ParameterType);
             return (Action<T, object>) closedImpl.Invoke(null, new object[] {method});
         }
 
@@ -88,7 +93,7 @@ namespace Google.ProtocolBuffers.FieldAccess
             // Convert the reflection call into an open delegate, i.e. instead of calling x.Method(y) we'll
             // call Method(x, y)
             Action<TSource, TParam> call =
-                (Action<TSource, TParam>) Delegate.CreateDelegate(typeof (Action<TSource, TParam>), null, method);
+                (Action<TSource, TParam>) Delegate.CreateDelegate(typeof(Action<TSource, TParam>), null, method);
 
             return delegate(TSource source, object parameter) { call(source, (TParam) parameter); };
         }
@@ -99,8 +104,8 @@ namespace Google.ProtocolBuffers.FieldAccess
         /// </summary>
         public static Action<T, object> CreateDowncastDelegateIgnoringReturn<T>(MethodInfo method)
         {
-            MethodInfo openImpl = typeof (ReflectionUtil).GetMethod("CreateDowncastDelegateIgnoringReturnImpl");
-            MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof (T), method.GetParameters()[0].ParameterType,
+            MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateDowncastDelegateIgnoringReturnImpl");
+            MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof(T), method.GetParameters()[0].ParameterType,
                                                                method.ReturnType);
             return (Action<T, object>) closedImpl.Invoke(null, new object[] {method});
         }
@@ -111,7 +116,7 @@ namespace Google.ProtocolBuffers.FieldAccess
             // Convert the reflection call into an open delegate, i.e. instead of calling x.Method(y) we'll
             // call Method(x, y)
             Func<TSource, TParam, TReturn> call = (Func<TSource, TParam, TReturn>)
-                                                  Delegate.CreateDelegate(typeof (Func<TSource, TParam, TReturn>), null,
+                                                  Delegate.CreateDelegate(typeof(Func<TSource, TParam, TReturn>), null,
                                                                           method);
 
             return delegate(TSource source, object parameter) { call(source, (TParam) parameter); };
@@ -122,14 +127,14 @@ namespace Google.ProtocolBuffers.FieldAccess
         /// </summary>
         public static Func<IBuilder> CreateStaticUpcastDelegate(MethodInfo method)
         {
-            MethodInfo openImpl = typeof (ReflectionUtil).GetMethod("CreateStaticUpcastDelegateImpl");
+            MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateStaticUpcastDelegateImpl");
             MethodInfo closedImpl = openImpl.MakeGenericMethod(method.ReturnType);
             return (Func<IBuilder>) closedImpl.Invoke(null, new object[] {method});
         }
 
         public static Func<IBuilder> CreateStaticUpcastDelegateImpl<T>(MethodInfo method)
         {
-            Func<T> call = (Func<T>) Delegate.CreateDelegate(typeof (Func<T>), null, method);
+            Func<T> call = (Func<T>) Delegate.CreateDelegate(typeof(Func<T>), null, method);
             return delegate { return (IBuilder) call(); };
         }
     }

src/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs

@@ -66,14 +66,14 @@ namespace Google.ProtocolBuffers.FieldAccess
 
         internal RepeatedPrimitiveAccessor(string name)
         {
-            PropertyInfo messageProperty = typeof (TMessage).GetProperty(name + "List");
-            PropertyInfo builderProperty = typeof (TBuilder).GetProperty(name + "List");
-            PropertyInfo countProperty = typeof (TMessage).GetProperty(name + "Count");
-            MethodInfo clearMethod = typeof (TBuilder).GetMethod("Clear" + name, EmptyTypes);
-            getElementMethod = typeof (TMessage).GetMethod("Get" + name, new Type[] {typeof (int)});
+            PropertyInfo messageProperty = typeof(TMessage).GetProperty(name + "List", ReflectionUtil.EmptyTypes);
+            PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name + "List", ReflectionUtil.EmptyTypes);
+            PropertyInfo countProperty = typeof(TMessage).GetProperty(name + "Count", ReflectionUtil.EmptyTypes);
+            MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name, EmptyTypes);
+            getElementMethod = typeof(TMessage).GetMethod("Get" + name, new Type[] {typeof(int)});
             clrType = getElementMethod.ReturnType;
-            MethodInfo addMethod = typeof (TBuilder).GetMethod("Add" + name, new Type[] {ClrType});
-            setElementMethod = typeof (TBuilder).GetMethod("Set" + name, new Type[] {typeof (int), ClrType});
+            MethodInfo addMethod = typeof(TBuilder).GetMethod("Add" + name, new Type[] {ClrType});
+            setElementMethod = typeof(TBuilder).GetMethod("Set" + name, new Type[] {typeof(int), ClrType});
             if (messageProperty == null
                 || builderProperty == null
                 || countProperty == null
@@ -85,9 +85,9 @@ namespace Google.ProtocolBuffers.FieldAccess
                 throw new ArgumentException("Not all required properties/methods available");
             }
             clearDelegate =
-                (Func<TBuilder, IBuilder>) Delegate.CreateDelegate(typeof (Func<TBuilder, IBuilder>), null, clearMethod);
+                (Func<TBuilder, IBuilder>) Delegate.CreateDelegate(typeof(Func<TBuilder, IBuilder>), null, clearMethod);
             countDelegate = (Func<TMessage, int>) Delegate.CreateDelegate
-                                                      (typeof (Func<TMessage, int>), null, countProperty.GetGetMethod());
+                                                      (typeof(Func<TMessage, int>), null, countProperty.GetGetMethod());
             getValueDelegate = ReflectionUtil.CreateUpcastDelegate<TMessage>(messageProperty.GetGetMethod());
             addValueDelegate = ReflectionUtil.CreateDowncastDelegateIgnoringReturn<TBuilder>(addMethod);
             getRepeatedWrapperDelegate = ReflectionUtil.CreateUpcastDelegate<TBuilder>(builderProperty.GetGetMethod());

src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs

@@ -50,7 +50,7 @@ namespace Google.ProtocolBuffers.FieldAccess
 
         internal SingleMessageAccessor(string name) : base(name)
         {
-            MethodInfo createBuilderMethod = ClrType.GetMethod("CreateBuilder", EmptyTypes);
+            MethodInfo createBuilderMethod = ClrType.GetMethod("CreateBuilder", ReflectionUtil.EmptyTypes);
             if (createBuilderMethod == null)
             {
                 throw new ArgumentException("No public static CreateBuilder method declared in " + ClrType.Name);

src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs

@@ -47,8 +47,6 @@ namespace Google.ProtocolBuffers.FieldAccess
         private readonly Func<TMessage, bool> hasDelegate;
         private readonly Func<TBuilder, IBuilder> clearDelegate;
 
-        internal static readonly Type[] EmptyTypes = new Type[0];
-
         /// <summary>
         /// The CLR type of the field (int, the enum type, ByteString, the message etc).
         /// As declared by the property.
@@ -60,14 +58,14 @@ namespace Google.ProtocolBuffers.FieldAccess
 
         internal SinglePrimitiveAccessor(string name)
         {
-            PropertyInfo messageProperty = typeof (TMessage).GetProperty(name);
-            PropertyInfo builderProperty = typeof (TBuilder).GetProperty(name);
+            PropertyInfo messageProperty = typeof(TMessage).GetProperty(name, ReflectionUtil.EmptyTypes);
+            PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name, ReflectionUtil.EmptyTypes);
             if (builderProperty == null)
             {
-                builderProperty = typeof (TBuilder).GetProperty(name);
+                builderProperty = typeof(TBuilder).GetProperty(name, ReflectionUtil.EmptyTypes);
             }
-            PropertyInfo hasProperty = typeof (TMessage).GetProperty("Has" + name);
-            MethodInfo clearMethod = typeof (TBuilder).GetMethod("Clear" + name, EmptyTypes);
+            PropertyInfo hasProperty = typeof(TMessage).GetProperty("Has" + name, ReflectionUtil.EmptyTypes);
+            MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name, ReflectionUtil.EmptyTypes);
             if (messageProperty == null || builderProperty == null || hasProperty == null || clearMethod == null)
             {
                 throw new ArgumentException("Not all required properties/methods available");
@@ -75,9 +73,9 @@ namespace Google.ProtocolBuffers.FieldAccess
             clrType = messageProperty.PropertyType;
             hasDelegate =
                 (Func<TMessage, bool>)
-                Delegate.CreateDelegate(typeof (Func<TMessage, bool>), null, hasProperty.GetGetMethod());
+                Delegate.CreateDelegate(typeof(Func<TMessage, bool>), null, hasProperty.GetGetMethod());
             clearDelegate =
-                (Func<TBuilder, IBuilder>) Delegate.CreateDelegate(typeof (Func<TBuilder, IBuilder>), null, clearMethod);
+                (Func<TBuilder, IBuilder>) Delegate.CreateDelegate(typeof(Func<TBuilder, IBuilder>), null, clearMethod);
             getValueDelegate = ReflectionUtil.CreateUpcastDelegate<TMessage>(messageProperty.GetGetMethod());
             setValueDelegate = ReflectionUtil.CreateDowncastDelegate<TBuilder>(builderProperty.GetSetMethod());
         }

src/ProtocolBuffers/GeneratedExtensionBase.cs

@@ -85,7 +85,7 @@ namespace Google.ProtocolBuffers
                 if (defaultInstanceProperty == null)
                 {
                     throw new ArgumentException("No public static DefaultInstance property for type " +
-                                                typeof (TExtension).Name);
+                                                typeof(TExtension).Name);
                 }
 
                 messageDefaultInstance = (IMessageLite) defaultInstanceProperty.GetValue(null, null);

src/ProtocolBuffers/GeneratedRepeatExtension.cs

@@ -46,7 +46,7 @@ namespace Google.ProtocolBuffers
     /// </summary>
     public sealed class GeneratedRepeatExtension<TExtensionElement> : GeneratedExtensionBase<IList<TExtensionElement>>
     {
-        private GeneratedRepeatExtension(FieldDescriptor field) : base(field, typeof (TExtensionElement))
+        private GeneratedRepeatExtension(FieldDescriptor field) : base(field, typeof(TExtensionElement))
         {
         }
 

src/ProtocolBuffers/GeneratedSingleExtension.cs

@@ -44,7 +44,7 @@ namespace Google.ProtocolBuffers
     /// </remarks>
     public sealed class GeneratedSingleExtension<TExtension> : GeneratedExtensionBase<TExtension>
     {
-        internal GeneratedSingleExtension(FieldDescriptor descriptor) : base(descriptor, typeof (TExtension))
+        internal GeneratedSingleExtension(FieldDescriptor descriptor) : base(descriptor, typeof(TExtension))
         {
         }
 

src/ProtocolBuffers/MessageStreamIterator.cs

@@ -84,16 +84,16 @@ namespace Google.ProtocolBuffers
                 Type builderType = FindBuilderType();
 
                 // Yes, it's redundant to find this again, but it's only the once...
-                MethodInfo createBuilderMethod = typeof (TMessage).GetMethod("CreateBuilder", EmptyTypes);
+                MethodInfo createBuilderMethod = typeof(TMessage).GetMethod("CreateBuilder", EmptyTypes);
                 Delegate builderBuilder = Delegate.CreateDelegate(
-                    typeof (Func<>).MakeGenericType(builderType), null, createBuilderMethod);
+                    typeof(Func<>).MakeGenericType(builderType), null, createBuilderMethod);
 
-                MethodInfo buildMethod = typeof (MessageStreamIterator<TMessage>)
+                MethodInfo buildMethod = typeof(MessageStreamIterator<TMessage>)
                     .GetMethod("BuildImpl", BindingFlags.Static | BindingFlags.NonPublic)
-                    .MakeGenericMethod(typeof (TMessage), builderType);
+                    .MakeGenericMethod(typeof(TMessage), builderType);
 
                 return (Func<CodedInputStream, ExtensionRegistry, TMessage>) Delegate.CreateDelegate(
-                    typeof (Func<CodedInputStream, ExtensionRegistry, TMessage>), builderBuilder, buildMethod);
+                    typeof(Func<CodedInputStream, ExtensionRegistry, TMessage>), builderBuilder, buildMethod);
             }
             catch (ArgumentException e)
             {
@@ -116,28 +116,28 @@ namespace Google.ProtocolBuffers
         /// </summary>
         private static Type FindBuilderType()
         {
-            MethodInfo createBuilderMethod = typeof (TMessage).GetMethod("CreateBuilder", EmptyTypes);
+            MethodInfo createBuilderMethod = typeof(TMessage).GetMethod("CreateBuilder", EmptyTypes);
             if (createBuilderMethod == null)
             {
-                throw new ArgumentException("Message type " + typeof (TMessage).FullName +
+                throw new ArgumentException("Message type " + typeof(TMessage).FullName +
                                             " has no CreateBuilder method.");
             }
-            if (createBuilderMethod.ReturnType == typeof (void))
+            if (createBuilderMethod.ReturnType == typeof(void))
             {
-                throw new ArgumentException("CreateBuilder method in " + typeof (TMessage).FullName +
+                throw new ArgumentException("CreateBuilder method in " + typeof(TMessage).FullName +
                                             " has void return type");
             }
             Type builderType = createBuilderMethod.ReturnType;
-            Type messageInterface = typeof (IMessage<,>).MakeGenericType(typeof (TMessage), builderType);
-            Type builderInterface = typeof (IBuilder<,>).MakeGenericType(typeof (TMessage), builderType);
-            if (Array.IndexOf(typeof (TMessage).GetInterfaces(), messageInterface) == -1)
+            Type messageInterface = typeof(IMessage<,>).MakeGenericType(typeof(TMessage), builderType);
+            Type builderInterface = typeof(IBuilder<,>).MakeGenericType(typeof(TMessage), builderType);
+            if (Array.IndexOf(typeof(TMessage).GetInterfaces(), messageInterface) == -1)
             {
-                throw new ArgumentException("Message type " + typeof (TMessage) + " doesn't implement " +
+                throw new ArgumentException("Message type " + typeof(TMessage) + " doesn't implement " +
                                             messageInterface.FullName);
             }
             if (Array.IndexOf(builderType.GetInterfaces(), builderInterface) == -1)
             {
-                throw new ArgumentException("Builder type " + typeof (TMessage) + " doesn't implement " +
+                throw new ArgumentException("Builder type " + typeof(TMessage) + " doesn't implement " +
                                             builderInterface.FullName);
             }
             return builderType;

src/ProtocolBuffers/MessageUtil.cs

@@ -65,7 +65,7 @@ namespace Google.ProtocolBuffers
                 throw new ArgumentException("Unable to get a default message for an abstract or generic type (" +
                                             type.FullName + ")");
             }
-            if (!typeof (IMessage).IsAssignableFrom(type))
+            if (!typeof(IMessage).IsAssignableFrom(type))
             {
                 throw new ArgumentException("Unable to get a default message for non-message type (" + type.FullName +
                                             ")");

src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs

@@ -255,7 +255,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertBytesEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());
         }
 
-        [TestMethod, ExpectedException(typeof (UninitializedMessageException))]
+        [TestMethod, ExpectedException(typeof(UninitializedMessageException))]
         public void TestIBuilderLiteWeakBuildUninitialized()
         {
             IBuilderLite builder = TestRequiredLite.CreateBuilder();

src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs

@@ -111,7 +111,7 @@ namespace Google.ProtocolBuffers
         public void TestIMessageLiteWeakCreateBuilderForType()
         {
             IMessageLite msg = TestRequiredLite.DefaultInstance;
-            Assert.AreEqual(typeof (TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
+            Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
         }
 
         [TestMethod]

src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs

@@ -128,7 +128,7 @@ namespace Google.ProtocolBuffers
                 Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));
         }
 
-        [TestMethod, ExpectedException(typeof (ArgumentOutOfRangeException))]
+        [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
         public void TestGetExtensionTIndexOutOfRange()
         {
             TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
@@ -154,7 +154,7 @@ namespace Google.ProtocolBuffers
                 Assert.AreEqual(5 + i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));
         }
 
-        [TestMethod, ExpectedException(typeof (ArgumentOutOfRangeException))]
+        [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
         public void TestSetExtensionTIndexOutOfRange()
         {
             TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
@@ -209,7 +209,7 @@ namespace Google.ProtocolBuffers
             Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));
         }
 
-        [TestMethod, ExpectedException(typeof (ArgumentOutOfRangeException))]
+        [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
         public void TestIndexedByDescriptorAndOrdinalOutOfRange()
         {
             TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs

@@ -47,7 +47,7 @@ namespace Google.ProtocolBuffers
     public class ExtendableMessageLiteTest
     {
         //The lite framework does not make this assertion
-        //[TestMethod, Ignore, ExpectedException(typeof (ArgumentException))]
+        //[TestMethod, Ignore, ExpectedException(typeof(ArgumentException))]
         //public void ExtensionWriterInvalidExtension()
         //{
         //    TestPackedExtensionsLite.CreateBuilder()[