MonoMod.Backports

Indicates that certain members on a specified are accessed dynamically, for example through .

This allows tools to understand which members are being accessed during the execution of a program. This attribute is valid on members whose type is or . When this attribute is applied to a location of type , the assumption is that the string represents a fully qualified type name. When this attribute is applied to a class, interface, or struct, the members specified can be accessed dynamically on instances returned from calling on instances of that class, interface, or struct. If the attribute is applied to a method it's treated as a special case and it implies the attribute should be applied to the "this" parameter of the method. As such the attribute should only be used on instance methods of types assignable to System.Type (or string, but no methods will use it there).

Initializes a new instance of the class with the specified member types.

The types of members dynamically accessed.

Gets the which specifies the type of members dynamically accessed.

Specifies the types of members that are dynamically accessed. This enumeration has a attribute that allows a bitwise combination of its member values.

Specifies no members.

Specifies the default, parameterless public constructor.

Specifies all public constructors.

Specifies all non-public constructors.

Specifies all public methods.

Specifies all non-public methods.

Specifies all public fields.

Specifies all non-public fields.

Specifies all public nested types.

Specifies all non-public nested types.

Specifies all public properties.

Specifies all non-public properties.

Specifies all public events.

Specifies all non-public events.

Specifies all members.

Used to indicate a byref escapes and is not scoped.

There are several cases where the C# compiler treats a as implicitly - where the compiler does not allow the to escape the method. For example: for instance methods. parameters that refer to types. parameters. This attribute is used in those instances where the should be allowed to escape. Applying this attribute, in any form, has impact on consumers of the applicable API. It is necessary for API authors to understand the lifetime implications of applying this attribute and how it may impact their users.

Initializes a new instance of the class.

Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code.

