API Reference

Public types, one page each, grouped by assembly.

FoundationDB.Aspire

Aspire.FoundationDb.Client

• FdbClientSettings — Provides the client configuration settings for connecting to a FoundationDB cluster.

Microsoft.Extensions.Hosting

• FdbAspireComponentExtensions — Provides extension methods for registering FoundationDB-related services in an IHostApplicationBuilder.

OpenTelemetry.Trace

• FdbClientOpenTelemetryExtensions — Helper methods for configuring OpenTelemetry with FoundationDB

FoundationDB.Aspire.Hosting

Aspire.Hosting

• FdbAspireHostingExtensions — Provides extension methods for adding FoundationDB resources to the application model.

Aspire.Hosting.ApplicationModel

• FdbClusterResource — Represents a FoundationDB cluster resource in a distributed application.
• FdbConnectionResource — Represents an externally hosted FoundationDB Cluster in a distributed application.
• FdbVersionPolicy — Specify the versioning rules for the FoundationDB docker image
• IFdbResource — Represents a FoundationDB resource that requires a cluster file.

FoundationDB.Client

FoundationDB.Client

• Fdb — FoundationDB binding
• Fdb.Bulk — Helper class for bulk operations
• Fdb.Bulk.BatchOperationContext — Context for a long-running batched read operation
• Fdb.Bulk.WriteOptions — Options bag for bulk write operations
• Fdb.Directory — Static helper class to open named partitions
• Fdb.Options — Global settings for the FoundationDB binding
• Fdb.Provisioning — Helper class for provisioning a database on a freshly created cluster
• Fdb.Provisioning.FdbCliRunner — Runs fdbcli with the given arguments, and returns its exit code and combined console output
• Fdb.System — Helper class for reading from the reserved System subspace
• Fdb.Tenants — Helper methods for managing Tenants in a FoundationDB cluster
• FdbBigEndianUInt32Value — Value that wraps a 32-bit unsigned value, encoded as 4 bytes in big-endian
• FdbBigEndianUInt64Value — Value that wraps a 64-bit unsigned value, encoded as 8 bytes in big-endian
• FdbClientInstrumentation —
• FdbClusterConnectionString — Class that exposes the content of a FoundationDB .cluster file
• FdbClusterOption — Defines a set of options for the cluster connection
• FdbCompactBigEndianUInt32Value — Value that wraps a 32-bit unsigned value, encoded in big-endian, using as few bytes as possible
• FdbCompactBigEndianUInt64Value — Value that wraps a 64-bit unsigned value, encoded in big-endian, using as few bytes as possible
• FdbCompactLittleEndianUInt32Value — Value that wraps a 32-bit unsigned value, encoded in little-endian, using as few bytes as possible
• FdbCompactLittleEndianUInt64Value — Value that wraps a 64-bit unsigned value, encoded in little-endian, using as few bytes as possible
• FdbConflictRangeType — Defines a type of conflict artificially added to a transaction
• FdbConnectionOptions — Settings used when establishing the connection with a FoundationDB cluster
• FdbDatabase — FoundationDB database session handle
• FdbDatabaseExtensions — Provides a set of extensions methods shared by all FoundationDB database implementations.
• FdbDatabaseOption — Defines a set of options for the database connection
• FdbDatabaseProviderExtensions —
• FdbDirectoryLayer — Provides a FdbDirectoryLayer class for managing directories in FoundationDB.
• FdbDirectoryLayer.State —
• FdbDirectoryPartition — Directory Partition that will use its own Directory Layer instance to manage any subdirectories
• FdbDirectorySubspace — A Directory Subspace represents the contents of a directory, but it also remembers the path with which it was opened and offers convenience methods to operate on the directory at that path.
• FdbDirectorySubspaceLocation —
• FdbEndPoint — Represents a FoundationDB network endpoint as an IP address, port number and TLS mode.
• FdbError — FoundationDB API Error Code
• FdbErrorDebugger — Exposes the client's error-translation internals (message lookup, exception mapping, error predicates), for test harnesses and diagnostics.
• FdbErrorMessages — Managed error-message table for FdbError codes
• FdbErrorPredicate —
• FdbException — Represents an error that occurred while calling the FoundationDB Client API
• FdbFetchMode — Defines if the range read will only return the keys, values or both.
• FdbIdempotencyExtensions — Extension exposing native FoundationDB idempotency helpers on a transaction's options.
• FdbIdentityKeyCodec<TKey> —
• FdbJsonValue — Value that wraps a JsonValue, encoded into UTF-8 bytes
• FdbJsonValue<T> — Value that wraps a JsonValue, encoded into UTF-8 bytes
• FdbKey — Factory class for keys
• FdbKey.PrettyPrintMode — How a key should be formatted
• FdbKeyCodec —
• FdbKeyCodec<TKey, TEncoded> —
• FdbKeyExtensions — Extension methods for working with IFdbKeyRange implementations
• FdbKeyRange — Helpers for creating IFdbKeyRange instances
• FdbKeyRange<TLowerKey, TUpperKey> — Range that matches all keys between a lower and upper bound
• FdbKeyRange<TLowerKey, TUpperKey>.BeginKey — Represents the "Begin" key of a key range
• FdbKeyRange<TLowerKey, TUpperKey>.EndKey — Represents the "End" key of a key range
• FdbKeySelector —
• FdbKeySelector<TKey> —
• FdbKeyValueAction<TState> — Delegate that will observe a key/value pair read from the database
• FdbKeyValueDecoder<TResult> — Delegate that will decode a key/value pair read from the database
• FdbKeyValueDecoder<TState, TResult> — Delegate that will decode a key/value pair read from the database
• FdbLastKey<TKey> — Key that appends the 0xFF byte to another key
• FdbLayerExtensions — Set of helper methods for working with IFdbLayer instances
• FdbLittleEndianUInt32Value — Value that wraps a 32-bit unsigned value, encoded as 4 bytes in little-endian
• FdbLittleEndianUInt64Value — Value that wraps a 64-bit unsigned value, encoded as 8 bytes in little-endian
• FdbMergeQueryExtensions —
• FdbMutationType — Defines a type of mutation applied to a key
• FdbNetworkOption — Defines a set of options for the network thread
• FdbNextSiblingKey<TKey> — Key that increments the last byte (with carry) of another key
• FdbOperationContext — Represents the context of a retry-able transactional function which accepts a read-only or read-write transaction.
• FdbPath — Represents a path in a Directory Layer
• FdbPathSegment — Represent a segment in a path to a Directory.
• FdbProtocolVersion — Represents the protocol version of a node, interface or service in a FoundationDB cluster.
• FdbProtocolVersionExtensions —
• FdbProtocolVersionMap — Contains the
• FdbRangeChunk — Page of results from a GetRangeAsync operation
• FdbRangeChunk.ChunkEnumerator —
• FdbRangeChunk.ChunkKeysEnumerator —
• FdbRangeChunk.ChunkValuesEnumerator —
• FdbRangeChunk.KeysCollection —
• FdbRangeChunk.ValuesCollection —
• FdbRangeChunk<TResult> —
• FdbRangeChunk<TResult>.ChunkEnumerator —
• FdbRangeDecoder<TResult> — Delegate that will decode a key or value read from the database
• FdbRangeDecoder<TState, TResult> — Delegate that will decode a key or value read from the database
• FdbRangeOptions — Container class for options in a Range query
• FdbRangeResult — Metadata about the result of a range read operation
• FdbRawKey — Wraps a Slice that contains a pre-encoded key in the database
• FdbRawKeyRange — Range where the "Begin" and "End" key are already encoded
• FdbRawMemoryValue — Value that wraps raw bytes
• FdbRawSpanValue — Value that wraps a span of bytes
• FdbRawValue — Value that wraps raw bytes
• FdbRawValueCodec —
• FdbStreamingMode — Defines how the client would like the data in a range a returned
• FdbSubspaceKey — Wraps the key prefix of a subspace
• FdbSubspaceKeyRange — Range that matches all the keys inside a subspace
• FdbSuccessorKey<TKey> — Key that appends the 0x00 byte to another key
• FdbSuffixKey — Wraps a Slice that wraps a pre-encoded binary suffix, relative to a subspace
• FdbSuffixKey<TKey> — Wraps another IFdbKey, with an added binary suffix
• FdbSystemKey — Wraps a Slice that wraps a key in either the System (`\xFF`) or Special Key (`\xFF\xFF`) subspaces
• FdbTenant —
• FdbTenantExtensions —
• FdbTenantMetadata —
• FdbTenantMode — Tenant configuration mode of a FoundationDB cluster
• FdbTenantName — Represents the name of a Tenant in the database
• FdbTenantName.Comparer —
• FdbTenantSubspace —
• FdbTracingOptions — Options that can configure the tracing for transactions
• FdbTransaction — FoundationDB transaction handle.
• FdbTransactionDebugger — Exposes the internal lifecycle state of transactions, for test harnesses and diagnostics.
• FdbTransactionDebugger.TransactionState — Lifecycle states of a transaction, as observed by GetState.
• FdbTransactionExtensions — Provides a set of extensions methods shared by all FoundationDB transaction implementations.
• FdbTransactionMode —
• FdbTransactionOption — Defines a set of options for a transaction
• FdbTransactionOptionsExtensions — Extension methods for IFdbTransactionOptions
• FdbTransactionState — Current state of a transaction
• FdbTupleKey — Key that is composed of a tuple inside a subspace
• FdbTupleKey<T1, T2, T3, T4, T5, T6, T7, T8> — Key that is composed of an 8-tuple inside a subspace
• FdbTupleKey<T1, T2, T3, T4, T5, T6, T7> — Key that is composed of a 7-tuple inside a subspace
• FdbTupleKey<T1, T2, T3, T4, T5, T6> — Key that is composed of a 6-tuple inside a subspace
• FdbTupleKey<T1, T2, T3, T4, T5> — Key that is composed of a 5-tuple inside a subspace
• FdbTupleKey<T1, T2, T3, T4> — Key that is composed of a 4-tuple inside a subspace
• FdbTupleKey<T1, T2, T3> — Key that is composed of a 3-tuple inside a subspace
• FdbTupleKey<T1, T2> — Key that is composed of a 2-tuple inside a subspace
• FdbTupleKey<T1> — Key that is composed of a 1-tuple inside a subspace
• FdbTupleSuffixKey<TKey, TTuple> — Wraps a parent key, followed by a Tuple suffix
• FdbTupleSuffixKey<TTuple> — Wraps a pre-encoded binary suffix and a Tuple suffix
• FdbTupleValueCodec<T> — Encodes a T value using the Tuple Encoding
• FdbUtf16SpanValue — Value that wraps text that is encoded as UTF-16 bytes
• FdbUtf16Value — Value that wraps text that is encoded as UTF-16 bytes
• FdbUtf16ValueCodec —
• FdbUtf8SpanValue — Value that wraps text that is encoded as UTF-8 bytes
• FdbUtf8Value — Value that wraps text that is encoded as UTF-8 bytes
• FdbUtf8ValueCodec —
• FdbValue — Factory class for values
• FdbValue<TValue, TEncoder> — Value that will be converted into bytes by a ISpanEncoder
• FdbValueCheckResult — Result of a deferred value-check
• FdbValueCodec —
• FdbValueCodec.FixedSize —
• FdbValueCodec.Tuples —
• FdbValueCodec<TValue, TEncoded> —
• FdbValueDecoder<TResult> — Delegate that will decode a value read from the database
• FdbValueDecoder<TState, TResult> — Delegate that will decode a value read from the database
• FdbValueEncoderCodec<TValue> —
• FdbValueExtensions —
• FdbValueSpanEncoderCodec<TValue, TCodec> —
• FdbValueTypeHint — Represents the possible type for a value in the database
• FdbVarTupleValue — Value that wraps an IVarTuple with any number of elements
• FdbVarTupleValueCodec —
• FdbWatch — Watch that triggers when a watched key has changed in the database
• FqlDirectoryExpression —
• FqlItemType —
• FqlParsingOptions — Options for configuration the parsing of FQL expressions
• FqlPathSegment —
• FqlPathSegmentType —
• FqlQuery —
• FqlQueryParser — Parser for FQL queries
• FqlSyntaxHighlighter —
• FqlTemplateExpression — Represents "template" for a key/value that can be decoded into a better text representation
• FqlTemplateTree — Tree that can match a key against a collection of FqlTemplateExpression>
• FqlTemplateTree.Builder — Builder for generating a tree of multiple FqlTemplateExpression
• FqlTupleExpression —
• FqlTupleItem —
• FqlValueTypeHinter —
• FqlVariableTypes —
• IFdbDatabase — Database connection context.
• IFdbDatabaseOptions —
• IFdbDatabaseProvider — Provides access to a FoundationDB database instance
• IFdbDatabaseScopeProvider —
• IFdbDatabaseScopeProvider<TState> —
• IFdbDirectory — Represents a directory in the DirectoryLayer.
• IFdbDirectoryLayerMapper — Helper interface that can map keys to their corresponding directories
• IFdbKey — Represents a key in the database, that can be serialized into bytes
• IFdbKeyCodec<TKey, TEncoded> —
• IFdbKeyRange — Range of keys, defined by a lower and upper bound.
• IFdbKeyValueRangeQuery — Query that will asynchronously stream the key/value pairs returned by one or more GetRange operations
• IFdbLayer — Represents a FoundationDB Layer that uses a metadata cache to speed up operations inside transactions
• IFdbLayer<TState, TOptions> — Represents a FoundationDB Layer that uses a metadata cache to speed up operations
• IFdbLayer<TState> — Represents a FoundationDB Layer that uses a metadata cache to speed up operations
• IFdbLayerSchemaMapper — Exposes the schema of key/value pairs used by this layer
• IFdbPagedQuery<TResult> — Query that will asynchronously stream batches of decoded results from onr or more GetRange operations
• IFdbRangeQuery — Base interface for queries that will read ranges of results from the database
• IFdbRangeQuery<TResult> — Query that will asynchronously stream decoded results from one or more GetRange operations
• IFdbReadOnlyRetryable — Transactional context that can execute, inside a retry loop, idempotent actions using read-only transactions.
• IFdbReadOnlyTransaction — Transaction that allows read operations
• IFdbRetryable — Transactional context that can execute, inside a retry loop, idempotent actions using read and/or write transactions.
• IFdbTenant — Database connection context.
• IFdbTransaction — Transaction that allows read and write operations
• IFdbTransactionOptions — Helper that can set various options on transactions
• IFdbValue — Value that can be encoded into bytes
• IFdbValueCodec<TValue, TEncoded> —
• IFqlExpression —
• IFqlQuery —
• IHandleTransactionLifecycle — Marker interface for objects that need to respond to transaction state change (commit, failure, ...)
• IKeySubspace — Represents a sub-partition of the global key space.
• ISubspaceContext — Represents the lifetime of a key subspace
• ISubspaceLocation — Represents the path to a specific subspace in the database
• ISubspaceLocation<TSubspace> — Represents the path to a typed subspace in the database
• KeyRange — Represents a pair of keys defining the range 'Begin <= key > End'
• KeyRange.Comparer —
• KeyRangeMode — Defines how a boundary key should be considered in a FdbKeyRange
• KeySelector — Defines a selector for a key in the database
• KeySelectorPair — Represents a pair of key selectors that range 'GetKey(Begin) <= key < GetKey(End)'
• KeySpanSelector — Defines a selector for a key in the database
• KeySubspace — Adds a prefix on every key, to group them inside a common subspace
• KeySubspaceExtensions — Extensions methods and helpers to work with Key Subspaces
• PageAction<TResult> —
• PageAggregator<TAggregate, TResult> —
• PageFunc<TResult, TOther> —
• SubspaceContext — Context for key subspaces that are always valid
• SubspaceLocation — Factory methods for creating locations in the keyspace of a FoundationDB database.
• SubspaceLocation<TSubspace> — Default implementation of a subspace location
• SubspaceLocationExtensions — Extension methods for ISubspaceLocation

