FrameworkExtensions.Backports 1.0.0.256

.NET 5.0 This package targets .NET 5.0. The package is compatible with this framework or higher. .NET Core 3.1 This package targets .NET Core 3.1. The package is compatible with this framework or higher. .NET Standard 2.0 This package targets .NET Standard 2.0. The package is compatible with this framework or higher. .NET Framework 2.0 This package targets .NET Framework 2.0. The package is compatible with this framework or higher. 
dotnet add package FrameworkExtensions.Backports --version 1.0.0.256
                    


                    

                
NuGet\Install-Package FrameworkExtensions.Backports -Version 1.0.0.256
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="FrameworkExtensions.Backports" Version="1.0.0.256" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
<PackageVersion Include="FrameworkExtensions.Backports" Version="1.0.0.256" />
                    


                            Directory.Packages.props
                        

                    

                
<PackageReference Include="FrameworkExtensions.Backports" />
                    


                            Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package. 
paket add FrameworkExtensions.Backports --version 1.0.0.256
                    


                    

                
#r "nuget: FrameworkExtensions.Backports, 1.0.0.256"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
#:package FrameworkExtensions.Backports@1.0.0.256
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package. 
#addin nuget:?package=FrameworkExtensions.Backports&version=1.0.0.256
                    


                            Install as a Cake Addin
                        

                    

                
#tool nuget:?package=FrameworkExtensions.Backports&version=1.0.0.256
                    


                            Install as a Cake Tool

FrameworkExtensions.Backports

Build Tests

Last Commit NuGet Version License

Overview

FrameworkExtensions.Backports is a NuGet package that provides a collection of extensions (Polyfills) to ensure that newer compiler features work in older versions of the .NET Framework/Standard/Core. This package allows developers to use modern C# language features and .NET APIs even when working on projects targeting earlier versions down to Net2.0.

Performance is not a primary concern here. This focuses mainly on functionality and ready-to-be-built without making adjustments to code.

How It Works

