Rename Throw (#350)

bitfaster · web-flow · commit 83732d394a63 · 2023-04-28T17:27:38.000-07:00
* throw

* debug

---------
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
@@ -27,7 +27,7 @@ public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
         {
             if (cache == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
@@ -25,7 +25,7 @@ public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
         {
             if (cache == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
@@ -27,7 +27,7 @@ public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> c
         {
             if (cache == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
@@ -107,7 +107,7 @@ private async ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TFactory>(K key, TFacto
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
                 {
-                    Ex.ThrowScopedRetryFailure();
+                    Throw.ScopedRetryFailure();
                 }
             }
         }
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
@@ -26,7 +26,7 @@ public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)
         {
             if (cache == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
@@ -107,7 +107,7 @@ private Lifetime<V> ScopedGetOrAdd<TFactory>(K key, TFactory valueFactory) where
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
                 {
-                    Ex.ThrowScopedRetryFailure();
+                    Throw.ScopedRetryFailure();
                 }
             }
         }
diff --git a/BitFaster.Caching/Buffers/MpmcBoundedBuffer.cs b/BitFaster.Caching/Buffers/MpmcBoundedBuffer.cs
@@ -25,7 +25,7 @@ public MpmcBoundedBuffer(int boundedLength)
         {
             if (boundedLength < 0)
             {
-                Ex.ThrowArgOutOfRange(nameof(boundedLength));
+                Throw.ArgOutOfRange(nameof(boundedLength));
             }
 
             // must be power of 2 to use & slotsMask instead of %
diff --git a/BitFaster.Caching/Buffers/MpscBoundedBuffer.cs b/BitFaster.Caching/Buffers/MpscBoundedBuffer.cs
@@ -25,7 +25,7 @@ public MpscBoundedBuffer(int boundedLength)
         {
             if (boundedLength < 0)
             {
-                Ex.ThrowArgOutOfRange(nameof(boundedLength));
+                Throw.ArgOutOfRange(nameof(boundedLength));
             }
 
             // must be power of 2 to use & slotsMask instead of %
diff --git a/BitFaster.Caching/CacheDebugView.cs b/BitFaster.Caching/CacheDebugView.cs
@@ -13,7 +13,7 @@ public CacheDebugView(ICache<K, V> cache)
         {
             if (cache is null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
diff --git a/BitFaster.Caching/Lfu/LfuCapacityPartition.cs b/BitFaster.Caching/Lfu/LfuCapacityPartition.cs
@@ -122,7 +122,7 @@ private static (int window, int mainProtected, int mainProbation) ComputeQueueCa
         {
             if (capacity < 3)
             {
-                Ex.ThrowArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
+                Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
             }
 
             int window = capacity - (int)(mainPercentage * capacity);
diff --git a/BitFaster.Caching/Lfu/LfuNodeList.cs b/BitFaster.Caching/Lfu/LfuNodeList.cs
@@ -66,7 +66,7 @@ public void Remove(LfuNode<K, V> node)
         public void RemoveFirst()
         {
 #if DEBUG
-            if (head == null) { Ex.ThrowInvalidOp("List is empty."); }
+            if (head == null) { Throw.InvalidOp("List is empty."); }
 #endif
             InternalRemoveNode(head);
         }
@@ -125,12 +125,12 @@ internal static void ValidateNewNode(LfuNode<K, V> node)
         {
             if (node == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.node);
+                Throw.ArgNull(ExceptionArgument.node);
             }
 
             if (node.list != null)
             {
-                Ex.ThrowInvalidOp("Node is already attached to a list.");
+                Throw.InvalidOp("Node is already attached to a list.");
             }
         }
 
@@ -139,12 +139,12 @@ internal void ValidateNode(LfuNode<K, V> node)
         {
             if (node == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.node);
+                Throw.ArgNull(ExceptionArgument.node);
             }
 
             if (node.list != this)
             {
-                Ex.ThrowInvalidOp("Node is already attached to a different list.");
+                Throw.InvalidOp("Node is already attached to a different list.");
             }
         }
 #endif
@@ -173,7 +173,7 @@ object IEnumerator.Current
                 {
                     if (index == 0 || (index == list.Count + 1))
                     {
-                        Ex.ThrowInvalidOp("Out of bounds");
+                        Throw.InvalidOp("Out of bounds");
                     }
 
                     return Current;
diff --git a/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs b/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs
@@ -16,17 +16,17 @@ public static void Validate(this ICapacityPartition capacity)
         {
             if (capacity.Cold < 1)
             { 
-                Ex.ThrowArgOutOfRange(nameof(capacity.Cold));
+                Throw.ArgOutOfRange(nameof(capacity.Cold));
             }
 
             if (capacity.Warm < 1)
             {
-                Ex.ThrowArgOutOfRange(nameof(capacity.Warm));
+                Throw.ArgOutOfRange(nameof(capacity.Warm));
             }
 
             if (capacity.Hot < 1)
             {
-                Ex.ThrowArgOutOfRange(nameof(capacity.Hot));
+                Throw.ArgOutOfRange(nameof(capacity.Hot));
             }
         }
     }
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -47,12 +47,12 @@ public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> compa
         {
             if (capacity < 3)
             {
-                Ex.ThrowArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
+                Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
             }
 
             if (comparer == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.comparer);
+                Throw.ArgNull(ExceptionArgument.comparer);
             }
 
             this.capacity = capacity;
@@ -353,7 +353,7 @@ public void Trim(int itemCount)
         {
             if (itemCount < 1 || itemCount > this.capacity)
             {
-                Ex.ThrowArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
+                Throw.ArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
             }
 
             for (int i = 0; i < itemCount; i++)
diff --git a/BitFaster.Caching/Lru/ConcurrentLruCore.cs b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
@@ -77,12 +77,12 @@ public ConcurrentLruCore(
         {
             if (capacity == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.capacity);
+                Throw.ArgNull(ExceptionArgument.capacity);
             }
 
             if (comparer == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.comparer);
+                Throw.ArgNull(ExceptionArgument.comparer);
             }
 
             capacity.Validate();
@@ -419,7 +419,7 @@ public void Trim(int itemCount)
 
             if (itemCount < 1 || itemCount > capacity)
             {
-                Ex.ThrowArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
+                Throw.ArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
             }
 
             // clamp itemCount to number of items actually in the cache
diff --git a/BitFaster.Caching/Lru/EqualCapacityPartition.cs b/BitFaster.Caching/Lru/EqualCapacityPartition.cs
@@ -38,7 +38,7 @@ private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity)
         {
             if (capacity < 3)
             {
-                Ex.ThrowArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
+                Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
             }
 
             int hotCapacity = capacity / 3;
diff --git a/BitFaster.Caching/Lru/FavorWarmPartition.cs b/BitFaster.Caching/Lru/FavorWarmPartition.cs
@@ -55,12 +55,12 @@ private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity,
         {
             if (capacity < 3)
             {
-                Ex.ThrowArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
+                Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
             }
 
             if (warmRatio <= 0.0 || warmRatio >= 1.0)
             {
-                Ex.ThrowArgOutOfRange(nameof(warmRatio), "warmRatio must be between 0.0 and 1.0");
+                Throw.ArgOutOfRange(nameof(warmRatio), "warmRatio must be between 0.0 and 1.0");
             }
 
             int warm2 = (int)(capacity * warmRatio);
diff --git a/BitFaster.Caching/Lru/StopwatchTickConverter.cs b/BitFaster.Caching/Lru/StopwatchTickConverter.cs
@@ -17,7 +17,7 @@ internal static long ToTicks(TimeSpan timespan)
             if (timespan <= TimeSpan.Zero || timespan.Ticks >= maxTicks)
             {
                 TimeSpan maxRepresentable = TimeSpan.FromTicks((long)maxTicks);
-                Ex.ThrowArgOutOfRange(nameof(timespan), $"Value must be greater than zero and less than {maxRepresentable}");
+                Throw.ArgOutOfRange(nameof(timespan), $"Value must be greater than zero and less than {maxRepresentable}");
             }
 
             return (long)(timespan.Ticks * stopwatchAdjustmentFactor);
diff --git a/BitFaster.Caching/Lru/TlruTickCount64Policy.cs b/BitFaster.Caching/Lru/TlruTickCount64Policy.cs
@@ -32,7 +32,7 @@ public TLruLongTicksPolicy(TimeSpan timeToLive)
             TimeSpan maxRepresentable = TimeSpan.FromTicks(9223372036854769664);
             if (timeToLive <= TimeSpan.Zero || timeToLive > maxRepresentable)
             {
-                Ex.ThrowArgOutOfRange(nameof(timeToLive), $"Value must greater than zero and less than {maxRepresentable}");
+                Throw.ArgOutOfRange(nameof(timeToLive), $"Value must greater than zero and less than {maxRepresentable}");
             }
 
             this.timeToLive = (long)timeToLive.TotalMilliseconds;
diff --git a/BitFaster.Caching/Scoped.cs b/BitFaster.Caching/Scoped.cs
@@ -70,7 +70,7 @@ public Lifetime<T> CreateLifetime()
         {
             if (!TryCreateLifetime(out var lifetime))
             {
-                Ex.ThrowDisposed<T>();
+                Throw.Disposed<T>();
             }
 
             return lifetime;
@@ -127,7 +127,7 @@ public ScopedDebugView(Scoped<T> scoped)
             {
                 if (scoped is null)
                 {
-                    Ex.ThrowArgNull(ExceptionArgument.scoped);
+                    Throw.ArgNull(ExceptionArgument.scoped);
                 }
 
                 this.scoped = scoped;
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -29,7 +29,7 @@ public ScopedAsyncCache(IAsyncCache<K, Scoped<V>> cache)
         {
             if (cache == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
@@ -80,7 +80,7 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scop
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
                 {
-                    Ex.ThrowScopedRetryFailure();
+                    Throw.ScopedRetryFailure();
                 }
             }
         }
diff --git a/BitFaster.Caching/ScopedAsyncCacheDebugView.cs b/BitFaster.Caching/ScopedAsyncCacheDebugView.cs
@@ -13,7 +13,7 @@ public ScopedAsyncCacheDebugView(IScopedAsyncCache<K, V> cache)
         {
             if (cache is null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs
@@ -27,7 +27,7 @@ public ScopedCache(ICache<K, Scoped<V>> cache)
         {
             if (cache == null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
@@ -78,7 +78,7 @@ public Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory)
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
                 {
-                    Ex.ThrowScopedRetryFailure();
+                    Throw.ScopedRetryFailure();
                 }
             }
         }
diff --git a/BitFaster.Caching/ScopedCacheDebugView.cs b/BitFaster.Caching/ScopedCacheDebugView.cs
@@ -13,7 +13,7 @@ public ScopedCacheDebugView(IScopedCache<K, V> cache)
         {
             if (cache is null)
             {
-                Ex.ThrowArgNull(ExceptionArgument.cache);
+                Throw.ArgNull(ExceptionArgument.cache);
             }
 
             this.cache = cache;
diff --git a/BitFaster.Caching/Throw.cs b/BitFaster.Caching/Throw.cs
@@ -5,20 +5,20 @@
 
 namespace BitFaster.Caching
 {
-    internal static class Ex
+    internal static class Throw
     {
-        public static void ThrowArgNull(ExceptionArgument arg) => throw CreateArgumentNullException(arg);
+        public static void ArgNull(ExceptionArgument arg) => throw CreateArgumentNullException(arg);
 
-        public static void ThrowArgOutOfRange(string paramName) => throw CreateArgumentOutOfRangeException(paramName);
+        public static void ArgOutOfRange(string paramName) => throw CreateArgumentOutOfRangeException(paramName);
 
-        public static void ThrowArgOutOfRange(string paramName, string message) => throw CreateArgumentOutOfRangeException(paramName, message);
+        public static void ArgOutOfRange(string paramName, string message) => throw CreateArgumentOutOfRangeException(paramName, message);
 
         [ExcludeFromCodeCoverage]
-        public static void ThrowInvalidOp(string message) => throw CreateInvalidOperationException(message);
+        public static void InvalidOp(string message) => throw CreateInvalidOperationException(message);
 
-        public static void ThrowScopedRetryFailure() => throw CreateScopedRetryFailure();
+        public static void ScopedRetryFailure() => throw CreateScopedRetryFailure();
 
-        public static void ThrowDisposed<T>() => throw CreateObjectDisposedException<T>();
+        public static void Disposed<T>() => throw CreateObjectDisposedException<T>();
 
         [MethodImpl(MethodImplOptions.NoInlining)]
         private static ArgumentNullException CreateArgumentNullException(ExceptionArgument arg) => new ArgumentNullException(GetArgumentString(arg));

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)`
`27`	`27`	`{`
`28`	`28`	`if (cache == null)`
`29`	`29`	`{`
`30`		`- Ex.ThrowArgNull(ExceptionArgument.cache);`
	`30`	`+ Throw.ArgNull(ExceptionArgument.cache);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`this.cache = cache;`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)`
`25`	`25`	`{`
`26`	`26`	`if (cache == null)`
`27`	`27`	`{`
`28`		`- Ex.ThrowArgNull(ExceptionArgument.cache);`
	`28`	`+ Throw.ArgNull(ExceptionArgument.cache);`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`this.cache = cache;`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> c`
`27`	`27`	`{`
`28`	`28`	`if (cache == null)`
`29`	`29`	`{`
`30`		`- Ex.ThrowArgNull(ExceptionArgument.cache);`
	`30`	`+ Throw.ArgNull(ExceptionArgument.cache);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`this.cache = cache;`
`@@ -107,7 +107,7 @@ private async ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TFactory>(K key, TFacto`
`107`	`107`
`108`	`108`	`if (c++ > ScopedCacheDefaults.MaxRetry)`
`109`	`109`	`{`
`110`		`- Ex.ThrowScopedRetryFailure();`
	`110`	`+ Throw.ScopedRetryFailure();`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)`
`26`	`26`	`{`
`27`	`27`	`if (cache == null)`
`28`	`28`	`{`
`29`		`- Ex.ThrowArgNull(ExceptionArgument.cache);`
	`29`	`+ Throw.ArgNull(ExceptionArgument.cache);`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`this.cache = cache;`
`@@ -107,7 +107,7 @@ private Lifetime<V> ScopedGetOrAdd<TFactory>(K key, TFactory valueFactory) where`
`107`	`107`
`108`	`108`	`if (c++ > ScopedCacheDefaults.MaxRetry)`
`109`	`109`	`{`
`110`		`- Ex.ThrowScopedRetryFailure();`
	`110`	`+ Throw.ScopedRetryFailure();`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public MpmcBoundedBuffer(int boundedLength)`
`25`	`25`	`{`
`26`	`26`	`if (boundedLength < 0)`
`27`	`27`	`{`
`28`		`- Ex.ThrowArgOutOfRange(nameof(boundedLength));`
	`28`	`+ Throw.ArgOutOfRange(nameof(boundedLength));`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// must be power of 2 to use & slotsMask instead of %`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public MpscBoundedBuffer(int boundedLength)`
`25`	`25`	`{`
`26`	`26`	`if (boundedLength < 0)`
`27`	`27`	`{`
`28`		`- Ex.ThrowArgOutOfRange(nameof(boundedLength));`
	`28`	`+ Throw.ArgOutOfRange(nameof(boundedLength));`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// must be power of 2 to use & slotsMask instead of %`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public CacheDebugView(ICache<K, V> cache)`
`13`	`13`	`{`
`14`	`14`	`if (cache is null)`
`15`	`15`	`{`
`16`		`- Ex.ThrowArgNull(ExceptionArgument.cache);`
	`16`	`+ Throw.ArgNull(ExceptionArgument.cache);`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`this.cache = cache;`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ private static (int window, int mainProtected, int mainProbation) ComputeQueueCa`
`122`	`122`	`{`
`123`	`123`	`if (capacity < 3)`
`124`	`124`	`{`
`125`		`- Ex.ThrowArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");`
	`125`	`+ Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`int window = capacity - (int)(mainPercentage * capacity);`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public void Remove(LfuNode<K, V> node)`
`66`	`66`	`public void RemoveFirst()`
`67`	`67`	`{`
`68`	`68`	`#if DEBUG`
`69`		`- if (head == null) { Ex.ThrowInvalidOp("List is empty."); }`
	`69`	`+ if (head == null) { Throw.InvalidOp("List is empty."); }`
`70`	`70`	`#endif`
`71`	`71`	`InternalRemoveNode(head);`
`72`	`72`	`}`
`@@ -125,12 +125,12 @@ internal static void ValidateNewNode(LfuNode<K, V> node)`
`125`	`125`	`{`
`126`	`126`	`if (node == null)`
`127`	`127`	`{`
`128`		`- Ex.ThrowArgNull(ExceptionArgument.node);`
	`128`	`+ Throw.ArgNull(ExceptionArgument.node);`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`if (node.list != null)`
`132`	`132`	`{`
`133`		`- Ex.ThrowInvalidOp("Node is already attached to a list.");`
	`133`	`+ Throw.InvalidOp("Node is already attached to a list.");`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`@@ -139,12 +139,12 @@ internal void ValidateNode(LfuNode<K, V> node)`
`139`	`139`	`{`
`140`	`140`	`if (node == null)`
`141`	`141`	`{`
`142`		`- Ex.ThrowArgNull(ExceptionArgument.node);`
	`142`	`+ Throw.ArgNull(ExceptionArgument.node);`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`if (node.list != this)`
`146`	`146`	`{`
`147`		`- Ex.ThrowInvalidOp("Node is already attached to a different list.");`
	`147`	`+ Throw.InvalidOp("Node is already attached to a different list.");`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`	`#endif`
`@@ -173,7 +173,7 @@ object IEnumerator.Current`
`173`	`173`	`{`
`174`	`174`	`if (index == 0 \|\| (index == list.Count + 1))`
`175`	`175`	`{`
`176`		`- Ex.ThrowInvalidOp("Out of bounds");`
	`176`	`+ Throw.InvalidOp("Out of bounds");`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`return Current;`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,17 @@ public static void Validate(this ICapacityPartition capacity)`
`16`	`16`	`{`
`17`	`17`	`if (capacity.Cold < 1)`
`18`	`18`	`{`
`19`		`- Ex.ThrowArgOutOfRange(nameof(capacity.Cold));`
	`19`	`+ Throw.ArgOutOfRange(nameof(capacity.Cold));`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`if (capacity.Warm < 1)`
`23`	`23`	`{`
`24`		`- Ex.ThrowArgOutOfRange(nameof(capacity.Warm));`
	`24`	`+ Throw.ArgOutOfRange(nameof(capacity.Warm));`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`if (capacity.Hot < 1)`
`28`	`28`	`{`
`29`		`- Ex.ThrowArgOutOfRange(nameof(capacity.Hot));`
	`29`	`+ Throw.ArgOutOfRange(nameof(capacity.Hot));`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`