This definition is provided by the IsExternalInit NuGet package (https://www.nuget.org/packages/IsExternalInit). Please see https://github.com/manuelroemer/IsExternalInit for more information.

Gets the value of the specified key.

key of the value to find. Cannot be null. If the key is found, contains the value associated with the key upon method return. If the key is not found, contains default(TValue). Returns "true" if key was found, "false" otherwise. The key may get garbaged collected during the TryGetValue operation. If so, TryGetValue may at its discretion, return "false" and set "value" to the default (as if the key was not present.)

Adds a key to the table.

key to add. May not be null. value to associate with key. If the key is already entered into the dictionary, this method throws an exception. The key may get garbage collected during the Add() operation. If so, Add() has the right to consider any prior entries successfully removed and add a new entry without throwing an exception.

Adds a key to the table if it doesn't already exist.

The key to add. The key's property value. true if the key/value pair was added; false if the table already contained the key.

Adds the key and value if the key doesn't exist, or updates the existing key's value if it does exist.

key to add or update. May not be null. value to associate with key.

Removes a key and its value from the table.

key to remove. May not be null. true if the key is found and removed. Returns false if the key was not in the dictionary. The key may get garbage collected during the Remove() operation. If so, Remove() will not fail or throw, however, the return value can be either true or false depending on who wins the race.

Clear all the key/value pairs

Atomically searches for a specified key in the table and returns the corresponding value. If the key does not exist in the table, the method invokes a callback method to create a value that is bound to the specified key.

key of the value to find. Cannot be null. callback that creates value for key. Cannot be null. If multiple threads try to initialize the same key, the table may invoke createValueCallback multiple times with the same key. Exactly one of these calls will succeed and the returned value of that call will be the one added to the table and returned by all the racing GetValue() calls. This rule permits the table to invoke createValueCallback outside the internal table lock to prevent deadlocks.

Helper method to call GetValue without passing a creation delegate. Uses Activator.CreateInstance to create new instances as needed. If TValue does not have a default constructor, this will throw.

key of the value to find. Cannot be null.

Gets an enumerator for the table.

The returned enumerator will not extend the lifetime of any object pairs in the table, other than the one that's Current. It will not return entries that have already been collected, nor will it return entries added after the enumerator was retrieved. It may not return all entries that were present when the enumerat was retrieved, however, such as not returning entries that were collected or removed after the enumerator was retrieved but before they were enumerated.

Provides an enumerator for the table.

Worker for adding a new key/value pair. Will resize the container if it is full.

Container holds the actual data for the table. A given instance of Container always has the same capacity. When we need more capacity, we create a new Container, copy the old one into the new one, and discard the old one. This helps enable lock-free reads from the table, as readers never need to deal with motion of entries due to rehashing.

Worker for adding a new key/value pair. Container must NOT be full.

Worker for finding a key/value pair. Must hold _lock.

Returns -1 if not found (if key expires during FindEntry, this can be treated as "not found."). Must hold _lock, or be prepared to retry the search while holding _lock.

This method requires to be on the stack to be properly tracked.

Gets the entry at the specified entry index.

Removes all of the keys in the table.

Removes the specified key from the table, if it exists.

Resize, and scrub expired keys off bucket lists. Must hold _lock.

_firstEntry is less than _entries.Length on exit, that is, the table has at least one free entry.

Provides a handler used by the language compiler to process interpolated strings into instances.

Expected average length of formatted data used for an individual interpolation expression result.

This is inherited from string.Format, and could be changed based on further data. string.Format actually uses `format.Length + args.Length * 8`, but format.Length includes the format items themselves, e.g. "{0}", and since it's rare to have double-digit numbers of items, we bump the 8 up to 11 to account for the three extra characters in "{d}", since the compiler-provided base length won't include the equivalent character count.

Minimum size array to rent from the pool.

Same as stack-allocation size used today by string.Format.

Optional provider to pass to IFormattable.ToString or ISpanFormattable.TryFormat calls.

Array rented from the array pool and used to back .

The span to write into.

Position at which to write the next character.

Whether provides an ICustomFormatter.

Custom formatters are very rare. We want to support them, but it's ok if we make them more expensive in order to make them as pay-for-play as possible. So, we avoid adding another reference type field to reduce the size of the handler and to reduce required zero'ing, by only storing whether the provider provides a formatter, rather than actually storing the formatter. This in turn means, if there is a formatter, we pay for the extra interface call on each AppendFormatted that needs it.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. An object that supplies culture-specific formatting information. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. An object that supplies culture-specific formatting information. A buffer temporarily transferred to the handler for use as part of its formatting. Contents may be overwritten. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Derives a default length with which to seed the handler.

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string.

Gets the built .

The built string.

Gets the built and clears the handler.

The built string. This releases any resources used by the handler. The method should be invoked only once and as the last thing performed on the handler. Subsequent use is erroneous, ill-defined, and may destabilize the process, as may using any other copies of the handler after ToStringAndClear is called on any one of them.

Clears the handler, returning any rented array to the pool.

Gets a span of the written characters thus far.

Writes the specified string to the handler.

The string to write.

Writes the specified string to the handler.

The string to write.

Writes the specified value to the handler.

The value to write. The type of the value to write.

Writes the specified value to the handler.

The value to write. The format string. The type of the value to write.

Writes the specified value to the handler.

The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The type of the value to write.

Writes the specified value to the handler.

The value to write. The format string. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The type of the value to write.

Writes the specified character span to the handler.

The span to write.

Writes the specified string of chars to the handler.

The span to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string.

Writes the specified value to the handler.

The value to write.

Writes the specified value to the handler.

The value to write. Slow path to handle a custom formatter, potentially null value, or a string that doesn't fit in the current buffer.

Writes the specified value to the handler.

Gets whether the provider provides a custom formatter.

Formats the value using the custom formatter from the provider.

The value to write. The format string. The type of the value to write.

Handles adding any padding required for aligning a formatted value in an interpolation expression.

The position at which the written value started. Non-zero minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value.

Ensures has the capacity to store beyond .

Fallback for fast path in when there's not enough space in the destination.

The string to write.

Fallback for for when not enough space exists in the current buffer.

The span to write.

Grows to have the capacity to store at least beyond .

Grows the size of .

Grow the size of to at least the specified .

Disables the built-in runtime managed/unmanaged marshalling subsystem for P/Invokes, Delegate types, and unmanaged function pointer invocations.

Note: This does nothing on runtimes older than .NET 7. It is provided entirely for forward compatibility. The built-in marshalling subsystem has some behaviors that cannot be changed due to backward-compatibility requirements. This attribute allows disabling the built-in subsystem and instead uses the following rules for P/Invokes, Delegates, and unmanaged function pointer invocations: - All value types that do not contain reference type fields recursively (unmanaged in C#) are blittable - Value types that recursively have any fields that have [StructLayout(LayoutKind.Auto)] are disallowed from interop. - All reference types are disallowed from usage in interop scenarios. - SetLastError support in P/Invokes is disabled. - varargs support is disabled. - LCIDConversionAttribute support is disabled.

Indicates the attributed type is to be used as an interpolated string handler.

Initializes the .

Indicates which arguments to a method involving an interpolated string handler should be passed to that handler.

Initializes a new instance of the class.

The name of the argument that should be passed to the handler. may be used as the name of the receiver in an instance method.

Initializes a new instance of the class.

The names of the arguments that should be passed to the handler. may be used as the name of the receiver in an instance method.

Gets the names of the arguments that should be passed to the handler.

may be used as the name of the receiver in an instance method.

This interface is required for types that want to be indexed into by dynamic patterns.

The number of positions in this data structure.

Get the element at position .

Used to indicate to the compiler that a method should be called in its containing module's initializer.

When one or more valid methods with this attribute are found in a compilation, the compiler will emit a module initializer which calls each of the attributed methods. Certain requirements are imposed on any method targeted with this attribute: - The method must be `static`. - The method must be an ordinary member method, as opposed to a property accessor, constructor, local function, etc. - The method must be parameterless. - The method must return `void`. - The method must not be generic or be contained in a generic type. - The method's effective accessibility must be `internal` or `public`. The specification for module initializers in the .NET runtime can be found here: https://github.com/dotnet/runtime/blob/main/docs/design/specs/Ecma-335-Augments.md#module-initializer

Indicates that the use of on a member is meant to be treated as a tuple with element names.

Initializes a new instance of the class.

Specifies, in a pre-order depth-first traversal of a type's construction, which occurrences are meant to carry element names. This constructor is meant to be used on types that contain an instantiation of that contains element names. For instance, if C is a generic type with two type parameters, then a use of the constructed type C{, might be intended to treat the first type argument as a tuple with element names and the second as a tuple without element names. In which case, the appropriate attribute specification should use a transformNames value of


                    { "name1", "name2", null, null,
                    null }

Specifies, in a pre-order depth-first traversal of a type's construction, which elements are meant to carry element names.

Provides a collection of methods for interoperating with , , , and .

Get an array segment from the underlying memory. If unable to get the array segment, return false with a default array segment.

Gets an from the underlying read-only memory. If unable to get the type, returns false.

The element type of the . The type of to try and retrive. The memory to get the manager for. The returned manager of the . A indicating if it was successful.

Gets an and , from the underlying read-only memory. If unable to get the type, returns false.

The element type of the . The type of to try and retrive. The memory to get the manager for. The returned manager of the . The offset from the start of the that the represents. The length of the that the represents. A indicating if it was successful.

Creates an view of the given to allow the to be used in existing APIs that take an .

The element type of the . The ReadOnlyMemory to view as an An view of the given

Attempts to get the underlying from a .

The memory that may be wrapping a object. The string. The starting location in . The number of items in .

Reads a structure of type T out of a read-only span of bytes.

Reads a structure of type T out of a span of bytes. If the span is too small to contain the type T, return false.

Writes a structure of type T into a span of bytes.

Writes a structure of type T into a span of bytes. If the span is too small to contain the type T, return false.

Creates a new memory over the portion of the pre-pinned target array beginning at 'start' index and ending at 'end' index (exclusive).

The pre-pinned target array. The index at which to begin the memory. The number of items in the memory. This method should only be called on an array that is already pinned and that array should not be unpinned while the returned Memory is still in use. Calling this method on an unpinned array could result in memory corruption. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Casts a Span of one primitive type to Span of bytes. That type may not contain pointers or references. This is checked at runtime in order to preserve type safety.

The source slice, of type . Thrown when contains pointers. Thrown if the Length property of the new Span would exceed Int32.MaxValue.

Casts a ReadOnlySpan of one primitive type to ReadOnlySpan of bytes. That type may not contain pointers or references. This is checked at runtime in order to preserve type safety.

The source slice, of type . Thrown when contains pointers. Thrown if the Length property of the new Span would exceed Int32.MaxValue.

Creates a from a .

The . A representing the same memory as the , but writable. must be used with extreme caution. is used to represent immutable data and other memory that is not meant to be written to; instances created by should not be written to. The method exists to enable variables typed as but only used for reading to store a .

Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to the location where the 0th element would have been stored. Such a reference can be used for pinning but must never be dereferenced.

Returns a reference to the 0th element of the ReadOnlySpan. If the Span is empty, returns a reference to the location where the 0th element would have been stored. Such a reference can be used for pinning but must never be dereferenced.

Casts a Span of one primitive type to another primitive type . These types may not contain pointers or references. This is checked at runtime in order to preserve type safety.

Supported only for platforms that support misaligned memory access. The source slice, of type . Thrown when or contains pointers.

Casts a ReadOnlySpan of one primitive type to another primitive type . These types may not contain pointers or references. This is checked at runtime in order to preserve type safety.

Supported only for platforms that support misaligned memory access. The source slice, of type . Thrown when or contains pointers.

Provides a collection of methods for interoperating with

Get from the underlying . If unable to get the , return false.

Get an array segment from the underlying . If unable to get the array segment, return false with a default array segment.

Get from the underlying . If unable to get the , return false.

Extensions to providing consistent access to APIs introduced after the type.

Provides a resource pool that enables reusing instances of arrays.

Renting and returning buffers with an can increase performance in situations where arrays are created and destroyed frequently, resulting in significant memory pressure on the garbage collector. This class is thread-safe. All members may be used by multiple threads concurrently.

Retrieves a shared instance.

The shared pool provides a default implementation of that's intended for general applicability. It maintains arrays of multiple sizes, and may hand back a larger array than was actually requested, but will never hand back a smaller array than was requested. Renting a buffer from it with will result in an existing buffer being taken from the pool if an appropriate buffer is available or in a new buffer being allocated if one is not available. byte[] and char[] are the most commonly pooled array types. For these we use a special pool type optimized for very fast access speeds, at the expense of more memory consumption. The shared pool instance is created lazily on first access.

Creates a new instance using default configuration options.

A new instance.

Creates a new instance using custom configuration options.

The maximum length of array instances that may be stored in the pool. The maximum number of array instances that may be stored in each bucket in the pool. The pool groups arrays of similar lengths into buckets for faster access. A new instance with the specified configuration options. The created pool will group arrays into buckets, with no more than in each bucket and with those arrays not exceeding in length.

Retrieves a buffer that is at least the requested length.

The minimum length of the array needed. An array that is at least in length. This buffer is loaned to the caller and should be returned to the same pool via so that it may be reused in subsequent usage of . It is not a fatal error to not return a rented buffer, but failure to do so may lead to decreased application performance, as the pool may need to create a new buffer to replace the one lost.

Returns to the pool an array that was previously obtained via on the same instance.

The buffer previously obtained from to return to the pool. If true and if the pool will store the buffer to enable subsequent reuse, will clear of its contents so that a subsequent consumer via will not see the previous consumer's content. If false or if the pool will release the buffer, the array's contents are left unchanged. Once a buffer has been returned to the pool, the caller gives up all ownership of the buffer and must not use it. The reference returned from a given call to must only be returned via once. The default may hold onto the returned buffer in order to rent it again, or it may release the returned buffer if it's determined that the pool already has enough buffers stored.

Extension methods for

Returns position of first occurrence of item in the

Copy the to the specified .

The source . The destination .

Converts the to an array

Writes contents of to

The default maximum length of each array in the pool (2^20).

The default maximum number of arrays per bucket that are available for rent.

Gets an ID for the pool to use with events.

Provides a thread-safe bucket containing buffers that can be Rent'd and Return'd.

Creates the pool with numberOfBuffers arrays where each buffer is of bufferLength length.

Gets an ID for the bucket to use with events.

Takes an array from the bucket. If the bucket is empty, returns null.

Attempts to return the buffer to the bucket. If successful, the buffer will be stored in the bucket and true will be returned; otherwise, the buffer won't be stored, and false will be returned.

Represents a sink

Notifies that amount of data was written to /

Requests the that is at least in size if possible, otherwise returns maximum available memory. If is equal to 0, currently available memory would get returned.

Owner of Memory that is responsible for disposing the underlying memory appropriately.

Returns a Memory.

Provides a mechanism for pinning and unpinning objects to prevent the GC from moving them.

Call this method to indicate that the IPinnable object can not be moved by the garbage collector. The address of the pinned object can be taken. The offset to the element within the memory at which the returned points to.

Call this method to indicate that the IPinnable object no longer needs to be pinned. The garbage collector is free to move the object now.

A handle for the memory.

Creates a new memory handle for the memory.

pointer to memory reference to manually managed object, or default if there is no memory manager handle used to pin array buffers

Returns the pointer to memory, where the memory is assumed to be pinned and hence the address won't change.

Frees the pinned handle and releases IPinnable.

Manager of that provides the implementation.

Returns a .

Returns a span wrapping the underlying memory.

Returns a handle to the memory that has been pinned and hence its address can be taken.

The offset to the element within the memory at which the returned points to. (default = 0)

Lets the garbage collector know that the object is free to be moved now.

Returns a for the current .

The element count in the memory, starting at offset 0.

Returns a for the current .

The offset to the element which the returned memory starts at. The element count in the memory, starting at element offset .

Returns an array segment. Returns the default array segment if not overriden.

Implements IDisposable.

Clean up of any leftover managed and unmanaged resources.

Represents a sequence that can read a sequential series of .

Returns empty

Length of the .

Determines if the is empty.

Determines if the contains a single segment.

Gets from the first segment.

A position to the start of the .

A position to the end of the

Creates an instance of from linked memory list represented by start and end segments and corresponding indexes in them.

Creates an instance of from the .

Creates an instance of from the , start and index.

Creates an instance of from the . Consumer is expected to manage lifetime of memory until is not used anymore.

Forms a slice out of the given , beginning at , with items

The index at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , ending at (inclusive).

The index at which to begin this slice. The end (inclusive) of the slice

Forms a slice out of the given , beginning at , with items

The starting (inclusive) at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , with items

The index at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , ending at (inclusive).

The index at which to begin this slice. The end (inclusive) of the slice

Forms a slice out of the given , beginning at ', with items

The starting (inclusive) at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , ending at (inclusive).

The starting (inclusive) at which to begin this slice. The ending (inclusive) of the slice

Forms a slice out of the given , beginning at , ending at the existing 's end.

The starting (inclusive) at which to begin this slice.

Forms a slice out of the given , beginning at , ending at the existing 's end.

The start index at which to begin this slice.

Returns an enumerator over the

Returns a new at an from the start of the sequence.

Returns a new at an from the

Tries to retrieve next segment after and return its contents in . Returns false if end of was reached otherwise true. Sets to the beginning of next segment if is set to true.

An enumerator over the

Initialize the enumerator.

The to enumerate.

The current

Moves to the next in the

Represents a linked list of nodes.

The value for current node.

The next node.

The sum of node length before current.

Represents a standard formatting string without using an actual String. A StandardFormat consists of a character (such as 'G', 'D' or 'X') and an optional precision ranging from 0..99, or the special value NoPrecision.

Precision values for format that don't use a precision, or for when the precision is to be unspecified.

The maximum valid precision value.

The character component of the format.

The precision component of the format. Ranges from 0..9 or the special value NoPrecision.

true if Precision is a value other than NoPrecision

true if the StandardFormat == default(StandardFormat)

Create a StandardFormat.

A type-specific formatting character such as 'G', 'D' or 'X' An optional precision ranging from 0..9 or the special value NoPrecision (the default)

Converts a character to a StandardFormat using the NoPrecision precision.

Converts a classic .NET format string into a StandardFormat

Returns true if both the Symbol and Precision are equal.

Compute a hash code.

Returns true if both the Symbol and Precision are equal.

Returns the format in classic .NET format.

Returns true if both the Symbol and Precision are equal.

Returns false if both the Symbol and Precision are equal.

Provides an ArrayPool implementation meant to be used as the singleton returned from ArrayPool.Shared.

The implementation uses a tiered caching scheme, with a small per-thread cache for each array size, followed by a cache per array size shared by all threads, split into per-core stacks meant to be used by threads running on that core. Locks are used to protect each per-core stack, because a thread can migrate after checking its processor number, because multiple threads could interleave on the same core, and because a thread is allowed to check other core's buckets if its core's bucket is empty/full.

The number of buckets (array sizes) in the pool, one for each array length, starting from length 16.

Maximum number of per-core stacks to use per array size.

The maximum number of buffers to store in a bucket's global queue.

A per-thread array of arrays, to cache one array per array size per thread.

Used to keep track of all thread local buckets for trimming if needed.

An array of per-core array stacks. The slots are lazily initialized to avoid creating lots of overhead for unused array sizes.

Whether the callback to trim arrays in response to memory pressure has been created.

Allocate a new PerCoreLockedStacks and try to store it into the array.

Gets an ID for the pool to use with events.

Stores a set of stacks of arrays, with one stack per core.

Number of locked stacks to employ.

The stacks.

Initializes the stacks.

Try to push the array into the stacks. If each is full when it's tested, the array will be dropped.

Try to get an array from the stacks. If each is empty when it's tested, null will be returned.

Provides a simple, bounded stack of arrays, protected by a lock.

The arrays in the stack.

Number of arrays stored in .

Timestamp set by Trim when it sees this as 0.

Wrapper for arrays stored in ThreadStatic buckets.

The stored array.

Environment.TickCount timestamp for when this array was observed by Trim.

Represents position in non-contiguous set of memory. Properties of this type should not be interpreted by anything but the type that created it.

Creates new

Returns object part of this

Returns integer part of this

Indicates whether the current is equal to another . equality does not guarantee that they point to the same location in

Represents a thread-safe, unordered collection of objects.

Specifies the type of elements in the bag. Bags are useful for storing objects when ordering doesn't matter, and unlike sets, bags support duplicates. is a thread-safe bag implementation, optimized for scenarios where the same thread will be both producing and consuming data stored in the bag. accepts null reference (Nothing in Visual Basic) as a valid value for reference types. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

The per-bag, per-thread work-stealing queues.

The head work stealing queue in a linked list of queues.

Number of times any list transitions from empty to non-empty.

Initializes a new instance of the class.

Initializes a new instance of the class that contains elements copied from the specified collection.

The collection whose elements are copied to the new . is a null reference (Nothing in Visual Basic).

Adds an object to the .

The object to be added to the . The value can be a null reference (Nothing in Visual Basic) for reference types.

Attempts to add an object to the .

The object to be added to the . The value can be a null reference (Nothing in Visual Basic) for reference types. Always returns true

Attempts to remove and return an object from the .

When this method returns, contains the object removed from the or the default value of if the operation failed. true if an object was removed successfully; otherwise, false.

Attempts to return an object from the without removing it.

When this method returns, contains an object from the or the default value of if the operation failed. true if and object was returned successfully; otherwise, false.

Gets the work-stealing queue data structure for the current thread.

Whether to create a new queue if this thread doesn't have one. The local queue object, or null if the thread doesn't have one.

Try to reuse an unowned queue. If a thread interacts with the bag and then exits, the bag purposefully retains its queue, as it contains data associated with the bag.

The queue object, or null if no unowned queue could be gathered.

Local helper method to steal an item from any other non empty thread.

To receive the item retrieved from the bag Whether to remove or peek. True if succeeded, false otherwise.

Attempts to steal from each queue starting from to .

Copies the elements to an existing one-dimensional Array, starting at the specified array index.

The one-dimensional Array that is the destination of the elements copied from the . The Array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- the number of elements in the source is greater than the available space from to the end of the destination .

Copies from each queue to the target array, starting at the specified index.

Copies the elements of the to an , starting at a particular index.

The one-dimensional Array that is the destination of the elements copied from the . The Array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is multidimensional. -or- does not have zero-based indexing. -or- is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination . -or- The type of the source cannot be cast automatically to the type of the destination .

Copies the elements to a new array.

A new array containing a snapshot of elements copied from the .

Removes all values from the .

Returns an enumerator that iterates through the .

An enumerator for the contents of the . The enumeration represents a moment-in-time snapshot of the contents of the bag. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the bag.

Returns an enumerator that iterates through the .

An enumerator for the contents of the . The items enumerated represent a moment-in-time snapshot of the contents of the bag. It does not reflect any update to the collection after was called.

Gets the number of elements contained in the .

The number of elements contained in the . The count returned represents a moment-in-time snapshot of the contents of the bag. It does not reflect any updates to the collection after was called.

Gets the number of items stored in the bag.

Only provides a stable result when the bag is frozen.

Gets a value that indicates whether the is empty.

true if the is empty; otherwise, false.

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized with the SyncRoot; otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

Global lock used to synchronize the queues pointer and all bag-wide operations (e.g. ToArray, Count, etc.).

"Freezes" the bag, such that no concurrent operations will be mutating the bag when it returns.

true if the global lock was taken; otherwise, false.

"Unfreezes" a bag frozen with .

The result of the method.

Provides a work-stealing queue data structure stored per thread.

Initial size of the queue's array.

Starting index for the head and tail indices.

Head index from which to steal. This and'd with the is the index into .

Tail index at which local pushes/pops happen. This and'd with the is the index into .

The array storing the queue's data.

Mask and'd with and to get an index into .

Numbers of elements in the queue from the local perspective; needs to be combined with to get an actual Count.

Number of steals; needs to be combined with to get an actual Count.

The current queue operation. Used to quiesce before performing operations from one thread onto another.

true if this queue's lock is held as part of a global freeze.

Next queue in the 's set of thread-local queues.

Thread ID that owns this queue.

Initialize the WorkStealingQueue.

The next queue in the linked list of work-stealing queues.

Gets whether the queue is empty.

Add new item to the tail of the queue.

The item to add.

Clears the contents of the local queue.

Remove an item from the tail of the queue.

The removed item

Peek an item from the tail of the queue.

the peeked item True if succeeded, false otherwise

Steal an item from the head of the queue.

the removed item true to take the item; false to simply peek at it

Copies the contents of this queue to the target array starting at the specified index.

Gets the total number of items in the queue.

This is not thread safe, only providing an accurate result either from the owning thread while its lock is held or from any thread while the bag is frozen.

Lock-free operations performed on a queue.

Provides an enumerator for the bag.

The original implementation of ConcurrentBag used a as part of the GetEnumerator implementation. That list was then changed to be an array, but array's GetEnumerator has different behavior than does list's, in particular for the case where Current is used after MoveNext returns false. To avoid any concerns around compatibility, we use a custom enumerator rather than just returning array's. This enumerator provides the essential elements of both list's and array's enumerators.

Represents a thread-safe collection of keys and values.

The type of the keys in the dictionary. The type of the values in the dictionary. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

Internal tables of the dictionary.

Key equality comparer.

Default comparer for TKey.

Used to avoid repeatedly accessing the shared default generic static, in particular for reference types where it's currently not devirtualized: https://github.com/dotnet/runtime/issues/10050.

Whether to dynamically increase the size of the striped lock.

The maximum number of elements per lock before a resize operation is triggered.

The default capacity, i.e. the initial # of buckets.

When choosing this value, we are making a trade-off between the size of a very small dictionary, and the number of resizes when constructing a large dictionary. Also, the capacity should not be divisible by a small prime.

The maximum size of the striped lock that will not be exceeded when locks are automatically added as the dictionary grows.

The user is allowed to exceed this limit by passing a concurrency level larger than MaxLockNumber into the constructor.

Whether TValue is a type that can be written atomically (i.e., with no danger of torn reads).

Determines whether type TValue can be written atomically.

Initializes a new instance of the class that is empty, has the default concurrency level, has the default initial capacity, and uses the default comparer for the key type.

Initializes a new instance of the class that is empty, has the specified concurrency level and capacity, and uses the default comparer for the key type.

The estimated number of threads that will update the concurrently. The initial number of elements that the can contain. is less than 1. is less than 0.

Initializes a new instance of the class that contains elements copied from the specified , has the default concurrency level, has the default initial capacity, and uses the default comparer for the key type.

The whose elements are copied to the new . is a null reference (Nothing in Visual Basic). contains one or more duplicate keys.

Initializes a new instance of the class that is empty, has the specified concurrency level and capacity, and uses the specified .

The implementation to use when comparing keys.

Initializes a new instance of the class that contains elements copied from the specified , has the default concurrency level, has the default initial capacity, and uses the specified .

The whose elements are copied to the new . The implementation to use when comparing keys. is a null reference (Nothing in Visual Basic).

Initializes a new instance of the class that contains elements copied from the specified , has the specified concurrency level, has the specified initial capacity, and uses the specified .

The estimated number of threads that will update the concurrently. The whose elements are copied to the new . The implementation to use when comparing keys. is a null reference (Nothing in Visual Basic). is less than 1. contains one or more duplicate keys.

Initializes a new instance of the class that is empty, has the specified concurrency level, has the specified initial capacity, and uses the specified .

The estimated number of threads that will update the concurrently. The initial number of elements that the can contain. The implementation to use when comparing keys. is less than 1. -or- is less than 0.

Attempts to add the specified key and value to the .

The key of the element to add. The value of the element to add. The value can be a null reference (Nothing in Visual Basic) for reference types. true if the key/value pair was added to the successfully; otherwise, false. is null reference (Nothing in Visual Basic). The contains too many elements.

Determines whether the contains the specified key.

The key to locate in the . true if the contains an element with the specified key; otherwise, false. is a null reference (Nothing in Visual Basic).

Attempts to remove and return the value with the specified key from the .

The key of the element to remove and return. When this method returns, contains the object removed from the or the default value of if the operation failed. true if an object was removed successfully; otherwise, false. is a null reference (Nothing in Visual Basic).

Removes a key and value from the dictionary.

The representing the key and value to remove. true if the key and value represented by are successfully found and removed; otherwise, false. Both the specifed key and value must match the entry in the dictionary for it to be removed. The key is compared using the dictionary's comparer (or the default comparer for if no comparer was provided to the dictionary when it was constructed). The value is compared using the default comparer for . The property of is a null reference.

Removes the specified key from the dictionary if it exists and returns its associated value. If matchValue flag is set, the key will be removed only if is associated with a particular value.

The key to search for and remove if it exists. The variable into which the removed value, if found, is stored. Whether removal of the key is conditional on its value. The conditional value to compare against if is true

Attempts to get the value associated with the specified key from the .

The key of the value to get. When this method returns, contains the object from the with the specified key or the default value of , if the operation failed. true if the key was found in the ; otherwise, false. is a null reference (Nothing in Visual Basic).

Updates the value associated with to if the existing value is equal to .

The key whose value is compared with and possibly replaced. The value that replaces the value of the element with if the comparison results in equality. The value that is compared to the value of the element with . true if the value with was equal to and replaced with ; otherwise, false. is a null reference.

Updates the value associated with to if the existing value is equal to .

The key whose value is compared with and possibly replaced. The hashcode computed for . The value that replaces the value of the element with if the comparison results in equality. The value that is compared to the value of the element with . true if the value with was equal to and replaced with ; otherwise, false. is a null reference.

Removes all keys and values from the .

Copies the elements of the to an array of type , starting at the specified array index.

The one-dimensional array of type that is the destination of the elements copied from the . The array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than 0. is equal to or greater than the length of the . -or- The number of elements in the source is greater than the available space from to the end of the destination .

Copies the key and value pairs stored in the to a new array.

A new array containing a snapshot of key and value pairs copied from the .

Copy dictionary contents to an array - shared implementation between ToArray and CopyTo.

Important: the caller must hold all locks in _locks before calling CopyToPairs.

Copy dictionary contents to an array - shared implementation between ToArray and CopyTo.

Important: the caller must hold all locks in _locks before calling CopyToPairs.

Copy dictionary contents to an array - shared implementation between ToArray and CopyTo.

Important: the caller must hold all locks in _locks before calling CopyToPairs.

Returns an enumerator that iterates through the .

An enumerator for the . The enumerator returned from the dictionary is safe to use concurrently with reads and writes to the dictionary, however it does not represent a moment-in-time snapshot of the dictionary. The contents exposed through the enumerator may contain modifications made to the dictionary after was called.

Provides an enumerator implementation for the dictionary.

Shared internal implementation for inserts and updates. If key exists, we always return false; and if updateIfExists == true we force update with value; If key doesn't exist, we always add value and return true;

Gets or sets the value associated with the specified key.

The key of the value to get or set. The value associated with the specified key. If the specified key is not found, a get operation throws a , and a set operation creates a new element with the specified key. is a null reference (Nothing in Visual Basic). The property is retrieved and does not exist in the collection.

Throws a KeyNotFoundException.

Separate from ThrowHelper to avoid boxing at call site while reusing this generic instantiation.

Gets the that is used to determine equality of keys for the dictionary.

The generic interface implementation that is used to determine equality of keys for the current and to provide hash values for the keys. requires an equality implementation to determine whether keys are equal. You can specify an implementation of the generic interface by using a constructor that accepts a comparer parameter; if you do not specify one, the default generic equality comparer is used.

Gets the number of key/value pairs contained in the .

The dictionary contains too many elements. The number of key/value pairs contained in the . Count has snapshot semantics and represents the number of items in the at the moment when Count was accessed.

Gets the number of key/value pairs contained in the . Should only be used after all locks have been acquired.

Adds a key/value pair to the if the key does not already exist.

The key of the element to add. The function used to generate a value for the key is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value for the key as returned by valueFactory if the key was not in the dictionary.

Adds a key/value pair to the if the key does not already exist.

The key of the element to add. The function used to generate a value for the key An argument value to pass into . is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value for the key as returned by valueFactory if the key was not in the dictionary.

Adds a key/value pair to the if the key does not already exist.

The key of the element to add. the value to be added, if the key does not already exist is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value if the key was not in the dictionary.

Adds a key/value pair to the if the key does not already exist, or updates a key/value pair in the if the key already exists.

The key to be added or whose value should be updated The function used to generate a value for an absent key The function used to generate a new value for an existing key based on the key's existing value An argument to pass into and . is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The new value for the key. This will be either be the result of addValueFactory (if the key was absent) or the result of updateValueFactory (if the key was present).

Adds a key/value pair to the if the key does not already exist, or updates a key/value pair in the if the key already exists.

The key to be added or whose value should be updated The function used to generate a value for an absent key The function used to generate a new value for an existing key based on the key's existing value is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The new value for the key. This will be either the result of addValueFactory (if the key was absent) or the result of updateValueFactory (if the key was present).

Adds a key/value pair to the if the key does not already exist, or updates a key/value pair in the if the key already exists.

The key to be added or whose value should be updated The value to be added for an absent key The function used to generate a new value for an existing key based on the key's existing value is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The new value for the key. This will be either the value of addValue (if the key was absent) or the result of updateValueFactory (if the key was present).

Gets a value that indicates whether the is empty.

true if the is empty; otherwise, false.

Adds the specified key and value to the .

The object to use as the key of the element to add. The object to use as the value of the element to add. is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. An element with the same key already exists in the .

Removes the element with the specified key from the .

The key of the element to remove. true if the element is successfully remove; otherwise false. This method also returns false if was not found in the original . is a null reference (Nothing in Visual Basic).

Gets a collection containing the keys in the .

An containing the keys in the .

Gets a collection containing the values in the .

An containing the values in the .

Adds the specified value to the with the specified key.

The structure representing the key and value to add to the . The of is null. The contains too many elements. An element with the same key already exists in the

Determines whether the contains a specific key and value.

The structure to locate in the . true if the is found in the ; otherwise, false.

Gets a value indicating whether the dictionary is read-only.

true if the is read-only; otherwise, false. For , this property always returns false.

Removes a key and value from the dictionary.

The structure representing the key and value to remove from the . true if the key and value represented by is successfully found and removed; otherwise, false. The Key property of is a null reference (Nothing in Visual Basic).

Returns an enumerator that iterates through the .

Adds the specified key and value to the dictionary.

The object to use as the key. The object to use as the value. is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. is of a type that is not assignable to the key type of the . -or- is of a type that is not assignable to , the type of values in the . -or- A value with the same key already exists in the .

Gets whether the contains an element with the specified key.

The key to locate in the . true if the contains an element with the specified key; otherwise, false. is a null reference (Nothing in Visual Basic).

Provides an for the .

An for the .

Gets a value indicating whether the has a fixed size.

true if the has a fixed size; otherwise, false. For , this property always returns false.

Gets a value indicating whether the is read-only.

true if the is read-only; otherwise, false. For , this property always returns false.

Gets an containing the keys of the .

An containing the keys of the .

Removes the element with the specified key from the .

The key of the element to remove. is a null reference (Nothing in Visual Basic).

Gets an containing the values in the .

An containing the values in the .

Gets or sets the value associated with the specified key.

The key of the value to get or set. The value associated with the specified key, or a null reference (Nothing in Visual Basic) if is not in the dictionary or is of a type that is not assignable to the key type of the . is a null reference (Nothing in Visual Basic). A value is being assigned, and is of a type that is not assignable to the key type of the . -or- A value is being assigned, and is of a type that is not assignable to the value type of the

Copies the elements of the to an array, starting at the specified array index.

The one-dimensional array that is the destination of the elements copied from the . The array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than 0. is equal to or greater than the length of the . -or- The number of elements in the source is greater than the available space from to the end of the destination .

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized (thread safe); otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

Replaces the bucket table with a larger one. To prevent multiple threads from resizing the table as a result of races, the Tables instance that holds the table of buckets deemed too small is passed in as an argument to GrowTable(). GrowTable() obtains a lock, and then checks the Tables instance has been replaced in the meantime or not.

The number of concurrent writes for which to optimize by default.

Acquires all locks for this hash table, and increments locksAcquired by the number of locks that were successfully acquired. The locks are acquired in an increasing order.

Acquires a contiguous range of locks for this hash table, and increments locksAcquired by the number of locks that were successfully acquired. The locks are acquired in an increasing order.

Releases a contiguous range of locks.

Gets a collection containing the keys in the dictionary.

Gets a collection containing the values in the dictionary.

A node in a singly-linked list representing a particular hash table bucket.

Tables that hold the internal state of the ConcurrentDictionary

Wrapping the three tables in a single object allows us to atomically replace all tables at once.

A singly-linked list for each bucket.

A set of locks, each guarding a section of the table.

The number of elements guarded by each lock.

Pre-computed multiplier for use on 64-bit performing faster modulo operations.

Computes a ref to the bucket for a particular key.

Computes the bucket and lock number for a particular key.

A private class to represent enumeration over the dictionary that implements the IDictionaryEnumerator interface.

Represents a thread-safe first-in, first-out collection of objects.

Specifies the type of elements in the queue. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

Initial length of the segments used in the queue.

Maximum length of the segments used in the queue. This is a somewhat arbitrary limit: larger means that as long as we don't exceed the size, we avoid allocating more segments, but if we do exceed it, then the segment becomes garbage.

Lock used to protect cross-segment operations, including any updates to or and any operations that need to get a consistent view of them.

The current tail segment.

The current head segment.

Initializes a new instance of the class.

Initializes a new instance of the class that contains elements copied from the specified collection.

The collection whose elements are copied to the new . The argument is null.

Copies the elements of the to an , starting at a particular index.

The one-dimensional Array that is the destination of the elements copied from the . must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is multidimensional. -or- does not have zero-based indexing. -or- is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination . -or- The type of the source cannot be cast automatically to the type of the destination .

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized with the SyncRoot; otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

Returns an enumerator that iterates through a collection.

An that can be used to iterate through the collection.

Attempts to add an object to the .

The object to add to the . The value can be a null reference (Nothing in Visual Basic) for reference types. true if the object was added successfully; otherwise, false. For , this operation will always add the object to the end of the and return true.

Attempts to remove and return an object from the .

When this method returns, if the operation was successful, contains the object removed. If no object was available to be removed, the value is unspecified. true if an element was removed and returned successfully; otherwise, false. For , this operation will attempt to remove the object from the beginning of the .

Gets a value that indicates whether the is empty.

true if the is empty; otherwise, false. For determining whether the collection contains any items, use of this property is recommended rather than retrieving the number of items from the property and comparing it to 0. However, as this collection is intended to be accessed concurrently, it may be the case that another thread will modify the collection after returns, thus invalidating the result.

Copies the elements stored in the to a new array.

A new array containing a snapshot of elements copied from the .

Gets the number of elements contained in the .

The number of elements contained in the . For determining whether the collection contains any items, use of the property is recommended rather than retrieving the number of items from the property and comparing it to 0.

Computes the number of items in a segment based on a fixed head and tail in that segment.

Gets the number of items in snapped region.

Copies the elements to an existing one-dimensional Array, starting at the specified array index.

The one-dimensional Array that is the destination of the elements copied from the . The Array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination .

Returns an enumerator that iterates through the .

An enumerator for the contents of the . The enumeration represents a moment-in-time snapshot of the contents of the queue. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the queue.

Gets the head and tail information of the current contents of the queue. After this call returns, the specified region can be enumerated any number of times and will not change.

Gets the item stored in the th entry in .

Adds an object to the end of the .

The object to add to the end of the . The value can be a null reference (Nothing in Visual Basic) for reference types.

Adds to the end of the queue, adding a new segment if necessary.

Attempts to remove and return the object at the beginning of the .

When this method returns, if the operation was successful, contains the object removed. If no object was available to be removed, the value is unspecified. true if an element was removed and returned from the beginning of the successfully; otherwise, false.

Tries to dequeue an item, removing empty segments as needed.

Attempts to return an object from the beginning of the without removing it.

When this method returns, contains an object from the beginning of the or default(T) if the operation failed. true if and object was returned successfully; otherwise, false. For determining whether the collection contains any items, use of the property is recommended rather than peeking.

Attempts to retrieve the value for the first element in the queue.

The value of the first element, if found. true if the result is needed; otherwise false if only the true/false outcome is needed. true if an element was found; otherwise, false.

Removes all objects from the .

Provides a multi-producer, multi-consumer thread-safe bounded segment. When the queue is full, enqueues fail and return false. When the queue is empty, dequeues fail and return null. These segments are linked together to form the unbounded .

The array of items in this queue. Each slot contains the item in that slot and its "sequence number".

Mask for quickly accessing a position within the queue's array.

The head and tail positions, with padding to help avoid false sharing contention.

Dequeuing happens from the head, enqueuing happens at the tail.

Indicates whether the segment has been marked such that dequeues don't overwrite the removed data.

Indicates whether the segment has been marked such that no additional items may be enqueued.

The segment following this one in the queue, or null if this segment is the last in the queue.

Creates the segment.

The maximum number of elements the segment can contain. Must be a power of 2.

Gets the number of elements this segment can store.

Gets the "freeze offset" for this segment.

Ensures that the segment will not accept any subsequent enqueues that aren't already underway.

When we mark a segment as being frozen for additional enqueues, we set the bool, but that's mostly as a small helper to avoid marking it twice. The real marking comes by modifying the Tail for the segment, increasing it by this . This effectively knocks it off the sequence expected by future enqueuers, such that any additional enqueuer will be unable to enqueue due to it not lining up with the expected sequence numbers. This value is chosen specially so that Tail will grow to a value that maps to the same slot but that won't be confused with any other enqueue/dequeue sequence number.

Tries to dequeue an element from the queue.

Tries to peek at an element from the queue, without removing it.

Attempts to enqueue the item. If successful, the item will be stored in the queue and true will be returned; otherwise, the item won't be stored, and false will be returned.

Represents a slot in the queue.

The item.

The sequence number for this slot, used to synchronize between enqueuers and dequeuers.

Padded head and tail indices, to avoid false sharing between producers and consumers.

Represents a thread-safe last-in, first-out collection of objects.

Specifies the type of elements in the stack. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

A simple (internal) node type used to store elements of concurrent stacks and queues.

Constructs a new node with the specified value and no next node.

The value of the node.

Initializes a new instance of the class.

Initializes a new instance of the class that contains elements copied from the specified collection

The collection whose elements are copied to the new . The argument is null.

Initializes the contents of the stack from an existing collection.

A collection from which to copy elements.

Gets a value that indicates whether the is empty.

Gets the number of elements contained in the .

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized with the SyncRoot; otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported

Removes all objects from the .

Copies the elements of the to an , starting at a particular index.

The one-dimensional that is the destination of the elements copied from the . The must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is multidimensional. -or- does not have zero-based indexing. -or- is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination . -or- The type of the source cannot be cast automatically to the type of the destination .

Copies the elements to an existing one-dimensional , starting at the specified array index.

The one-dimensional that is the destination of the elements copied from the . The must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination .

Inserts an object at the top of the .

The object to push onto the . The value can be a null reference (Nothing in Visual Basic) for reference types.

Inserts multiple objects at the top of the atomically.

The objects to push onto the . is a null reference (Nothing in Visual Basic). When adding multiple items to the stack, using PushRange is a more efficient mechanism than using one item at a time. Additionally, PushRange guarantees that all of the elements will be added atomically, meaning that no other threads will be able to inject elements between the elements being pushed. Items at lower indices in the array will be pushed before items at higher indices.

Inserts multiple objects at the top of the atomically.

The objects to push onto the . The zero-based offset in at which to begin inserting elements onto the top of the . The number of elements to be inserted onto the top of the . is a null reference (Nothing in Visual Basic). or is negative. Or is greater than or equal to the length of . + is greater than the length of . When adding multiple items to the stack, using PushRange is a more efficient mechanism than using one item at a time. Additionally, PushRange guarantees that all of the elements will be added atomically, meaning that no other threads will be able to inject elements between the elements being pushed. Items at lower indices in the array will be pushed before items at higher indices.

Push one or many nodes into the stack, if head and tails are equal then push one node to the stack other wise push the list between head and tail to the stack

The head pointer to the new list The tail pointer to the new list

Local helper function to validate the Pop Push range methods input

Attempts to add an object to the .

Attempts to return an object from the top of the without removing it.

When this method returns, contains an object from the top of the or an unspecified value if the operation failed. true if and object was returned successfully; otherwise, false.

Attempts to pop and return the object at the top of the .

When this method returns, if the operation was successful, contains the object removed. If no object was available to be removed, the value is unspecified. true if an element was removed and returned from the top of the successfully; otherwise, false.

Attempts to pop and return multiple objects from the top of the atomically.

The to which objects popped from the top of the will be added. The number of objects successfully popped from the top of the and inserted in . is a null argument (Nothing in Visual Basic). When popping multiple items, if there is little contention on the stack, using TryPopRange can be more efficient than using once per item to be removed. Nodes fill the with the first node to be popped at the startIndex, the second node to be popped at startIndex + 1, and so on.

Attempts to pop and return multiple objects from the top of the atomically.

The to which objects popped from the top of the will be added. The zero-based offset in at which to begin inserting elements from the top of the . The number of elements to be popped from top of the and inserted into . The number of objects successfully popped from the top of the and inserted in . is a null reference (Nothing in Visual Basic). or is negative. Or is greater than or equal to the length of . + is greater than the length of . When popping multiple items, if there is little contention on the stack, using TryPopRange can be more efficient than using once per item to be removed. Nodes fill the with the first node to be popped at the startIndex, the second node to be popped at startIndex + 1, and so on.

Local helper function to Pop an item from the stack, slow path

The popped item True if succeeded, false otherwise

Slow path helper for TryPop. This method assumes an initial attempt to pop an element has already occurred and failed, so it begins spinning right away.

The number of items to pop. When this method returns, if the pop succeeded, contains the removed object. If no object was available to be removed, the value is unspecified. This parameter is passed uninitialized. The number of objects successfully popped from the top of the .

Local helper function to copy the popped elements into a given collection

The head of the list to be copied The collection to place the popped items in the beginning of index of where to place the popped items The number of nodes.

Attempts to remove and return an object from the .

Copies the items stored in the to a new array.

A new array containing a snapshot of elements copied from the .

Returns an array containing a snapshot of the list's contents, using the target list node as the head of a region in the list.

A list of the stack's contents.

Returns an array containing a snapshot of the list's contents starting at the specified node.

A list of the stack's contents starting at the specified node.

Returns an enumerator that iterates through the .

An enumerator for the . The enumeration represents a moment-in-time snapshot of the contents of the stack. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the stack.

Returns an enumerator that iterates through a collection.

An that can be used to iterate through the collection. The enumeration represents a moment-in-time snapshot of the contents of the stack. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the stack.

A common interface for all concurrent collections. Defines methods to manipulate thread-safe collections intended for producer/consumer usage.

Specifies the type of elements in the collection. All implementations of this interface must enable all members of this interface to be used concurrently from multiple threads.

Copies the elements of the to an , starting at a specified index.

The one-dimensional that is the destination of the elements copied from the . The array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination .

Attempts to add an object to the .

The object to add to the . true if the object was added successfully; otherwise, false. The was invalid for this collection.

Attempts to remove and return an object from the .

When this method returns, if the object was removed and returned successfully, contains the removed object. If no object was available to be removed, the value is unspecified. true if an object was removed and returned successfully; otherwise, false.

Copies the elements contained in the to a new array.

A new array containing the elements copied from the .

A debugger view of the IProducerConsumerCollection that makes it simple to browse the collection's contents at a point in time.

The type of elements stored within.

Constructs a new debugger view object for the provided collection object.

A collection to browse in the debugger.

Returns a snapshot of the underlying collection's elements.

Represents a particular manner of splitting an orderable data source into multiple partitions.

Type of the elements in the collection. Each element in each partition has an integer index associated with it, which determines the relative order of that element against elements in other partitions. Inheritors of must adhere to the following rules:

All indices must be unique, such that there may not be duplicate indices. If all indices are not unique, the output ordering may be scrambled.
All indices must be non-negative. If any indices are negative, consumers of the implementation may throw exceptions.
and should throw a if the requested partition count is less than or equal to zero.
and should always return a number of enumerables equal to the requested partition count. If the partitioner runs out of data and cannot create as many partitions as requested, an empty enumerator should be returned for each of the remaining partitions. If this rule is not followed, consumers of the implementation may throw a .
, , , and should never return null. If null is returned, a consumer of the implementation may throw a .
, , , and should always return partitions that can fully and uniquely enumerate the input data source. All of the data and only the data contained in the input source should be enumerated, with no duplication that was not already in the input, unless specifically required by the particular partitioner's design. If this is not followed, the output ordering may be scrambled.
If returns true, each partition must return elements with increasing key indices.
If returns true, all the keys in partition numbered N must be larger than all the keys in partition numbered N-1.
If returns true, all indices must be monotonically increasing from 0, though not necessarily within a single partition.

Initializes a new instance of the class with the specified constraints on the index keys.

Indicates whether the elements in each partition are yielded in the order of increasing keys. Indicates whether elements in an earlier partition always come before elements in a later partition. If true, each element in partition 0 has a smaller order key than any element in partition 1, each element in partition 1 has a smaller order key than any element in partition 2, and so on. Indicates whether keys are normalized. If true, all order keys are distinct integers in the range [0 .. numberOfElements-1]. If false, order keys must still be distinct, but only their relative order is considered, not their absolute values.

Partitions the underlying collection into the specified number of orderable partitions.

Each partition is represented as an enumerator over key-value pairs. The value of the pair is the element itself, and the key is an integer which determines the relative ordering of this element against other elements in the data source. The number of partitions to create. A list containing enumerators.

Creates an object that can partition the underlying collection into a variable number of partitions.

The returned object implements the interface. Calling GetEnumerator on the object creates another partition over the sequence. Each partition is represented as an enumerator over key-value pairs. The value in the pair is the element itself, and the key is an integer which determines the relative ordering of this element against other elements. The method is only supported if the SupportsDynamicPartitions property returns true. An object that can create partitions over the underlying data source. Dynamic partitioning is not supported by this partitioner.

Gets whether elements in each partition are yielded in the order of increasing keys.

Gets whether elements in an earlier partition always come before elements in a later partition.

If returns true, each element in partition 0 has a smaller order key than any element in partition 1, each element in partition 1 has a smaller order key than any element in partition 2, and so on.

Gets whether order keys are normalized.

If returns true, all order keys are distinct integers in the range [0 .. numberOfElements-1]. If the property returns false, order keys must still be distinct, but only their relative order is considered, not their absolute values.

Partitions the underlying collection into the given number of ordered partitions.

The default implementation provides the same behavior as except that the returned set of partitions does not provide the keys for the elements. The number of partitions to create. A list containing enumerators.

Creates an object that can partition the underlying collection into a variable number of partitions.

The returned object implements the interface. Calling GetEnumerator on the object creates another partition over the sequence. The default implementation provides the same behavior as except that the returned set of partitions does not provide the keys for the elements. The method is only supported if the property returns true. An object that can create partitions over the underlying data source. Dynamic partitioning is not supported by this partitioner.

Converts an enumerable over key-value pairs to an enumerable over values.

Represents a particular manner of splitting a data source into multiple partitions.

Type of the elements in the collection. Inheritors of must adhere to the following rules:

should throw a if the requested partition count is less than or equal to zero.
should always return a number of enumerables equal to the requested partition count. If the partitioner runs out of data and cannot create as many partitions as requested, an empty enumerator should be returned for each of the remaining partitions. If this rule is not followed, consumers of the implementation may throw a .
and should never return null. If null is returned, a consumer of the implementation may throw a .
and should always return partitions that can fully and uniquely enumerate the input data source. All of the data and only the data contained in the input source should be enumerated, with no duplication that was not already in the input, unless specifically required by the particular partitioner's design. If this is not followed, the output ordering may be scrambled.

Partitions the underlying collection into the given number of partitions.

The number of partitions to create. A list containing enumerators.

Gets whether additional partitions can be created dynamically.

true if the can create partitions dynamically as they are requested; false if the can only allocate partitions statically. If a derived class does not override and implement , should return false. The value of should not vary over the lifetime of this instance.

Creates an object that can partition the underlying collection into a variable number of partitions.

The returned object implements the interface. Calling GetEnumerator on the object creates another partition over the sequence. The method is only supported if the property returns true. An object that can create partitions over the underlying data source. Dynamic partitioning is not supported by this partitioner.

Provides common partitioning strategies for arrays, lists, and enumerables.

The static methods on are all thread-safe and may be used concurrently from multiple threads. However, while a created partitioner is in use, the underlying data source should not be modified, whether from the same thread that's using a partitioner or from a separate thread.

Creates an orderable partitioner from an instance.

Type of the elements in source list. The list to be partitioned. A Boolean value that indicates whether the created partitioner should dynamically load balance between partitions rather than statically partition. An orderable partitioner based on the input list.

Creates an orderable partitioner from a instance.

Type of the elements in source array. The array to be partitioned. A Boolean value that indicates whether the created partitioner should dynamically load balance between partitions rather than statically partition. An orderable partitioner based on the input array.

Creates an orderable partitioner from a instance.

Type of the elements in source enumerable. The enumerable to be partitioned. An orderable partitioner based on the input array. The ordering used in the created partitioner is determined by the natural order of the elements as retrieved from the source enumerable.

Creates an orderable partitioner from a instance.

Type of the elements in source enumerable. The enumerable to be partitioned. Options to control the buffering behavior of the partitioner. The argument specifies an invalid value for . An orderable partitioner based on the input array. The ordering used in the created partitioner is determined by the natural order of the elements as retrieved from the source enumerable.

Creates a partitioner that chunks the user-specified range.

The lower, inclusive bound of the range. The upper, exclusive bound of the range. The size of each subrange. A partitioner. The argument is less than or equal to the argument. The argument is less than or equal to 0.

Creates a partitioner that chunks the user-specified range.

The lower, inclusive bound of the range. The upper, exclusive bound of the range. A partitioner. The argument is less than or equal to the argument. if ProccessorCount == 1, for correct rangeSize calculation the const CoreOversubscriptionRate must be > 1 (avoid division by 1), and the same issue could occur with rangeSize == -1 when fromInclusive = int.MinValue and toExclusive = int.MaxValue.

Creates a partitioner that chunks the user-specified range.

DynamicPartitionEnumerator_Abstract defines the enumerator for each partition for the dynamic load-balance partitioning algorithm. - Partition is an enumerator of KeyValuePairs, each corresponding to an item in the data source: the key is the index in the source collection; the value is the item itself. - a set of such partitions share a reader over data source. The type of the reader is specified by TSourceReader. - each partition requests a contiguous chunk of elements at a time from the source data. The chunk size is initially 1, and doubles every time until it reaches the maximum chunk size. The implementation for GrabNextChunk() method has two versions: one for data source of IndexRange types (IList and the array), one for data source of IEnumerable. - The method "Reset" is not supported for any partitioning algorithm. - The implementation for MoveNext() method is same for all dynamic partitioners, so we provide it in this abstract class.

Type of the elements in the data source Type of the reader on the data source

Abstract method to request a contiguous chunk of elements from the source collection

specified number of elements requested true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

Abstract property, returns whether or not the shared reader has already read the last element of the source data

Get the current element in the current partition. Property required by IEnumerator interface This property is abstract because the implementation is different depending on the type of the source data: IList, Array or IEnumerable

Dispose is abstract, and depends on the type of the source data: - For source data type IList and Array, the type of the shared reader is just the data itself. We don't do anything in Dispose method for IList and Array. - For source data type IEnumerable, the type of the shared reader is an enumerator we created. Thus we need to dispose this shared reader enumerator, when there is no more active partitions left.

Reset on partitions is not supported

Get the current element in the current partition. Property required by IEnumerator interface

Moves to the next element if any. Try current chunk first, if the current chunk do not have any elements left, then we attempt to grab a chunk from the source collection.

true if successfully moving to the next position; false otherwise, if and only if there is no more elements left in the current chunk AND the source collection is exhausted.

Inherits from DynamicPartitioners Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance of EnumerableOfPartitionsForIEnumerator defined internally

Type of elements in the source data

Overrides OrderablePartitioner.GetOrderablePartitions. Partitions the underlying collection into the given number of orderable partitions.

number of partitions requested A list containing enumerators.

Overrides OrderablePartitioner.GetOrderableDynamicPartitions

a enumerable collection of orderable partitions

Whether additional partitions can be created dynamically.

Provides customized implementation for source data of IEnumerable Different from the counterpart for IList/Array, this enumerable maintains several additional fields shared by the partitions it owns, including a boolean "_hasNoElementsLef", a shared lock, and a shared count "_activePartitionCount" used to track active partitions when they were created statically

This is the common entry point for consuming items from the source enumerable

true if we successfully reserved at least one element false if all elements in the source collection have been reserved.

Version of GrabChunk that grabs a single element at a time from the source enumerable

true if we successfully reserved an element false if all elements in the source collection have been reserved.

Version of GrabChunk that uses buffering scheme to grab items out of source enumerable

true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

Inherits from DynamicPartitionEnumerator_Abstract directly Provides customized implementation for: GrabNextChunk, HasNoElementsLeft, Current, Dispose

Reserves a contiguous range of elements from source data

specified number of elements requested true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

Returns whether or not the shared reader has already read the last element of the source data

We cannot call _sharedReader.MoveNext(), to see if it hits the last element or not, because we can't undo MoveNext(). Thus we need to maintain a shared boolean value _hasNoElementsLeft across all partitions

Dynamic load-balance partitioner. This class is abstract and to be derived from by the customized partitioner classes for IList, Array, and IEnumerable

Type of the elements in the source data Type of the source data collection

Constructs a new orderable partitioner

source data collection

Partition the source data and create an enumerable over the resulting partitions.

the source data collection an enumerable of partitions of

Overrides OrderablePartitioner.GetOrderablePartitions. Partitions the underlying collection into the given number of orderable partitions.

number of partitions requested A list containing enumerators.

Overrides OrderablePartitioner.GetOrderableDynamicPartitions

a enumerable collection of orderable partitions

Whether additional partitions can be created dynamically.

Defines dynamic partition for source data of IList and Array. This class inherits DynamicPartitionEnumerator_Abstract - implements GrabNextChunk, HasNoElementsLeft, and Dispose methods for IList and Array - Current property still remains abstract, implementation is different for IList and Array - introduces another abstract method SourceCount, which returns the number of elements in the source data. Implementation differs for IList and Array

Type of the elements in the data source Type of the reader on the source data

Get the number of elements from the source reader. It calls IList.Count or Array.Length

Reserves a contiguous range of elements from source data

specified number of elements requested true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

Returns whether or not the shared reader has already read the last element of the source data

For source data type IList and Array, the type of the shared reader is just the data itself. We don't do anything in Dispose method for IList and Array.

Inherits from DynamicPartitioners Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance of EnumerableOfPartitionsForIList defined internally

Type of elements in the source data

Inherits from PartitionList_Abstract Provides customized implementation for source data of IList

Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract Provides customized implementation of SourceCount property and Current property for IList

return a KeyValuePair of the current element and its key

Inherits from DynamicPartitioners Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance of EnumerableOfPartitionsForArray defined internally

Type of elements in the source data

Inherits from PartitionList_Abstract Provides customized implementation for source data of Array

Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract Provides customized implementation of SourceCount property and Current property for Array

Static partitioning over IList. - dynamic and load-balance - Keys are ordered within each partition - Keys are ordered across partitions - Keys are normalized - Number of partitions is fixed once specified, and the elements of the source data are distributed to each partition as evenly as possible.

type of the elements Type of the source data collection

Abstract method to return the number of elements in the source data

Abstract method to create a partition that covers a range over source data, starting from "startIndex", ending at "endIndex"

start index of the current partition on the source data end index of the current partition on the source data a partition enumerator over the specified range

Overrides OrderablePartitioner.GetOrderablePartitions Return a list of partitions, each of which enumerate a fixed part of the source data The elements of the source data are distributed to each partition as evenly as possible. Specifically, if the total number of elements is N, and number of partitions is x, and N = a*x +b, where a is the quotient, and b is the remainder. Then the first b partitions each has a + 1 elements, and the last x-b partitions each has a elements. For example, if N=10, x =3, then partition 0 ranges [0,3], partition 1 ranges [4,6], partition 2 ranges [7,9]. This also takes care of the situation of (x>N), the last x-N partitions are empty enumerators. An empty enumerator is indicated by (_startIndex == list.Count && _endIndex == list.Count -1)

specified number of partitions a list of partitions

Static Partition for IList/Array. This class implements all methods required by IEnumerator interface, except for the Current property. Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster element retrieval.

Constructs an instance of StaticIndexRangePartition

the start index in the source collection for the current partition the end index in the source collection for the current partition

Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster element retrieval.

We don't dispose the source for IList and array

Moves to the next item Before the first MoveNext is called: _offset == _startIndex-1;

true if successful, false if there is no item left

Inherits from StaticIndexRangePartitioner Provides customized implementation of SourceCount and CreatePartition

Inherits from StaticIndexRangePartition Provides customized implementation of Current property

Inherits from StaticIndexRangePartitioner Provides customized implementation of SourceCount and CreatePartition for Array

Inherits from StaticIndexRangePartitioner Provides customized implementation of SourceCount and CreatePartition

A very simple primitive that allows us to share a value across multiple threads.

Out-of-the-box partitioners are created with a set of default behaviors. For example, by default, some form of buffering and chunking will be employed to achieve optimal performance in the common scenario where an implementation is fast and non-blocking. These behaviors can be overridden via this enumeration.

Use the default behavior (i.e., use buffering to achieve optimal performance)

Creates a partitioner that will take items from the source enumerable one at a time and will not use intermediate storage that can be accessed more efficiently by multiple threads. This option provides support for low latency (items will be processed as soon as they are available from the source) and partial support for dependencies between items (a thread cannot deadlock waiting for an item that it, itself, is responsible for processing).

Returns approximate reciprocal of the divisor: ceil(2**64 / divisor).

This should only be used on 64-bit.

Performs a mod operation using the multiplier pre-computed with .

This should only be used on 64-bit.

Schedules a callback roughly every gen 2 GC (you may see a Gen 0 an Gen 1 but only once) (We can fix this by capturing the Gen 2 count at startup and testing, but I mostly don't care)

Schedule 'callback' to be called in the next GC. If the callback returns true it is rescheduled for the next Gen 2 GC. Otherwise the callbacks stop.

Schedule 'callback' to be called in the next GC. If the callback returns true it is rescheduled for the next Gen 2 GC. Otherwise the callbacks stop. NOTE: This callback will be kept alive until either the callback function returns false, or the target object dies.

Adds a span of bytes to the hash code.

The span. This method does not guarantee that the result of adding a span of bytes will match the result of adding the same bytes individually.

Extensions to providing consistent access to APIs introduced after the type.

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Memory represents a contiguous region of arbitrary memory similar to . Unlike , it is not a byref-like type.

Creates a new memory over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. The number of items in the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new memory from a memory manager that provides specific method implementations beginning at 0 index and ending at 'end' index (exclusive).

The memory manager. The number of items in the memory. Thrown when the specified is negative. For internal infrastructure only

Creates a new memory from a memory manager that provides specific method implementations beginning at 'start' index and ending at 'end' index (exclusive).

The memory manager. The index at which to begin the memory. The number of items in the memory. Thrown when the specified or is negative. For internal infrastructure only

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns an empty

The number of items in the memory.

Returns true if Length is 0.

For , returns a new instance of string that represents the characters pointed to by the memory. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given memory, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given memory, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Returns a span from the memory.

Copies the contents of the memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. The Memory to copy items into. Thrown when the destination is shorter than the source.

Copies the contents of the memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. If the destination is shorter than the source, this method return false and no data is written to the destination.

The span to copy items into.

Creates a handle for the memory. The GC will not move the memory until the returned is disposed, enabling taking and using the memory's address. An instance with nonprimitive (non-blittable) members cannot be pinned.

Copies the contents from the memory into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Determines whether the specified object is equal to the current object. Returns true if the object is Memory or ReadOnlyMemory and if both objects point to the same array and have the same length.

Returns true if the memory points to the same array and has the same length. Note that this does *not* check to see if the *contents* are equal.

Serves as the default hash function.

Extension methods for Span{T}, Memory{T}, and friends.

Removes all leading and trailing white-space characters from the span.

Removes all leading white-space characters from the span.

Removes all trailing white-space characters from the span.

Removes all leading and trailing occurrences of a specified character.

The source span from which the character is removed. The specified character to look for and remove.

Removes all leading occurrences of a specified character.

The source span from which the character is removed. The specified character to look for and remove.

Removes all trailing occurrences of a specified character.

The source span from which the character is removed. The specified character to look for and remove.

Removes all leading and trailing occurrences of a set of characters specified in a readonly span from the span.

The source span from which the characters are removed. The span which contains the set of characters to remove. If is empty, white-space characters are removed instead.

Removes all leading occurrences of a set of characters specified in a readonly span from the span.

The source span from which the characters are removed. The span which contains the set of characters to remove. If is empty, white-space characters are removed instead.

Removes all trailing occurrences of a set of characters specified in a readonly span from the span.

The source span from which the characters are removed. The span which contains the set of characters to remove. If is empty, white-space characters are removed instead.

Indicates whether the specified span contains only white-space characters.

Searches for the specified value and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).

Determines the relative order of the sequences being compared by comparing the elements using IComparable{T}.CompareTo(T).

Searches for the specified value and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).

Determines the relative order of the sequences being compared by comparing the elements using IComparable{T}.CompareTo(T).

Determines whether the specified sequence appears at the start of the span.

Determines whether the specified sequence appears at the end of the span.

Reverses the sequence of the elements in the entire span.

Creates a new span over the target array.

Creates a new Span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the Span. The number of items in the Span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new span over the portion of the target array segment.

Creates a new Span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the Span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=segment.Count).

