Fx

System\Runtime\ActionItem.cs (39)

System\Runtime\AsyncEventArgs.cs (5)

9[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking, SupportsAsync = true, ReleaseMethod = "Complete")] 40throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.AsyncEventArgsCompletionPending(GetType()))); 53throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.AsyncEventArgsCompletedTwice(GetType()))); 93throw Fx.Exception.ArgumentNull("callback");

System\Runtime\AsyncResult.cs (20)

System\Runtime\AsyncWaitHandle.cs (11)

11[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.MonitorWait, SupportsAsync = true, ReleaseMethod = "Set")] 20[Fx.Tag.SynchronizationObject(Kind = Fx.Tag.SynchronizationKind.MonitorWait)] 97[Fx.Tag.Blocking] 214[Fx.Tag.SecurityNote(Critical = "Store the delegate to be invoked")] 217[Fx.Tag.SecurityNote(Critical = "Stores the state object to be passed to the callback")] 223[Fx.Tag.SecurityNote(Critical = "Access critical members", Safe = "Doesn't leak information")] 244[Fx.Tag.SecurityNote(Critical = "Calls into critical method Schedule", Safe = "Invokes the given delegate under the current context")] 251[Fx.Tag.SecurityNote(Critical = "Overriding an inherited critical method, access critical members")] 263throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.MustCancelOldTimer));

System\Runtime\BufferedOutputStream.cs (24)

13[Fx.Tag.Cache(typeof(byte), Fx.Tag.CacheAttrition.None, Scope = Fx.Tag.Strings.ExternallyManaged, 14SizeLimit = Fx.Tag.Strings.ExternallyManaged)] 17[Fx.Tag.Queue(typeof(byte), SizeLimit = "BufferedOutputStream(maxSize)", 84throw Fx.Exception.AsError(new NotSupportedException(InternalSR.SeekNotSupported)); 88throw Fx.Exception.AsError(new NotSupportedException(InternalSR.SeekNotSupported)); 99Fx.Assert(!this.initialized, "Clear must be called before re-initializing stream"); 140throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ReadNotSupported)); 145throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ReadNotSupported)); 187throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ReadNotSupported)); 192throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ReadNotSupported)); 197throw Fx.Exception.AsError(new NotSupportedException(InternalSR.SeekNotSupported)); 202throw Fx.Exception.AsError(new NotSupportedException(InternalSR.SeekNotSupported)); 214Fx.Assert(this.initialized, "No data to return from uninitialized stream"); 215Fx.Assert(!this.bufferReturned, "ToArray cannot be called more than once"); 260Fx.Assert(this.initialized, "Cannot write to uninitialized stream"); 261Fx.Assert(!this.bufferReturned, "Cannot write to stream once ToArray has been called."); 265throw Fx.Exception.ArgumentOutOfRange("size", size, InternalSR.ValueMustBeNonNegative); 270throw Fx.Exception.AsError(CreateQuotaExceededException(this.maxSizeQuota)); 276throw Fx.Exception.AsError(CreateQuotaExceededException(this.maxSizeQuota)); 305Fx.Assert(this.initialized, "Cannot write to uninitialized stream"); 306Fx.Assert(!this.bufferReturned, "Cannot write to stream once ToArray has been called."); 310throw Fx.Exception.AsError(CreateQuotaExceededException(this.maxSize));

System\Runtime\CallbackException.cs (3)

21Fx.Assert(innerException != null, "CallbackException requires an inner exception."); 22Fx.Assert(!Fx.IsFatal(innerException), "CallbackException can't be used to wrap fatal exceptions.");

System\Runtime\Collections\HopperCache.cs (6)

