This package provides collections that are thread safe and guaranteed to never change their contents, also known as immutable collections. Like strings, any methods that perform modifications will not change the existing instance but instead return a new instance. For efficiency reasons, the implementation uses a sharing mechanism to ensure that newly created instances share as much data as possible with the previous instance while ensuring that operations have a predictable time complexity. The System.Collections.Immutable library is built-in as part of the shared framework in .NET Runtime. The package can be installed when you need to use it in other target frameworks.
Recommended Google client library to access the Google Cloud Storage API. It wraps the Google.Apis.Storage.v1 client library, making common operations simpler in client code. Google Cloud Storage stores and retrieves potentially large, immutable data objects.
An AutoFixture customization that allows AutoFixture to create specimens of the immutable collections found in the System.Collections.Immutable namespace.
Retargeted for .Net 4.0. Unofficial, unsupported build https://github.com/jlanng/ImmutableCollectionsNet40
This library uses and abuses the features of C# to provide a functional 'Base class library', that, if you squint, can look like extensions to the language itself.
Deprecated package to add System.Collections.Immutable support to MessagePack. This is now built into the main package.
A lightweight library designed to help create immutable domain objects and DTOs in .Net.
Get all the common units of measurement and the conversions between them. It is light-weight and thoroughly tested.
A member of the Visual Studio SDK
This package provides attributes for immutable entities source code generation. This package is part of the Uno.CodeGen to generate immutable entities in your project.
A member of the Visual Studio SDK
A member of the Visual Studio SDK
A member of the Visual Studio SDK
F# bindings for System.Collections.Immutable
Immutable persistent collections, algebraic sum-type aka descriminated union, Ref type and supportive extensions for performant functional programming in C#. Split from the DryIoc: https://github.com/dadhi/DryIoc
Fluent property-to-column mapping for Dapper, including explicit maps, naming conventions, profiles, diagnostics, and supported immutable object materialization.
Helper library for LanguageExt.Core that facilitates conversion between F# native types like Option, Map, List, etc to .NET and Language Ext types.
Parser combinators library based on Haskell Parsec. This is part of the LanguageExt functional base class library and requires LanguageExt.Core
Attributes used by Apex.Analyzers.Immutable
Remora.Extensions is a set of libraries that extend the C# ecosystem, in similar vein to Microsoft.Extenions. This package adds support for immutable option types for Microsoft's DI containers.
This package contains a Souce Generator which generates Value Objects that wrap simple primitives such as int, string, double etc. A ValueObject is a strongly typed (strongly, not stringly) domain object that is immutable. Instead of `int customerId = 42;` we have `var customerId = CustomerId.From(42);` To use, just create something like this: [ValueObject(typeof(int))] public partial struct CustomerId { } var customerId = CustomerId.From(42); Validation is in just one place. You can't introduce bad objects into your domain, therefore you can assume that in your domain every ValueObject is valid.
.NET for Android and MAUI bindings for the Android Java library 'com.google.auto.value:auto-value-annotations'. Library description: Immutable value-type code generation for Java 8+.
Support for Reactive Extensions overloads for various types in the LanguageExt.Core
Lightweight and performant immutable linked list data structure for .NET
Add ImmutableCollection formatters to Utf8Json.
A lightweight, flexible and easy to use do/undo/redo implementation based on immutable objects for .NET.
Roslyn powered analyzers for C# to support defining immutable types
A way to make it easier to create and work with immutable classes in Bridge.NET
Core components of Stl.Fusion - a new implementation of "computed observables" designed to power distributed apps. Thread-safe, asynchronous, immutable, and ready to serve replicas of computed instances to remote clients.
An implementation of IImmutableDictionary<TKey, TValue> that maintains O(1) value lookup, at the cost of mutation performance.
This package provides the Visual Studio "Shell Immutable" reference assembly used by Visual Studio 2012 and newer. Microsoft.VisualStudio.Shell.Immutable.11.0.dll
Common classes and extension methods for use with the ProductiveRage.Immutable library
.NET Standard library for building immutable models
CK.Core contains types and helpers that are used across different projects. Main types are: - NormalizedPath: Normalizes / and \ separators to /, exposes Parts and handle multiple kind of roots: / (RootedBySeparator), 'X:' or ':' (RootedByFirstPart), '//' (RootedByDoubleSeparator), or 'xx://' (RootedByURIScheme). - CKTrait: Thread safe set of (immutable) string tags that support all set operations. - DateTimeStamp: Simple DateTime with byte uniquifier. - SimpleServiceContainer: Basic IServiceProvider implementation. - HashStream and SHA1Value, SHA256Value and SHA512Value. - ISystemClock and SystemClock default implementation. - Completable & Completion: Are "futures" or "yet another promises" (based on Task/TaskCompletionSource). Offer Covariance of the completion result and optional extension points to map errors (exceptions or cancellation) to regular results. - CKBinaryReader/Writer: extend IBinaryReader/Writer with nullable support, more read/write of standard types and optional value sharing.
C# generator for model generated interfaces
Functions like MapT, BindT, ForAllT, etc. for the nested monadic type extensions (i.e. `Seq<Option>`
Immutable versions of `Memory<T>` and `Span<T>`, because `ReadOnlyMemory/Span` doesn't imply the underlying memory won't be mutated. These types either wrap known immutable objects (`String`, `ImmutableArray<T>`), or they take sole ownership of a defensive copy of the underlying memory. They then provide a non-mutating API which closely resembles `ReadOnlyMemory/Span`.
T4Immutable is a T4 template for C# .NET apps that generates code for immutable classes.
Dolittle is a platform designed to build Line of Business applications without sacrificing architectural quality, code quality or scalability.
Client-side components of Stl.Fusion - a new implementation of "computed observables" designed to power distributed apps. Thread-safe, asynchronous, immutable, and ready to serve replicas of computed instances to remote clients.
An buffer of bytes implemented internally as immutable array ReadOnlyMemory<byte>