The package uses conditional compilation (#if directives) and MSBuild target framework detection to decide, per feature, whether to:

  1. Use the native implementation -- when the target framework already provides the API (e.g., Span<T> on .NET Core 2.1+).
  2. Reference an official Microsoft NuGet package -- when Microsoft ships a standalone backport (e.g., System.Memory for .NET Framework 4.5+).
  3. Provide a custom polyfill -- when neither of the above is available (e.g., Span<T> on .NET Framework 2.0/3.5).

All polyfills live under the original namespace of the type they replace, so consuming code requires no extra using directives and compiles identically across all targets.

Supported Target Frameworks

Target Framework TFM Notes
.NET Framework 2.0 net20 Oldest supported; custom polyfills for most APIs
.NET Framework 3.5 net35 Adds LINQ expressions, DLR
.NET Framework 4.0 net40 Task/async support via Microsoft.Bcl.Async
.NET Framework 4.5 net45 Official System.Memory, System.Buffers packages used
.NET Framework 4.6 net46
.NET Framework 4.6.1 net461 Official System.Collections.Immutable, Microsoft.Bcl.HashCode used
.NET Framework 4.6.2 net462
.NET Framework 4.7 net47
.NET Framework 4.7.1 net471
.NET Framework 4.7.2 net472
.NET Framework 4.8 net48
.NET Standard 2.0 netstandard2.0 Broad compatibility surface
.NET Standard 2.1 netstandard2.1 Adds Span-native APIs
.NET Core 3.1 netcoreapp3.1
.NET 5.0 net5.0
.NET 6.0 net6.0
.NET 7.0 net7.0
.NET 8.0 net8.0
.NET 9.0 net9.0

Architecture

Official Package Integration

To avoid conflicts with official Microsoft BCL backport packages and ensure optimal compatibility, FrameworkExtensions.Backports uses a hybrid approach:

  • When official packages exist: For target frameworks where Microsoft provides official backport packages (such as System.Memory, System.Buffers, System.ValueTuple, etc.), this package automatically references and uses those official implementations.

  • When official packages don't exist: For older target frameworks (like .NET Framework 2.0, 3.5) or for features not covered by official packages, this package provides custom backport implementations.

This approach means:

  • ✅ Users only need to reference FrameworkExtensions.Backports - all necessary dependencies are included automatically
  • ✅ No package conflicts - official implementations are used when available, avoiding type conflicts
  • ✅ Better performance and compatibility - official Microsoft implementations are optimized and thoroughly tested
  • ✅ Seamless experience - the same API surface works across all target frameworks

Official Packages Included

The following official Microsoft packages are conditionally referenced based on your target framework:

Active Packages:

  • System.Memory - Provides Span<T>, ReadOnlySpan<T>, Memory<T>, and MemoryMarshal (.NET Framework 4.5+, .NET Standard 2.0)
  • System.Buffers - Provides ArrayPool<T> (.NET Framework 4.5+, .NET Standard 2.0)
  • System.ValueTuple - Provides ValueTuple types (.NET Framework 4.0+)
  • System.Runtime.CompilerServices.Unsafe - Provides the Unsafe class (.NET Framework 4.5+, .NET Standard 1.0+)
  • System.Numerics.Vectors - Provides Vector types (.NET Framework 4.5+, .NET Standard 2.0)
  • System.Numerics.Tensors - Provides Tensor<T>, TensorSpan<T>, TensorPrimitives and related tensor types (.NET 9.0+; polyfill for earlier versions)
  • System.Threading.Tasks.Extensions - Provides ValueTask (.NET Framework 4.5+, .NET Standard 2.0)
  • Microsoft.Bcl.HashCode - Provides HashCode (.NET Framework 4.6.1+, .NET Standard 2.0)
  • Microsoft.Bcl.AsyncInterfaces - Provides IAsyncEnumerable<T>, IAsyncDisposable and related async interfaces (.NET Framework 4.6.1+, .NET Standard 2.0)
  • System.Runtime.InteropServices.RuntimeInformation - Provides RuntimeInformation, OSPlatform, Architecture (.NET Framework 4.5+)
  • System.Collections.Immutable - Provides ImmutableArray<T>, ImmutableDictionary<TKey,TValue>, and other immutable collections (.NET Framework 4.6.1+, .NET Standard 2.0)
  • System.Text.Json - Provides JsonSerializer, JsonDocument, Utf8JsonReader/Writer and related JSON types (.NET Framework 4.6.2+, .NET Standard 2.0)
  • System.IO.Hashing - Provides Crc32, Crc64, XxHash32, XxHash64, XxHash128 (.NET Framework 4.6.2+, .NET Standard 2.0)

Deprecated Packages (still included for compatibility):

  • Microsoft.Bcl - Provides CallerMemberNameAttribute and related attributes (.NET Framework 4.0 only)
  • Microsoft.Bcl.Async - Provides TaskAwaiter and async/await support (.NET Framework 4.0 only)

Microsoft.Bcl and Microsoft.Bcl.Async are officially deprecated but are still included for .NET Framework 4.0 to avoid conflicts with existing projects that may reference these packages.

For target frameworks where these packages are not available (e.g., .NET Framework 2.0/3.5), custom implementations are provided.

Project Structure

Backports/
  Backports.csproj          # Multi-targeting project file (net20 through net9.0)
  Features/                 # Feature directories, each containing one polyfill
    ActionFunc/             # Action/Func delegate types
    AggregateException/     # AggregateException for pre-.NET 4.0
    AsyncEnumerable/        # IAsyncEnumerable/IAsyncEnumerator
    BigInteger/             # System.Numerics.BigInteger polyfill
    CollectionsMarshal/     # CollectionsMarshal.AsSpan, GetValueRefOrNullRef, SetCount
    ExceptionDispatchInfo/  # Exception capture/rethrow preserving stack trace
    FormattableString/      # C# 6 string interpolation support
    RuntimeInformation/     # OSPlatform, Architecture, RuntimeInformation
    SystemTextJson/         # JSON serialization polyfill
    ...                     # (one directory per feature)
  System/                   # Shared type definitions and helpers
  Utilities/                # Internal utilities (method impl options, guards, etc.)
  build/                    # MSBuild .props/.targets for conditional compilation flags

Each feature directory follows the pattern Features/<FeatureName>/System/<Namespace>/<TypeName>.cs and is guarded by a #if !SUPPORTS_<FEATURE> conditional compilation directive that is set in the build/ directory's .props files.

Features

Interfaces

Types

Attributes

Delegates

  • System
    • Func<T> (up to 16 types)
    • Action<T> (up to 16 types)

Static Methods

Methods

  • System.Array

    • Span<T> AsSpan<T>(this T[] @this)
    • Span<T> AsSpan<T>(this T[] @this, int start)
    • Span<T> AsSpan<T>(this T[] @this, int start, int length)
    • Span<T> AsSpan<T>(this T[] @this, Index startIndex)
    • Span<T> AsSpan<T>(this T[] @this, Range range)
    • Memory<T> AsMemory<T>(this T[] @this)
    • Memory<T> AsMemory<T>(this T[] @this, int start)
    • Memory<T> AsMemory<T>(this T[] @this, int start, int length)
    • Memory<T> AsMemory<T>(this T[] @this, Index startIndex)
    • Memory<T> AsMemory<T>(this T[] @this, Range range)

  • System.ReadOnlySpan

    • bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other)
    • bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other)
    • bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, IEqualityComparer<T> comparer)
    • int IndexOf<T>(this ReadOnlySpan<T> span, T value)
    • int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
    • int IndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
    • int LastIndexOf<T>(this ReadOnlySpan<T> span, T value)
    • int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
    • int LastIndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
    • bool StartsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
    • bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
    • bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value)
    • int Count<T>(this Span<T> span, T value)
    • int Count<T>(this ReadOnlySpan<T> span, T value)
    • void Sort<T>(Span<T> span)
    • void Sort<T>(Span<T> span, Comparison<T> comparison)
    • void Sort<T, TComparer>(Span<T> span, TComparer comparer)
    • void Sort<TKey, TValue>(Span<TKey> keys, Span<TValue> items)
    • void Sort<TKey, TValue>(Span<TKey> keys, Span<TValue> items, Comparison<TKey> comparison)
    • void Sort<TKey, TValue, TComparer>(Span<TKey> keys, Span<TValue> items, TComparer comparer)
    • void Reverse<T>(Span<T> span)
    • int CommonPrefixLength<T>(this Span<T> span, ReadOnlySpan<T> other)
    • int CommonPrefixLength<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other)
    • int CommonPrefixLength<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, IEqualityComparer<T> comparer)

  • System.Collections.Concurrent.ConcurrentBag

    • void Clear<T>(this ConcurrentBag<T>)

  • System.Collections.Concurrent.ConcurrentDictionary

    • TValue AddOrUpdate<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> @this, TKey key, Func<TKey, TArg, TValue> addValueFactory, Func<TKey, TValue, TArg, TValue> updateValueFactory, TArg factoryArgument)

  • System.Collections.Concurrent.ConcurrentQueue

    • void Clear<T>(this ConcurrentQueue<T>)

  • System.Collections.Concurrent.ConcurrentStack

    • void Clear<T>(this ConcurrentStack<T>)

  • System.Collections.Generic.IEnumerable

    • HashSet<TItem> ToHashSet<TItem>(this IEnumerable<TItem> @this)
    • HashSet<TItem> ToHashSet<TItem>(this IEnumerable<TItem> @this, IEqualityComparer<TItem> comparer)

  • System.Collections.Generic.KeyValuePair

    • KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue value)
    • void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> @this, out TKey key, out TValue value)

  • System.Collections.Generic.Stack

    • bool TryPop<TItem>(this Stack<TItem> @this, out TItem result)
    • bool TryPeek<TItem>(this Stack<TItem> @this, out TItem result)
    • int EnsureCapacity<T>(this Stack<T> @this, int capacity)

  • System.Collections.Generic.Queue

    • bool TryDequeue<TItem>(this Queue<TItem> @this, out TItem result)
    • int EnsureCapacity<T>(this Queue<T> @this, int capacity)
    • bool TryPeek<TItem>(this Queue<TItem> @this, out TItem result)

  • System.Collections.Generic.Dictionary

    • int EnsureCapacity<TKey, TValue>(this Dictionary<TKey, TValue> @this, int capacity)
    • TValue? GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> @this, TKey key)
    • TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> @this, TKey key, TValue defaultValue)
    • bool TryAdd<TKey, TValue>(this Dictionary<TKey, TValue> @this, TKey key, TValue value)

  • System.Collections.Generic.HashSet

    • int EnsureCapacity<T>(this HashSet<T> @this, int capacity)
    • bool TryGetValue<T>(this HashSet<T> @this, T equalValue, out T actualValue)

  • System.Collections.Generic.SortedSet

    • bool TryGetValue<T>(this SortedSet<T> @this, T equalValue, out T actualValue)

  • System.Collections.Generic.List

    • List<T> Slice<T>(this List<T> @this, int start, int length)
    • int EnsureCapacity<T>(this List<T> @this, int capacity)

  • System.Collections.Generic.CollectionExtensions

    • ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list)
    • ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)

  • System.DateTime

    • int Microsecond(this DateTime @this)
    • int Nanosecond(this DateTime @this)
    • DateTime AddMicroseconds(this DateTime @this, double value)
    • bool TryFormat(this DateTime @this, Span<char> destination, out int charsWritten, ...)
    • void Deconstruct(this DateTime @this, out DateOnly date, out TimeOnly time)
    • void Deconstruct(this DateTime @this, out int year, out int month, out int day)

  • System.DateTimeOffset

  • System.Diagnostics.Stopwatch

  • System.Environment

  • System.GC

  • System.Globalization.CompareInfo

    • int GetHashCode(this CompareInfo @this, string source, CompareOptions options)

  • System.Guid

  • System.Enum

  • System.IO.DirectoryInfo

  • System.IO.FileInfo

    • void MoveTo(this FileInfo @this, string destFileName, bool overwrite)

  • System.IO.BinaryReader

    • byte[] ReadExactly(this BinaryReader @this, int count)
    • void ReadExactly(this BinaryReader @this, Span<byte> buffer)

  • System.IO.Stream

    • void CopyTo(this Stream @this, Stream target)
    • void Flush(this Stream @this, bool flushToDisk)
    • Task<int> ReadAsync(this Stream @this, byte[] buffer, int offset, int count)
    • Task<int> ReadAsync(this Stream @this, byte[] buffer, int offset, int count, CancellationToken cancellationToken)
    • Task WriteAsync(this Stream @this, byte[] buffer, int offset, int count)
    • Task WriteAsync(this Stream @this, byte[] buffer, int offset, int count, CancellationToken cancellationToken)
    • Task CopyToAsync(this Stream @this, Stream destination, int bufferSize, CancellationToken cancellationToken)
    • int Read(this Stream @this, Span<byte> buffer)
    • void Write(this Stream @this, ReadOnlySpan<byte> buffer)
    • void ReadExactly(this Stream @this, byte[] buffer, int offset, int count)
    • void ReadExactly(this Stream @this, Span<byte> buffer)
    • int ReadAtLeast(this Stream @this, Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true)
    • ValueTask<int> ReadAsync(this Stream @this, Memory<byte> buffer, CancellationToken cancellationToken = default)
    • ValueTask WriteAsync(this Stream @this, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
    • ValueTask ReadExactlyAsync(this Stream @this, byte[] buffer, int offset, int count, CancellationToken cancellationToken = default)
    • ValueTask ReadExactlyAsync(this Stream @this, Memory<byte> buffer, CancellationToken cancellationToken = default)

  • System.IO.TextWriter

    • void Write(this TextWriter @this, ReadOnlySpan<char> buffer)
    • void WriteLine(this TextWriter @this, ReadOnlySpan<char> buffer)
    • Task WriteAsync(this TextWriter @this, string? value)
    • Task WriteAsync(this TextWriter @this, char value)
    • Task WriteAsync(this TextWriter @this, char[] buffer, int index, int count)
    • Task WriteLineAsync(this TextWriter @this)
    • Task WriteLineAsync(this TextWriter @this, string? value)
    • Task WriteLineAsync(this TextWriter @this, char value)
    • Task WriteLineAsync(this TextWriter @this, char[] buffer, int index, int count)
    • Task FlushAsync(this TextWriter @this)

  • System.IO.TextReader

    • int Read(this TextReader @this, Span<char> buffer)
    • Task<string?> ReadLineAsync(this TextReader @this)
    • Task<string> ReadToEndAsync(this TextReader @this)
    • Task<int> ReadAsync(this TextReader @this, char[] buffer, int index, int count)
    • Task<int> ReadBlockAsync(this TextReader @this, char[] buffer, int index, int count)

  • System.IO.Directory

  • System.Type

  • System.Text.Encoding

    • bool TryGetBytes(this Encoding @this, ReadOnlySpan<char> chars, Span<byte> bytes, out int bytesWritten)
    • bool TryGetChars(this Encoding @this, ReadOnlySpan<byte> bytes, Span<char> chars, out int charsWritten)

  • System.Text.StringBuilder

    • StringBuilder Append(this StringBuilder @this, ReadOnlySpan<char> value)
    • StringBuilder AppendJoin(this StringBuilder @this, string separator, params object[] values)
    • StringBuilder AppendJoin(this StringBuilder @this, string separator, params string[] values)
    • StringBuilder AppendJoin(this StringBuilder @this, char separator, params object[] values)
    • StringBuilder AppendJoin(this StringBuilder @this, char separator, params string[] values)
    • ChunkEnumerator GetChunks(this StringBuilder @this)
    • StringBuilder Insert(this StringBuilder @this, int index, ReadOnlySpan<char> value)

  • System.Linq

    • TResult[] ToArray<TResult>(this IEnumerable<TResult> @this)
    • List<TResult> ToList<TResult>(this IEnumerable<TResult> @this)
    • ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> @this, Func<TSource, TKey> keySelector)
    • ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> @this, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    • IEnumerable<TResult> Cast<TResult>(this IEnumerable @this)
    • IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> @this, Func<TSource, int, bool> predicate)
    • IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> @this, Func<TSource, TResult> selector)
    • IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> @this, Func<TSource, int, TResult> selector)
    • IEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> @this, Func<TSource, TKey> keySelector)
    • IEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> @this, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
    • IEnumerable<TSource> ThenBy<TSource, TKey>(this IEnumerable<TSource> @this, Func<TSource, TKey> keySelector)
    • IEnumerable<TSource> ThenBy<TSource, TKey>(this IEnumerable<TSource> @this, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
    • TSource First<TSource>(this IEnumerable<TSource> @this)
    • TSource First<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TSource FirstOrDefault<TSource>(this IEnumerable<TSource> @this)
    • TSource FirstOrDefault<TSource>(this IEnumerable<TSource> @this, TSource defaultValue)
    • TSource FirstOrDefault<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TSource FirstOrDefault<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate, TSource defaultValue)
    • TSource Single<TSource>(this IEnumerable<TSource> @this)
    • TSource Single<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TSource SingleOrDefault<TSource>(this IEnumerable<TSource> @this)
    • TSource SingleOrDefault<TSource>(this IEnumerable<TSource> @this, TSource defaultValue)
    • TSource SingleOrDefault<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate, TSource defaultValue)
    • TSource SingleOrDefault<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TSource Last<TSource>(this IEnumerable<TSource> @this)
    • TSource Last<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TSource LastOrDefault<TSource>(this IEnumerable<TSource> @this)
    • TSource LastOrDefault<TSource>(this IEnumerable<TSource> @this, TSource defaultValue)
    • TSource LastOrDefault<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TSource LastOrDefault<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate, TSource defaultValue)
    • TSource Min<TSource>(this IEnumerable<TSource> source)
    • TItem MinBy<TItem, TKey>(this IEnumerable<TItem> @this, Func<TItem, TKey> keySelector)
    • TItem MinBy<TItem, TKey>(this IEnumerable<TItem> @this, Func<TItem, TKey> keySelector, IComparer<TKey> comparer)
    • TSource Max<TSource>(this IEnumerable<TSource> source)
    • bool Any<TSource>(this IEnumerable<TSource> @this)
    • bool Any<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • bool All<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • int Count<TSource>(this IEnumerable<TSource> @this)
    • int Count<TSource>(this IEnumerable<TSource> @this, Func<TSource, bool> predicate)
    • TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> @this, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
    • TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> @this, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
    • TSource Aggregate<TSource>(this IEnumerable<TSource> @this, Func<TSource, TSource, TSource> func)
    • TItem MaxBy<TItem, TKey>(this IEnumerable<TItem> @this, Func<TItem, TKey> keySelector)
    • TItem MaxBy<TItem, TKey>(this IEnumerable<TItem> @this, Func<TItem, TKey> keySelector, IComparer<TKey> comparer)
    • IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    • IEnumerable<TItem> Prepend<TItem>(this IEnumerable<TItem> @this, TItem item)
    • IEnumerable<TItem> Append<TItem>(this IEnumerable<TItem> @this, TItem item)
    • bool TryGetNonEnumeratedCount<TItem>(this IEnumerable<TItem> source, out int count)
    • IEnumerable<TItem> Zip<TFirst, TSecond, TResult>(IEnumerable<TFirst> @this, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
    • IEnumerable<TSource[]> Chunk<TSource>(this IEnumerable<TSource> source, int size)
    • IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    • IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelector)
    • IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelector)
    • IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector)
    • IOrderedEnumerable<T> Order<T>(this IEnumerable<T> source)
    • IOrderedEnumerable<T> OrderDescending<T>(this IEnumerable<T> source)
    • IEnumerable<(int Index, TSource Item)> Index<TSource>(this IEnumerable<TSource> source)
    • IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    • IEnumerable<KeyValuePair<TKey, TAccumulate>> AggregateBy<TSource, TKey, TAccumulate>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, TAccumulate> seed, Func<TAccumulate, TSource, TAccumulate> func)
    • IEnumerable<TSource> Shuffle<TSource>(this IEnumerable<TSource> source)
    • IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
    • IEnumerable<TResult> RightJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
    • IEnumerable<TSource> Reverse<TSource>(this TSource[] source)
    • IEnumerable<T> Sequence<T>(T start, T endInclusive, T step)
    • IEnumerable<T> InfiniteSequence<T>(T start, T step)
    • IEnumerable<TSource> TakeLast<TSource>(this IEnumerable<TSource> source, int count)
    • IEnumerable<TSource> SkipLast<TSource>(this IEnumerable<TSource> source, int count)

  • System.Delegate

  • System.Random

    • long NextInt64(this Random @this)
    • long NextInt64(this Random @this, long maxValue)
    • long NextInt64(this Random @this, long minValue, long maxValue)
    • float NextSingle(this Random @this)
    • void NextBytes(this Random @this, Span<byte> buffer)
    • T[] GetItems<T>(this Random @this, T[] choices, int length)
    • void GetItems<T>(this Random @this, ReadOnlySpan<T> choices, Span<T> destination)
    • void Shuffle<T>(this Random @this, T[] values)
    • void Shuffle<T>(this Random @this, Span<T> values)
    • string GetHexString(this Random @this, int length, bool lowercase = false)
    • void GetHexString(this Random @this, Span<char> destination, bool lowercase = false)
    • string GetString(this Random @this, ReadOnlySpan<char> choices, int length)

  • System.Reflection.Assembly

  • System.Reflection.Module

  • System.Reflection.MemberInfo

  • System.Reflection.ParameterInfo

  • System.Reflection.MethodInfo

  • System.Reflection.PropertyInfo

    • object GetValue(this PropertyInfo @this, object obj)
    • void SetValue(this PropertyInfo @this, object obj, object value)

  • System.String

    • int GetHashCode(this string @this, StringComparison comparisonType)
    • bool Contains(this string @this, string value, StringComparison comparisonType)
    • bool Contains(this string @this, char value)
    • bool Contains(this string @this, char value, StringComparison comparisonType)
    • bool StartsWith(this string @this, char value)
    • bool EndsWith(this string @this, char value)
    • string Trim(this string @this, char trimChar)
    • string TrimStart(this string @this, char trimChar)
    • string TrimEnd(this string @this, char trimChar)
    • string Replace(this string @this, string oldValue, string? newValue, StringComparison comparisonType)
    • string ReplaceLineEndings(this string @this)
    • string ReplaceLineEndings(this string @this, string replacementText)
    • LineSplitEnumerator EnumerateLines(this string @this)
    • void CopyTo(this string @this, Span<char> destination)
    • bool TryCopyTo(this string @this, Span<char> destination)
    • string[] Split(this string @this, char separator, StringSplitOptions options = StringSplitOptions.None)
    • string[] Split(this string @this, char separator, int count, StringSplitOptions options = StringSplitOptions.None)
    • string[] Split(this string @this, string separator, StringSplitOptions options = StringSplitOptions.None)
    • string[] Split(this string @this, string separator, int count, StringSplitOptions options = StringSplitOptions.None)
    • int IndexOf(this string @this, char value, StringComparison comparisonType)
    • ReadOnlySpan<char> AsSpan(this string @this)
    • ReadOnlySpan<char> AsSpan(this string @this, int start)
    • ReadOnlySpan<char> AsSpan(this string @this, int start, int length)
    • ReadOnlySpan<char> AsSpan(this string @this, Index startIndex)
    • ReadOnlySpan<char> AsSpan(this string @this, Range range)
    • ReadOnlyMemory<char> AsMemory(this string @this)
    • ReadOnlyMemory<char> AsMemory(this string @this, int start)
    • ReadOnlyMemory<char> AsMemory(this string @this, int start, int length)
    • ReadOnlyMemory<char> AsMemory(this string @this, Index startIndex)
    • ReadOnlyMemory<char> AsMemory(this string @this, Range range)

  • System.Type

  • System.Numerics.Matrix3x2

  • System.Numerics.Matrix4x4

  • System.Numerics.Plane

    • Plane Create(Vector4 value)
    • Plane Create(Vector3 normal, float d)
    • Plane Create(float x, float y, float z, float d)

  • System.Numerics.Quaternion

    • Quaternion Zero (static property)
    • float GetElement(this Quaternion @this, int index)
    • Quaternion WithElement(this Quaternion @this, int index, float value)
    • Quaternion Create(Vector3 vectorPart, float scalarPart)
    • Quaternion Create(float x, float y, float z, float w)

  • System.RuntimeServices.CompilerServices.RuntimeHelpers

  • System.Text.StringBuilder

    • void Clear(this StringBuilder @this)

  • System.Threading.Tasks

    • TaskAwaiter GetAwaiter(this Task task)
    • TaskAwaiter<TResult> GetAwaiter<TResult>(this Task<TResult> task)
    • ConfiguredTaskAwaitable ConfigureAwait(this Task task, bool continueOnCapturedContext)
    • ConfiguredTaskAwaitable<TResult> ConfigureAwait<TResult>(this Task<TResult> task, bool continueOnCapturedContext)

  • System.Threading.CancellationTokenSource

    • bool TryReset(this CancellationTokenSource @this)
    • Task CancelAsync(this CancellationTokenSource @this)
    • void CancelAfter(this CancellationTokenSource @this, int millisecondsDelay)
    • void CancelAfter(this CancellationTokenSource @this, TimeSpan delay)

  • System.Threading.WaitHandle

    • void Dispose(this WaitHandle @this)

  • System.Threading.PeriodicTimer

    • TimeSpan Period (instance property)

  • System.Threading.Tasks.Task

    • Task WaitAsync(this Task @this, TimeSpan timeout)
    • Task WaitAsync(this Task @this, CancellationToken cancellationToken)
    • Task WaitAsync(this Task @this, TimeSpan timeout, CancellationToken cancellationToken)

  • System.Threading.Tasks.TaskCompletionSource

    • bool TrySetCanceled<TResult>(this TaskCompletionSource<TResult> @this, CancellationToken cancellationToken)

  • System.Diagnostics.Process

    • Task WaitForExitAsync(this Process @this, CancellationToken cancellationToken = default)

  • System.Text.RegularExpressions.Regex

    • int Count(this Regex @this, string input)
    • int Count(this Regex @this, ReadOnlySpan<char> input)
    • int Count(this Regex @this, string input, int startAt)

  • System.Collections.Generic.List

    • void AddRange<T>(this List<T> @this, ReadOnlySpan<T> source)
    • void InsertRange<T>(this List<T> @this, int index, ReadOnlySpan<T> source)
    • void CopyTo<T>(this List<T> @this, Span<T> destination)
    • List<T> GetRange<T>(this List<T> @this, int index, int count)

  • System.Half

    • Half Clamp(Half value, Half min, Half max)

  • System.Net.Http.HttpContent

  • System.Text.Json.JsonNamingPolicy

  • System.StringSplitOptions

    • StringSplitOptions TrimEntries (constant value for frameworks without native support)