63Fx.Assert(hopperSize > 0, "HopperCache hopperSize must be positive."); 76Fx.Assert(key != null, "HopperCache key cannot be null."); 77Fx.Assert(value != null, "HopperCache value cannot be null."); 85Fx.Assert(this.strongHopper.Count <= this.hopperSize * 2, 113Fx.Assert(key != null, "Can't look up a null key."); 176Fx.Assert(this.outstandingHopper.Count <= this.hopperSize,

System\Runtime\Collections\NullableKeyDictionary.cs (8)

60throw Fx.Exception.AsError(new KeyNotFoundException()); 88throw Fx.Exception.Argument("key", InternalSR.NullKeyAlreadyPresent); 250throw Fx.Exception.AsError(new NotSupportedException(InternalSR.KeyCollectionUpdatesNotAllowed)); 255throw Fx.Exception.AsError(new NotSupportedException(InternalSR.KeyCollectionUpdatesNotAllowed)); 274throw Fx.Exception.AsError(new NotSupportedException(InternalSR.KeyCollectionUpdatesNotAllowed)); 325throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ValueCollectionUpdatesNotAllowed)); 330throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ValueCollectionUpdatesNotAllowed)); 350throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ValueCollectionUpdatesNotAllowed));

System\Runtime\Collections\ObjectCache.cs (15)

39Fx.Assert(settings != null, "caller must use a valid settings object"); 75Fx.Assert(key != null, "caller must validate parameters"); 76Fx.Assert(value != null, "caller must validate parameters"); 99Fx.Assert(key != null, "caller must validate parameters"); 118Fx.Assert(createdObject != null, "initializer delegate must always give us a valid object"); 168Fx.Assert(removedFromItems, "we should always find the key"); 203Fx.Assert(!item.Equals(default(T)), "item should never be null"); 407Fx.Assert(this.parent.cacheItems.ContainsValue(this), "should have a valid value"); 408Fx.Assert(this.Value != null, "should have a valid value"); 428Fx.Assert(this.referenceCount == 1, "reference count should have never increased"); 458Fx.Assert(this.referenceCount >= 0, "cannot take the item marked for disposal"); 464Fx.Assert(this.referenceCount > 0, "can only release an item that has references"); 471Fx.Assert(this.referenceCount == 0, "we should only dispose items without references"); 482Fx.Assert(localDisposeItemCallback == null, "shouldn't have both this.disposeItemCallback and this.parent"); 502Fx.Assert(this.referenceCount == -1, "we should only dispose items that have had LockedDispose called on them");

System\Runtime\Collections\ObjectCacheSettings.cs (4)

48Fx.Assert(value >= 0, "caller should validate cache limit is non-negative"); 61Fx.Assert(value >= TimeSpan.Zero, "caller should validate cache limit is non-negative"); 74Fx.Assert(value >= TimeSpan.Zero, "caller should validate cache limit is non-negative"); 87Fx.Assert(value >= 0, "caller should validate purge frequency is non-negative");

System\Runtime\Collections\OrderedDictionary.cs (10)

58throw Fx.Exception.ArgumentNull("key"); 67throw Fx.Exception.AsError(new KeyNotFoundException(InternalSR.KeyNotFoundInDictionary)); 74throw Fx.Exception.ArgumentNull("key"); 128throw Fx.Exception.ArgumentNull("key"); 155throw Fx.Exception.ArgumentNull("key"); 165throw Fx.Exception.ArgumentNull("array"); 170throw Fx.Exception.AsError(new ArgumentOutOfRangeException("arrayIndex")); 175throw Fx.Exception.Argument("array", InternalSR.BadCopyToArray); 216throw Fx.Exception.ArgumentNull("key"); 234throw Fx.Exception.ArgumentNull("key");

System\Runtime\CompletedAsyncResult.cs (6)

19[Fx.Tag.GuaranteeNonBlocking] 22Fx.AssertAndThrowFatal(result.IsCompleted, "CompletedAsyncResult was not completed!"); 38[Fx.Tag.GuaranteeNonBlocking] 41Fx.AssertAndThrowFatal(result.IsCompleted, "CompletedAsyncResult<T> was not completed!"); 60[Fx.Tag.GuaranteeNonBlocking] 63Fx.AssertAndThrowFatal(result.IsCompleted, "CompletedAsyncResult<T> was not completed!");

System\Runtime\Diagnostics\DiagnosticEventProvider.cs (16)