Creates a new Span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

Creates a new memory over the target array.

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=array.Length).

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

Creates a new memory over the portion of the target array.

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

Copies the contents of the array into the span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten. The array to copy items from. The span to copy items into. Thrown when the destination Span is shorter than the source array.

Copies the contents of the array into the memory. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. The array to copy items from. The memory to copy items into. Thrown when the destination is shorter than the source array.

Determines whether two sequences overlap in memory.

Determines whether two sequences overlap in memory and outputs the element offset.

Determines whether two sequences overlap in memory.

Determines whether two sequences overlap in memory and outputs the element offset.

Searches an entire sorted for a value using the specified generic interface.

The element type of the span. The sorted to search. The to use when comparing. The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for a value using the specified generic type.

The element type of the span. The specific type of . The sorted to search. The to use when comparing. The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for the specified using the specified generic type.

The element type of the span. The specific type of . The sorted to search. The object to locate. The value can be null for reference types. The to use when comparing. /// The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for a value using the specified generic interface.

Searches an entire sorted for a value using the specified generic type.

Searches an entire sorted for the specified using the specified generic type.

Creates a new span over the portion of the target array.

Returns a value indicating whether the specified occurs within the . The source span. The value to seek within the source span. One of the enumeration values that determines how the and are compared.

Determines whether this and the specified span have the same characters when compared using the specified option. The source span. The value to compare with the source span. One of the enumeration values that determines how the and are compared.