Installation

You can install the FrameworkExtensions.Backports package via NuGet Package Manager or the .NET CLI:

NuGet Package Manager

Install-Package FrameworkExtensions.Backports

.NET CLI

dotnet add package FrameworkExtensions.Backports

Build/Test Guidelines

Building

# Build for all target frameworks
dotnet build Backports/Backports.csproj

# Build for a specific target framework
dotnet build Backports/Backports.csproj -f net8.0

Testing

# Run all tests
dotnet test Backports.Tests/Backports.Tests.csproj

# Run tests for a specific framework
dotnet test Backports.Tests/Backports.Tests.csproj -f net8.0

# Run a specific test category
dotnet test --filter "Category=Unit"

Requirements

  • .NET SDK 10.0+ (to build for all target frameworks)
  • Visual Studio 2026 or later (recommended for multi-targeting support)
  • NuGet package restore is automatic on build

Usage

Below are some examples of how to use the features provided by this package. Note that the namespaces are kept original, so no additional using directives are needed.

Range and Index

public class Program {
    public static void Main() {
        int[] numbers = { 1, 2, 3, 4, 5 };
        var slice = numbers[1..^1];
        Console.WriteLine(string.Join(", ", slice)); // Output: 2, 3, 4
    }
}

Lazy Initialization

