Rename Preconditions to ProtoPreconditions
(Generated code changes in next commit.)
diff --git a/Makefile.am b/Makefile.am
index c7267e02..fbd27fc 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -133,7 +133,7 @@
   csharp/src/Google.Protobuf/LimitedInputStream.cs                           \
   csharp/src/Google.Protobuf/MessageExtensions.cs                            \
   csharp/src/Google.Protobuf/MessageParser.cs                                \
-  csharp/src/Google.Protobuf/Preconditions.cs                                \
+  csharp/src/Google.Protobuf/ProtoPreconditions.cs                           \
   csharp/src/Google.Protobuf/Properties/AssemblyInfo.cs                      \
   csharp/src/Google.Protobuf/Reflection/Descriptor.cs                        \
   csharp/src/Google.Protobuf/Reflection/DescriptorBase.cs                    \
diff --git a/csharp/src/Google.Protobuf/CodedInputStream.cs b/csharp/src/Google.Protobuf/CodedInputStream.cs
index 65d0e71..91bed8e 100644
--- a/csharp/src/Google.Protobuf/CodedInputStream.cs
+++ b/csharp/src/Google.Protobuf/CodedInputStream.cs
@@ -115,7 +115,7 @@
         /// <summary>

         /// Creates a new CodedInputStream reading data from the given byte array.

         /// </summary>

-        public CodedInputStream(byte[] buffer) : this(null, Preconditions.CheckNotNull(buffer, "buffer"), 0, buffer.Length)

+        public CodedInputStream(byte[] buffer) : this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), 0, buffer.Length)

         {            

         }

 

@@ -123,7 +123,7 @@
         /// Creates a new CodedInputStream that reads from the given byte array slice.

         /// </summary>

         public CodedInputStream(byte[] buffer, int offset, int length)

-            : this(null, Preconditions.CheckNotNull(buffer, "buffer"), offset, offset + length)

