-Explicit enum values

Src/Newtonsoft.Json/Bson/BsonReader.cs

@@ -61,15 +61,15 @@ namespace Newtonsoft.Json.Bson
 
         private enum BsonReaderState
         {
-            Normal,
-            ReferenceStart,
-            ReferenceRef,
-            ReferenceId,
-            CodeWScopeStart,
-            CodeWScopeCode,
-            CodeWScopeScope,
-            CodeWScopeScopeObject,
-            CodeWScopeScopeEnd
+            Normal = 0,
+            ReferenceStart = 1,
+            ReferenceRef = 2,
+            ReferenceId = 3,
+            CodeWScopeStart = 4,
+            CodeWScopeCode = 5,
+            CodeWScopeScope = 6,
+            CodeWScopeScopeObject = 7,
+            CodeWScopeScopeEnd = 8
         }
 
         private class ContainerContext

Src/Newtonsoft.Json/DateParseHandling.cs

@@ -33,17 +33,17 @@ namespace Newtonsoft.Json
         /// <summary>
         /// Date formatted strings are not parsed to a date type and are read as strings.
         /// </summary>
-        None,
+        None = 0,
 
         /// <summary>
         /// Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to <see cref="DateTime"/>.
         /// </summary>
-        DateTime,
+        DateTime = 1,
 #if !NET20
         /// <summary>
         /// Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to <see cref="DateTimeOffset"/>.
         /// </summary>
-        DateTimeOffset
+        DateTimeOffset = 2
 #endif
     }
 }

Src/Newtonsoft.Json/DateTimeZoneHandling.cs

@@ -35,22 +35,22 @@ namespace Newtonsoft.Json
         /// <summary>
         /// Treat as local time. If the <see cref="DateTime"/> object represents a Coordinated Universal Time (UTC), it is converted to the local time.
         /// </summary>
-        Local,
+        Local = 0,
 
         /// <summary>
         /// Treat as a UTC. If the <see cref="DateTime"/> object represents a local time, it is converted to a UTC.
         /// </summary>
-        Utc,
+        Utc = 1,
 
         /// <summary>
         /// Treat as a local time if a <see cref="DateTime"/> is being converted to a string.
         /// If a string is being converted to <see cref="DateTime"/>, convert to a local time if a time zone is specified.
         /// </summary>
-        Unspecified,
+        Unspecified = 2,
 
         /// <summary>
         /// Time zone information should be preserved when converting.
         /// </summary>
-        RoundtripKind
+        RoundtripKind = 3
     }
 }

Src/Newtonsoft.Json/FloatFormatHandling.cs

@@ -34,17 +34,17 @@ namespace Newtonsoft.Json
         /// <summary>
         /// Write special floating point values as strings in JSON, e.g. "NaN", "Infinity", "-Infinity".
         /// </summary>
-        String,
+        String = 0,
 
         /// <summary>
         /// Write special floating point values as symbols in JSON, e.g. NaN, Infinity, -Infinity.
         /// Note that this will produce non-valid JSON.
         /// </summary>
-        Symbol,
+        Symbol = 1,
 
         /// <summary>
         /// Write special floating point values as the property's default value in JSON, e.g. 0.0 for a <see cref="System.Double"/> property, null for a <see cref="System.Nullable{Double}"/> property.
         /// </summary>
-        DefaultValue
+        DefaultValue = 2
     }
 }

Src/Newtonsoft.Json/FloatParseHandling.cs

@@ -33,11 +33,11 @@ namespace Newtonsoft.Json
         /// <summary>
         /// Floating point numbers are parsed to <see cref="Double"/>.
         /// </summary>
-        Double,
+        Double = 0,
 
         /// <summary>
         /// Floating point numbers are parsed to <see cref="Decimal"/>.
         /// </summary>
-        Decimal
+        Decimal = 1
     }
 }

Src/Newtonsoft.Json/FormatterAssemblyStyle.cs

@@ -11,12 +11,12 @@ namespace System.Runtime.Serialization.Formatters
         /// <summary>
         /// In simple mode, the assembly used during deserialization need not match exactly the assembly used during serialization. Specifically, the version numbers need not match as the LoadWithPartialName method is used to load the assembly.
         /// </summary>
-        Simple,
+        Simple = 0,
 
         /// <summary>
         /// In full mode, the assembly used during deserialization must match exactly the assembly used during serialization. The Load method of the Assembly class is used to load the assembly.
         /// </summary>