FoundationDB.Client.Core

• IFdbDatabaseHandler — Basic API for FoundationDB databases
• IFdbTenantHandler — Basic API for FoundationDB tenants
• IFdbTransactionHandler — Basic API for FoundationDB transactions

FoundationDB.Client.Native

• FdbFuture — Helper class to create FDBFutures
• FdbFuture.Flags —
• FdbFuture<TResult> — Base class for all FDBFuture wrappers
• FdbFutureArray<TState, TResult> — FDBFuture[] wrapper
• FdbFutureSingle<TState, TResult> — FDBFuture wrapper
• FdbFutureTask<TResult> — Generic FdbFuture that will behave like a Task
• FdbSafeHandle — Base class for all wrappers on FDBxxxx* opaque pointers
• FutureHandle — Wrapper on a FDBFuture*

FoundationDB.Client.Status

• ClientMessages — List of well known client messages
• ClientStatus — Description of the current status of the local FoundationDB client
• ClientStatus.CoordinatorDescriptor — Details about a coordinator, as known by a client
• ClusterClientsMetrics —
• ClusterConfiguration —
• ClusterControllerRoleMetrics — Metrics related to the cluster_controller role
• ClusterMessages — List of well known cluster messages
• ClusterStatus — Description of the current status of a FoundationDB cluster
• ClusterTenantsMetrics —
• CommitProxyRoleMetrics — Metrics related to the commit_proxy role
• ConsistencyScanRoleMetrics — Metrics related to the consistency_scan role
• CoordinatorRoleMetrics — Metrics related to the coordinator role
• DataDistributorRoleMetrics — Metrics related to the data_distributor role
• DataMetrics — Details about the volume of data stored in the cluster
• DiskBasedRoleMetrics —
• DiskCounter — Measured quantity that changes over time
• FdbClientStatus —
• FdbClientStatus.ConnectionStatus —
• FdbClientStatus.StorageServerStatus —
• FdbSystemStatus — Snapshot of the state of a FoundationDB cluster
• GrvProxyRoleMetrics — Metrics related to the grv_proxy role
• LagCounter —
• LatencyMetrics —
• LoadCounter —
• LocalityConfiguration —
• LogRoleMetrics — Metrics related to the log role
• MachineCpuMetrics — CPU performance counters for machine hosting one or more FoundationDB processes
• MachineMemoryMetrics — Memory performance counters for machine hosting one or more FoundationDB processes
• MachineNetworkMetrics — Network performance counters for machine hosting one or more FoundationDB processes
• MachineStatus —
• MasterRoleMetrics — Metrics related to the master role
• Message — Details about a notification, alert or error, as reported by a component of a FoundationDB cluster
• MetricStatistics — Characteristics of a measured value (count, max, avg, percentiles, ...)
• MetricsBase — Base class for all metrics containers
• ProcessCpuMetrics — CPU performance counters for a FoundationDB process
• ProcessDiskMetrics — Disk performance counters for a FoundationDB process
• ProcessMemoryMetrics — Memory performance counters for a FoundationDB process
• ProcessMessages — List of well known process messages
• ProcessNetworkMetrics — Network performance counters for a FoundationDB process or machine
• ProcessRoleMetrics —
• ProcessStatus — Details about a FoundationDB process
• ProxyRoleMetrics — Metrics related to the proxy_proxy role
• QosMetrics — Details about the quality of service offered by the cluster
• RateCounter — Measured quantity that changes over time
• RateKeeperRoleMetrics — Metrics related to the ratekeeper role
• ResolverRoleMetrics — Metrics related to the resolver role
• RoughnessCounter — Measured quantity that changes over time
• StorageMetadataMetrics — Measured quantity that changes over time
• StorageRoleMetrics — Metrics related to the storage role
• WorkloadBytesMetrics — Throughput of a FoundationDB cluster
• WorkloadMetrics — Details about the current wokrload of the cluster
• WorkloadOperationsMetrics — Operations workload of a FoundationDB cluster
• WorkloadTransactionsMetrics — Transaction workload of a FoundationDB cluster