Compares the specified and using the specified , and returns an integer that indicates their relative position in the sort order. The source span. The value to compare with the source span. One of the enumeration values that determines how the and are compared.

Reports the zero-based index of the first occurrence of the specified in the current . The source span. The value to seek within the source span. One of the enumeration values that determines how the and are compared.

Copies the characters from the source span into the destination, converting each character to lowercase, using the casing rules of the specified culture.

The source span. The destination span which contains the transformed characters. An object that supplies culture-specific casing rules. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. Thrown when is null.

Copies the characters from the source span into the destination, converting each character to lowercase, using the casing rules of the invariant culture.

The source span. The destination span which contains the transformed characters. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten.

Copies the characters from the source span into the destination, converting each character to uppercase, using the casing rules of the specified culture.

Copies the characters from the source span into the destination, converting each character to uppercase using the casing rules of the invariant culture.

Determines whether the end of the matches the specified when compared using the specified option.

The source span. The sequence to compare to the end of the source span. One of the enumeration values that determines how the and are compared.

Determines whether the beginning of the matches the specified when compared using the specified option.

The source span. The sequence to compare to the beginning of the source span. One of the enumeration values that determines how the and are compared.

Creates a new readonly span over the portion of the target string.

The target string. Returns default when is null.

Creates a new readonly span over the portion of the target string.