-        Full
+        Full = 1
     }
 }
 

Src/Newtonsoft.Json/Formatting.cs

@@ -33,11 +33,11 @@ namespace Newtonsoft.Json
         /// <summary>
         /// No special formatting is applied. This is the default.
         /// </summary>
-        None,
+        None = 0,
 
         /// <summary>
         /// Causes child objects to be indented according to the <see cref="JsonTextWriter.Indentation"/> and <see cref="JsonTextWriter.IndentChar"/> settings.
         /// </summary>
-        Indented
+        Indented = 1
     }
 }

Src/Newtonsoft.Json/JsonPosition.cs

@@ -33,10 +33,10 @@ namespace Newtonsoft.Json
 {
     internal enum JsonContainerType
     {
-        None,
-        Object,
-        Array,
-        Constructor
+        None = 0,
+        Object = 1,
+        Array = 2,
+        Constructor = 3
     }
 
     internal struct JsonPosition

Src/Newtonsoft.Json/JsonToken.cs

@@ -37,91 +37,91 @@ namespace Newtonsoft.Json
         /// <summary>
         /// This is returned by the <see cref="JsonReader"/> if a <see cref="JsonReader.Read"/> method has not been called. 
         /// </summary>
-        None,
+        None = 0,
 
         /// <summary>
         /// An object start token.
         /// </summary>
-        StartObject,
+        StartObject = 1,
 
         /// <summary>
         /// An array start token.
         /// </summary>
-        StartArray,
+        StartArray = 2,
 
         /// <summary>
         /// A constructor start token.
         /// </summary>
-        StartConstructor,
+        StartConstructor = 3,
 
         /// <summary>
         /// An object property name.
         /// </summary>
-        PropertyName,
+        PropertyName = 4,
 
         /// <summary>
         /// A comment.
         /// </summary>
-        Comment,
+        Comment = 5,
 
         /// <summary>
         /// Raw JSON.
         /// </summary>
-        Raw,
+        Raw = 6,
 
         /// <summary>
         /// An integer.
         /// </summary>
-        Integer,
+        Integer = 7,
 
         /// <summary>
         /// A float.
         /// </summary>
-        Float,
+        Float = 8,
 
         /// <summary>
         /// A string.
         /// </summary>
-        String,
+        String = 9,
 
         /// <summary>
         /// A boolean.
         /// </summary>
-        Boolean,
+        Boolean = 10,
 
         /// <summary>
         /// A null token.
         /// </summary>
-        Null,
+        Null = 11,
 
         /// <summary>
         /// An undefined token.
         /// </summary>
-        Undefined,
+        Undefined = 12,
 
         /// <summary>
         /// An object end token.
         /// </summary>
-        EndObject,
+        EndObject = 13,
 
         /// <summary>
         /// An array end token.
         /// </summary>
-        EndArray,
+        EndArray = 14,
 
         /// <summary>
         /// A constructor end token.
         /// </summary>
-        EndConstructor,
+        EndConstructor = 15,
 
         /// <summary>
         /// A Date.
         /// </summary>
-        Date,
+        Date = 16,
 
         /// <summary>
         /// Byte data.
         /// </summary>
-        Bytes
+        Bytes = 17
     }
 }

Src/Newtonsoft.Json/JsonWriter.cs