FoundationDB.Client.Utils

• DebugCounters — Simple debug counters container that is used to troubleshoot alloc/free problems...

FoundationDB.DependencyInjection

• FdbDatabaseProvider — Provides access to a FoundationDB database instance
• FdbDatabaseProviderBuilderExtensions — Extension methods for IFdbDatabaseProvider
• FdbDatabaseProviderOptions —
• FdbDatabaseServiceCollectionExtensions — Extension methods for registering a IFdbDatabaseProvider service
• FdbDatabaseSingletonProvider<TState> — Default implementation of a scope provider that uses a pre-initialized database instance
• IFdbDatabaseProviderBuilder —

FoundationDB.Filters.Logging

• FdbLoggedFields —
• FdbLoggingExtensions — Set of extension methods that add logging support on transactions
• FdbLoggingOptions —
• FdbTransactionFileFormat —
• FdbTransactionFileLogger —
• FdbTransactionHistory —
• FdbTransactionHistory.TimeSlice —
• FdbTransactionLog — Container that logs all operations performed by a transaction
• FdbTransactionLog.AddConflictRangeCommand —
• FdbTransactionLog.AtomicCommand —
• FdbTransactionLog.CancelCommand —
• FdbTransactionLog.CheckValueCommand —
• FdbTransactionLog.ClearCommand —
• FdbTransactionLog.ClearRangeCommand —
• FdbTransactionLog.Command — Base class of all types of operations performed on a transaction
• FdbTransactionLog.Command<TResult> — Base class of all types of operations performed on a transaction, that return a result
• FdbTransactionLog.CommitCommand —
• FdbTransactionLog.DirectoryKeyResolver — Key resolver which replace key prefixes by the name of their enclosing directory subspace
• FdbTransactionLog.GetAddressesForKeyCommand —
• FdbTransactionLog.GetApproximateSizeCommand —
• FdbTransactionLog.GetCommand<TResult> — Represents a GetAsync operation
• FdbTransactionLog.GetEstimatedRangeSizeBytesCommand —
• FdbTransactionLog.GetKeyCommand —
• FdbTransactionLog.GetKeysCommand —
• FdbTransactionLog.GetMetadataVersionCommand —
• FdbTransactionLog.GetRangeCommand —
• FdbTransactionLog.GetRangeCommand<TResult> —
• FdbTransactionLog.GetRangeSplitPointsCommand —
• FdbTransactionLog.GetReadVersionCommand —
• FdbTransactionLog.GetValuesCommand —
• FdbTransactionLog.GetValuesCommand<TValue> —
• FdbTransactionLog.GetVersionStampCommand —
• FdbTransactionLog.KeyResolver —
• FdbTransactionLog.LogCommand —
• FdbTransactionLog.Mode — Categories of operations supported by a transaction
• FdbTransactionLog.OnErrorCommand —
• FdbTransactionLog.Operation — List of all operation types supported by a transaction
• FdbTransactionLog.ResetCommand —
• FdbTransactionLog.SetCommand —
• FdbTransactionLog.SetOptionCommand —
• FdbTransactionLog.TouchMetadataVersionKeyCommand —
• FdbTransactionLog.VisitRangeCommand —
• FdbTransactionLog.WatchCommand —

FoundationDB.Layers.Allocators

• FdbHighContentionAllocator — Custom allocator that generates unique integer values with low probability of conflicts
• FdbHighContentionAllocator.State —

SnowBank.Core

SnowBank.Buffers

• ArraySliceAllocator — Allocator that stores all data into slabs allocated from the heap.
• ArraySliceWriter — Buffer writer that writes all data into a single consecutive buffer allocated from the heap
• BitMap64 — Represents a fixed-size bit map, backed by an array of 64-bit words
• BitMap64.BitEnumerator — Enumerator for the content of a BitMap64
• BitMap64.BitIndexEnumerable — List of the indexes of all the set bits in a BitMap64
• Buffer<T> — Small buffer that keeps a list of chunks that are larger and larger
• Buffer<T>.Aggregator<T, TAggregate> —
• Buffer<T>.SegmentAggregator<T, TAggregate> —
• BufferExtensions — Helper methods for working with buffers
• BufferFormatter — Helper type for writing binary data into a IBufferWriter of bytes
• ByteStringTokenDictionary<TValue> — Dictionary of tokens with string literals addressable via their encoded byte representation (ex: UTF-8)
• ByteStringTokenMap<TToken> — Bi-directional mapping table between the in-memory (ReadOnlySpan<>) and literal (String) representation of a TToken
• CharStringTokenDictionary<TValue> — Dictionary of tokens with string literals addressable via ReadOnlySpan<char> keys
• CharStringTokenMap<TToken> — Bi-directional mapping table between the encoded (ReadOnlySpan<>) and literal (String) representation of a TToken
• ISliceAllocator — Allocator that slices of bytes
• ISliceBufferWriter — IBufferWriter that can also allocate Slice chunks
• ISliceSerializable — Supports direct binary serialization
• ISliceSerializer<T> — Can serialize instances of type T to and from binary form
• ISpanBufferWriter<T> — Represents an output sink into which data can be written.
• PooledBuffer<T> — Lightweight wrapper over a pooled buffer, that can be resized whenever necessary.
• PooledSliceAllocator — Allocator that stores all data into slabs allocated from a pool (or the heap for large allocations)
• PooledSliceWriter — Buffer writer that writes all data into a single consecutive buffer allocated from a pool
• SegmentedValueBuffer<T> — Buffer that will accumulate data in a contiguous span, starting from a stack allocated buffer, and switching to pooled buffers if required
• SegmentedValueBuffer<T>.Enumerator — Enumerates the contents of a SegmentedValueBuffer
• SegmentedValueBuffer<T>.Scratch — Helper type for quickly allocating space on the heap
• SlabSliceWriter — Buffer writer that writes all data into a slabs allocated from a pool (or the heap)
• SliceBuffer — Buffer that can be used to efficiently store multiple slices into as few chunks as possible
• SliceBufferWriterExtensions — Helper methods for working with slice allocators and writers
• SlicePool — Slice generator that use one or more underlying buffers to store the produced bytes, in order to reduce memory allocations.
• SliceReader — Helper class that holds the internal state used to parse tuples from slices
• SliceWriter — Slice buffer that emulates a pseudo-stream using a byte array that will automatically grow in size, if necessary
• SpanReader — Helper type for ready binary data from a Span of bytes
• SpanWriter — Helper type for writing binary data into a Span of bytes
• TokenDictionary<TValue, TLiteral, TRune> — Dictionary that can look up tokens either via their TLiteral representation (ex: string), or via their representation as a ReadOnlySpan (ex: ReadOnlySpan<char>)
• TokenMap<TToken, TLiteral, TRune> — Bi-directional mapping table between the binary (ReadOnlySpan<>) and literal (TLiteral) representation of a TToken
• ValueBuffer<T> — Buffer that will accumulate data in a contiguous span, starting from a stack allocated buffer, and switching to pooled buffers if required
• ValueBuffer<T>.Aggregator<T, TAggregate> — Delegate that can update an aggregate by reference
• ValueBufferExtensions — Helper methods for working with ValueBuffer