The target string. The index at which to begin this slice. Returns default when is null. Thrown when the specified index is not in range (<0 or >text.Length).

Creates a new readonly span over the portion of the target string.

The target string. The index at which to begin this slice. The desired length for the slice (exclusive). Returns default when is null. Thrown when the specified index or is not in range.

Creates a new over the portion of the target string.

The target string. Returns default when is null.

Creates a new over the portion of the target string.

The target string. The index at which to begin this slice. Returns default when is null. Thrown when the specified index is not in range (<0 or >text.Length).

Creates a new over the portion of the target string.

The target string. The index at which to begin this slice. The desired length for the slice (exclusive). Returns default when is null. Thrown when the specified index or is not in range.

Represents a contiguous region of memory, similar to . Unlike , it is not a byref-like type.

Creates a new memory over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

Creates a new memory over the existing object, start, and length. No validation is performed.

The target object. The index at which to begin the memory. The number of items in the memory.

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns an empty

The number of items in the memory.

Returns true if Length is 0.

For , returns a new instance of string that represents the characters pointed to by the memory. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given memory, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given memory, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Returns a span from the memory.

Copies the contents of the read-only memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. The Memory to copy items into. Thrown when the destination is shorter than the source.

Copies the contents of the readonly-only memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. If the destination is shorter than the source, this method return false and no data is written to the destination.