@@ -47,16 +47,16 @@ namespace Newtonsoft.Json
     {
         internal enum State
         {
-            Start,
-            Property,
-            ObjectStart,
-            Object,
-            ArrayStart,
-            Array,
-            ConstructorStart,
-            Constructor,
-            Closed,
-            Error
+            Start = 0,
+            Property = 1,
+            ObjectStart = 2,
+            Object = 3,
+            ArrayStart = 4,
+            Array = 5,
+            ConstructorStart = 6,
+            Constructor = 7,
+            Closed = 8,
+            Error = 9
         }
 
         // array that gives a new state based on the current state an the token being written

Src/Newtonsoft.Json/Linq/JTokenType.cs

@@ -33,91 +33,91 @@ namespace Newtonsoft.Json.Linq
         /// <summary>
         /// No token type has been set.
         /// </summary>
-        None,
+        None = 0,
 
         /// <summary>
         /// A JSON object.
         /// </summary>
-        Object,
+        Object = 1,
 
         /// <summary>
         /// A JSON array.
         /// </summary>
-        Array,
+        Array = 2,
 
         /// <summary>
         /// A JSON constructor.
         /// </summary>
-        Constructor,
+        Constructor = 3,
 
         /// <summary>
         /// A JSON object property.
         /// </summary>
-        Property,
+        Property = 4,
 
         /// <summary>
         /// A comment.
         /// </summary>
-        Comment,
+        Comment = 5,
 
         /// <summary>
         /// An integer value.
         /// </summary>
-        Integer,
+        Integer = 6,
 
         /// <summary>
         /// A float value.
         /// </summary>
-        Float,
+        Float = 7,
 
         /// <summary>
         /// A string value.
         /// </summary>
-        String,
+        String = 8,
 
         /// <summary>
         /// A boolean value.
         /// </summary>
-        Boolean,
+        Boolean = 9,
 
         /// <summary>
         /// A null value.
         /// </summary>
-        Null,
+        Null = 10,
 
         /// <summary>
         /// An undefined value.
         /// </summary>
-        Undefined,
+        Undefined = 11,
 
         /// <summary>
         /// A date value.
         /// </summary>
-        Date,
+        Date = 12,
 
         /// <summary>
         /// A raw JSON value.
         /// </summary>
-        Raw,
+        Raw = 13,
 
         /// <summary>
         /// A collection of bytes value.
         /// </summary>
-        Bytes,
+        Bytes = 14,
 
         /// <summary>
         /// A Guid value.
         /// </summary>
-        Guid,
+        Guid = 15,
 
         /// <summary>
         /// A Uri value.
         /// </summary>
-        Uri,
+        Uri = 16,
 
         /// <summary>
         /// A TimeSpan value.
         /// </summary>
-        TimeSpan
+        TimeSpan = 17
     }
 }

Src/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs

@@ -5,16 +5,16 @@ namespace Newtonsoft.Json.Linq.JsonPath
 {
     internal enum QueryOperator
     {
-        None,
-        Equals,
-        NotEquals,
-        Exists,
-        LessThan,
-        LessThanOrEquals,
-        GreaterThan,
-        GreaterThanOrEquals,
-        And,
-        Or
+        None = 0,
+        Equals = 1,
+        NotEquals = 2,
+        Exists = 3,
+        LessThan = 4,
+        LessThanOrEquals = 5,
+        GreaterThan = 6,
+        GreaterThanOrEquals = 7,
+        And = 8,
+        Or = 9
     }
 
     internal abstract class QueryExpression

Src/Newtonsoft.Json/Linq/MergeArrayHandling.cs

@@ -6,15 +6,15 @@ namespace Newtonsoft.Json.Linq
     public enum MergeArrayHandling
     {
         /// <summary>Concatenate arrays.</summary>
-        Concat,
+        Concat = 0,
 
         /// <summary>Union arrays, skipping items that already exist.</summary>
-        Union,
+        Union = 1,
 
         /// <summary>Replace all array items.</summary>
-        Replace,
+        Replace = 2,
 
         /// <summary>Merge array items together, matched by index.</summary>
-        Merge
+        Merge = 3
     }
 }

Src/Newtonsoft.Json/MemberSerialization.cs

@@ -39,20 +39,20 @@ namespace Newtonsoft.Json
         /// All public members are serialized by default. Members can be excluded using <see cref="JsonIgnoreAttribute"/> or <see cref="NonSerializedAttribute"/>.
         /// This is the default member serialization mode.
         /// </summary>
-        OptOut,
+        OptOut = 0,
 
         /// <summary>
         /// Only members must be marked with <see cref="JsonPropertyAttribute"/> or <see cref="DataMemberAttribute"/> are serialized.
         /// This member serialization mode can also be set by marking the class with <see cref="DataContractAttribute"/>.
         /// </summary>
-        OptIn,
+        OptIn = 1,
 
         /// <summary>
         /// All public and private fields are serialized. Members can be excluded using <see cref="JsonIgnoreAttribute"/> or <see cref="NonSerializedAttribute"/>.
         /// This member serialization mode can also be set by marking the class with <see cref="SerializableAttribute"/>
         /// and setting IgnoreSerializableAttribute on <see cref="DefaultContractResolver"/> to false.
         /// </summary>
-        Fields
+        Fields = 2
 #pragma warning restore 1584,1711,1572,1581,1580,1574
     }
 }