public class Program {
    private static Lazy<int> lazyValue = new Lazy<int>(() => ComputeValue());

    public static void Main() {
        Console.WriteLine(lazyValue.Value); // Output: Computed Value
    }

    private static int ComputeValue() {
        Console.WriteLine("Computed Value");
        return 42;
    }
}

LINQ Methods

using System.Collections.Generic;
using System.Linq;

public class Program {
    public static void Main() {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        var max = numbers.Max();
        var minBy = numbers.MinBy(n => n);

        Console.WriteLine($"Max: {max}");    // Output: Max: 5
        Console.WriteLine($"MinBy: {minBy}");// Output: MinBy: 1
    }
}

Task Extensions

using System.Threading.Tasks;

public class Program {
    public static async Task Main() {
        Task task = Task.Delay(1000);
        await task.ConfigureAwait(false);
        Console.WriteLine("Task completed");
    }
}

Expression Trees

using System;
using System.Linq.Expressions;

public class Program {
    public static void Main() {
        // Build an expression tree for: (x, y) => x + y
        var x = Expression.Parameter(typeof(int), "x");
        var y = Expression.Parameter(typeof(int), "y");
        var add = Expression.Add(x, y);
        var lambda = Expression.Lambda<Func<int, int, int>>(add, x, y);

        // Compile and execute
        var compiled = lambda.Compile();
        Console.WriteLine(compiled(3, 4)); // Output: 7

        // Build a conditional expression: x > 0 ? x : -x (absolute value)
        var param = Expression.Parameter(typeof(int), "x");
        var zero = Expression.Constant(0);
        var condition = Expression.GreaterThan(param, zero);
        var negate = Expression.Negate(param);
        var conditional = Expression.Condition(condition, param, negate);
        var absLambda = Expression.Lambda<Func<int, int>>(conditional, param);

        var abs = absLambda.Compile();
        Console.WriteLine(abs(-5)); // Output: 5
        Console.WriteLine(abs(3));  // Output: 3

        // Method call expression
        var str = Expression.Parameter(typeof(string), "str");
        var toUpper = Expression.Call(str, typeof(string).GetMethod("ToUpper", Type.EmptyTypes)!);
        var toUpperLambda = Expression.Lambda<Func<string, string>>(toUpper, str);

        var upper = toUpperLambda.Compile();
        Console.WriteLine(upper("hello")); // Output: HELLO
    }
}

