Workable.AspNetCore
1.1.80526.1
See the version list below for details.
dotnet add package Workable.AspNetCore --version 1.1.80526.1
NuGet\Install-Package Workable.AspNetCore -Version 1.1.80526.1
<PackageReference Include="Workable.AspNetCore" Version="1.1.80526.1" />
<PackageVersion Include="Workable.AspNetCore" Version="1.1.80526.1" />
<PackageReference Include="Workable.AspNetCore" />
paket add Workable.AspNetCore --version 1.1.80526.1
#r "nuget: Workable.AspNetCore, 1.1.80526.1"
#:package Workable.AspNetCore@1.1.80526.1
#addin nuget:?package=Workable.AspNetCore&version=1.1.80526.1
#tool nuget:?package=Workable.AspNetCore&version=1.1.80526.1
Workable
Workable is a .NET work orchestration library for applications that need more than "run this in the background." It turns background jobs, operational tasks, recurring work, and user-triggered actions into first-class work the host can queue, observe, control, and configure.
Most applications eventually grow work that does not fit cleanly inside the request, controller action, message handler, or command that started it. Sending email, refreshing caches, synchronizing data, running maintenance tasks, retrying transient failures, and coordinating long-running operations all need identity, state, cancellation, status, events, and a way to be found later. Workable gives that work a consistent runtime model instead of leaving each feature to invent its own.
Workable is useful when you want feature code to define work near the feature that needs it, while the host application keeps control of execution. Feature assemblies can declare their own work with Workable.Sdk. Libraries that need to use a hosted system can depend on Workable.Abstractions and accept IWorkSystem from the host. The host application owns the actual Workable systems, decides which work belongs in each system, and controls how workers start, retry, recur, respect concurrency, and stay available for inspection.
That split lets teams add work near the feature that needs it without forcing every feature library to know how the application hosts work. At runtime, the host gets a consistent surface for queueing work, awaiting completion, pausing, canceling, reconfiguring workers, and subscribing to work events.
Workable also gives applications a path to expose the same authored work through more than one channel. Direct .NET callers, HTTP endpoints, MCP clients, and realtime SignalR clients can all work against the same catalog while preserving request context, structured outcomes, worker history, and invocation rules.
Why Use Workable?
- Define work once and invoke it through .NET, HTTP, or MCP when those channels are enabled.
- Register workflow definitions that coordinate existing work through dispatch, typed fan-out, parallel branches, and join steps inside the host runtime.
- Keep feature libraries independent from the host runtime while still letting them contribute work.
- Queue fire-and-forget work without losing the ability to query, observe, cancel, pause, retry, or purge it.
- Give operators a real admin surface for work: live system and worker visibility, executable definitions, diagnostics, and control actions instead of one-off job screens and custom tooling.
- Attach runtime behavior such as recurrence, transient retry, failed-worker handling, idempotency, concurrency, durability, retention, logging, profiling, initialization, invocation policy, and start policy.
- Use structured inputs, outputs, messages, worker snapshots, event payloads, and status summaries instead of ad hoc task tracking.
- Preserve who or what started work through request context and origin metadata for HTTP, MCP, SignalR, and direct .NET calls.
Packages
Core Packages
Workable.Sdk: contracts and registration helpers for assemblies that author work.Workable.Abstractions: contracts for libraries that consume an already-hosted work system.Workable: in-process host and runtime for Workable systems.
Optional Packages
Workable.SqlServer: SQL Server persistence integration for durable queueing and completion, durable workflows, persistence-backed idempotency, and persistence-backed concurrency.Workable.AspNetCore: ASP.NET Core request-context and authorization integration for custom endpoints and hosts.Workable.Entra: Microsoft Entra ID bearer-token validation and Workable authorization claim mapping for ASP.NET Core target apps.Workable.Views: shared component-view contracts and projections used by HTTP and SignalR adapters; most applications receive it transitively throughWorkable.HttpApiorWorkable.SignalRinstead of referencing it directly.Workable.HttpApi: standard HTTP endpoints for queueing, querying, and controlling workers and workflow runs.Workable.Mcp: MCP server adapter for authored work, worker and workflow queries, and worker and workflow actions.Workable.SignalR: realtime worker and workflow events plus component-view updates for ASP.NET Core clients.
Apps And Tools
apps/samples/Workable.SampleHost: runnable ASP.NET Core sample app with HTTP API, MCP, SignalR, fake-auth profiles, and SQL Server LocalDB durability scenarios.apps/tools/Workable.PerformanceHarness: opt-in scenario runner and BenchmarkDotNet harness for runtime, query, view, realtime, and SQL durability performance work.apps/tools/Workable.SqlServer.Cli: SQL Server schema generation and deployment CLI for Workable persistence.apps/web/workable-admin-ui: Next.js admin UI for inspecting and operating Workable systems through the HTTP API and SignalR realtime updates.
Documentation
Start with the docs landing page: Workable Docs.
Recommended entry points:
- Getting Started if you are evaluating or integrating Workable.
- Registration if you are authoring work in feature assemblies.
- Workflows if you want to author multi-step orchestrations from existing work definitions.
- Implementation if you want to implement work classes and understand what executor code can do at runtime.
- Queueing if you already have work definitions and want to invoke them.
- Configuration if you are tuning start behavior, retry, recurrence, failed-worker handling, concurrency, durability, logging, retention, or invocation rules.
- HTTP API, MCP, and Realtime if you are exposing Workable over transports.
- Abstractions Surface if you are consuming a hosted system from another library.
- Workable SQL Server Integration if you need durable queueing, durable workflows, or persistence-backed coordination.
- Sample Host if you want a runnable reference app.
- Admin UI if you want the browser-based operator surface.
- Performance Harness if you are measuring runtime or adapter performance.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0 is compatible. 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. |
-
net10.0
- Workable.Abstractions (>= 1.1.80526.1)
NuGet packages (4)
Showing the top 4 NuGet packages that depend on Workable.AspNetCore:
| Package | Downloads |
|---|---|
|
Workable.Entra
Microsoft Entra ID integration for interpreting host-authenticated actors and authorization claims on Workable ASP.NET Core adapter surfaces. |
|
|
Workable.SignalR
Expose Workable worker events and component-view updates to ASP.NET Core clients through SignalR. |
|
|
Workable.HttpApi
Expose standard ASP.NET Core HTTP endpoints for queueing Workable definitions, querying workers, and sending worker actions. |
|
|
Workable.Mcp
Expose Workable definitions, query tools, and worker action tools through an ASP.NET Core MCP server adapter. |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 1.1.82326.1 | 222 | 8/24/2026 |
| 1.1.81126.1 | 200 | 8/11/2026 |
| 1.1.80926.1 | 130 | 8/9/2026 |
| 1.1.80726.1 | 153 | 8/8/2026 |
| 1.1.80526.1 | 159 | 8/5/2026 |
| 1.1.71926.1 | 175 | 7/21/2026 |
| 1.1.70926.1 | 195 | 7/10/2026 |
| 1.1.70626.2 | 247 | 7/6/2026 |
| 1.1.70626.1 | 160 | 7/6/2026 |
| 1.1.63026.1 | 187 | 6/30/2026 |
| 1.1.61226.1 | 199 | 6/12/2026 |
| 1.1.159.1 | 229 | 6/8/2026 |
| 1.1.158.1 | 171 | 6/7/2026 |
| 1.1.157 | 173 | 6/7/2026 |
| 1.1.153.1 | 180 | 6/2/2026 |
| 1.1.146.1 | 380 | 5/26/2026 |
| 1.1.142.3 | 203 | 5/23/2026 |
| 1.1.0 | 185 | 5/22/2026 |
| 1.1.0-preview | 145 | 5/21/2026 |
| 1.0.0 | 173 | 5/21/2026 |
# 1.1.080526.1
Date: 2026-08-05
## Added
- Added automatic outbound `HttpClient` profiling through `AddWorkableHttpClientProfiling()`. Workable uses the built-in `System.Net.Http` activity source, so existing `HttpClient` code does not need a wrapper or delegating handler. Each timing covers the outgoing request and its returned response and can include the HTTP method, sanitized URI, protocol version, response status, outcome, and transport error type.
- Added temporary full-profile capture rules for future workers. Operators can target a work definition, a stable actor/user id, or both; configure a match count and expiration; and manage rules from the work-definition and worker detail screens or the built-in HTTP API at `/workable/profiling/capture-rules`.
- Added `WorkerOptions.ProfilingCaptureMode` with `Bounded` and `Full` capture. A matched rule enables profiling and resolves the accepted worker to `Full`, bypassing the automatic instrumentation node limit while preserving normal authorization, privacy, and retention behavior. Durable SQL Server queues retain the resolved mode across delayed execution.
- Added a shared automatic-instrumentation extension model through `IWorkProfilingInstrumentationFactory`, `IWorkAutomaticProfiler`, and pending-instrumentation lifecycle contracts. SQL, HTTP, and future integrations now use the same admission, finalization, snapshot, and truncation behavior.
- Added required stable instrumentation identity to every profile node. Built-in keys include `application`, `workable.profiling`, `sql.client`, and `http.client`, allowing clients and custom integrations to classify entries without inspecting labels or context payloads.
- Added an HTTP-only profile filter to the admin UI alongside the SQL filter. SQL and HTTP filters use exact instrumentation identity and are enabled only when the selected system advertises the corresponding capability.
- Added profiling performance benchmarks covering automatic admission, HTTP capture and URI sanitization, SQL diagnostics, snapshot creation, finalization, and teardown.
## Changed
- Automatic SQL, HTTP, and custom instrumentation now share a configurable per-iteration limit of `500` nodes by default. Configure it with `ConfigureProfiling(maximumAutomaticInstrumentationNodes: ...)`. Explicit application entries created through `IWorkProfiler` do not consume this budget.
- Bounded profiles that exceed the automatic limit now retain one `Automatic instrumentation truncated` summary with omission counts grouped by instrumentation source. Full-capture workers intentionally bypass this node limit for targeted diagnostics.
- Registered HTTP profiling follows the existing development default: work definitions without explicit default options are profiled automatically outside Production. Production workers must still opt in through definition defaults, queue options, reconfiguration, or a targeted capture rule.
- HTTP capture is privacy-limited even in `Full` mode. Workable never retains request or response headers, bodies, URI query contents, URI fragments, URI user information, or exception messages. URI inspection and retained values are bounded, and malformed or unsafe URI forms are omitted rather than copied as raw text.
- Retained profile telemetry, explicit `Full` capture selection, and capture-rule administration now require system diagnostics permission on authorization-enabled systems. Callers without diagnostics permission still receive otherwise-authorized worker and iteration data, but profile fields are omitted. Creating a rule does not grant permission to queue matching work.
- The admin UI hides full-capture controls without diagnostics access, exposes capture-rule status and deletion to authorized operators, and includes sample-host diagnostics authorization for the profiling lab.
- Profile snapshots retain their instrumentation source throughout worker, iteration, HTTP, and admin UI contracts. This is a contract change for custom profile consumers and instrumenters: `WorkProfileSnapshotNode.Instrumentation` is required rather than optional or inferred.
## Fixed
- The admin UI now renews delegated Entra access tokens based on the server-reported token lifetime before SignalR negotiation and reconnect. A `401` invalidates the cached token, forces one refresh, and retries the shared realtime connection instead of repeatedly negotiating with an expired bearer token.
- In-flight HTTP and SQL operations are finalized as `Incomplete` before a worker profile snapshot is published. Late provider callbacks cannot mutate an already-published snapshot, and finalization waits for concurrent instrumentation registration windows without active spinning.
- HTTP activity sampling stops requesting full activity data after a bounded worker reaches its automatic-node limit and does not set the distributed-tracing recorded flag, avoiding unintended downstream sampling and unnecessary tag materialization.
- Automatic profile admission is lock-free and reserves capacity atomically, preventing concurrent SQL and HTTP bursts from overshooting the configured limit or forcing unrelated outbound requests through a global lock.
- Capture-rule matching now uses immutable selector indexes and atomic reservation/completion, avoiding a global administration lock or full rule scan on the queue hot path while preserving match counts when queue acceptance fails.
- SQL profiling now shares one lifecycle-managed observer across Workable systems, avoids process-wide command payload construction when no eligible profile is active, and uses the same bounded admission and pending-operation finalization path as HTTP profiling.
- Durable SQL Server queue serialization now round-trips explicit `Bounded` and `Full` capture modes, ensuring a targeted durable worker does not lose its capture decision before execution.
- Profile filtering and capture controls now honor system capability and diagnostics-access changes across worker and iteration navigation, preventing stale SQL, HTTP, or full-capture UI state from being offered for an ineligible system.
- Expanded backend, SQL Server integration, admin UI, security, lifecycle, concurrency, and performance regression coverage for automatic profiling, capture-rule authorization, token renewal, instrumentation identity, bounded growth, and durable capture behavior.