Reuse a broad set of shared helper extensions for composition, collections, async flows, and more.
Common.Abstractions contains a broad extensions layer under Extensions. This is the shared utility surface that many other devkit packages build on.
This page is intentionally an overview, not an API catalog. The goal is to show what kinds of extensions are available and where to look when you need them.
The folder contains two styles of extension classes:
- focused classes with explicit names such as
DateTimeExtensions,StringExtensions, orConditionalLinqExtensions - many small helper files that contribute methods to the partial static
Extensionsclass
That means the package is best understood by capability area rather than by a single class name.
These extensions help with shaping, slicing, filtering, and traversing in-memory collections.
Representative files:
ConditionalCollectionExtensions.csConditionalLinqExtensions.csEnumerableExtensions.csListExtensions.csDictionaryExtensions.csAsyncEnumerableExtensions.csToHierarchy.csBatch.csPartition.csSlice.csSliceFrom.csSliceTill.csDistinctIf.csMerge.csForEach.csParallelForeach.cs
Typical use cases:
- conditional
Where,Select, and ordering logic - batching and partitioning large in-memory collections
- building tree structures from flat data
- working with
IAsyncEnumerable<T>without pulling in another utility package
This area overlaps with the higher-level extension docs in Extensions, but the code lives here in Common.Abstractions.
Representative files:
LinqFluentExtensions.csMatch.csTo.csToType.csSafeNull.csSafeAny.csSafeWhere.csSafeEquals.csSafeRemove.csEmptyToNull.csExcludeNull.csIsNullOrEmpty.cs
Typical use cases:
- fluent chaining around nullable or optional values
- safe collection access when inputs may be null
- lightweight conversions and pattern-style branching
- avoiding repetitive guard code in application and infrastructure layers
If you want the conceptual guidance for these fluent patterns, start with Extensions. This page is the package-level map of where those helpers live.
These extensions provide common date and time calculations and parsing helpers.
Representative files:
DateTimeExtensions.csDateTimeOffsetExtensions.csDateOnlyExtensions.csTimeOnlyExtensions.csTimeSpanExtensions.cs
Typical use cases:
- start/end of day, week, month, or year
- relative date calculations
- parsing dates from multiple string formats
- range checks and date/time convenience operations
These extensions focus on small but frequently used text and enum operations.
Representative files:
StringExtensions.csStartsWithAny.csContainsAny.csTruncate.csEnumExtensions.csConcatArgs.csToString.cs
Typical use cases:
- string cleanup and matching
- working with multiple prefixes or tokens
- enum metadata and helper logic
- building shell or command arguments safely
These support lower-level workflow code where streams, tasks, and async pipelines are common.
Representative files:
StreamExtensions.csTaskExtensions.csAsyncEnumerableExtensions.cs
Typical use cases:
- convenience helpers for stream handling
- async sequence querying and projection
- task composition helpers used by infrastructure code
These are support extensions for infrastructure code, configuration, and dynamic behavior.
Representative files:
TypeExtensions.csAssemblyExtensions.csExpressionExtensions.csExceptionExtensions.cs
Typical use cases:
- finding types during registration or assembly scanning
- working with expression trees
- extracting useful exception information
- reflection-heavy infrastructure code
These extensions help with configuration access and service-collection inspection.
Representative files:
ConfExtensions.csServiceCollectionExtensions.cs
Typical use cases:
- reading configuration sections while replacing placeholder values such as
{{Some:Key}} - checking whether a service has already been added to
IServiceCollection - finding or locating a registered service descriptor during startup composition
- Use these helpers to reduce boilerplate, not to hide business logic.
- Prefer the narrowly named extension classes when you are browsing for behavior such as date, string, or configuration helpers.
- Expect many small general-purpose methods to live in the partial
Extensionsclass. - For the fluent null-safe and query-composition style, read Extensions for the conceptual usage patterns and this page for the package layout.
This page does not list every overload or method. The extensions folder is too broad for that to stay useful. Treat this page as a map of the available families of helpers, then go to the specific file when you need exact behavior.