Src/Newtonsoft.Json/Required.cs

@@ -33,16 +33,16 @@ namespace Newtonsoft.Json
         /// <summary>
         /// The property is not required. The default state.
         /// </summary>
-        Default,
+        Default = 0,
 
         /// <summary>
         /// The property must be defined in JSON but can be a null value.
         /// </summary>
-        AllowNull,
+        AllowNull = 1,
 
         /// <summary>
         /// The property must be defined in JSON and cannot be a null value.
         /// </summary>
-        Always
+        Always = 2
     }
 }

Src/Newtonsoft.Json/Serialization/JsonContract.cs

@@ -35,19 +35,19 @@ namespace Newtonsoft.Json.Serialization
 {
     internal enum JsonContractType
     {
-        None,
-        Object,
-        Array,
-        Primitive,
-        String,
-        Dictionary,
+        None = 0,
+        Object = 1,
+        Array = 2,
+        Primitive = 3,
+        String = 4,
+        Dictionary = 5,
 #if !(NET35 || NET20 || PORTABLE40)
-        Dynamic,
+        Dynamic = 6,
 #endif
 #if !(NETFX_CORE || PORTABLE || PORTABLE40)
-        Serializable,
+        Serializable = 7,
 #endif
-        Linq
+        Linq = 8
     }
 
     /// <summary>

Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs

@@ -52,9 +52,9 @@ namespace Newtonsoft.Json.Serialization
     {
         internal enum PropertyPresence
         {
-            None,
-            Null,
-            Value
+            None = 0,
+            Null = 1,
+            Value = 2
         }
 
         private JsonSerializerProxy _internalSerializer;

Src/Newtonsoft.Json/StringEscapeHandling.cs

@@ -33,16 +33,16 @@ namespace Newtonsoft.Json
         /// <summary>
         /// Only control characters (e.g. newline) are escaped.
         /// </summary>
-        Default,
+        Default = 0,
 
         /// <summary>
         /// All non-ASCII and control characters (e.g. newline) are escaped.
         /// </summary>
-        EscapeNonAscii,
+        EscapeNonAscii = 1,
 
         /// <summary>
         /// HTML (&lt;, &gt;, &amp;, &apos;, &quot;) and control characters (e.g. newline) are escaped.
         /// </summary>
-        EscapeHtml
+        EscapeHtml = 2
     }
 }

Src/Newtonsoft.Json/TraceLevel.cs

@@ -12,27 +12,27 @@ namespace Newtonsoft.Json
         /// <summary>
         /// Output no tracing and debugging messages.
         /// </summary>
-        Off,
+        Off = 0,
 
         /// <summary>
         /// Output error-handling messages.
         /// </summary>
-        Error,
+        Error = 1,
 
         /// <summary>
         /// Output warnings and error-handling messages.
         /// </summary>
-        Warning,
+        Warning = 2,
 
         /// <summary>
         /// Output informational messages, warnings, and error-handling messages.
         /// </summary>
-        Info,
+        Info = 3,
 
         /// <summary>
         /// Output all debugging and tracing messages.
         /// </summary>
-        Verbose
+        Verbose = 4
     }
 }
 

Src/Newtonsoft.Json/Utilities/ConvertUtils.cs