+            : this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), offset, offset + length)

         {            

             if (offset < 0 || offset > buffer.Length)

             {

@@ -140,7 +140,7 @@
         /// </summary>

         public CodedInputStream(Stream input) : this(input, new byte[BufferSize], 0, 0)

         {

-            Preconditions.CheckNotNull(input, "input");

+            ProtoPreconditions.CheckNotNull(input, "input");

         }

 

         /// <summary>

diff --git a/csharp/src/Google.Protobuf/Collections/MapField.cs b/csharp/src/Google.Protobuf/Collections/MapField.cs
index 04754ae..90a5ff1 100644
--- a/csharp/src/Google.Protobuf/Collections/MapField.cs
+++ b/csharp/src/Google.Protobuf/Collections/MapField.cs
@@ -123,7 +123,7 @@
         /// <returns><c>true</c> if the map contains the given key; <c>false</c> otherwise.</returns>
         public bool ContainsKey(TKey key)
         {
-            Preconditions.CheckNotNullUnconstrained(key, "key");
+            ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
             return map.ContainsKey(key);
         }
 
@@ -140,7 +140,7 @@
         /// <returns><c>true</c> if the map contained the given key before the entry was removed; <c>false</c> otherwise.</returns>
         public bool Remove(TKey key)
         {
-            Preconditions.CheckNotNullUnconstrained(key, "key");
+            ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
             LinkedListNode<KeyValuePair<TKey, TValue>> node;
             if (map.TryGetValue(key, out node))
             {
@@ -188,7 +188,7 @@
         {
             get
             {
-                Preconditions.CheckNotNullUnconstrained(key, "key");
+                ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
                 TValue value;
                 if (TryGetValue(key, out value))
                 {
@@ -198,11 +198,11 @@
             }
             set
             {
-                Preconditions.CheckNotNullUnconstrained(key, "key");
+                ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
                 // value == null check here is redundant, but avoids boxing.
                 if (value == null)
                 {
-                    Preconditions.CheckNotNullUnconstrained(value, "value");
+                    ProtoPreconditions.CheckNotNullUnconstrained(value, "value");
                 }
                 LinkedListNode<KeyValuePair<TKey, TValue>> node;
                 var pair = new KeyValuePair<TKey, TValue>(key, value);
@@ -234,7 +234,7 @@
         /// <param name="entries">The entries to add to the map.</param>
         public void Add(IDictionary<TKey, TValue> entries)
         {
-            Preconditions.CheckNotNull(entries, "entries");
+            ProtoPreconditions.CheckNotNull(entries, "entries");
             foreach (var pair in entries)
             {
                 Add(pair.Key, pair.Value);
@@ -501,7 +501,7 @@
 
         void IDictionary.Remove(object key)
         {
-            Preconditions.CheckNotNull(key, "key");
+            ProtoPreconditions.CheckNotNull(key, "key");
             if (!(key is TKey))
             {
                 return;
@@ -530,7 +530,7 @@
         {
             get
             {
-                Preconditions.CheckNotNull(key, "key");
+                ProtoPreconditions.CheckNotNull(key, "key");
                 if (!(key is TKey))
                 {
                     return null;
diff --git a/csharp/src/Google.Protobuf/Google.Protobuf.csproj b/csharp/src/Google.Protobuf/Google.Protobuf.csproj
index 326b6d3..45ef8c6 100644
--- a/csharp/src/Google.Protobuf/Google.Protobuf.csproj
+++ b/csharp/src/Google.Protobuf/Google.Protobuf.csproj
@@ -123,7 +123,7 @@
     <Compile Include="Reflection\RepeatedFieldAccessor.cs" />

     <Compile Include="Reflection\ServiceDescriptor.cs" />

     <Compile Include="Reflection\SingleFieldAccessor.cs" />

-    <Compile Include="Preconditions.cs" />

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

     <Compile Include="Reflection\TypeRegistry.cs" />

     <Compile Include="WellKnownTypes\Any.cs" />

     <Compile Include="WellKnownTypes\AnyPartial.cs" />

diff --git a/csharp/src/Google.Protobuf/JsonFormatter.cs b/csharp/src/Google.Protobuf/JsonFormatter.cs
index 1749574..60f61fc 100644
--- a/csharp/src/Google.Protobuf/JsonFormatter.cs
+++ b/csharp/src/Google.Protobuf/JsonFormatter.cs
@@ -141,7 +141,7 @@
         /// <returns>The formatted message.</returns>
         public string Format(IMessage message)
         {
-            Preconditions.CheckNotNull(message, nameof(message));
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
             StringBuilder builder = new StringBuilder();
             if (message.Descriptor.IsWellKnownType)
             {
@@ -173,7 +173,7 @@
         /// <returns>The diagnostic-only JSON representation of the message</returns>
         public static string ToDiagnosticString(IMessage message)
         {
-            Preconditions.CheckNotNull(message, nameof(message));
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
             return diagnosticFormatter.Format(message);
         }
 
@@ -858,7 +858,7 @@
             public Settings(bool formatDefaultValues, TypeRegistry typeRegistry)
             {
                 FormatDefaultValues = formatDefaultValues;
-                TypeRegistry = Preconditions.CheckNotNull(typeRegistry, nameof(typeRegistry));
+                TypeRegistry = ProtoPreconditions.CheckNotNull(typeRegistry, nameof(typeRegistry));
             }
         }
     }
diff --git a/csharp/src/Google.Protobuf/JsonParser.cs b/csharp/src/Google.Protobuf/JsonParser.cs
index c07b16e..80d3013 100644
--- a/csharp/src/Google.Protobuf/JsonParser.cs
+++ b/csharp/src/Google.Protobuf/JsonParser.cs
@@ -374,7 +374,7 @@
         /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
         public T Parse<T>(string json) where T : IMessage, new()
         {
-            Preconditions.CheckNotNull(json, nameof(json));
+            ProtoPreconditions.CheckNotNull(json, nameof(json));
             return Parse<T>(new StringReader(json));
         }
 
@@ -387,7 +387,7 @@
         /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
         public T Parse<T>(TextReader jsonReader) where T : IMessage, new()
         {
-            Preconditions.CheckNotNull(jsonReader, nameof(jsonReader));
+            ProtoPreconditions.CheckNotNull(jsonReader, nameof(jsonReader));
             T message = new T();
             Merge(message, jsonReader);
             return message;
@@ -402,8 +402,8 @@
         /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
         public IMessage Parse(string json, MessageDescriptor descriptor)
         {
-            Preconditions.CheckNotNull(json, nameof(json));
-            Preconditions.CheckNotNull(descriptor, nameof(descriptor));
+            ProtoPreconditions.CheckNotNull(json, nameof(json));
+            ProtoPreconditions.CheckNotNull(descriptor, nameof(descriptor));
             return Parse(new StringReader(json), descriptor);
         }
 
@@ -416,8 +416,8 @@
         /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
         public IMessage Parse(TextReader jsonReader, MessageDescriptor descriptor)
         {
-            Preconditions.CheckNotNull(jsonReader, nameof(jsonReader));
-            Preconditions.CheckNotNull(descriptor, nameof(descriptor));
+            ProtoPreconditions.CheckNotNull(jsonReader, nameof(jsonReader));
+            ProtoPreconditions.CheckNotNull(descriptor, nameof(descriptor));
             IMessage message = descriptor.Parser.CreateTemplate();
             Merge(message, jsonReader);
             return message;
@@ -1011,7 +1011,7 @@
             public Settings(int recursionLimit, TypeRegistry typeRegistry)
             {
                 RecursionLimit = recursionLimit;
-                TypeRegistry = Preconditions.CheckNotNull(typeRegistry, nameof(typeRegistry));
+                TypeRegistry = ProtoPreconditions.CheckNotNull(typeRegistry, nameof(typeRegistry));
             }
         }
     }
diff --git a/csharp/src/Google.Protobuf/MessageExtensions.cs b/csharp/src/Google.Protobuf/MessageExtensions.cs
index d2d057c..047156c 100644
--- a/csharp/src/Google.Protobuf/MessageExtensions.cs
+++ b/csharp/src/Google.Protobuf/MessageExtensions.cs
@@ -46,8 +46,8 @@
         /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
         public static void MergeFrom(this IMessage message, byte[] data)
         {
-            Preconditions.CheckNotNull(message, "message");
-            Preconditions.CheckNotNull(data, "data");
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(data, "data");
             CodedInputStream input = new CodedInputStream(data);
             message.MergeFrom(input);
             input.CheckReadEndOfStreamTag();
@@ -60,8 +60,8 @@
         /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
         public static void MergeFrom(this IMessage message, ByteString data)
         {
-            Preconditions.CheckNotNull(message, "message");
-            Preconditions.CheckNotNull(data, "data");
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(data, "data");
             CodedInputStream input = data.CreateCodedInput();
             message.MergeFrom(input);
             input.CheckReadEndOfStreamTag();
@@ -74,8 +74,8 @@
         /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param>
         public static void MergeFrom(this IMessage message, Stream input)
         {
-            Preconditions.CheckNotNull(message, "message");
-            Preconditions.CheckNotNull(input, "input");
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(input, "input");
             CodedInputStream codedInput = new CodedInputStream(input);
             message.MergeFrom(codedInput);
             codedInput.CheckReadEndOfStreamTag();
@@ -92,8 +92,8 @@
         /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param>
         public static void MergeDelimitedFrom(this IMessage message, Stream input)
         {
-            Preconditions.CheckNotNull(message, "message");
-            Preconditions.CheckNotNull(input, "input");
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(input, "input");
             int size = (int) CodedInputStream.ReadRawVarint32(input);
             Stream limitedStream = new LimitedInputStream(input, size);
             message.MergeFrom(limitedStream);
@@ -106,7 +106,7 @@
         /// <returns>The message data as a byte array.</returns>
         public static byte[] ToByteArray(this IMessage message)
         {
-            Preconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(message, "message");
             byte[] result = new byte[message.CalculateSize()];
             CodedOutputStream output = new CodedOutputStream(result);
             message.WriteTo(output);
@@ -121,8 +121,8 @@
         /// <param name="output">The stream to write to.</param>
         public static void WriteTo(this IMessage message, Stream output)
         {
-            Preconditions.CheckNotNull(message, "message");
-            Preconditions.CheckNotNull(output, "output");
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(output, "output");
             CodedOutputStream codedOutput = new CodedOutputStream(output);
             message.WriteTo(codedOutput);
             codedOutput.Flush();
@@ -135,8 +135,8 @@
         /// <param name="output">The output stream to write to.</param>
         public static void WriteDelimitedTo(this IMessage message, Stream output)
         {
-            Preconditions.CheckNotNull(message, "message");
-            Preconditions.CheckNotNull(output, "output");
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(output, "output");
             CodedOutputStream codedOutput = new CodedOutputStream(output);
             codedOutput.WriteRawVarint32((uint)message.CalculateSize());
             message.WriteTo(codedOutput);
@@ -150,7 +150,7 @@
         /// <returns>The message data as a byte string.</returns>
         public static ByteString ToByteString(this IMessage message)
         {
-            Preconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(message, "message");
             return ByteString.AttachBytes(message.ToByteArray());
         }        
     }
diff --git a/csharp/src/Google.Protobuf/MessageParser.cs b/csharp/src/Google.Protobuf/MessageParser.cs
index 81be3c2..8889638 100644
--- a/csharp/src/Google.Protobuf/MessageParser.cs
+++ b/csharp/src/Google.Protobuf/MessageParser.cs
@@ -64,7 +64,7 @@
         /// <returns>The newly parsed message.</returns>
         public IMessage ParseFrom(byte[] data)
         {
-            Preconditions.CheckNotNull(data, "data");
+            ProtoPreconditions.CheckNotNull(data, "data");
             IMessage message = factory();
             message.MergeFrom(data);
             return message;
@@ -77,7 +77,7 @@
         /// <returns>The parsed message.</returns>
         public IMessage ParseFrom(ByteString data)
         {
-            Preconditions.CheckNotNull(data, "data");
+            ProtoPreconditions.CheckNotNull(data, "data");
             IMessage message = factory();
             message.MergeFrom(data);
             return message;
@@ -191,7 +191,7 @@
         /// <returns>The newly parsed message.</returns>
         public new T ParseFrom(byte[] data)
         {
-            Preconditions.CheckNotNull(data, "data");
+            ProtoPreconditions.CheckNotNull(data, "data");
             T message = factory();
             message.MergeFrom(data);
             return message;
@@ -204,7 +204,7 @@
         /// <returns>The parsed message.</returns>
         public new T ParseFrom(ByteString data)
         {
-            Preconditions.CheckNotNull(data, "data");
+            ProtoPreconditions.CheckNotNull(data, "data");
             T message = factory();
             message.MergeFrom(data);
             return message;
diff --git a/csharp/src/Google.Protobuf/Preconditions.cs b/csharp/src/Google.Protobuf/ProtoPreconditions.cs
similarity index 89%
rename from csharp/src/Google.Protobuf/Preconditions.cs
rename to csharp/src/Google.Protobuf/ProtoPreconditions.cs
index 2db35ff..abaeb9b 100644
--- a/csharp/src/Google.Protobuf/Preconditions.cs
+++ b/csharp/src/Google.Protobuf/ProtoPreconditions.cs
@@ -35,9 +35,14 @@
 namespace Google.Protobuf
 {
     /// <summary>
-    /// Helper methods for throwing exceptions
+    /// Helper methods for throwing exceptions when preconditions are not met.
     /// </summary>
-    public static class Preconditions
+    /// <remarks>
+    /// This class is used internally and by generated code; it is not particularly
+    /// expected to be used from application code, although nothing prevents it
+    /// from being used that way.
+    /// </remarks>
+    public static class ProtoPreconditions
     {
         /// <summary>
         /// Throws an ArgumentNullException if the given value is null, otherwise
diff --git a/csharp/src/Google.Protobuf/Reflection/Descriptor.cs b/csharp/src/Google.Protobuf/Reflection/Descriptor.cs
index aac7994..9680b5f 100644
--- a/csharp/src/Google.Protobuf/Reflection/Descriptor.cs
+++ b/csharp/src/Google.Protobuf/Reflection/Descriptor.cs
@@ -317,7 +317,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -330,7 +330,7 @@
     public string Package {
       get { return package_; }
       set {
-        package_ = pb::Preconditions.CheckNotNull(value, "value");
+        package_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -446,7 +446,7 @@
     public string Syntax {
       get { return syntax_; }
       set {
-        syntax_ = pb::Preconditions.CheckNotNull(value, "value");
+        syntax_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -702,7 +702,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1275,7 +1275,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1326,7 +1326,7 @@
     public string TypeName {
       get { return typeName_; }
       set {
-        typeName_ = pb::Preconditions.CheckNotNull(value, "value");
+        typeName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1340,7 +1340,7 @@
     public string Extendee {
       get { return extendee_; }
       set {
-        extendee_ = pb::Preconditions.CheckNotNull(value, "value");
+        extendee_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1357,7 +1357,7 @@
     public string DefaultValue {
       get { return defaultValue_; }
       set {
-        defaultValue_ = pb::Preconditions.CheckNotNull(value, "value");
+        defaultValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1387,7 +1387,7 @@
     public string JsonName {
       get { return jsonName_; }
       set {
-        jsonName_ = pb::Preconditions.CheckNotNull(value, "value");
+        jsonName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1720,7 +1720,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1828,7 +1828,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -1986,7 +1986,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2152,7 +2152,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2313,7 +2313,7 @@
     public string Name {
       get { return name_; }
       set {
-        name_ = pb::Preconditions.CheckNotNull(value, "value");
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2327,7 +2327,7 @@
     public string InputType {
       get { return inputType_; }
       set {
-        inputType_ = pb::Preconditions.CheckNotNull(value, "value");
+        inputType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2337,7 +2337,7 @@
     public string OutputType {
       get { return outputType_; }
       set {
-        outputType_ = pb::Preconditions.CheckNotNull(value, "value");
+        outputType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2583,7 +2583,7 @@
     public string JavaPackage {
       get { return javaPackage_; }
       set {
-        javaPackage_ = pb::Preconditions.CheckNotNull(value, "value");
+        javaPackage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2600,7 +2600,7 @@
     public string JavaOuterClassname {
       get { return javaOuterClassname_; }
       set {
-        javaOuterClassname_ = pb::Preconditions.CheckNotNull(value, "value");
+        javaOuterClassname_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2687,7 +2687,7 @@
     public string GoPackage {
       get { return goPackage_; }
       set {
-        goPackage_ = pb::Preconditions.CheckNotNull(value, "value");
+        goPackage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2773,7 +2773,7 @@
     public string ObjcClassPrefix {
       get { return objcClassPrefix_; }
       set {
-        objcClassPrefix_ = pb::Preconditions.CheckNotNull(value, "value");
+        objcClassPrefix_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -2786,7 +2786,7 @@
     public string CsharpNamespace {
       get { return csharpNamespace_; }
       set {
-        csharpNamespace_ = pb::Preconditions.CheckNotNull(value, "value");
+        csharpNamespace_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -4369,7 +4369,7 @@
     public string IdentifierValue {
       get { return identifierValue_; }
       set {
-        identifierValue_ = pb::Preconditions.CheckNotNull(value, "value");
+        identifierValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -4409,7 +4409,7 @@
     public pb::ByteString StringValue {
       get { return stringValue_; }
       set {
-        stringValue_ = pb::Preconditions.CheckNotNull(value, "value");
+        stringValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -4419,7 +4419,7 @@
     public string AggregateValue {
       get { return aggregateValue_; }
       set {
-        aggregateValue_ = pb::Preconditions.CheckNotNull(value, "value");
+        aggregateValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
       }
     }
 
@@ -4621,7 +4621,7 @@
         public string NamePart_ {
           get { return namePart_; }
           set {
-            namePart_ = pb::Preconditions.CheckNotNull(value, "value");
+            namePart_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
           }
         }
 
@@ -5004,7 +5004,7 @@
         public string LeadingComments {
           get { return leadingComments_; }
           set {
-            leadingComments_ = pb::Preconditions.CheckNotNull(value, "value");
+            leadingComments_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
           }
         }
 
@@ -5014,7 +5014,7 @@
         public string TrailingComments {
           get { return trailingComments_; }
           set {
-            trailingComments_ = pb::Preconditions.CheckNotNull(value, "value");
+            trailingComments_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
           }
         }
 
diff --git a/csharp/src/Google.Protobuf/Reflection/TypeRegistry.cs b/csharp/src/Google.Protobuf/Reflection/TypeRegistry.cs
index 31d5a30..e94e3e6 100644
--- a/csharp/src/Google.Protobuf/Reflection/TypeRegistry.cs
+++ b/csharp/src/Google.Protobuf/Reflection/TypeRegistry.cs
@@ -91,7 +91,7 @@
         /// <returns>A type registry for the given files.</returns>
         public static TypeRegistry FromFiles(IEnumerable<FileDescriptor> fileDescriptors)
         {
-            Preconditions.CheckNotNull(fileDescriptors, nameof(fileDescriptors));
+            ProtoPreconditions.CheckNotNull(fileDescriptors, nameof(fileDescriptors));
             var builder = new Builder();
             foreach (var file in fileDescriptors)
             {
@@ -128,7 +128,7 @@
         /// <returns>A type registry for the given files.</returns>
         public static TypeRegistry FromMessages(IEnumerable<MessageDescriptor> messageDescriptors)
         {
-            Preconditions.CheckNotNull(messageDescriptors, nameof(messageDescriptors));
+            ProtoPreconditions.CheckNotNull(messageDescriptors, nameof(messageDescriptors));
             return FromFiles(messageDescriptors.Select(md => md.File));
         }
 
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/AnyPartial.cs b/csharp/src/Google.Protobuf/WellKnownTypes/AnyPartial.cs
index 082f743..9d43856 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/AnyPartial.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/AnyPartial.cs
@@ -72,7 +72,7 @@
         /// <returns>An Any message with the content and type URL of <paramref name="message"/>.</returns>
         public static Any Pack(IMessage message)
         {
-            Preconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(message, "message");
             return new Any { TypeUrl = GetTypeUrl(message.Descriptor), Value = message.ToByteString() };
         }
     }
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/DurationPartial.cs b/csharp/src/Google.Protobuf/WellKnownTypes/DurationPartial.cs
index e5247e9..f164bfd 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/DurationPartial.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/DurationPartial.cs
@@ -118,7 +118,7 @@
         /// <returns>The negated value of this duration.</returns>
         public static Duration operator -(Duration value)
         {
-            Preconditions.CheckNotNull(value, "value");
+            ProtoPreconditions.CheckNotNull(value, "value");
             checked
             {
                 return Normalize(-value.Seconds, -value.Nanos);
@@ -133,8 +133,8 @@
         /// <returns></returns>
         public static Duration operator +(Duration lhs, Duration rhs)
         {
-            Preconditions.CheckNotNull(lhs, "lhs");
-            Preconditions.CheckNotNull(rhs, "rhs");
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
             checked
             {
                 return Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos);
@@ -149,8 +149,8 @@
         /// <returns>The difference between the two specified durations.</returns>
         public static Duration operator -(Duration lhs, Duration rhs)
         {
-            Preconditions.CheckNotNull(lhs, "lhs");
-            Preconditions.CheckNotNull(rhs, "rhs");
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
             checked
             {
                 return Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos);
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/TimestampPartial.cs b/csharp/src/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
index 86998e2..aa40347 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
@@ -59,8 +59,8 @@
         /// <returns>The difference between the two specified timestamps.</returns>
         public static Duration operator -(Timestamp lhs, Timestamp rhs)
         {
-            Preconditions.CheckNotNull(lhs, "lhs");
-            Preconditions.CheckNotNull(rhs, "rhs");
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
             checked
             {
                 return Duration.Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos);
@@ -75,8 +75,8 @@
         /// <returns>The result of adding the duration to the timestamp.</returns>
         public static Timestamp operator +(Timestamp lhs, Duration rhs)
         {
-            Preconditions.CheckNotNull(lhs, "lhs");
-            Preconditions.CheckNotNull(rhs, "rhs");
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
             checked
             {
                 return Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos);
@@ -91,8 +91,8 @@
         /// <returns>The result of subtracting the duration from the timestamp.</returns>
         public static Timestamp operator -(Timestamp lhs, Duration rhs)
         {
-            Preconditions.CheckNotNull(lhs, "lhs");
-            Preconditions.CheckNotNull(rhs, "rhs");
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
             checked
             {
                 return Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos);
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/ValuePartial.cs b/csharp/src/Google.Protobuf/WellKnownTypes/ValuePartial.cs
index b4b6c05..d34b560 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/ValuePartial.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/ValuePartial.cs
@@ -41,7 +41,7 @@
         /// <returns>A newly-created Value message with the given value.</returns>
         public static Value ForString(string value)
         {
-            Preconditions.CheckNotNull(value, "value");
+            ProtoPreconditions.CheckNotNull(value, "value");
             return new Value { StringValue = value };
         }
 
@@ -81,7 +81,7 @@
         /// <returns>A newly-created Value message an initial list value.</returns>
         public static Value ForList(params Value[] values)
         {
-            Preconditions.CheckNotNull(values, "values");
+            ProtoPreconditions.CheckNotNull(values, "values");
             return new Value { ListValue = new ListValue { Values = { values } } };
         }
 
@@ -92,7 +92,7 @@
         /// <returns>A newly-created Value message an initial struct value.</returns>
         public static Value ForStruct(Struct value)
         {
-            Preconditions.CheckNotNull(value, "value");
+            ProtoPreconditions.CheckNotNull(value, "value");
             return new Value { StructValue = value };
         }
     }
diff --git a/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc b/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
index 76d5b24..60afd89 100644
--- a/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
@@ -83,7 +83,7 @@
   } else {
     printer->Print(
       variables_,
-      "    $name$_ = pb::Preconditions.CheckNotNull(value, \"value\");\n");
+      "    $name$_ = pb::ProtoPreconditions.CheckNotNull(value, \"value\");\n");
   }
   printer->Print(
     "  }\n"
@@ -186,7 +186,7 @@
     } else {
       printer->Print(
         variables_,
-        "    $oneof_name$_ = pb::Preconditions.CheckNotNull(value, \"value\");\n");
+        "    $oneof_name$_ = pb::ProtoPreconditions.CheckNotNull(value, \"value\");\n");
     }
     printer->Print(
       variables_,