25[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of UnsafeNativeMethods.EtwEnableCallback")] 202[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 391[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 399throw Fx.Exception.AsError(new ArgumentNullException("eventMessage")); 438[Fx.Tag.SecurityNote(Critical = "Accesses security critical code WriteMessageEvent")] 451[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 527throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", 566throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", 644[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 700[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 730[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 737Fx.Assert(false, "eventTraceActivity should not be null for WriteTransferEvent"); 754throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", 793throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", 863[Fx.Tag.SecurityNote(Critical = "Calling Unsafe code; usage of EventDescriptor, which is protected by a LinkDemand")] 869throw Fx.Exception.ArgumentNull("eventTraceActivity");

System\Runtime\Diagnostics\DiagnosticTraceBase.cs (17)

System\Runtime\Diagnostics\EtwDiagnosticTrace.cs (34)

System\Runtime\Diagnostics\EtwProvider.cs (29)

System\Runtime\Diagnostics\EventDescriptor.cs (4)

40throw Fx.Exception.ArgumentOutOfRange("id", id, InternalSR.ValueMustBeNonNegative); 45throw Fx.Exception.ArgumentOutOfRange("id", id, string.Empty); 57throw Fx.Exception.ArgumentOutOfRange("task", task, InternalSR.ValueMustBeNonNegative); 62throw Fx.Exception.ArgumentOutOfRange("task", task, string.Empty);

System\Runtime\Diagnostics\EventLogger.cs (13)

System\Runtime\Diagnostics\EventTraceActivity.cs (3)

53[Fx.Tag.SecurityNote(Critical = "Critical because the CorrelationManager property has a link demand on UnmanagedCode.", 72[Fx.Tag.SecurityNote(Critical = "Critical because the CorrelationManager property has a link demand on UnmanagedCode.", 85[Fx.Tag.SecurityNote(Critical = "Critical because the CorrelationManager property has a link demand on UnmanagedCode.",

System\Runtime\DuplicateDetector.cs (4)

18Fx.Assert(capacity >= 0, "The capacity parameter must be a positive value."); 28Fx.Assert(value != null, "The value must be non null."); 45Fx.Assert(this.items.Count == this.fifoList.Count, "The items and fifoList must be synchronized."); 59Fx.Assert(value != null, "The value must be non null.");

System\Runtime\ExceptionTrace.cs (10)

26Fx.Assert(diagnosticTrace != null, "'diagnosticTrace' MUST NOT be NULL."); 84Fx.Assert(targetInvocationException != null, "targetInvocationException cannot be null."); 88if (Fx.IsFatal(targetInvocationException)) 128Fx.Assert(aggregateException != null, "aggregateException cannot be null."); 132if (Fx.IsFatal(aggregateException)) 167Fx.Assert(innerExceptions.Count > 0, "InnerException.Count is known to be > 0 here."); 279[Fx.Tag.SecurityNote(Critical = "Calls 'System.Runtime.Interop.UnsafeNativeMethods.IsDebuggerPresent()' which is a P/Invoke method", 295[Fx.Tag.SecurityNote(Critical = "Calls into critical method UnsafeNativeMethods.IsDebuggerPresent and UnsafeNativeMethods.DebugBreak", 349if (Fx.IsFatal(exception)) 369if (Fx.IsFatal(ex))

System\Runtime\FatalException.cs (2)

24Fx.Assert(innerException == null || !Fx.IsFatal(innerException), "FatalException can't be used to wrap fatal exceptions.");

System\Runtime\Fx.cs (49)

System\Runtime\InputQueue.cs (44)

System\Runtime\InternalBufferManager.cs (13)

36Fx.Assert(maxBufferPoolSize > 0 && maxBufferSize >= 0, "bad params, caller should verify"); 121if (TraceCore.BufferPoolChangeQuotaIsEnabled(Fx.Trace)) 123TraceCore.BufferPoolChangeQuota(Fx.Trace, bufferPool.BufferSize, delta); 216Fx.Assert(buffer != null, "caller must verify"); 244throw Fx.Exception.Argument("buffer", InternalSR.BufferIsNotRightSizeForBufferManager); 256Fx.Assert(bufferSize >= 0, "caller must ensure a non-negative argument"); 279if (TraceCore.BufferPoolAllocationIsEnabled(Fx.Trace)) 281TraceCore.BufferPoolAllocation(Fx.Trace, bufferPool.BufferSize); 284returnValue = Fx.AllocateByteArray(bufferPool.BufferSize); 289if (TraceCore.BufferPoolAllocationIsEnabled(Fx.Trace)) 291TraceCore.BufferPoolAllocation(Fx.Trace, bufferSize); 294returnValue = Fx.AllocateByteArray(bufferSize); 562return Fx.AllocateByteArray(bufferSize);

System\Runtime\Interop\SafeEventLogWriteHandle.cs (4)

14[Fx.Tag.SecurityNote(Critical = "Usage of SafeHandleZeroOrMinusOneIsInvalid, which is protected by a LinkDemand and InheritanceDemand")] 19[Fx.Tag.SecurityNote(Critical = "Usage of SafeHandleZeroOrMinusOneIsInvalid, which is protected by a LinkDemand and InheritanceDemand")] 24[Fx.Tag.SecurityNote(Critical = "Usage of SafeHandleZeroOrMinusOneIsInvalid, which is protected by a LinkDemand and InheritanceDemand")] 43[Fx.Tag.SecurityNote(Critical = "Usage of SafeHandleZeroOrMinusOneIsInvalid, which is protected by a LinkDemand and InheritanceDemand")]

System\Runtime\Interop\UnsafeNativeMethods.cs (5)

111throw Fx.Exception.AsError(new System.ComponentModel.Win32Exception(error)); 117Fx.AssertAndThrow("GetComputerName returned an invalid length: " + length); 124throw Fx.Exception.AsError(new System.ComponentModel.Win32Exception(error)); 234[Fx.Tag.SecurityNote(Critical = "Accesses security critical type SafeHandle")] 243[Fx.Tag.SecurityNote(Critical = "Returns security critical type SafeEventLogWriteHandle")]

System\Runtime\IOThreadCancellationTokenSource.cs (4)

12static readonly Action<object> onCancel = Fx.ThunkCallback<object>(OnCancel); 58Fx.Assert(this.timer != null, "timer should not be null."); 69Fx.Assert(obj != null, "obj should not be null."); 76Fx.Assert(this.source != null, "source should not be null.");

System\Runtime\IOThreadScheduler.cs (47)

System\Runtime\IOThreadTimer.cs (19)

73[Fx.Tag.SecurityNote(Critical = "Calls critical method GetSystemTimeAdjustment", Safe = "method is a SafeNativeMethod")] 113[Fx.Tag.SynchronizationObject(Blocking = false, Scope = Fx.Tag.Strings.AppDomain)] 118[Fx.Tag.Queue(typeof(IOThreadTimer), Scope = Fx.Tag.Strings.AppDomain, StaleElementsRemovedImmediately = true)] 124[Fx.Tag.SynchronizationObject(Blocking = false)] 399Fx.Assert(this.count > 0, "Should have at least one timer in our queue."); 414Fx.Assert(index > 0, ""); 415Fx.Assert(index <= this.count, ""); 445Fx.Assert(timer.index == 0, "Timer should not have an index."); 498Fx.Assert(index > 0, ""); 499Fx.Assert(index <= count, ""); 600[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)] 606[Fx.Tag.SecurityNote(Critical = "Call the critical CreateWaitableTimer method in TimerHelper", 619[Fx.Tag.SecurityNote(Critical = "Call the critical Set method in TimerHelper", 626[Fx.Tag.SecurityNote(Critical = "Provides a set of unsafe methods used to work with the WaitableTimer")] 637throw Fx.Exception.AsError(exception); 645throw Fx.Exception.AsError(new Win32Exception());

System\Runtime\MruCache.cs (4)

34Fx.Assert(lowWatermark < highWatermark, ""); 35Fx.Assert(lowWatermark >= 0, ""); 60Fx.Assert(null != key, ""); 109Fx.Assert(null != key, "");

System\Runtime\PartialTrustHelpers.cs (12)

System\Runtime\ReadOnlyDictionaryInternal.cs (6)

50throw Fx.Exception.AsError(CreateReadOnlyException()); 73throw Fx.Exception.AsError(CreateReadOnlyException()); 78throw Fx.Exception.AsError(CreateReadOnlyException()); 83throw Fx.Exception.AsError(CreateReadOnlyException()); 112throw Fx.Exception.AsError(CreateReadOnlyException()); 117throw Fx.Exception.AsError(CreateReadOnlyException());

System\Runtime\ReadOnlyKeyedCollection.cs (1)

16Fx.Assert(innerCollection != null, "innerCollection should not be null");

System\Runtime\ScheduleActionItemAsyncResult.cs (1)

37if (Fx.IsFatal(ex))

System\Runtime\SignalGate.cs (7)

10[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)] 13[Fx.Tag.SynchronizationObject(Blocking = false, Kind = Fx.Tag.SynchronizationKind.InterlockedNoSpin)] 86throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.InvalidSemaphoreExit)); 98[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]

System\Runtime\SynchronizedPool.cs (3)

48[Fx.Tag.SynchronizationObject(Blocking = false)] 337[Fx.Tag.SecurityNote(Critical = "Asserts in order to get the processor count from the environment", Safe = "This data isn't actually protected so it's ok to leak")] 346[Fx.Tag.SynchronizationObject(Blocking = false)]

System\Runtime\TaskExtensions.cs (9)

17throw Fx.Exception.ArgumentNull("task"); 22throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.SFxTaskNotStarted)); 59throw Fx.Exception.ArgumentNull("task"); 64throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.SFxTaskNotStarted)); 125throw Fx.Exception.AsError<TException>(ex); 137throw Fx.Exception.AsError<TException>(ex); 156throw Fx.Exception.AsError<TException>(ex); 177if (Fx.IsFatal(ex) || exceptionConverter == null) 187throw Fx.Exception.AsError(new TimeoutException(InternalSR.TaskTimedOutError(timeout)));

System\Runtime\ThreadNeutralSemaphore.cs (14)

13[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.PrivatePrimitive, 28[Fx.Tag.SynchronizationObject(Blocking = false)] 31[Fx.Tag.SynchronizationObject] 41Fx.Assert(maxCount > 0, "maxCount must be positive"); 74Fx.Assert(callback != null, "must have a non-null call back for async purposes"); 82throw Fx.Exception.AsError(CreateObjectAbortedException()); 114Fx.Assert(!thisPtr.waiters.Contains(data.Waiter), "The waiter should have been removed already."); 138[Fx.Tag.Blocking(CancelMethod = "Abort")] 143throw Fx.Exception.AsError(CreateEnterTimedOutException(timeout)); 147[Fx.Tag.Blocking(CancelMethod = "Abort")] 158throw Fx.Exception.AsError(CreateObjectAbortedException()); 225throw Fx.Exception.AsError(CreateObjectAbortedException()); 266throw Fx.Exception.AsError(new SynchronizationLockException(message));

System\Runtime\Ticks.cs (1)

14[Fx.Tag.SecurityNote(Miscellaneous = "Why isn't the SuppressUnmanagedCodeSecurity attribute working in this case?")]

System\Runtime\TimeoutHelper.cs (5)

19Fx.Assert(timeout >= TimeSpan.Zero, "timeout must be non-negative"); 142Fx.Assert(!deadlineSet, "TimeoutHelper deadline set twice."); 156throw Fx.Exception.ArgumentOutOfRange(argumentName, timeout, InternalSR.TimeoutMustBeNonNegative(argumentName, timeout)); 169throw Fx.Exception.ArgumentOutOfRange(argumentName, timeout, InternalSR.TimeoutMustBePositive(argumentName, timeout)); 173[Fx.Tag.Blocking]

System\Runtime\TypeHelper.cs (4)

64Fx.Assert(!sourceType.IsValueType && !destinationType.IsValueType, "AreReferenceTypesCompatible can only be used for reference types"); 111throw Fx.Exception.AsError(new InvalidCastException(InternalSR.CannotConvertObject(source, typeof(T)))); 123throw Fx.Exception.AsError(new InvalidCastException(InternalSR.CannotConvertObject(source, typeof(T)))); 312Fx.Assert(source != null, "caller must verify");

System\Runtime\UrlUtility.cs (3)

25throw Fx.Exception.ArgumentNull("query"); 30throw Fx.Exception.ArgumentNull("encoding"); 358Fx.Assert(n < 0x10, "n < 0x10");