SnowBank.Buffers.Binary

• BitHelpers — Helper methods to work with bits
• ByteSize — Represents the size (in bytes) of a buffer or range of data, with its associated "natural" unit (KB, KiB, GiB, ...)
• SizeUnit — Units for size of buffers or arrays of bytes (KB = 1_000 bytes, KiB = 1_024 bytes, ...)
• UnsafeHelpers — Helper methods for dealing with unmanaged memory.

SnowBank.Buffers.Text

• FastStringBuilder — Span-based implementation of a StringBuilder, with reduced safety checks
• Utf8String — Represents a string that is stored as UTF-8 bytes in managed memory
• Utf8String.Comparer — Implementation that compares UTF-8 encoded strings using ordinal sort rules.
• Utf8String.Enumerator — Enumerator that lists all the UnicodeCodePoint in a Utf8String
• Utf8String.SpanEnumerator — Enumerator that lists all the UnicodeCodePoint in a Utf8String
• Utf8StringWriter — TextWriter that writes UTF-8 bytes into an in-memory buffer.
• ValueStringWriter — Small buffer that keeps a list of chunks that are larger and larger

SnowBank.Collections.CacheOblivious

• ColaOrderedDictionary<TKey, TValue> — Represent an ordered set of key/value pairs, stored in a Cache Oblivious Lookahead Array
• ColaOrderedDictionary<TKey, TValue>.Enumerator — Enumerates the key/value pairs stored in a ColaOrderedDictionary
• ColaOrderedSet<T> — Represent an ordered set of elements, stored in a Cache Oblivious Lookup Array
• ColaOrderedSet<T>.Enumerator — Enumerates the elements stored in a ColaOrderedSet
• ColaRangeDictionary<TKey, TValue> — Represent an ordered list of ranges, each associated with a specific value, stored in a Cache Oblivious Lookup Array
• ColaRangeDictionary<TKey, TValue>.Entry — Mutable range
• ColaRangeSet<TKey> — Represent an ordered list of ranges, stored in a Cache Oblivious Lookup Array
• ColaRangeSet<TKey>.Entry — Mutable range
• ColaStore — Helper methods used by ColaStore and derived implementations
• ColaStore.Enumerator<T> — Enumerates the elements stored in a ColaOrderedSet
• ColaStore<T> — Store elements in a list of ordered levels
• ColaStore<T>.Iterator — Iterator for scanning the contents of a ColaStore

SnowBank.Collections.Caching

• ICache<TKey, TElement> —
• ObjectPool<T> — Generic implementation of object pooling pattern with predefined pool size limit.
• QuasiImmutableCache<TKey, TValue> — Implements a cache with values that do not frequently change

SnowBank.Collections.Generic

• Grouping —
• Grouping<TKey, TElement> — Container for a set of elements that share the same key
• Grouping<TKey, TElement>.Comparer —
• Grouping<TKey, TElement>.Enumerator —
• Grouping<TKey, TElement>.EqualityComparer —
• HashLookup<TKey, TElement> — Lookup table that groups elements by a common key

SnowBank.Data

• CrystalConverterAttribute — Marks a partial class as a container of source-generated serializers, for one or more output formats
• CrystalOutputAttribute — Base class of the attributes that request one output format from a CrystalConverterAttribute container
• CrystalSerializableAttribute — Registers one or more types in a source-generated serializer container

SnowBank.Data.Binary

• ISpanDecoder<TValue> — Defines methods to decode the binary representation of instances of type TValue from a span
• ISpanEncodable — Provides functionality to encode the binary representation of an instance into a span
• ISpanEncoder<TValue> — Defines methods to encode the binary representation of instances of type TValue into a span
• IValueEncoder<TValue, TStorage> — Class that know how to encode and decode values of a fixed type into a lower format
• IValueEncoder<TValue> — Class that know how to encode and decode values of a fixed type
• Int32Value —
• Int64Value —
• SpanEncoders — Encoders that can encode primitive types into binary form
• SpanEncoders.CompactBigEndianEncoder — Encodes primitive integers into little-endian, using as few bytes as possible
• SpanEncoders.CompactLittleEndianEncoder — Encodes primitive integers into little-endian, using as few bytes as possible
• SpanEncoders.FixedSizeBigEndianEncoder — Encodes primitive integers into big-endian, using a fixed size
• SpanEncoders.FixedSizeLittleEndianEncoder — Encodes primitive integers into little-endian, using a fixed size
• SpanEncoders.FixedSizeUuidEncoder — Encodes UUID values into big-endian, using a fixed size
• SpanEncoders.RawEncoder — Encodes raw binary values (Slice, spans or arrays of bytes, ...)
• SpanEncoders.TupleEncoder<TTuple> — Encodes tuples using the Tuple Layer Encoding
• SpanEncoders.Utf16Encoder — Encodes strings as UTF-16 bytes
• SpanEncoders.Utf8Encoder — Encodes strings as UTF-8 bytes
• SpanEncoders.VarIntEncoder — Encodes primitive integers using the VarInt compact representation
• UInt32Value —
• UInt64Value —
• Utf8StringValue —
• ValueEncoderExtensions — Extension methods for working with value encoders

SnowBank.Data.Json