Dynamic Language Runtime (DLR)

The Dynamic Language Runtime (DLR) provides infrastructure for dynamic languages and the dynamic keyword in C#. This polyfill enables DLR functionality for .NET 2.0 and .NET 3.5.

using System;
using System.Dynamic;
using System.Collections.Generic;

public class Program {
    public static void Main() {
        // ExpandoObject - dynamic property bag
        dynamic expando = new ExpandoObject();
        expando.Name = "John";
        expando.Age = 30;
        expando.Greet = (Func<string>)(() => $"Hello, I'm {expando.Name}!");

        Console.WriteLine(expando.Name);    // Output: John
        Console.WriteLine(expando.Age);     // Output: 30
        Console.WriteLine(expando.Greet()); // Output: Hello, I'm John!

        // Access as dictionary
        var dict = (IDictionary<string, object>)expando;
        dict["City"] = "New York";
        Console.WriteLine(expando.City);    // Output: New York

        // Enumerate properties
        foreach (var kvp in dict)
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
    }
}

// Custom DynamicObject implementation
public class DynamicDictionary : DynamicObject {
    private readonly Dictionary<string, object> _storage = new();

    public override bool TryGetMember(GetMemberBinder binder, out object result) {
        return _storage.TryGetValue(binder.Name, out result);
    }