@@ -46,52 +46,52 @@ namespace Newtonsoft.Json.Utilities
 {
     internal enum PrimitiveTypeCode
     {
-        Empty,
-        Object,
-        Char,
-        CharNullable,
-        Boolean,
-        BooleanNullable,
-        SByte,
-        SByteNullable,
-        Int16,
-        Int16Nullable,
-        UInt16,
-        UInt16Nullable,
-        Int32,
-        Int32Nullable,
-        Byte,
-        ByteNullable,
-        UInt32,
-        UInt32Nullable,
-        Int64,
-        Int64Nullable,
-        UInt64,
-        UInt64Nullable,
-        Single,
-        SingleNullable,
-        Double,
-        DoubleNullable,
-        DateTime,
-        DateTimeNullable,
+        Empty = 0,
+        Object = 1,
+        Char = 2,
+        CharNullable = 3,
+        Boolean = 4,
+        BooleanNullable = 5,
+        SByte = 6,
+        SByteNullable = 7,
+        Int16 = 8,
+        Int16Nullable = 9,
+        UInt16 = 10,
+        UInt16Nullable = 11,
+        Int32 = 12,
+        Int32Nullable = 13,
+        Byte = 14,
+        ByteNullable = 15,
+        UInt32 = 16,
+        UInt32Nullable = 17,
+        Int64 = 18,
+        Int64Nullable = 19,
+        UInt64 = 20,
+        UInt64Nullable = 21,
+        Single = 22,
+        SingleNullable = 23,
+        Double = 24,
+        DoubleNullable = 25,
+        DateTime = 26,
+        DateTimeNullable = 27,
 #if !NET20
-        DateTimeOffset,
-        DateTimeOffsetNullable,
+        DateTimeOffset = 28,
+        DateTimeOffsetNullable = 29,
 #endif
-        Decimal,
-        DecimalNullable,
-        Guid,
-        GuidNullable,
-        TimeSpan,
-        TimeSpanNullable,
+        Decimal = 30,
+        DecimalNullable = 31,
+        Guid = 32,
+        GuidNullable = 33,
+        TimeSpan = 34,
+        TimeSpanNullable = 35,
 #if !(PORTABLE || NET35 || NET20)
-        BigInteger,
-        BigIntegerNullable,
+        BigInteger = 36,
+        BigIntegerNullable = 37,
 #endif
-        Uri,
-        String,
-        Bytes,
-        DBNull
+        Uri = 38,
+        String = 39,
+        Bytes = 40,
+        DBNull = 41
     }
 
     internal class TypeInformation
@@ -102,10 +102,10 @@ namespace Newtonsoft.Json.Utilities
 
     internal enum ParseResult
     {
-        None,
-        Success,
-        Overflow,
-        Invalid
+        None = 0,
+        Success = 1,
+        Overflow = 2,
+        Invalid = 3
     }
 
     internal static class ConvertUtils
@@ -360,10 +360,10 @@ namespace Newtonsoft.Json.Utilities
         #region TryConvert
         internal enum ConvertResult
         {
-            Success,
-            CannotConvertNull,
-            NotInstantiableType,
-            NoValidConversion
+            Success = 0,
+            CannotConvertNull = 1,
+            NotInstantiableType = 2,
+            NoValidConversion = 3
         }
 
         public static object Convert(object initialValue, CultureInfo culture, Type targetType)

Src/Newtonsoft.Json/Utilities/DateTimeParser.cs

@@ -29,10 +29,10 @@ namespace Newtonsoft.Json.Utilities
 {
     internal enum ParserTimeZone
     {
-        Unspecified,
-        Utc,
-        LocalWestOfUtc,
-        LocalEastOfUtc
+        Unspecified = 0,
+        Utc = 1,
+        LocalWestOfUtc = 2,
+        LocalEastOfUtc = 3
     }
 
     internal struct DateTimeParser

Src/Newtonsoft.Json/Utilities/ReflectionUtils.cs

@@ -46,11 +46,11 @@ namespace Newtonsoft.Json.Utilities
 #if (NETFX_CORE || PORTABLE || PORTABLE40)
     internal enum MemberTypes
     {
-        Property,
-        Field,
-        Event,
-        Method,
-        Other
+        Property = 0,
+        Field = 1,
+        Event = 2,
+        Method = 3,
+        Other = 4
     }
 #endif
 

Src/Newtonsoft.Json/WriteState.cs

@@ -37,36 +37,36 @@ namespace Newtonsoft.Json
         /// You may call the <see cref="JsonWriter.Close"/> method to put the <see cref="JsonWriter"/> in the <c>Closed</c> state.
         /// Any other <see cref="JsonWriter"/> method calls results in an <see cref="InvalidOperationException"/> being thrown. 
         /// </summary>
-        Error,
+        Error = 0,
 
         /// <summary>
         /// The <see cref="JsonWriter.Close"/> method has been called. 
         /// </summary>
-        Closed,
+        Closed = 1,
 
         /// <summary>
         /// An object is being written. 
         /// </summary>
-        Object,
+        Object = 2,
 
         /// <summary>
         /// A array is being written.
         /// </summary>
-        Array,
+        Array = 3,
 
         /// <summary>
         /// A constructor is being written.
         /// </summary>
-        Constructor,
+        Constructor = 4,
 
         /// <summary>
         /// A property is being written.
         /// </summary>
-        Property,
+        Property = 5,
 
         /// <summary>
         /// A write method has not been called.
         /// </summary>
-        Start
+        Start = 6
     }
 }