• CrystalJson — Helper class to serialize, parse or deserialize JSON documents
• CrystalJson.Errors —
• CrystalJson.LoadOptions — Options when load JSON from disk
• CrystalJson.SaveOptions — Options when save JSON to disk
• CrystalJsonConverterAttribute — Mono-format alias that marks a partial class as a container of source-generated JSON converters
• CrystalJsonCustomJsonConverter — Converter that adds support for JsonValue (and derived types) to System.Text.Json's JsonConverter
• CrystalJsonDomWriter —
• CrystalJsonFormatter —
• CrystalJsonKnownNamingPolicy — The JsonNamingPolicy to be used at run time.
• CrystalJsonMarshall — Advanced methods only intended to be used by generated code
• CrystalJsonMemberDefinition — Structure that holds the cached serialization metadata for a field or property of a class or struct
• CrystalJsonMemberFlags —
• CrystalJsonOutputAttribute — Requests JSON output from a CrystalConverterAttribute container, and carries the parameters of that output
• CrystalJsonPackContext — State of one packing walk: the settings and resolver in effect, and the recursion guards
• CrystalJsonParser —
• CrystalJsonParser<TReader> —
• CrystalJsonSelfSerializableAttribute — Meta-attribute that marks another attribute as enabling JSON source code generation on the types it decorates
• CrystalJsonSerializableAttribute — Attribute that adds a custom JSON converter for one or more types
• CrystalJsonSerializerDefaults — List of default configurations for source-generated converters
• CrystalJsonSettings — JSON serialization settings
• CrystalJsonSettings.DateFormat — Rules for serializing dates and times
• CrystalJsonSettings.FloatFormat — Rules for serializing special floating points numbers, like NaN or PositiveInfinity
• CrystalJsonSettings.Layout — Rules for indentation and spacing
• CrystalJsonSettings.OptionFlags —
• CrystalJsonSettings.StringInterning — Rules for interning strings, and reduce memory allocations
• CrystalJsonSettings.Target —
• CrystalJsonSettingsExtensions —
• CrystalJsonStreamReader — Type that can read JSON fragments from a stream
• CrystalJsonStreamWriter — Writes JSON document fragments into a destination stream
• CrystalJsonStreamWriter.ArrayStream —
• CrystalJsonStreamWriter.ObjectStream —
• CrystalJsonTokenizer<TReader> — Tokenizer for JSON text documents
• CrystalJsonTypeBinder — Delegate called to bind a JSON value into a managed CLR instance
• CrystalJsonTypeDefinition —
• CrystalJsonTypeFlags —
• CrystalJsonTypeResolver — Default JSON resolver that uses reflection to serialize and deserialize managed types
• CrystalJsonTypeResolverChain — Collection that aggregates multiple smaller collections into a single chain
• CrystalJsonTypeVisitor — Delegate that will serialize a value into JSON
• CrystalJsonVisitor — Internal helper to convert values into JSON strings
• CrystalJsonVisitor.CustomVisitor<T> —
• CrystalJsonWriter — Serialize values into JSON
• CrystalJsonWriter.NodeType —
• CrystalJsonWriter.State —
• ICrystalJsonTypeResolver — Type that is able to extra type metadata used during JSON serialization
• IJsonConverter — Base non-generic interface for IJsonConverter implementations
• IJsonConverter<T> — Bundle interface that is implemented by source-generated encoders
• IJsonConverter<TValue, TReadOnlyProxy, TWritableProxy> — Bundle interface that is implemented by source-generated encoders, with support for read-only and writable proxies.
• IJsonDeserializable<TSelf> — Supports custom JSON deserialization from JsonValue into instances of TSelf
• IJsonDeserializer<T> — Type that can deserialize instances of T from JSON
• IJsonMemberConverter<T> — Convenience bundle for a symmetric custom converter attached to a member (or a type) via JsonConvertWithAttribute or [JsonConverter(typeof(...))]
• IJsonPackable — Supports custom JSON serialization into JsonValue.
• IJsonPacker<T> — Types that implement this interface support packing directly into a JsonValue
• IJsonProxyNode — Node in the hierarchy of a document proxy
• IJsonReadOnlyConverter<TValue, TReadOnlyProxy> — Bundle interface that is implemented by source-generated encoders for read-only proxies.
• IJsonReadOnlyProxy — Wraps a JsonValue into a typed read-only proxy
• IJsonReadOnlyProxy<TValue, TProxy> — Wraps a JsonValue into typed read-only proxy that emulates the type TValue
• IJsonReadOnlyProxy<TValue, TReadOnlyProxy, TWritableProxy> — Wraps a JsonValue into typed read-only proxy that emulates the type TValue with support for copy-on-write.
• IJsonReadOnlyProxy<TValue> — Wraps a JsonValue into typed read-only proxy that emulates the type TValue
• IJsonReader — Source of JSON text that can be parsed
• IJsonSerializable — Supports custom JSON direct serialization.
• IJsonSerializer<T> — Type that can serialize instances of T into JSON
• IJsonWritableConverter<TValue, TWritableProxy> — Bundle interface that is implemented by source-generated encoders for writable proxies.
• IJsonWritableProxy — Wraps a JsonValue into a typed mutable proxy
• IJsonWritableProxy<TValue, TProxy> — Wraps a JsonValue into typed mutable proxy that emulates the type TValue
• IJsonWritableProxy<TValue> — Wraps a JsonValue into typed mutable proxy that emulates the type TValue
• IMutableJsonContext — Context that will record all the changes made to a MutableJsonValue
• IObservableJsonContext — Context that will record all the reads performed on a ObservableJsonValue
• JPathExtensions — Extensions methods for working with JPathQuery
• JsonArray — Array of JSON values
• JsonArray.Enumerator — Enumerates through the elements of a JsonArray
• JsonArray.ReadOnly — Operations for read-only JSON arrays
• JsonArray<TValue> — Wrapper for a JsonArray that casts each element into a required TValue.
• JsonArray<TValue>.Enumerator — Enumerator that casts each element of a JsonArray into a specified JSON type.
• JsonArrayExtensions — Extension methods for JsonArray
• JsonArrayOrDefault<TValue> — Wrapper for a JsonArray that casts each element into an optional TValue.
• JsonArrayOrDefault<TValue>.Enumerator — Enumerator that casts each element of a JsonArray into a specified type.
• JsonBindingException — Error that occurred while deserializing a JSON value back into a CLR type
• JsonBoolean — JSON Boolean (true or false)
• JsonBooleanLiteralsAttribute — Specifies custom output literals for a Boolean (or bool?) member, for compatibility with producers that do not emit real JSON booleans
• JsonBooleanLiteralsConverter — Converter installed for members carrying JsonBooleanLiteralsAttribute; feeds the same per-member converter slot as [JsonConverter(typeof(...))]
• JsonCharReader — JSON Text reader that wraps an in-memory buffer of characters
• JsonConvertWithAttribute — Attaches a CrystalJson custom converter to a member or a type
• JsonDateTime — JSON DateTime
• JsonEncodedPropertyName — Cache for the various encoded forms of a JSON property name
• JsonEnumFormat — Specifies how enums are serialized into JSON
• JsonNull — JSON null
• JsonNumber — JSON number
• JsonNumberFormat — Specifies how numeric members are serialized into JSON
• JsonObject — JSON Object with fields
• JsonObject.ReadOnly — Operations for read-only JSON objects
• JsonPath — Represents a path inside a JSON document to a nested child (ex: "id", "user.id"``"tags[2].id"
• JsonPath.Comparer —
• JsonPath.CustomConverter —
• JsonPath.SegmentTokenizer —
• JsonPath.Tokenizable —
• JsonPath.Tokenizator —
• JsonPathBuilder —
• JsonPathSegment —
• JsonPathSegment.Comparer —
• JsonPropertyAttribute — Attribute that controls how a field or property is serialized into JSON
• JsonProxyNodeExtensions — Extension methods for working with IJsonProxyNode
• JsonReadOnlyProxyArray<TValue, TProxy> — Wraps a JsonArray into a typed read-only proxy that emulates an array of elements of type TValue
• JsonReadOnlyProxyArray<TValue> — Wraps a JsonArray into a typed read-only proxy that emulates an array of elements of type TValue
• JsonReadOnlyProxyDictionary<TValue, TProxy> — Wraps a JsonObject into a typed read-only proxy that emulates a dictionary of elements of type TValue
• JsonReadOnlyProxyDictionary<TValue> — Wraps a JsonObject into a typed read-only proxy that emulates a dictionary of elements of type TValue
• JsonReadOnlyProxyInt32Dictionary<TValue, TProxy> — Wraps a JsonObject into a typed read-only proxy that emulates a dictionary of elements of type TValue with integer keys
• JsonReadOnlyProxyInt32Dictionary<TValue> — Wraps a JsonObject into a typed read-only proxy that emulates a dictionary of elements of type TValue with integer keys
• JsonReadOnlyProxyInt32DictionaryOfArray<TValue, TProxy> — Wraps a JsonObject into a typed read-only proxy that emulates a dictionary of elements of type TValue with integer keys
• JsonReflectionDisabledException — Thrown when DisableReflection is set and a value would be (de)serialized through the runtime reflection path instead of a source-generated converter or the JSON DOM.
• JsonSerializationException — Error that occurred while serializing a value or object into a JSON document
• JsonSerializerExtensions — Helper methods for working with JSON converters
• JsonSliceReader — JSON text reader that reads UTF-8 encoded bytes from an in-memory buffer
• JsonSliceSerializer —
• JsonString — JSON string literal
• JsonString.WellKnown —
• JsonString.WellKnown.CamelCase — camelCase
• JsonString.WellKnown.PascalCase — PascalCase
• JsonStringReader — JSON Text reader that wraps a string
• JsonSyntaxException — Syntax error that occurred while parsing a JSON document
• JsonTextReader — JSON text reader that wraps an underlying TextReader instance
• JsonType — Type of JSON value (String, Number, Boolean, Object, Array, Null, ...)
• JsonUnmanagedReader — JSON text reader that reads from UTF-8 encoded bytes in native memory
• JsonValue — Represents a value in a JSON Document
• JsonValue.ReadOnly — Operations for read-only JSON values
• JsonValueComparer — Comparer for JsonValue instances
• JsonValueDefaultComparer —
• JsonValueExtensions — Extension methods for JsonValue and other derived types
• JsonValueStrictComparer —
• JsonWritableProxyArray<TValue, TProxy> — Wraps a JsonArray into a typed mutable proxy that emulates an array of elements of type TValue
• JsonWritableProxyArray<TValue, TProxy>.Enumerable — Optimized implementation used to enumerate the deserialized elements of a proxy array
• JsonWritableProxyArray<TValue, TProxy>.Enumerator — Optimized implementation used to enumerate the deserialized elements of a proxy array
• JsonWritableProxyArray<TValue> — Wraps a JsonArray into a typed mutable proxy that emulates an array of elements of type TValue
• JsonWritableProxyArrayBuilder —
• JsonWritableProxyDictionary<TValue, TProxy> — Wraps a JsonObject into a typed mutable proxy that emulates a dictionary of elements of type TValue
• JsonWritableProxyDictionary<TValue> — Wraps a JsonObject into a typed mutable proxy that emulates a dictionary of elements of type TValue
• JsonWritableProxyObjectBase — Base class for custom or source generated implementations of a IJsonWritableProxy
• MutableJsonValue — Mutable JSON Object
• ObservableJsonAccess — Represents the type of read access to a node in an observable JSON document
• ObservableJsonTrace — Recording of all the nodes of a JSON document that were accessed by a previous computation.
• ObservableJsonTrace.Node — Represents a node in the subtree of a monitored JSON document
• ObservableJsonTraceCapturingContext — Context that will capture all read access to an ObservableJsonValue into a ObservableJsonTrace
• ObservableJsonValue — Observable JSON Object that will capture all reads

SnowBank.Data.Json.Binary

• CrystalJsonCodec — Codecs that encodes CLR types into either database keys (ordered) or values (unordered)
• CrystalJsonCodec<T> — Codec that encodes T instances into either database keys (ordered) or values (unordered)
• JsonPack — Fast and compact binary JSON encoder
• JsonValueCodec — Codec that encodes JsonValue instances into either database keys (ordered) or values (unordered)
• Jsonb — Compact binary JSON encoder that supports partial decoding of documents
• Jsonb.JLookupSelector — Selector that will always return the value of the element at the given path of a Jsonb document
• Jsonb.Writer — Instance that outputs Jsonb values into a binary buffer
• JsonbWriterOptions — Options to configure the behavior of the Jsonb parser

SnowBank.Data.Json.JPath

• JPathArrayIndexer — Expression that represents a single element of a JSON Array
• JPathArrayRange — Expression that represents the access to a part of a JSON Array
• JPathBinaryOperator — Expression that applies a binary operator on two expressions, or an expression and a constant
• JPathExpression — Base class of a node in a JPath query AST
• JPathFilterExpression — Expression that outputs only the elements or a source expression that pass a filter
• JPathObjectIndexer — Expression that represents a field access in a JSON Object (ex: foo['bar'])
• JPathQuery — Represents a query in a JSON Document
• JPathQuoteExpression — Expression that buffers the elements returned by another expression, into a single JSON Array
• JPathSpecialToken — Expression that represents a special JPath Token (either $ or @)
• JPathUnaryOperator — Expression that applies a unary operator onto another expression

SnowBank.Data.Tuples

• IVarTuple — Represents a Tuple of variable length and elements of different types
• JoinedTuple<THead, TTail> — Tuple that represents the concatenation of two tuples
• LinkedTuple<T> — Tuple that adds a value at the end of an already existing tuple
• ListTuple<T> — Tuple that can hold any number of untyped items
• STuple — Factory class for Tuples
• STuple.Deformatter — Methods for parsing tuples from strings
• STuple.Formatter — Methods for formatting tuples into strings
• STuple<T1, T2, T3, T4, T5, T6, T7, T8> — Tuple that can hold eight items
• STuple<T1, T2, T3, T4, T5, T6, T7, T8>.Comparer — Comparer for tuples with 7 elements
• STuple<T1, T2, T3, T4, T5, T6, T7, T8>.EqualityComparer — Comparer for tuples with 7 elements
• STuple<T1, T2, T3, T4, T5, T6, T7> — Tuple that can hold seven items
• STuple<T1, T2, T3, T4, T5, T6, T7>.Comparer — Comparer for tuples with 7 elements
• STuple<T1, T2, T3, T4, T5, T6, T7>.EqualityComparer — Comparer for tuples with 7 elements
• STuple<T1, T2, T3, T4, T5, T6> — Tuple that can hold six items
• STuple<T1, T2, T3, T4, T5, T6>.Comparer —
• STuple<T1, T2, T3, T4, T5, T6>.EqualityComparer —
• STuple<T1, T2, T3, T4, T5> — Tuple that can hold five items
• STuple<T1, T2, T3, T4, T5>.Comparer —
• STuple<T1, T2, T3, T4, T5>.EqualityComparer —
• STuple<T1, T2, T3, T4> — Tuple that can hold four items
• STuple<T1, T2, T3, T4>.Comparer —
• STuple<T1, T2, T3, T4>.EqualityComparer —
• STuple<T1, T2, T3> — Tuple that can hold three items
• STuple<T1, T2, T3>.Comparer —
• STuple<T1, T2, T3>.EqualityComparer —
• STuple<T1, T2> — Tuple that holds a pair of items
• STuple<T1, T2>.Comparer —
• STuple<T1, T2>.EqualityComparer —
• STuple<T1> — Tuple that holds only one item
• STuple<T1>.Comparer —
• STuple<T1>.EqualityComparer —
• TuPack — Tuple Binary Encoding
• TupleComparisons — Helper class for tuple comparisons
• TupleComparisons.CompositeComparer<T1, T2, T3> — Comparer that compares tuples with at least 3 items
• TupleComparisons.CompositeComparer<T1, T2> — Comparer that compares tuples with at least 2 items
• TupleComparisons.CompositeComparer<T1> — Comparer that compares tuples with at least 1 item
• TupleComparisons.EqualityComparer —
• TupleExtensions — Add extensions methods that deal with tuples on various types
• TupleHelpers — Helpers for writing custom IVarTuple implementations

SnowBank.Data.Tuples.Binary

• ITupleFormattable — Represents a tuple that can formats its item into a string representation
• ITuplePackable — Represents an object that can serialize itself using the Tuple Binary Encoding format
• ITupleSpanPackable — Represents an object that can serialize itself using the Tuple Binary Encoding format
• PrefixedTuple — Tuple that has a fixed arbitrary binary prefix
• SlicedTuple — Lazily-evaluated tuple that was unpacked from a key
• SpanTuple — Lazily-evaluated tuple that was unpacked from a key
• TuPackUserType — Represent a custom user type for the TuPack encoding
• TupleEncoder — Helper class to encode and decode tuples to and from binary buffers
• TuplePacker<T> — Helper class for serializing and deserializing values of type T using the tuple binary format
• TuplePackers — Helper methods used during serialization of values to the tuple binary format
• TuplePackers.Decoder<T> — Delegate that decodes a value of type T from encoded bytes
• TuplePackers.Encoder<T> — Delegate that writes a value of type T into a TupleWriter
• TuplePackers.SpanEncoder<T> — Delegate that writes a value of type T into a TupleWriter
• TupleParser — Helper class that contains low-level encoders for the tuple binary format
• TupleReader — Reads bytes from a contiguous region of arbitrary memory
• TupleSegmentType — Logical type of packed element of a tuple
• TupleSpanWriter — Buffer for writing tuples into a Span<byte>
• TupleTypes — Constants for the various tuple value types
• TupleWriter — Writes bytes to a contiguous region of arbitrary memory

SnowBank.Data.Xml

• CrystalXDocumentEmitter — XML infoset emitter that builds an in-memory XDocument
• CrystalXml — Sink plumbing for ICrystalXmlSerializer: the eight output entry points
• CrystalXml.Scalar — Entry points for a document whose root is a bare scalar (a string, a number, a date, ...)
• CrystalXmlConverterAttribute — Mono-format alias that marks a partial class as a container of source-generated XML serializers
• CrystalXmlCycleException — Error thrown when a reference cycle is detected while serializing an object graph to XML
• CrystalXmlDictionaryFormat — Specifies how a dictionary-like member is represented in XML output
• CrystalXmlEmptyElementStyle — How an element with no children or text is written
• CrystalXmlFormatters — Lexical formatters for XML scalar values
• CrystalXmlName — Name of an XML element or attribute, held in both its text and UTF-8 representations, with an optional namespace
• CrystalXmlNamespace — Namespace URI of an XML element or attribute, held in both its text and UTF-8 representations
• CrystalXmlNamespaces — The namespaces of the DataContract format that no CLR namespace derives
• CrystalXmlNewLine — Structural line ending written between XML elements when Indented is set
• CrystalXmlOutputAttribute — Requests XML output from a CrystalConverterAttribute container, and carries the parameters of that format
• CrystalXmlRootNameException — Error thrown when a root element has no name: the serializer declares no default, and the caller passed none
• CrystalXmlSerializerDefaults — List of default configurations for source-generated XML converters
• CrystalXmlSettings — Runtime options a CrystalXml writer reads while it turns a value into text or bytes
• CrystalXmlSettings.OptionFlags — Bit layout of CrystalXmlSettings
• CrystalXmlSettingsExtensions — Extension methods for CrystalXmlSettings
• CrystalXmlUnknownTypeException — Error thrown when the runtime type of a value is not part of the XML serialization graph known at generation time
• CrystalXmlWriter<TRune, TWriter> — XML text emitter that produces a byte-exact output, over either UTF-16 or UTF-8 output
• CrystalXmlWriterEmitter — XML infoset emitter that forwards events straight into a XmlWriter
• ICrystalXmlElementSerializer<T> — Serializes instances of T as a named element inside a larger document, and names itself
• ICrystalXmlEmitter — Set of XML output events emitted by generated serializers
• ICrystalXmlSerializable — Instance hook letting a type write its own XML representation
• ICrystalXmlSerializer<T> — Serializes instances of T to XML, through any ICrystalXmlEmitter
• XmlPropertyAttribute — Attribute that controls how a field or property is projected into XML output

SnowBank.Diagnostics.Contracts

• Contract — Helper type to check for pre-requisites, invariants, assertions, ...
• Contract.Debug — Contracts that are only evaluated in Debug builds
• ContractException —
• Paranoid — Helper class present only in Paranoid mode, for checking pre-requisites, invariants, assertions, ...
• ThrowHelper —

SnowBank.IO

• FastStringWriter — "Fast" version of StringWriter, that performs fewer checks, but is a good fit for specific use cases (serialization, ...)
• PartialReadOnlyStream — Stream that exposes a readonly-only subsection of another stream Stream.
• PartialWritableStream — Stream that exposes a writable subsection of another stream Stream.

SnowBank.IO.Hashing

• Fnv1Hash32 — Helper for computing 32-bits FNV-1 hashes (Fowler–Noll–Vo)
• Fnv1Hash64 — Helper for computing 64-bits FNV-1 hashes (Fowler–Noll–Vo)
• Fnv1aHash32 — Helper for computing 32-bits FNV-1a hashes (aka "Alternative" Fowler–Noll–Vo)
• Fnv1aHash64 — Helper for computing 64-bits FNV-1a hashes (aka "Alternative" Fowler–Noll–Vo)
• HighestRandomWeightHash<TKey, TBucket> — Uses the the Highest Random Weight Hashing strategy (HRW, also called Rendezvous Hashing) to deterministically choose a TBucket for any TKey
• HighestRandomWeightHash<TKey, TBucket>.Bucket —
• Murmur3Hash128 — Computes a 128-bit "Murmur3" hash
• Murmur3Hash32 — Computes a 32-bit "Murmur3" hash
• XxHash32 — Computes a 32-bit xxHash
• XxHash64 — Computes a 64-bit xxHash
• XxHash64.StreamContext — Context for computing the hash in a streaming scenario

SnowBank.Linq

• AsyncIterationHint — Defines the intent of a consumer of an async query
• AsyncIterators — Contains generic fallback implementations for custom async iterators
• AsyncQuery — Provides a set of static methods for querying objects that implement IAsyncEnumerable.
• DataSizeStatistics —
• EnumerableExtensions — Provides a set of static methods for querying objects that implement IEnumerable.
• IAsyncLinqQuery<T> — Provides optimized LINQ operations other the results of an asynchronous query
• IAsyncQuery<T> — Provides asynchronous iteration over the results of a query from a remote source.
• KeyValueSizeStatistics —
• ParallelAsyncQueryOptions — Container class for all settings relative to parallel operations
• QueryStatistics<TData> —

SnowBank.Linq.Async

• AsyncCancelableMutex — Implements a async mutex that supports cancellation
• IAsyncBuffer<TInput, TOutput> — Defines a producer/consumer buffer queue that can hold several items before blocking the producer
• IAsyncSource<T> — Defines a source that can produce items
• IAsyncTarget<T> — Defines a target that receive items and can throttle the producer

SnowBank.Linq.Async.Expressions

• AsyncFilterExpression<TSource> — Expression that evaluate a condition on each item
• AsyncObserverExpression<TSource> — Expression that execute an action on each item, but does not change the source expression in any way
• AsyncTransformExpression<TSource, TResult> — Expression that applies a transformation on each item

SnowBank.Linq.Async.Iterators

• AnonymousAsyncGenerator<TOutput> — Generate items asynchronously, using a user-provided lambda
• AsyncFilterIterator<TSource, TResult> —
• AsyncIteratorPump<TInput> — Pump that repeatedly calls MoveNext on an iterator and tries to publish the values in a Producer/Consumer queue
• AsyncLinqIterator<TResult> — Base class for all async iterators
• AsyncTransformQueue<TInput, TOutput> — Implements an async queue that asynchronously transform items, outputting them in arrival order, while throttling the producer
• BatchingAsyncIterator<TInput> — Packs items from an inner sequence, into a sequence of fixed-size arrays.
• DistinctAsyncIterator<TSource> — Filters duplicate items from an async sequence
• ExceptAsyncIterator<TSource, TKey, TResult> — Returns only the values for the keys that are in the first sub query, but not in the others
• IntersectAsyncIterator<TSource, TKey, TResult> — Returns only the values for the keys that are in all the sub queries
• MergeAsyncIterator<TSource, TKey, TResult> — Performs a Merge Sort on several concurrent range queries
• MergeSortAsyncIterator<TSource, TKey, TResult> — Merge all the elements of several ordered queries into one single async sequence
• ObserverAsyncIterator<TSource> — Observe the items of an async sequence
• ParallelAsyncIterator<TSource, TResult> — [EXPERIMENTAL] Iterates over an async sequence of items, kick off an async task in parallel, and returning the results in order
• PrefetchingAsyncIterator<TInput> — Prefetches items from the inner sequence, before outputting them down the line.
• TakeWhileAsyncIterator<TSource> — Reads an async sequence of items until a condition becomes false
• WindowingAsyncIterator<TInput> — Merges bursts of already-completed items from a source async sequence, into a sequence of batches.

SnowBank.Linq.Iterators

• ExceptIterator<TSource, TKey, TResult> — Returns only the values for the keys that are in the first sub query, but not in the others
• FilterIterator<TSource, TResult> —
• IntersectIterator<TSource, TKey, TResult> — Returns only the values for the keys that are in all the sub queries
• Iterator<TResult> — Base class for all async iterators
• MergeIterator<TSource, TKey, TResult> — Performs a Merge Sort on several concurrent range queries
• MergeSortIterator<TSource, TKey, TResult> — Merge all the elements of several ordered queries into one single async sequence
• ObserverIterator<TSource> — Observe the items of a sequence

SnowBank.Messaging

• BufferedMessageDispatcher<TMessage, TState> — Dispatch messages using a buffered channel for async processing
• DirectMessageDispatcher<TMessage, TState> — Dispatch messages directly, using the caller's thread
• IMessageDispatcher<TMessage> —
• MessageDispatcher —
• MultipleMessageDispatcher<TMessage> — Dispatch messages to multiple dispatchers
• NullMessageDispatcher<TMessage> — Dispatch messages into the void

SnowBank.Messaging.Events

• EventBus —
• EventFilters —
• IEvent —
• IEventBus —
• IEventFilter —
• IEventSink —
• InMemoryEventSink — Implementation of a Job Event Log that keeps all events in memory, mostly intended for unit testing
• NullEventSink — Ignore all received messages

SnowBank.Messaging.PubSub

• IPubSub — Base interface for PubSub implementations
• MemoryPubSub —
• MemoryPubSubExtension —
• MemoryPubSubOptions —
• PubSubExtensions — Extensions methods for the IPubSub abstraction

SnowBank.Networking

• IPAddressComparer —
• IPAddressHelpers — Helpers for working with IP addresses (or MAC addresses)
• IPEndPointComparer — Compares two IPEndPoint instances
• TracerouteHop —
• TracerouteReply —

SnowBank.Numerics

• DiyDouble —
• DiyFp — This "Do It Yourself Floating Point" class implements a floating-point number with a uint64 significand and an int exponent.
• DiySingle —
• PeirceCriterion — Helper for computing Peirce's Criterion
• RobustBenchmark — Helper for measuring the results of benchmarks
• RobustBenchmark.Report<TResult> — Report for a benchmark session
• RobustBenchmark.RunData<TResult> — Data for a run of the benchmark
• RobustChart — Generates ASCII Art that look like plots
• RobustChart.Axis — Helper class for generating axis
• RobustChart.Data — Series of data
• RobustChart.FrameBuffer — Buffer use for rendering a frame
• RobustCounter — Isolated counter that will not introduce false-sharing between concurrent threads
• RobustCounters — Distributed global counter made up of individual counters
• RobustHistogram — Helper that will aggregate individual measurements, and output detailed distribution reports and charts.
• RobustHistogram.DimensionType — Specifies the type of the measurement
• RobustHistogram.TimeScale — Specifies the scale and/or type of units for the measurement
• RobustStopwatch — Helper for measuring precise elapsed time
• RobustTimeLine — Helper for generating reports of time measurements

SnowBank.Reactive.Disposables

• Disposable — Helper type that can create IDisposable wrappers
• Disposable<T> — Token that wraps any value into an IDisposable instance
• IDisposable<T> — Type that encapsulates a value of type T, and that implements IDisposable with a customizable behavior when it is disposed.

SnowBank.Runtime

• Boxed<T> — Wraps any type of CLR objects
• CanExplainExtensions — Extensions methods for ICanExplain types
• ExceptionExtensions — Helper methods for working with exceptions
• ExplanationBuilder — Builder for generating text descriptions of types that implement ICanExplain
• ExpressionExtensions —
• ICanExplain — Interface for expressions or AST nodes that can generate a human-readable description of their part in a query or command
• PlatformHelpers —
• TypeEqualityComparer — Equality comparer for types
• TypeHelper — Extensions methods that add advanced features on Type

SnowBank.Runtime.Converters

• ComparisonHelper — Helper class used to compare object of "compatible" types
• ComparisonHelper.TypePair — Pair of types that can be used as a key in a dictionary
• ComparisonHelper.TypePairComparer — Helper class to use TypePair as keys in a dictionary
• ITypeConverter — Base class of all value converters
• ITypeConverter<TSource, TDestination> — Class that can convert values of type TSource into values of type TDestination
• SimilarValueComparer — Helper that compares instances for "similarity"
• StringConverters — Helper methods for converting common types into string literals
• TypeConverters — Helper class for converting instances from one type to another

SnowBank.Text

• Base1024Encoding — Helper type for using the Base-1024 encoding
• Base32Encoding — Helper type for using the Base32 encoding
• Base62Encoding — Helper type for using the Base62 encoding
• Base62FormattingOptions — Options used to configure the behavior or Base62Encoding encoding and decoding methods.
• Base64Encoding — Helper type for using the Base62 encoding
• DebugStatementWriter — Very simple writer to dump query expressions into a statement useful for logging/debugging
• HexaDump — Helper class for formatting binary blobs into hexadecimal for logging or troubleshooting
• HexaDump.Options — Formatting options
• JavaScriptEncoding —
• JavaScriptEncoding.Tokens —
• JsonEncoding — Provides methods for encoding and escaping JSON strings.
• StringBuilderCache —
• StringTable — This is basically a lossy cache of strings that is searchable by strings, string sub ranges, character array ranges or string-builder.
• StringTable.Hash — Helpers for Hash computation
• UnicodeCodePoint —
• UrlEncoding — Helper for encoding/decoding URIs
• Utf8Encoder —

SnowBank.Text.Xml

• XPathEncoder — XPATH Codec
• XmlEncoder — XML Codec

SnowBank.Threading

• ExponentialRandomizedBackoff — Provides a state machine that can be used to retry operations after a randomized delay with built-in exponential backoff
• NodaTimeProvider — A single source of time exposed through BOTH the BCL TimeProvider facade (timestamps, timers, delays, timeouts) and the NodaTime IClock facade (Instants)
• NodaTimeProviderExtensions — Extensions for consuming NodaTime instants from a plain TimeProvider
• ProbabilisticTrigger — Helps decide whether to trigger some process or postpone to the next opportunity, with some adjustable probabilities
• ReaderWriterLockSlimExtensions — Extensions methods for working with ReaderWriterLockSlim
• ReaderWriterLockSlimExtensions.ReadLockDisposable — Token that represents a read lock on a ReaderWriterLockSlim
• ReaderWriterLockSlimExtensions.UpgradeableReadLockDisposable — Token that represents an upgradable read lock on a ReaderWriterLockSlim
• ReaderWriterLockSlimExtensions.WriteLockDisposable — Token that represents a write lock on a ReaderWriterLockSlim

SnowBank.Threading.Operations

• IOperationContext — Represents the execution context for an asynchronous operation that can be observed from the outside
• IOperationContext<TResult> — Represents the context of an Operation
• IOperationInvoker<TService> —
• IOperationOverlord — Service that monitors the executions of operations in the scope of the process
• IOperationScheduler — Service that can schedule and run Operations
• IOperationWorkflow — Base interface for a Workflow
• IOperationWorkflow<TArguments, TResult> — Base interface of a Workflow that processes a TArguments and returns a TResult
• IOperationWorkflow<TWorkflow, TArguments, TResult> — Base interface of a Workflow that processes a TArguments and returns a TResult
• IStoryBook —
• OperationActionAttribute —
• OperationCallSite<TResult, T0, T1, T2, T3, T4, T5> — Call-site of an operation that takes six arguments
• OperationCallSite<TResult, T0, T1, T2, T3, T4> — Call-site of an operation that takes five arguments
• OperationCallSite<TResult, T0, T1, T2, T3> — Call-site of an operation that takes four arguments
• OperationCallSite<TResult, T0, T1, T2> — Call-site of an operation that takes three arguments
• OperationCallSite<TResult, T0, T1> — Call-site of an operation that takes two arguments
• OperationCallSite<TResult, T0> — Call-site of an operation that takes one argument
• OperationContext<TResult> — Context of an operation
• OperationContextExtensions —
• OperationError — Result of a failed Operation.
• OperationErrorException — Exception that can be used to bubble up an OperationError from deep inside the execution of an Operatin.
• OperationFailed — Represents the result of a failed Operation.
• OperationInvokerAttribute<TService> —
• OperationInvokerExtensions — Helper methods for Operation Invokers
• OperationResult<TResult> — Represents the result of the execution of an operation
• OperationScheduler — Service that tracks and runs Operations
• OperationState —
• OperationWorkflowBase<TWorkflow, TArguments, TResult> — Generic implementation for Workflows

System

• HashCodes — Helper methods to work with hashcodes
• Maybe — Provides a set of static methods to work with the Maybe monad, enabling functional programming patterns in C#.
• Maybe<T> — Represents a value that may or may not be present, along with an optional error state.
• MaybeError — Represents an error captured during a computation
• Slice — Delimits a read-only section of a byte array
• Slice.Comparer — Performs optimized equality and comparison checks on Slices
• Slice.Pinned — Structure that keeps buffers from moving in memory during GC collections
• SliceExtensions — Helper methods for Slice
• SliceMarshal — Advanced or unsafe operations on Slice
• SliceOwner — A container for rented Slice that can be returned into a ArrayPool after it is not needed anymore.
• SpanDecoderExtensions — Helper methods to help decode the content of spans
• SystemStringExtensions —
• Uuid128 — Represents an RFC 4122 compliant 128-bit UUID
• Uuid128.Comparer — Instance of this times can be used to test Uuid128 for equality and ordering
• Uuid48 — Represents a 48-bit UUID that is stored in high-endian format in the output
• Uuid48.Comparer — Compares Uuid48 instances for equality and ordering
• Uuid48.RandomGenerator — Generates 48-bit UUIDs using a secure random number generator
• Uuid64 — Represents a 64-bit UUID that is stored in high-endian format in the output
• Uuid64.Comparer — Compares Uuid64 instances for equality and ordering
• Uuid64.RandomGenerator — Generates 64-bit UUIDs using a secure random number generator
• Uuid80 — Represents an 80-bit UUID that is stored in high-endian format in the output
• Uuid80.Comparer — Instance of this times can be used to test Uuid80 for equality and ordering
• Uuid80.RandomGenerator — Generates 80-bit UUIDs using a secure random number generator
• Uuid96 — Represents a 96-bit UUID that is stored in high-endian format in the output
• Uuid96.Comparer — Instance of this times can be used to test Uuid96 for equality and ordering
• Uuid96.RandomGenerator — Generates 96-bit UUIDs using a secure random number generator
• VersionStamp — VersionStamp
• VersionStamp.Comparer — Compares VersionStamp instances for equality and ordering

System.Collections.Generic

• IOrderedAsyncQuery<T> — Provides asynchronous iteration over the results of a query from a remote source.

System.IO.Hashing

• XxHashExtensions — Extension methods for computing XxHash values

System.Text

• InvariantAppendInterpolatedStringHandler — Interpolated string handler that appends to a StringBuilder in a culture-invariant manner.
• StringBuilderInvariantExtensions — Extension methods for StringBuilder which format interpolated strings with InvariantCulture, without having to pass the provider on each call.