    public override bool TrySetMember(SetMemberBinder binder, object value) {
        _storage[binder.Name] = value;
        return true;
    }

    public override IEnumerable<string> GetDynamicMemberNames() => _storage.Keys;
}

The DLR polyfill for .NET 2.0/3.5 provides the core dynamic infrastructure including ExpandoObject, DynamicObject, CallSite<T>, and all binder types. On .NET 4.0+, the BCL implementation is used automatically.

Span Extensions

using System;

public class Program {
    public static void Main() {
        // Create a Span from an array
        int[] numbers = { 1, 2, 3, 4, 5 };
        Span<int> span = numbers.AsSpan();
        
        // Slice operations
        Span<int> slice = span.Slice(1, 3); // { 2, 3, 4 }
        Console.WriteLine($"Slice length: {slice.Length}"); // Output: 3
        
        // Fill and Clear
        Span<int> buffer = stackalloc int[10];
        buffer.Fill(42);
        Console.WriteLine($"First element: {buffer[0]}"); // Output: 42
        
        // ReadOnlySpan from string
        ReadOnlySpan<char> text = "Hello World".AsSpan();
        ReadOnlySpan<char> world = text.Slice(6); // "World"
        Console.WriteLine(world.ToString()); // Output: World
        
        // Sequence comparison
        ReadOnlySpan<int> a = new[] { 1, 2, 3 };
        ReadOnlySpan<int> b = new[] { 1, 2, 3 };
        Console.WriteLine(a.SequenceEqual(b)); // Output: True
        
        // Index and LastIndex operations
        ReadOnlySpan<int> data = new[] { 1, 2, 3, 2, 1 };
        Console.WriteLine(data.IndexOf(2));     // Output: 1
        Console.WriteLine(data.LastIndexOf(2)); // Output: 3
    }
}

