Sphere10 Framework
Sphere10 Framework is the reusable .NET foundation behind Sphere 10 software. It brings application architecture, user interfaces, data access and specialised storage into a consistent set of C# libraries, so we can spend more of a project on the business problem and less on rebuilding its infrastructure.
The current Framework targets .NET 10. Choose the libraries your application needs, extend their contracts and keep your business rules in your own product. The source is available under the MIT licence.
.NET Application Foundations
A Consistent Structure for Growing Applications
Sphere10.Framework.Application supplies service composition through Microsoft.Extensions.DependencyInjection, configuration and settings, application lifecycle tasks, commands and wizard infrastructure. Its shared application-block model organises features into blocks, menus and screen definitions.
WinForms and Blazor adapters use those common contracts while retaining their own platform lifetimes. Startup plugins can contribute services and application blocks. Your application owns its workflows, permissions and business rules; the Framework provides reusable mechanisms around them.
Collections and Persistence
Control Memory, Storage and Transaction Boundaries
The core library includes extended, paged and stream-mapped collections, B-tree families, clustered streams, caches and synchronised collection wrappers. These building blocks support workloads where an ordinary in-memory collection is not the right fit. Decorators add change notification and locking to any of them, and transactional streams give an ordinary file commit and rollback.
Sphere10.Framework.Data adds database contexts, provider SQL builders, schema access and connection and transaction scopes. Provider libraries support SQL Server, SQLite, Firebird, PostgreSQL, MySQL and Oracle, with separate NHibernate integration. We select the provider and transaction model around the application instead of promising identical behaviour from every database.
-
How to Build a Disk-Backed C# Collection
-
How to Page a Large List Between Memory and Disk in C#
-
How to Build a Persistent Dictionary and Set in C#
-
How to Build a Persistent B+ Tree for Range Queries
-
How to Observe and Synchronize Collections with Decorators in C#
-
How to Give an Ordinary File Commit and Rollback in C#
-
How to Share One Transaction Across Nested Calls in C#
-
How to Run SQL Against Any Database Engine Through One API
-
How to Store Many Independent Streams Inside One File
ObjectSpace Embedded Storage
Typed Objects With Explicit Commit and Rollback
ObjectSpace is a typed embedded object store over clustered streams. Registered CLR types have dimensions, serializers, recyclable object slots and member indexes. MemoryObjectSpace and FileObjectSpace provide different storage choices through the same construction model.
FileObjectSpace exposes explicit commit and rollback. Index definitions, serializer layout and storage settings form part of the store's opening contract. This makes ObjectSpace useful for deliberately designed local persistence, with its capabilities and limits considered as part of the application's architecture.
-
How to Build an Embedded Object Database in C#
-
How to Query Objects Without Scanning Every Record
-
How to Add Commit and Rollback to a C# Object Store
-
How to Build a Self-Describing Object Store
-
How to Add Cryptographic Integrity to an Object Store
-
How to Autosave Changed Objects in an ObjectSpace
-
How to Tune an ObjectSpace for Your Workload
-
How to Store Indexed Records with ObjectStream
Serialization and Integration
Define Data Formats and Service Contracts Deliberately
Composable binary serializers, serializer factories and endian-aware readers and writers support application-specific formats and stream-mapped storage. They let us define how records are encoded and how existing data is reopened, rather than treating persistence as an incidental object dump.
BinarySerializer writes any object graph to a stream in two calls, with no attributes or registrations, and restores derived types, shared references and cycles. It fills the place BinaryFormatter left when it was removed from .NET 9.
The communications libraries include JSON-RPC clients and servers, TCP endpoints and inter-process pipe components. We combine these with explicit service contracts and application-owned error handling. Hash functions, Merkle structures and digital-signature primitives are available where a system needs integrity proofs or cryptographic verification.
-
How to Replace BinaryFormatter in Modern .NET with BinarySerializer
-
How to Serialize an Object Graph Without Losing Shared References
-
How to Write a Custom Binary Serializer in C#
-
How to Serialize Polymorphic Types in C#
-
How to Store Serializer Definitions Alongside Your Data
-
How to Dispatch JSON-RPC Calls to C# Methods by Name
-
How to Write a Custom Network Transport with ProtocolChannel
-
How to Add Bounds, Hashing and Encryption to Any Stream in C#
Runtime Services
Caching, Scheduling, Logging and Scopes Without Another Dependency
The core library carries the services most applications end up writing for themselves. Caches fetch on demand or in bulk, expire by age, cap their size and share a memory budget. An in-process scheduler runs recurring and one-shot jobs from serializable schedules. Loggers are composed from sinks and decorators, so adding a timestamp, a prefix or a second destination is one wrapper.
Scopes tie cleanup and shared context to a using block, comparers are composed instead of hand-written, and data sources put paging, sorting, filtering and editing behind one contract that the WinForms and Blazor grids both consume.
-
How to Cache Expensive Lookups with Expiry and Capacity Limits in C#
-
How to Cache Whole Datasets and Sessions in C#
-
How to Schedule Background Jobs In-Process in C#
-
How to Compose Loggers from Sinks and Decorators in C#
-
How to Tie Cleanup and Shared Context to a C# Scope
-
How to Compose Comparers and Equality Rules in C#
-
How to Describe Filters and Sorts as Data in C#
-
How to Serve Paged, Editable Data Through One Contract in C#
-
How to Track Live Statistics Without Keeping Every Sample
Cryptography and Integrity
One API for Hashing, Signatures and Merkle Proofs
Hashing goes through one API whichever algorithm is selected, and the same holds for digital signatures across ECDSA, Schnorr and the one-time schemes. ECIES encrypts to a public key, and key derivation and random generation follow the same pattern.
Merkle trees are available on their own and built into lists, dictionaries, sets and object stores, so a collection can publish one root hash and prove that a record belongs to it.
-
How to Hash Data with One API across Algorithms
-
How to Sign and Verify Messages with ECDSA and Schnorr
-
How to Encrypt Data to a Public Key with ECIES
-
How to Derive Keys from Passwords and Generate Random Values in C#
-
How to Prove One Record Belongs to a Dataset
-
How to Prove Appends, Updates and Deletes in a Merkle Tree
-
How to Keep a Merkle Root over a List, Dictionary or Set
-
Hashes, Signatures and Merkle Proofs: What Does Each Actually Prove?
-
Why One-Time Signature Keys Must Never Be Reused
Windows Desktop Applications
Practical Controls for Data-Heavy Software
The Windows Forms libraries provide CRUD grids, typed editors, validation and reference selection, database connection panels, retained screens, dialogs and wizards. Numeric and telemetry charts present captured values with explicit units and gaps for missing observations.
Shared logging and output controls help expose useful diagnostics consistently. The application still owns its data collection, permissions, refresh cadence and business actions. Windows integration remains Windows-specific.
ASP.NET Core and Blazor
Bring the Same Application Patterns to the Browser
The ASP.NET Core libraries provide hosting and integration support, with a separate MVC layer for forms, filters and routing. The Blazor library targets .NET 10 Interactive Server applications and brings application-block navigation and data-source patterns to browser software.
Its typed CRUD grid supports buffered editing, validation, paging, reference pickers and async row commands. Dialogs, wizards, retained screens and scoped theme switching support larger business interfaces. The host owns browser and circuit integration; the library is not a standalone WebAssembly runtime.
Built Into Real Software
Infrastructure We Use Ourselves
Local Notion uses Framework, Application and Data libraries in its core and command-line application. The product synchronises Notion content, stores local copies and renders publications and websites; Framework provides reusable infrastructure beneath that product behaviour.
AutoMouse uses the application, drawing, Windows and Windows Forms libraries for its keyboard mouse controls and automatic clicking workflows. System Expert uses the same Windows application infrastructure for diagnostic screens, grids, charts and logging, while its own code collects and interprets system information.
Adopt the Framework
Use the Libraries or Work With Their Developers
Inspect the source and engineering documentation , then add the packages your project needs. Core is published on NuGet . Published package versions and the current source branch can differ, so select a compatible release and follow its documentation.
The Application and platform capabilities described here refer to the current source tree. Follow its source-build documentation for those libraries. Source builds require the .NET 10 SDK; Windows libraries also require Windows. The current source uses the MIT licence, allowing incorporation into your own software subject to its licence terms.
dotnet add package Sphere10.Framework
The Framework article series walks through each mechanism with a runnable sample.
Sphere 10 can design a new .NET application, extend an existing codebase, build a Blazor business system or resolve a difficult storage and integration problem. Discuss Your .NET Project or explore our .NET Application Services .