The span to copy items into.

Copies the contents from the memory into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Determines whether the specified object is equal to the current object.

Returns true if the memory points to the same array and has the same length. Note that this does *not* check to see if the *contents* are equal.

Returns the hash code for this

Gets the state of the memory as individual fields.

The offset. The count. The object.

ReadOnlySpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed or native memory, or to memory allocated on the stack. It is type- and memory-safe.

The number of items in the read-only span.

Returns true if Length is 0.

Returns false if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

This method is not supported as spans cannot be boxed. To compare two spans, use operator==. Always thrown by this method.

This method is not supported as spans cannot be boxed. Always thrown by this method.

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns a 0-length read-only span whose base is the null pointer.

Gets an enumerator for this span.

Enumerates the elements of a .

The span being enumerated.

The next index to yield.

Initialize the enumerator.

The span to enumerate.

Advances the enumerator to the next element of the span.

Gets the element at the current position of the enumerator.

Creates a new read-only span over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new read-only span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the read-only span. The number of items in the read-only span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new read-only span over the target unmanaged buffer. Clearly this is quite dangerous, because we are creating arbitrarily typed T's out of a void*-typed block of memory. And the length is not checked. But if this creation is correct, then all subsequent uses are correct.

An unmanaged pointer to memory. The number of elements the memory contains. Thrown when is reference type or contains pointers and hence cannot be stored in unmanaged memory. Thrown when the specified is negative.