Vector Extensions

using System;
using System.Numerics;

public class Program {
    public static void Main() {
        // Vector2 operations
        Vector2 position = new Vector2(3.0f, 4.0f);
        Console.WriteLine($"Length: {position.Length()}"); // Output: 5
        
        Vector2 normalized = Vector2.Normalize(position);
        Console.WriteLine($"Normalized: {normalized}"); // Output: <0.6, 0.8>
        
        // Vector3 operations
        Vector3 v1 = new Vector3(1, 0, 0);
        Vector3 v2 = new Vector3(0, 1, 0);
        Vector3 cross = Vector3.Cross(v1, v2);
        Console.WriteLine($"Cross product: {cross}"); // Output: <0, 0, 1>
        
        // Vector4 transformations
        Vector4 point = new Vector4(1, 2, 3, 1);
        Matrix4x4 scale = Matrix4x4.CreateScale(2.0f);
        Vector4 transformed = Vector4.Transform(new Vector3(1, 2, 3), scale);
        Console.WriteLine($"Scaled: {transformed}");
        
        // Linear interpolation
        Vector3 start = Vector3.Zero;
        Vector3 end = new Vector3(10, 10, 10);
        Vector3 midpoint = Vector3.Lerp(start, end, 0.5f);
        Console.WriteLine($"Midpoint: {midpoint}"); // Output: <5, 5, 5>
        
        // Matrix operations
        Matrix4x4 rotation = Matrix4x4.CreateRotationZ(MathF.PI / 4); // 45 degrees
        Vector4 row = rotation.GetRow(0);
        Console.WriteLine($"First row: {row}");
    }
}

Intrinsics Extensions

using System;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

