ArraySegment<T> exceptions to ThrowHelper (#7058)

benaadams · jkotas · commit a90f60e90ef5 · 2016-09-06T07:23:37.000-07:00
diff --git a/src/mscorlib/src/System/ArraySegment.cs b/src/mscorlib/src/System/ArraySegment.cs
@@ -35,7 +35,7 @@ public struct ArraySegment<T> : IList<T>, IReadOnlyList<T>
         public ArraySegment(T[] array)
         {
             if (array == null)
-                throw new ArgumentNullException("array");
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
             Contract.EndContractBlock();
 
             _array = array;
@@ -46,13 +46,13 @@ public ArraySegment(T[] array)
         public ArraySegment(T[] array, int offset, int count)
         {
             if (array == null)
-                throw new ArgumentNullException("array");
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
             if (offset < 0)
-                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.offset, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
             if (array.Length - offset < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
+                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
             Contract.EndContractBlock();
 
             _array = array;
@@ -146,9 +146,9 @@ T IList<T>.this[int index]
             get
             {
                 if (_array == null)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
                 if (index < 0 || index >=  _count)
-                    throw new ArgumentOutOfRangeException("index");
+                    ThrowHelper.ThrowArgumentOutOfRange_IndexException();
                 Contract.EndContractBlock();
 
                 return _array[_offset + index];
@@ -157,9 +157,9 @@ T IList<T>.this[int index]
             set
             {
                 if (_array == null)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
                 if (index < 0 || index >= _count)
-                    throw new ArgumentOutOfRangeException("index");
+                    ThrowHelper.ThrowArgumentOutOfRange_IndexException();
                 Contract.EndContractBlock();
 
                 _array[_offset + index] = value;
@@ -169,7 +169,7 @@ T IList<T>.this[int index]
         int IList<T>.IndexOf(T item)
         {
             if (_array == null)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
             Contract.EndContractBlock();
 
             int index = System.Array.IndexOf<T>(_array, item, _offset, _count);
@@ -182,12 +182,12 @@ int IList<T>.IndexOf(T item)
 
         void IList<T>.Insert(int index, T item)
         {
-            throw new NotSupportedException();
+            ThrowHelper.ThrowNotSupportedException();
         }
 
         void IList<T>.RemoveAt(int index)
         {
-            throw new NotSupportedException();
+            ThrowHelper.ThrowNotSupportedException();
         }
         #endregion
 
@@ -197,9 +197,9 @@ T IReadOnlyList<T>.this[int index]
             get
             {
                 if (_array == null)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
                 if (index < 0 || index >= _count)
-                    throw new ArgumentOutOfRangeException("index");
+                    ThrowHelper.ThrowArgumentOutOfRange_IndexException();
                 Contract.EndContractBlock();
 
                 return _array[_offset + index];
@@ -220,18 +220,18 @@ bool ICollection<T>.IsReadOnly
 
         void ICollection<T>.Add(T item)
         {
-            throw new NotSupportedException();
+            ThrowHelper.ThrowNotSupportedException();
         }
 
         void ICollection<T>.Clear()
         {
-            throw new NotSupportedException();
+            ThrowHelper.ThrowNotSupportedException();
         }
 
         bool ICollection<T>.Contains(T item)
         {
             if (_array == null)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
             Contract.EndContractBlock();
 
             int index = System.Array.IndexOf<T>(_array, item, _offset, _count);
@@ -245,23 +245,24 @@ bool ICollection<T>.Contains(T item)
         void ICollection<T>.CopyTo(T[] array, int arrayIndex)
         {
             if (_array == null)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
             Contract.EndContractBlock();
 
             System.Array.Copy(_array, _offset, array, arrayIndex, _count);
         }
 
         bool ICollection<T>.Remove(T item)
         {
-            throw new NotSupportedException();
+            ThrowHelper.ThrowNotSupportedException();
+            return default(bool);
         }
         #endregion
 
         #region IEnumerable<T>
         IEnumerator<T> IEnumerable<T>.GetEnumerator()
         {
             if (_array == null)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
             Contract.EndContractBlock();
 
             return new ArraySegmentEnumerator(this);
@@ -272,7 +273,7 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
         IEnumerator IEnumerable.GetEnumerator()
         {
             if (_array == null)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
             Contract.EndContractBlock();
 
             return new ArraySegmentEnumerator(this);
@@ -314,8 +315,8 @@ public T Current
             {
                 get
                 {
-                    if (_current < _start) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
-                    if (_current >= _end) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
+                    if (_current < _start) ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumNotStarted);
+                    if (_current >= _end) ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumEnded);
                     return _array[_current];
                 }
             }
diff --git a/src/mscorlib/src/System/ThrowHelper.cs b/src/mscorlib/src/System/ThrowHelper.cs
@@ -110,6 +110,11 @@ internal static void ThrowObjectDisposedException(string objectName, ExceptionRe
             throw new ObjectDisposedException(objectName, Environment.GetResourceString(GetResourceName(resource)));
         }
 
+        internal static void ThrowNotSupportedException()
+        {
+            throw new NotSupportedException();
+        }
+
         // Allow nulls for reference types and Nullable<U>, but not for value types.
         // Aggressively inline so the jit evaluates the if in place and either drops the call altogether
         // Or just leaves null test and call to the Non-returning ThrowHelper.ThrowArgumentNullException
@@ -171,7 +176,9 @@ internal enum ExceptionArgument {
         view,
         sourceBytesToCopy,
         action,
-        comparison
+        comparison,
+        offset,
+
     }
 
     //
@@ -225,7 +232,9 @@ internal enum ExceptionResource {
         ObjectDisposed_RegKeyClosed,
         NotSupported_InComparableType,
         Argument_InvalidRegistryOptionsCheck,
-        Argument_InvalidRegistryViewCheck
+        Argument_InvalidRegistryViewCheck,
+        InvalidOperation_NullArray,
+
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public struct ArraySegment<T> : IList<T>, IReadOnlyList<T>`
`35`	`35`	`public ArraySegment(T[] array)`
`36`	`36`	`{`
`37`	`37`	`if (array == null)`
`38`		`- throw new ArgumentNullException("array");`
	`38`	`+ ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);`
`39`	`39`	`Contract.EndContractBlock();`
`40`	`40`
`41`	`41`	`_array = array;`
`@@ -46,13 +46,13 @@ public ArraySegment(T[] array)`
`46`	`46`	`public ArraySegment(T[] array, int offset, int count)`
`47`	`47`	`{`
`48`	`48`	`if (array == null)`
`49`		`- throw new ArgumentNullException("array");`
	`49`	`+ ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);`
`50`	`50`	`if (offset < 0)`
`51`		`- throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));`
	`51`	`+ ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.offset, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);`
`52`	`52`	`if (count < 0)`
`53`		`- throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));`
	`53`	`+ ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);`
`54`	`54`	`if (array.Length - offset < count)`
`55`		`- throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));`
	`55`	`+ ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);`
`56`	`56`	`Contract.EndContractBlock();`
`57`	`57`
`58`	`58`	`_array = array;`
`@@ -146,9 +146,9 @@ T IList<T>.this[int index]`
`146`	`146`	`get`
`147`	`147`	`{`
`148`	`148`	`if (_array == null)`
`149`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`149`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`150`	`150`	`if (index < 0 \|\| index >= _count)`
`151`		`- throw new ArgumentOutOfRangeException("index");`
	`151`	`+ ThrowHelper.ThrowArgumentOutOfRange_IndexException();`
`152`	`152`	`Contract.EndContractBlock();`
`153`	`153`
`154`	`154`	`return _array[_offset + index];`
`@@ -157,9 +157,9 @@ T IList<T>.this[int index]`
`157`	`157`	`set`
`158`	`158`	`{`
`159`	`159`	`if (_array == null)`
`160`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`160`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`161`	`161`	`if (index < 0 \|\| index >= _count)`
`162`		`- throw new ArgumentOutOfRangeException("index");`
	`162`	`+ ThrowHelper.ThrowArgumentOutOfRange_IndexException();`
`163`	`163`	`Contract.EndContractBlock();`
`164`	`164`
`165`	`165`	`_array[_offset + index] = value;`
`@@ -169,7 +169,7 @@ T IList<T>.this[int index]`
`169`	`169`	`int IList<T>.IndexOf(T item)`
`170`	`170`	`{`
`171`	`171`	`if (_array == null)`
`172`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`172`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`173`	`173`	`Contract.EndContractBlock();`
`174`	`174`
`175`	`175`	`int index = System.Array.IndexOf<T>(_array, item, _offset, _count);`
`@@ -182,12 +182,12 @@ int IList<T>.IndexOf(T item)`
`182`	`182`
`183`	`183`	`void IList<T>.Insert(int index, T item)`
`184`	`184`	`{`
`185`		`- throw new NotSupportedException();`
	`185`	`+ ThrowHelper.ThrowNotSupportedException();`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`void IList<T>.RemoveAt(int index)`
`189`	`189`	`{`
`190`		`- throw new NotSupportedException();`
	`190`	`+ ThrowHelper.ThrowNotSupportedException();`
`191`	`191`	`}`
`192`	`192`	`#endregion`
`193`	`193`
`@@ -197,9 +197,9 @@ T IReadOnlyList<T>.this[int index]`
`197`	`197`	`get`
`198`	`198`	`{`
`199`	`199`	`if (_array == null)`
`200`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`200`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`201`	`201`	`if (index < 0 \|\| index >= _count)`
`202`		`- throw new ArgumentOutOfRangeException("index");`
	`202`	`+ ThrowHelper.ThrowArgumentOutOfRange_IndexException();`
`203`	`203`	`Contract.EndContractBlock();`
`204`	`204`
`205`	`205`	`return _array[_offset + index];`
`@@ -220,18 +220,18 @@ bool ICollection<T>.IsReadOnly`
`220`	`220`
`221`	`221`	`void ICollection<T>.Add(T item)`
`222`	`222`	`{`
`223`		`- throw new NotSupportedException();`
	`223`	`+ ThrowHelper.ThrowNotSupportedException();`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`void ICollection<T>.Clear()`
`227`	`227`	`{`
`228`		`- throw new NotSupportedException();`
	`228`	`+ ThrowHelper.ThrowNotSupportedException();`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`bool ICollection<T>.Contains(T item)`
`232`	`232`	`{`
`233`	`233`	`if (_array == null)`
`234`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`234`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`235`	`235`	`Contract.EndContractBlock();`
`236`	`236`
`237`	`237`	`int index = System.Array.IndexOf<T>(_array, item, _offset, _count);`
`@@ -245,23 +245,24 @@ bool ICollection<T>.Contains(T item)`
`245`	`245`	`void ICollection<T>.CopyTo(T[] array, int arrayIndex)`
`246`	`246`	`{`
`247`	`247`	`if (_array == null)`
`248`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`248`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`249`	`249`	`Contract.EndContractBlock();`
`250`	`250`
`251`	`251`	`System.Array.Copy(_array, _offset, array, arrayIndex, _count);`
`252`	`252`	`}`
`253`	`253`
`254`	`254`	`bool ICollection<T>.Remove(T item)`
`255`	`255`	`{`
`256`		`- throw new NotSupportedException();`
	`256`	`+ ThrowHelper.ThrowNotSupportedException();`
	`257`	`+ return default(bool);`
`257`	`258`	`}`
`258`	`259`	`#endregion`
`259`	`260`
`260`	`261`	`#region IEnumerable<T>`
`261`	`262`	`IEnumerator<T> IEnumerable<T>.GetEnumerator()`
`262`	`263`	`{`
`263`	`264`	`if (_array == null)`
`264`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`265`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`265`	`266`	`Contract.EndContractBlock();`
`266`	`267`
`267`	`268`	`return new ArraySegmentEnumerator(this);`
`@@ -272,7 +273,7 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()`
`272`	`273`	`IEnumerator IEnumerable.GetEnumerator()`
`273`	`274`	`{`
`274`	`275`	`if (_array == null)`
`275`		`- throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullArray"));`
	`276`	`+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);`
`276`	`277`	`Contract.EndContractBlock();`
`277`	`278`
`278`	`279`	`return new ArraySegmentEnumerator(this);`
`@@ -314,8 +315,8 @@ public T Current`
`314`	`315`	`{`
`315`	`316`	`get`
`316`	`317`	`{`
`317`		`- if (_current < _start) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));`
`318`		`- if (_current >= _end) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));`
	`318`	`+ if (_current < _start) ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumNotStarted);`
	`319`	`+ if (_current >= _end) ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumEnded);`
`319`	`320`	`return _array[_current];`
`320`	`321`	`}`
`321`	`322`	`}`