Returns the specified element of the read-only span.

Thrown when index less than 0 or index greater than or equal to Length

Returns a reference to the 0th element of the Span. If the Span is empty, returns null reference. It can be used for pinning and is required to support the use of span within a fixed statement.

Copies the contents of this read-only span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten.

The span to copy items into. Thrown when the destination Span is shorter than the source Span.

If the destination span is shorter than the source span, this method return false and no data is written to the destination. The span to copy items into.

Returns true if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

For , returns a new instance of string that represents the characters pointed to by the span. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given read-only span, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given read-only span, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Copies the contents of this read-only span into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed or native memory, or to memory allocated on the stack. It is type- and memory-safe.

The number of items in the span.

Returns true if Length is 0.

Returns false if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

This method is not supported as spans cannot be boxed. To compare two spans, use operator==. Always thrown by this method.

This method is not supported as spans cannot be boxed. Always thrown by this method.

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns an empty

Gets an enumerator for this span.

Enumerates the elements of a .

The span being enumerated.

The next index to yield.

Initialize the enumerator.

The span to enumerate.

Advances the enumerator to the next element of the span.

Gets the element at the current position of the enumerator.

Creates a new span over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the span. The number of items in the span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new span over the target unmanaged buffer. Clearly this is quite dangerous, because we are creating arbitrarily typed T's out of a void*-typed block of memory. And the length is not checked. But if this creation is correct, then all subsequent uses are correct.

Returns a reference to specified element of the Span.

Thrown when index less than 0 or index greater than or equal to Length

Returns a reference to the 0th element of the Span. If the Span is empty, returns null reference. It can be used for pinning and is required to support the use of span within a fixed statement.

Clears the contents of this span.

Fills the contents of this span with the given value.

Copies the contents of this span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten. The span to copy items into. Thrown when the destination Span is shorter than the source Span.

Copies the contents of this span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten. If the destination span is shorter than the source span, this method return false and no data is written to the destination.

The span to copy items into.

Returns true if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

Defines an implicit conversion of a to a

For , returns a new instance of string that represents the characters pointed to by the span. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given span, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given span, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Copies the contents of this span into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Implements the copy functionality used by Span and ReadOnlySpan. NOTE: Fast span implements TryCopyTo in corelib and therefore this implementation is only used by portable span. The code must live in code that only compiles for portable span which means either each individual span implementation of this shared code file. Other shared SpanHelper.X.cs files are compiled for both portable and fast span implementations.

Computes "start + index * sizeof(T)", using the unsigned IntPtr-sized multiplication for 32 and 64 bits. Assumptions: Start and index are non-negative, and already pre-validated to be within the valid range of their containing Span. If the byte length (Span.Length * sizeof(T)) does an unsigned overflow (i.e. the buffer wraps or is too big to fit within the address space), the behavior is undefined.

Determine if a type is eligible for storage in unmanaged memory. Portable equivalent of RuntimeHelpers.IsReferenceOrContainsReferences{T}()

Utility methods for intrinsic bit-twiddling operations. The methods use hardware intrinsics when available on the underlying platform, otherwise they use optimized software fallbacks.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since Log(0) is undefined. Does not directly use any hardware intrinsics, nor does it incur branching.

The value.

Returns the integer (ceiling) log of the specified value, base 2.

The value.

Returns the integer (ceiling) log of the specified value, base 2.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Reset the lowest significant bit in the given value

Reset specific bit in the given value

Extensions to providing consistent access to APIs introduced after the type.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Round the given integral value up to a power of 2.

The value. The smallest power of 2 which is greater than or equal to . If is 0 or the result overflows, returns 0.

Round the given integral value up to a power of 2.

The value. The smallest power of 2 which is greater than or equal to . If is 0 or the result overflows, returns 0.

Round the given integral value up to a power of 2.

The value. The smallest power of 2 which is greater than or equal to . If is 0 or the result overflows, returns 0.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32 on a 32-bit process, and any value outside the range [0..63] is treated as congruent mod 64 on a 64-bit process. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

Extensions to providing consistent access to APIs introduced after the type.

Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available.

Spin locks can be used for leaf-level locks where the object allocation implied by using a , in size or due to garbage collection pressure, is overly expensive. Avoiding blocking is another reason that a spin lock can be useful, however if you expect any significant amount of blocking, you are probably best not using spin locks due to excessive spinning. Spinning can be beneficial when locks are fine grained and large in number (for example, a lock per node in a linked list) as well as when lock hold times are always extremely short. In general, while holding a spin lock, one should avoid blocking, calling anything that itself may block, holding more than one spin lock at once, making dynamically dispatched calls (interface and virtuals), making statically dispatched calls into any code one doesn't own, or allocating memory. should only be used when it's been determined that doing so will improve an application's performance. It's also important to note that is a value type, for performance reasons. As such, one must be very careful not to accidentally copy a SpinLock instance, as the two instances (the original and the copy) would then be completely independent of one another, which would likely lead to erroneous behavior of the application. If a SpinLock instance must be passed around, it should be passed by reference rather than by value. Do not store instances in readonly fields. All members of are thread-safe and may be used from multiple threads concurrently.

Initializes a new instance of the structure with the option to track thread IDs to improve debugging.

The default constructor for tracks thread ownership. Whether to capture and use thread IDs for debugging purposes.

Initializes a new instance of the structure with the option to track thread IDs to improve debugging.

The default constructor for tracks thread ownership.

Acquires the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