public class Program {
    public static unsafe void Main() {
        // Note: Hardware intrinsics provide SIMD operations.
        // When native support is unavailable, software fallbacks are used.
        
        // Vector128 creation and manipulation
        Vector128<float> vec1 = Vector128.Create(1.0f, 2.0f, 3.0f, 4.0f);
        Vector128<float> vec2 = Vector128.Create(5.0f, 6.0f, 7.0f, 8.0f);
        
        // Element access
        float first = Vector128.GetElement(vec1, 0);
        Console.WriteLine($"First element: {first}"); // Output: 1
        
        // SSE operations (with software fallback)
        // Software fallback always available
        if (Sse.IsSupported || true) {
            Vector128<float> sum = Sse.Add(vec1, vec2);
            float[] result = new float[4];
            fixed (float* ptr = result)
                Sse.Store(ptr, sum);
            
            Console.WriteLine($"Sum: [{result[0]}, {result[1]}, {result[2]}, {result[3]}]");
            // Output: Sum: [6, 8, 10, 12]
        }
        
        // SSE2 integer operations
        Vector128<int> intVec1 = Vector128.Create(10, 20, 30, 40);
        Vector128<int> intVec2 = Vector128.Create(1, 2, 3, 4);
        Vector128<int> intSum = Sse2.Add(intVec1, intVec2);
        
        // SSE41 advanced operations
        float[] data = { 1.5f, 2.7f, 3.2f, 4.9f };
        fixed (float* ptr = data) {
            Vector128<float> loaded = Sse.LoadVector128(ptr);
            Vector128<float> rounded = Sse41.Floor(loaded);
            // Result: { 1.0, 2.0, 3.0, 4.0 }
        }
        
        // Dot product calculation
        Vector128<float> a = Vector128.Create(1.0f, 2.0f, 3.0f, 4.0f);
        Vector128<float> b = Vector128.Create(2.0f, 3.0f, 4.0f, 5.0f);
        Vector128<float> dot = Sse41.DotProduct(a, b, 0xFF);
        // Result contains dot product in all elements: 40 (1*2 + 2*3 + 3*4 + 4*5)
    }
}

Planned Features

The goal is to make Backports compiler-complete for older targets with the same runtime functionality as modern .NET.

Test Coverage

  • Add comprehensive tests for all existing polyfills
  • Add tests for Memory<T>, MemoryPool<T>, ReadOnlySequence<T>, Vector128/256/512<T>
  • Ensure test parity across all target frameworks (net35-net9.0)

Known Issues

  • net2.0 - Unit-tested using Hawkynt's custom nUnit-Runner.
  • netstandard2.0/2.1 test targets - These are API specifications, not runtimes. Tests compile but cannot execute directly; functionality is verified via compatible runtimes (netcoreapp3.1, net5.0+)
  • .NET SDK 10.0 test platform - VSTest 18.x has compatibility issues with older .NET Core runtimes when running from CLI; Visual Studio Test Explorer handles this better
  • TimeZoneInfo (net2.0) - Minimal stub implementation; most operations beyond Utc and Local throw NotSupportedException
  • ExceptionDispatchInfo (pre-net4.5) - Stack trace is not fully preserved on re-throw due to framework limitations
  • System.Text.Json polyfill - Subset of the full API; complex serialization scenarios may require the official NuGet package on supported frameworks
  • HttpContent.ReadAsStream - Only available on .NET Core targets (not .NET Framework) as it requires the built-in System.Net.Http

Contributing

Contributions are welcome! Please follow these steps:

  1. Fork the repository.
  2. Create a new branch with a descriptive name.
  3. Make your changes.
  4. Remember: Everything public in here should polyfill existing Microsoft functionality and thus should be mentioned in the Readme with a link to its original documentation. Don't expose public members not part of Microsoft's API.
  5. Submit a pull request.

License

This project is licensed under the LGPL-3.0-or-later License. See the LICENSE file for details.

Alternatives

Yes, there are other polyfill libraries available for .NET. Some only fill specific gaps, while others aim to provide a more comprehensive set of backports. Some use different approaches, such as source generators or IL weaving - some are indeed very similar. Sadly some are no longer actively maintained or horribly outdated.

Here are a few notable ones:

Acknowledgments

We appreciate the contributions of the .NET community in making this package possible.

Product Compatible and additional computed target framework versions.
.NET net5.0 is compatible.  net5.0-windows was computed.  net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 is compatible.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 is compatible.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 was computed.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 is compatible. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 is compatible. 
.NET Framework net20 is compatible.  net35 is compatible.  net40 is compatible.  net403 was computed.  net45 is compatible.  net451 was computed.  net452 was computed.  net46 is compatible.  net461 is compatible.  net462 is compatible.  net463 was computed.  net47 is compatible.  net471 is compatible.  net472 is compatible.  net48 is compatible.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (5)

Showing the top 5 NuGet packages that depend on FrameworkExtensions.Backports:

Package Downloads
FrameworkExtensions.Corlib

Extensions to the Corlib.
FrameworkExtensions.System.Windows.Forms

Extensions to WindowsForms.
FrameworkExtensions.PresentationCore

Extensions to WPF.
FrameworkExtensions.System.Drawing

Extensions to System.Drawing
FrameworkExtensions.DirectoryServices

Extensions to DirectoryServices.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
1.0.0.256 300 3/2/2026
1.0.0.254 202 2/9/2026
1.0.0.250 191 2/2/2026
1.0.0.245 179 1/26/2026
1.0.0.237 168 1/19/2026
1.0.0.235 146 1/12/2026
1.0.0.231 183 1/5/2026
1.0.0.212 178 12/29/2025
1.0.0.198 267 12/22/2025
1.0.0.183 427 12/15/2025
1.0.0.167 499 11/17/2025
1.0.0.166 252 11/10/2025
1.0.0.163 299 9/29/2025
1.0.0.159 314 9/22/2025
1.0.0.158 313 9/15/2025
1.0.0.157 584 8/18/2025
1.0.0.156 293 8/4/2025
1.0.0.147 415 7/21/2025
1.0.0.142 1,181 7/7/2025
1.0.0.137 239 6/23/2025
Loading failed