is a non-reentrant lock, meaning that if a thread holds the lock, it is not allowed to enter the lock again. If thread ownership tracking is enabled (whether it's enabled is available through ), an exception will be thrown when a thread tries to re-enter a lock it already holds. However, if thread ownership tracking is disabled, attempting to enter a lock already held will result in deadlock. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling Enter.

Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

Unlike , TryEnter will not block waiting for the lock to be available. If the lock is not available when TryEnter is called, it will return immediately without any further spinning. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling TryEnter.

Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

Unlike , TryEnter will not block indefinitely waiting for the lock to be available. It will block until either the lock is available or until the has expired. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling TryEnter. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than milliseconds.

Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

Unlike , TryEnter will not block indefinitely waiting for the lock to be available. It will block until either the lock is available or until the has expired. The number of milliseconds to wait, or (-1) to wait indefinitely. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling TryEnter. is a negative number other than -1, which represents an infinite time-out.

Try acquire the lock with long path, this is usually called after the first path in Enter and TryEnter failed The reason for short path is to make it inline in the run time which improves the performance. This method assumed that the parameter are validated in Enter or TryEnter method.

The timeout milliseconds The lockTaken param

decrements the waiters, in case of the timeout is expired

ContinueTryEnter for the thread tracking mode enabled

Releases the lock.

The default overload of provides the same behavior as if calling using true as the argument, but Exit() could be slightly faster than Exit(true). Thread ownership tracking is enabled, and the current thread is not the owner of this lock.

Releases the lock.

A Boolean value that indicates whether a memory fence should be issued in order to immediately publish the exit operation to other threads. Calling with the argument set to true will improve the fairness of the lock at the expense of some performance. The default overload behaves as if specifying true for . Thread ownership tracking is enabled, and the current thread is not the owner of this lock.

The slow path for exit method if the fast path failed

A Boolean value that indicates whether a memory fence should be issued in order to immediately publish the exit operation to other threads

Gets whether the lock is currently held by any thread.

Gets whether the lock is held by the current thread.

If the lock was initialized to track owner threads, this will return whether the lock is acquired by the current thread. It is invalid to use this property when the lock was initialized to not track thread ownership. Thread ownership tracking is disabled.

Gets whether thread ownership tracking is enabled for this instance.

internal class used by debug type proxy attribute to display the owner thread ID

SystemThreading_SpinLockDebugView constructor

The SpinLock to be proxied.

Checks if the lock is held by the current thread or not

Gets the current owner thread, zero if it is released

Gets whether the lock is currently held by any thread or not.

Provides support for spin-based waiting.

encapsulates common spinning logic. On single-processor machines, yields are always used instead of busy waits, and on computers with Intel(R) processors employing Hyper-Threading technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of spinning and true yielding. is a value type, which means that low-level code can utilize SpinWait without fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. In most cases, you should use the synchronization classes provided by the .NET Framework, such as . For most purposes where spin waiting is required, however, the type should be preferred over the method. While SpinWait is designed to be used in concurrent applications, it is not designed to be used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple threads must spin, each should use its own instance of SpinWait.

A suggested number of spin iterations before doing a proper wait, such as waiting on an event that becomes signaled when the resource becomes available.

These numbers were arrived at by experimenting with different numbers in various cases that currently use it. It's only a suggested value and typically works well when the proper wait is something like an event. Spinning less can lead to early waiting and more context switching, spinning more can decrease latency but may use up some CPU time unnecessarily. Depends on the situation too, for instance SemaphoreSlim uses more iterations because the waiting there is currently a lot more expensive (involves more spinning, taking a lock, etc.). It also depends on the likelihood of the spin being successful and how long the wait would be but those are not accounted for here.

Gets the number of times has been called on this instance.

Gets whether the next call to will yield the processor, triggering a forced context switch.

Whether the next call to will yield the processor, triggering a forced context switch. On a single-CPU machine, always yields the processor. On machines with multiple CPUs, may yield after an unspecified number of calls.

Performs a single spin.

This is typically called in a loop, and may change in behavior based on the number of times a has been called thus far on this instance.

Performs a single spin.

A minimum spin count after which Thread.Sleep(1) may be used. A value of -1 may be used to disable the use of Thread.Sleep(1). is less than -1. This is typically called in a loop, and may change in behavior based on the number of times a has been called thus far on this instance.

Resets the spin counter.

This makes and behave as though no calls to had been issued on this instance. If a instance is reused many times, it may be useful to reset it to avoid yielding too soon.

Spins until the specified condition is satisfied.

A delegate to be executed over and over until it returns true. The argument is null.

Spins until the specified condition is satisfied or until the specified timeout is expired.

A delegate to be executed over and over until it returns true. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. True if the condition is satisfied within the timeout; otherwise, false The argument is null. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than .

Spins until the specified condition is satisfied or until the specified timeout is expired.

A delegate to be executed over and over until it returns true. The number of milliseconds to wait, or (-1) to wait indefinitely. True if the condition is satisfied within the timeout; otherwise, false The argument is null. is a negative number other than -1, which represents an infinite time-out.

A helper class to capture a start time using as a time in milliseconds. Also updates a given timeout by subtracting the current time from the start time.

Returns as a start time in milliseconds as a . rolls over from positive to negative every ~25 days, then ~25 days to back to positive again. is used to ignore the sign and double the range to 50 days.

Helper function to measure and update the elapsed time

The first time (in milliseconds) observed when the wait started The original wait timeout in milliseconds The new wait time in milliseconds, or -1 if the time expired

Provides thread-local storage of data.

Specifies the type of data stored per-thread. With the exception of , all public and protected members of are thread-safe and may be used concurrently from multiple threads.

Initializes the instance.

Whether to track all values set on the instance and expose them through the Values property.

Initializes the instance with the specified function.

The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. is a null reference (Nothing in Visual Basic).

Initializes the instance with the specified function.

The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. Whether to track all values set on the instance and expose them via the Values property. is a null reference (Nothing in Visual Basic).

Releases the resources used by this instance.

Unlike most of the members of , this method is not thread-safe.

Releases the resources used by this instance.

A Boolean value that indicates whether this method is being called due to a call to . Unlike most of the members of , this method is not thread-safe.

Creates and returns a string representation of this instance for the current thread.

The result of calling on the . The for the current thread is a null reference (Nothing in Visual Basic). The initialization function referenced in an improper manner. The instance has been disposed. Calling this method forces initialization for the current thread, as is the case with accessing directly.

Gets or sets the value of this instance for the current thread.

The initialization function referenced in an improper manner. The instance has been disposed. If this instance was not previously initialized for the current thread, accessing will attempt to initialize it. If an initialization function was supplied during the construction, that initialization will happen by invoking the function to retrieve the initial value for . Otherwise, the default value of will be used.

Creates a LinkedSlot and inserts it into the linked list for this ThreadLocal instance.

Gets a list for all of the values currently stored by all of the threads that have accessed this instance.

The instance has been disposed.

Gets all of the threads' values in a list.

Gets the number of threads that have data in this instance.

Gets whether is initialized on the current thread.

The instance has been disposed.

Gets the value of the ThreadLocal<T> for debugging display purposes. It takes care of getting the value for the current thread in the ThreadLocal mode.

Gets the values of all threads that accessed the ThreadLocal<T>.

Resizes a table to a certain length (or larger).

Chooses the next larger table size

A wrapper struct used as LinkedSlotVolatile[] - an array of LinkedSlot instances, but with volatile semantics on array accesses.

A node in the doubly-linked list stored in the ThreadLocal instance. The value is stored in one of two places: 1. If SlotArray is not null, the value is in SlotArray.Table[id] 2. If SlotArray is null, the value is in FinalValue.

A manager class that assigns IDs to ThreadLocal instances

A class that facilitates ThreadLocal cleanup after a thread exits. After a thread with an associated thread-local table has exited, the FinalizationHelper is responsible for removing back-references to the table. Since an instance of FinalizationHelper is only referenced from a single thread-local slot, the FinalizationHelper will be GC'd once the thread has exited. The FinalizationHelper then locates all LinkedSlot instances with back-references to the table (all those LinkedSlot instances can be found by following references from the table slots) and releases the table so that it can get GC'd.

A debugger view of the ThreadLocal<T> to surface additional debugging properties and to ensure that the ThreadLocal<T> does not become initialized if it was not already.

Constructs a new debugger view object for the provided ThreadLocal object.

A ThreadLocal object to browse in the debugger.

Returns whether the ThreadLocal object is initialized or not.

Returns the value of the ThreadLocal object.

Return all values for all threads that have accessed this instance.

Methods for accessing memory with volatile semantics.

Helper so we can call some tuple methods recursively without knowing the underlying types.

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

The number of positions in this data structure.

Get the element at position .

Helper so we can call some tuple methods recursively without knowing the underlying types.

The ValueTuple types (from arity 0 to 8) comprise the runtime implementation that underlies tuples in C# and struct tuples in F#. Aside from created via language syntax, they are most easily created via the ValueTuple.Create factory methods. The System.ValueTuple types differ from the System.Tuple types in that: - they are structs rather than classes, - they are mutable rather than readonly, and - their members (such as Item1, Item2, etc) are fields rather than properties.

Returns a value that indicates whether the current instance is equal to a specified object.

The object to compare with this instance. if is a .

Returns a value indicating whether this instance is equal to a specified value.

An instance to compare to this instance. true if has the same value as this instance; otherwise, false.

Compares this instance to a specified instance and returns an indication of their relative values.

An instance to compare. A signed number indicating the relative values of this instance and . Returns less than zero if this instance is less than , zero if this instance is equal to , and greater than zero if this instance is greater than .

Returns the hash code for this instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form ().

The number of positions in this data structure.

Get the element at position .

Creates a new struct 0-tuple.

A 0-tuple.

Creates a new struct 1-tuple, or singleton.

The type of the first component of the tuple. The value of the first component of the tuple. A 1-tuple (singleton) whose value is (item1).

Creates a new struct 2-tuple, or pair.

The type of the first component of the tuple. The type of the second component of the tuple. The value of the first component of the tuple. The value of the second component of the tuple. A 2-tuple (pair) whose value is (item1, item2).

Creates a new struct 3-tuple, or triple.

The type of the first component of the tuple. The type of the second component of the tuple. The type of the third component of the tuple. The value of the first component of the tuple. The value of the second component of the tuple. The value of the third component of the tuple. A 3-tuple (triple) whose value is (item1, item2, item3).

Creates a new struct 4-tuple, or quadruple.

Creates a new struct 5-tuple, or quintuple.

Creates a new struct 6-tuple, or sextuple.

The type of the first component of the tuple. The type of the second component of the tuple. The type of the third component of the tuple. The type of the fourth component of the tuple. The type of the fifth component of the tuple. The type of the sixth component of the tuple. The value of the first component of the tuple. The value of the second component of the tuple. The value of the third component of the tuple. The value of the fourth component of the tuple. The value of the fifth component of the tuple. The value of the sixth component of the tuple. A 6-tuple (sextuple) whose value is (item1, item2, item3, item4, item5, item6).

Creates a new struct 7-tuple, or septuple.

The type of the first component of the tuple. The type of the second component of the tuple. The type of the third component of the tuple. The type of the fourth component of the tuple. The type of the fifth component of the tuple. The type of the sixth component of the tuple. The type of the seventh component of the tuple. The value of the first component of the tuple. The value of the second component of the tuple. The value of the third component of the tuple. The value of the fourth component of the tuple. The value of the fifth component of the tuple. The value of the sixth component of the tuple. The value of the seventh component of the tuple. A 7-tuple (septuple) whose value is (item1, item2, item3, item4, item5, item6, item7).

Creates a new struct 8-tuple, or octuple.

The type of the first component of the tuple. The type of the second component of the tuple. The type of the third component of the tuple. The type of the fourth component of the tuple. The type of the fifth component of the tuple. The type of the sixth component of the tuple. The type of the seventh component of the tuple. The type of the eighth component of the tuple. The value of the first component of the tuple. The value of the second component of the tuple. The value of the third component of the tuple. The value of the fourth component of the tuple. The value of the fifth component of the tuple. The value of the sixth component of the tuple. The value of the seventh component of the tuple. The value of the eighth component of the tuple. An 8-tuple (octuple) whose value is (item1, item2, item3, item4, item5, item6, item7, item8).

Represents a 1-tuple, or singleton, as a value type.

The type of the tuple's only component.

The current instance's first component.

Initializes a new instance of the value type.

The value of the tuple's first component.

Returns a value that indicates whether the current instance is equal to a specified object.

The object to compare with this instance. if the current instance is equal to the specified object; otherwise, . The parameter is considered to be equal to the current instance under the following conditions: It is a value type. Its components are of the same types as those of the current instance. Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its field is equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1), where Item1 represents the value of . If the field is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents a 2-tuple, or pair, as a value type.

The type of the tuple's first component. The type of the tuple's second component.

The current instance's first component.

The current instance's second component.

Initializes a new instance of the value type.

The value of the tuple's first component. The value of the tuple's second component.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Returns a value that indicates whether the current instance is equal to a specified object based on a specified comparison method.

The object to compare with this instance. An object that defines the method to use to evaluate whether the two objects are equal. if the current instance is equal to the specified object; otherwise, . This member is an explicit interface member implementation. It can be used only when the instance is cast to an interface. The implementation is called only if other is not , and if it can be successfully cast (in C#) or converted (in Visual Basic) to a whose components are of the same types as those of the current instance. The IStructuralEquatable.Equals(Object, IEqualityComparer) method first passes the values of the objects to be compared to the implementation. If this method call returns , the method is called again and passed the values of the two instances.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2), where Item1 and Item2 represent the values of the and fields. If either field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents a 3-tuple, or triple, as a value type.

The type of the tuple's first component. The type of the tuple's second component. The type of the tuple's third component.

The current instance's first component.

The current instance's second component.

The current instance's third component.

Initializes a new instance of the value type.

The value of the tuple's first component. The value of the tuple's second component. The value of the tuple's third component.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2, Item3). If any field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents a 4-tuple, or quadruple, as a value type.

The type of the tuple's first component. The type of the tuple's second component. The type of the tuple's third component. The type of the tuple's fourth component.

The current instance's first component.

The current instance's second component.

The current instance's third component.

The current instance's fourth component.

Initializes a new instance of the value type.

The value of the tuple's first component. The value of the tuple's second component. The value of the tuple's third component. The value of the tuple's fourth component.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2, Item3, Item4). If any field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents a 5-tuple, or quintuple, as a value type.

The current instance's first component.

The current instance's second component.

The current instance's third component.

The current instance's fourth component.

The current instance's fifth component.

Initializes a new instance of the value type.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5). If any field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents a 6-tuple, or sixtuple, as a value type.

The type of the tuple's first component. The type of the tuple's second component. The type of the tuple's third component. The type of the tuple's fourth component. The type of the tuple's fifth component. The type of the tuple's sixth component.

The current instance's first component.

The current instance's second component.

The current instance's third component.

The current instance's fourth component.

The current instance's fifth component.

The current instance's sixth component.

Initializes a new instance of the value type.

The value of the tuple's first component. The value of the tuple's second component. The value of the tuple's third component. The value of the tuple's fourth component. The value of the tuple's fifth component. The value of the tuple's sixth component.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5, Item6). If any field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents a 7-tuple, or sentuple, as a value type.

The current instance's first component.

The current instance's second component.

The current instance's third component.

The current instance's fourth component.

The current instance's fifth component.

The current instance's sixth component.

The current instance's seventh component.

Initializes a new instance of the value type.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5, Item6, Item7). If any field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .

Represents an 8-tuple, or octuple, as a value type.

The current instance's first component.

The current instance's second component.

The current instance's third component.

The current instance's fourth component.

The current instance's fifth component.

The current instance's sixth component.

The current instance's seventh component.

The current instance's eighth component.

Initializes a new instance of the value type.

Returns a value that indicates whether the current instance is equal to a specified object.

Returns a value that indicates whether the current instance is equal to a specified .

The tuple to compare with this instance. if the current instance is equal to the specified tuple; otherwise, . The parameter is considered to be equal to the current instance if each of its fields are equal to that of the current instance, using the default comparer for that field's type.

Compares this instance to a specified instance and returns an indication of their relative values.

Returns the hash code for the current instance.

A 32-bit signed integer hash code.

Returns a string that represents the value of this instance.

The string representation of this instance. The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5, Item6, Item7, Rest). If any field value is , it is represented as .

The number of positions in this data structure.

Get the element at position .