EffinitiveFramework.Core
2.8.0
dotnet add package EffinitiveFramework.Core --version 2.8.0
NuGet\Install-Package EffinitiveFramework.Core -Version 2.8.0
<PackageReference Include="EffinitiveFramework.Core" Version="2.8.0" />
<PackageVersion Include="EffinitiveFramework.Core" Version="2.8.0" />
<PackageReference Include="EffinitiveFramework.Core" />
paket add EffinitiveFramework.Core --version 2.8.0
#r "nuget: EffinitiveFramework.Core, 2.8.0"
#:package EffinitiveFramework.Core@2.8.0
#addin nuget:?package=EffinitiveFramework.Core&version=2.8.0
#tool nuget:?package=EffinitiveFramework.Core&version=2.8.0
EffinitiveFramework
A C# web framework built from scratch, implementing HTTP/1.1, HTTP/2 and HTTP/3 directly rather than layering on an existing server.
๐ Performance Goals
- Zero-allocation routing using
Span<T>andMemory<T> - Minimal overhead for request/response handling
- Optimized hot paths with aggressive inlining
- Efficient memory management using
ArrayPool<T> - Compile-time optimization for endpoint registration
๐ฆ Features
- Simple, intuitive API similar to FastEndpoints
- Type-safe endpoints with generic request/response handling
- Multiple endpoint types - Optimized for sync, async I/O, and streaming operations
EndpointBase<TRequest, TResponse>- Synchronous/cached operations (ValueTask)AsyncEndpointBase<TRequest, TResponse>- Async I/O operations (Task)NoRequestEndpointBase<TResponse>- Endpoints without request body (GET, health checks)NoRequestAsyncEndpointBase<TResponse>- Async endpoints without request body
- Server-Sent Events (SSE) - Real-time streaming with three endpoint patterns:
NoRequestSseEndpointBase- Simple streaming without request bodySseEndpointBase<TRequest>- Streaming with request parsingSseEndpointBase<TRequest, TEventData>- Strongly-typed event streaming
- WebSocket support (RFC 6455) - Full bidirectional messaging with
MapWebSocket()orWebSocketEndpointBase - Static file serving - Zero per-request I/O via in-memory
FrozenDictionarycache, 25+ MIME types - Response compression - Gzip middleware with single-pass serialize+compress pipeline
- Response caching - Opt-in
[ResponseCache]middleware serving repeat GETs from memory, withCache-Control/Vary/Ageheaders, ETag revalidation, and write-through invalidation (docs) - OpenAPI / Swagger -
UseOpenApi()serves an OpenAPI 3.0.3 document and Swagger UI, generated once at startup from the route table with zero per-request cost (docs) - Rate limiting -
UseRateLimiting()applies a token-bucket allowance per client IP with[RateLimit]/[DisableRateLimit]overrides, bounded memory, and reverse-proxy support (docs) - Custom HTTP server with direct socket handling for maximum performance
- High-performance transport layer -
IOQueue/SocketSenderPoolarchitecture mirroring Kestrel's design - HTTP/2 support via ALPN negotiation with binary framing and HPACK compression
- HTTP/3 / QUIC (experimental, .NET 10+) - RFC 9114 with QPACK compression, automatic alongside HTTPS
- HTTP/1.1 protocol - Battle-tested and optimized for speed
- TLS/HTTPS support with configurable certificates and modern protocol support
- Minimal allocations in hot code paths
- Benchmark suite included for performance validation
๐ Protocol Support
- โ HTTP/1.1 - Fully supported with custom parser (sub-50ฮผs response times)
- โ HTTPS/TLS - Full TLS 1.2/1.3 support with certificate configuration
- โ HTTP/2 - Complete implementation with binary framing, HPACK, stream multiplexing, and ALPN
- โ
HTTP/3/QUIC - Experimental, .NET 10+ only (RFC 9114 with QPACK, automatic when
QuicListener.IsSupported) - โ WebSocket - RFC 6455, full framing/fragmentation/ping-pong/close handshake
HTTP/2 Implementation
EffinitiveFramework includes a complete from-scratch HTTP/2 implementation:
- Binary framing layer - All 9 frame types (DATA, HEADERS, SETTINGS, PING, GOAWAY, etc.)
- HPACK compression - Static table (61 entries) + dynamic table + Huffman encoding
- Stream multiplexing - Multiple concurrent requests over single TCP connection
- Flow control - Per-stream and connection-level window management
- ALPN negotiation - Automatic protocol selection during TLS handshake ("h2" or "http/1.1")
- Settings management - Dynamic configuration via SETTINGS frames
HTTP/2 is automatically enabled for HTTPS connections when clients negotiate it via ALPN. See HTTP/2 Implementation Guide for details.
HTTP/3 Implementation (.NET 10+)
When targeting .NET 10 and TLS is configured, EffinitiveFramework starts a QUIC listener on the same HTTPS port:
- RFC 9114 - HTTP/3 framing (DATA, HEADERS, SETTINGS, GOAWAY)
- QPACK compression (RFC 9204) - Header encoding/decoding with static table and encoder/decoder streams
- Control streams - Bidirectional and unidirectional stream management
- Automatic - No extra configuration required; QUIC starts when
QuicListener.IsSupportedis true
WebSocket Implementation (RFC 6455)
- Full frame support - Text, Binary, Ping, Pong, Close, Continuation frames
- Fragmentation - Multi-frame messages transparently reassembled
- Keep-alive - Automatic Pong replies to client Ping frames
- Close handshake - Graceful connection termination with status codes
- Fluent registration -
MapWebSocket(path, handler)or subclassWebSocketEndpointBase
๐๏ธ Architecture
Core Components
- EffinitiveApp - Main application bootstrap
- Router - High-performance routing engine using zero-allocation techniques
- EndpointBase<TRequest, TResponse> - Base class for synchronous/cached operations (ValueTask)
- AsyncEndpointBase<TRequest, TResponse> - Base class for I/O operations (Task)
- IEndpoint - Core endpoint interfaces
Performance Optimizations
- Span-based routing - Routes are matched using
ReadOnlySpan<char>to avoid string allocations - Smart async handling -
ValueTask<T>for sync operations,Task<T>for I/O - Struct types - Key data structures use structs where appropriate
- ArrayPool - Reuses arrays for temporary operations
- Unsafe blocks enabled - Allows for low-level optimizations where needed
๐ Quick Start
1. Create an Endpoint
For simple GET endpoints without request body (use NoRequestEndpointBase):
using EffinitiveFramework.Core;
public class HealthCheckEndpoint : NoRequestEndpointBase<HealthResponse>
{
protected override string Method => "GET";
protected override string Route => "/api/health";
public override ValueTask<HealthResponse> HandleAsync(
CancellationToken cancellationToken = default)
{
return ValueTask.FromResult(new HealthResponse
{
Status = "Healthy",
Timestamp = DateTime.UtcNow,
Version = "2.0.0"
});
}
}
For in-memory/cached operations with request body (use EndpointBase):
using EffinitiveFramework.Core;
public class GetUsersEndpoint : EndpointBase<EmptyRequest, UsersResponse>
{
protected override string Method => "GET";
protected override string Route => "/api/users";
public override ValueTask<UsersResponse> HandleAsync(
EmptyRequest request,
CancellationToken cancellationToken = default)
{
var users = new List<User>
{
new User { Id = 1, Name = "Alice", Email = "alice@example.com" },
new User { Id = 2, Name = "Bob", Email = "bob@example.com" }
};
return ValueTask.FromResult(new UsersResponse { Users = users });
}
}
For database/I/O operations (use AsyncEndpointBase):
using EffinitiveFramework.Core;
public class CreateUserEndpoint : AsyncEndpointBase<CreateUserRequest, UserResponse>
{
protected override string Method => "POST";
protected override string Route => "/api/users";
public override async Task<UserResponse> HandleAsync(
CreateUserRequest request,
CancellationToken cancellationToken = default)
{
// True async I/O - database insert
var user = await _dbContext.Users.AddAsync(new User
{
Name = request.Name,
Email = request.Email
}, cancellationToken);
await _dbContext.SaveChangesAsync(cancellationToken);
return new UserResponse { User = user, Success = true };
}
}
For real-time Server-Sent Events streaming (use SSE endpoints):
using EffinitiveFramework.Core.Http.ServerSentEvents;
public class ServerTimeEndpoint : NoRequestSseEndpointBase
{
protected override string Method => "GET";
protected override string Route => "/api/stream/time";
protected override async Task HandleStreamAsync(
SseStream stream,
CancellationToken cancellationToken)
{
// Start automatic keep-alive pings
_ = stream.StartKeepAliveAsync(TimeSpan.FromSeconds(15), cancellationToken);
await stream.WriteAsync("connected", "Server time stream started");
while (!cancellationToken.IsCancellationRequested)
{
var timeData = new { Time = DateTime.UtcNow, Zone = "UTC" };
await stream.WriteJsonAsync(timeData, cancellationToken);
await Task.Delay(1000, cancellationToken);
}
}
}
Define your DTOs:
public record UsersResponse
{
public List<User> Users { get; init; } = new();
}
public record User
{
public int Id { get; init; }
public string Name { get; init; } = string.Empty;
public string Email { get; init; } = string.Empty;
}
๐ก See Endpoint Selection Guide for detailed guidance on choosing between
EndpointBaseandAsyncEndpointBase
For WebSocket connections (use MapWebSocket or subclass WebSocketEndpointBase):
using EffinitiveFramework.Core.WebSocket;
// Inline handler
app.MapWebSocket("/ws/echo", async (conn, ct) =>
{
while (conn.IsOpen)
{
var msg = await conn.ReceiveAsync(ct);
if (msg == null) break;
await conn.SendAsync(msg.Value.Data, msg.Value.Type, ct);
}
});
// Class-based handler
public class EchoEndpoint : WebSocketEndpointBase
{
public override string Route => "/ws/echo";
public override async Task OnConnectedAsync(
WebSocketConnection connection, CancellationToken cancellationToken)
{
while (connection.IsOpen)
{
var msg = await connection.ReceiveAsync(cancellationToken);
if (msg == null) break;
await connection.SendAsync(msg.Value.Data, msg.Value.Type, cancellationToken);
}
}
}
2. Bootstrap the Application
using EffinitiveFramework.Core;
var cts = new CancellationTokenSource();
Console.CancelKeyPress += (s, e) => { e.Cancel = true; cts.Cancel(); };
// Create the app, configure ports, TLS, services and endpoints, then build
var app = EffinitiveApp
.Create()
.UsePort(5000) // HTTP on port 5000
.UseHttpsPort(5001) // HTTPS on port 5001 (HTTP/2 + HTTP/3 via ALPN/QUIC)
.ConfigureTls(tls =>
{
tls.CertificatePath = "localhost.pfx";
tls.CertificatePassword = "dev-password";
})
.UseResponseCompression() // Enable gzip for supported clients
.UseStaticFiles("wwwroot") // Serve files from ./wwwroot at /static
.MapWebSocket("/ws", async (conn, ct) => // WebSocket endpoint
{
while (conn.IsOpen)
{
var msg = await conn.ReceiveAsync(ct);
if (msg != null) await conn.SendAsync(msg.Value.Data, msg.Value.Type, ct);
}
})
.MapEndpoints() // Automatically discovers and registers all endpoints
.Build();
// Run the server until cancelled
await app.RunAsync(cts.Token);
Dependency Injection (Configure services)
EffinitiveFramework exposes a light-weight DI integration via ConfigureServices on the builder. Use it to register DbContexts, services and middleware dependencies.
var app = EffinitiveApp.Create()
.ConfigureServices(services =>
{
// Register a scoped EF Core DbContext
services.AddScoped<AppDbContext>(sp =>
{
var options = new DbContextOptionsBuilder<AppDbContext>()
.UseSqlite("Data Source=products.db")
.Options;
return new AppDbContext(options);
});
// Register application services
services.AddScoped<IProductService, ProductService>();
services.AddScoped<IOrderService, OrderService>();
})
.MapEndpoints(typeof(Program).Assembly)
.Build();
// Resolve a scope for initialization or background work
using var scope = ((EffinitiveFramework.Core.DependencyInjection.ServiceProvider)app.Services!).CreateScope();
var ctx = scope.ServiceProvider.GetService<AppDbContext>();
3. Run the Application
dotnet run --project samples/EffinitiveFramework.Sample
The API will be available at http://localhost:5000 (or as configured).
๐งช Running Benchmarks
dotnet run --project benchmarks/EffinitiveFramework.Benchmarks -c Release
The benchmark suite compares:
- Route matching performance
- Endpoint invocation overhead
- Memory allocations
- Request/response throughput
๐ฏ Benchmark Results
Run the suite yourself on your own hardware and workload; that is the only measurement that tells you anything about your case.
BENCHMARK_RESULTS.md records an earlier comparison, kept for history. Those figures were taken on .NET 8 and do not describe the current build, which targets .NET 10.
๐ Project Structure
EffinitiveFramework/
โโโ src/
โ โโโ EffinitiveFramework.Core/ # Core framework library
โ โโโ EffinitiveApp.cs # Main application class + fluent builder
โ โโโ Router.cs # High-performance router (FrozenDictionary)
โ โโโ EndpointBase.cs # Base endpoint classes
โ โโโ IEndpoint.cs # Endpoint interfaces
โ โโโ Http/ # HTTP/1.1 parsing and response writing
โ โโโ Http2/ # HTTP/2 framing, HPACK, stream multiplexing
โ โโโ Http3/ # HTTP/3 / QUIC + QPACK (.NET 10+ only)
โ โโโ WebSocket/ # RFC 6455 WebSocket framing and endpoints
โ โโโ StaticFiles/ # In-memory static file handler
โ โโโ Transport/ # IOQueue, SocketSenderPool, DuplexPipe
โ โโโ Middleware/ # Pipeline + ResponseCompressionMiddleware
โ โโโ Authentication/ # JWT, API Key, custom auth handlers
โ โโโ Authorization/ # [Authorize], [AllowAnonymous] attributes
โ โโโ DependencyInjection/ # ServiceCollection + ServiceProvider
โ โโโ Configuration/ # ServerOptions, TlsOptions
โโโ samples/
โ โโโ EffinitiveFramework.Sample/ # Sample API project
โ โโโ Program.cs # Application entry point
โ โโโ Endpoints/ # Example endpoints
โโโ benchmarks/
โ โโโ EffinitiveFramework.Benchmarks/ # Performance benchmarks (BenchmarkDotNet)
โโโ tests/
โโโ EffinitiveFramework.Tests/ # Unit tests
๐ง Development
Prerequisites
- .NET 8 SDK or later (.NET 10 SDK for HTTP/3 support)
- Visual Studio 2022 / VS Code / Rider
Build
dotnet build
Run Tests
dotnet test
Run Sample
dotnet run --project samples/EffinitiveFramework.Sample
๐จ Design Principles
- Performance First - Every feature is evaluated for its performance impact
- Zero Allocations - Hot paths should allocate as little as possible
- Simple API - Easy to use, hard to misuse
- Type Safety - Leverage C# type system for compile-time guarantees
- Minimal Dependencies - Only depend on ASP.NET Core fundamentals
๐ฌ Performance Techniques Used
- Span<T> and Memory<T> - For zero-copy string operations
- ArrayPool<T> - For temporary buffer allocations
- ValueTask<T> - For reduced async allocations
- Aggressive Inlining -
[MethodImpl(MethodImplOptions.AggressiveInlining)] - Struct Types - Value types for small, frequently-used data
- Unsafe Code - Low-level optimizations where beneficial
๐ What's New in v2.8.0
| Change | Details |
|---|---|
| One hand-off per request, not two | Behaviour change. The receive completed on an I/O queue and the pipe then handed its reader continuation to the thread pool. The receive now completes on the pool and the reader runs on that same thread. At 4096 connections: 463,221 โ 732,706 req/s, 37.95 โ 24.43 us of processor time per request, p99 41.70 โ 17.40ms. The handler runs on a pool thread either way, so a handler that blocks costs the same resource as before. ServerOptions.InlineRequestProcessing = false restores the previous path. |
| WebSocket connections no longer share a cancellation source | A handler was given the server-wide shutdown token and passes it to a pipe read on every message. A suspended read registers against the source behind its token, so every connection on every core registered on one list and its lock sat on the path each message follows. Per-message processor time 26.3 โ 16.3 us, p99 6.56 โ 3.31ms, and the cost no longer rises with core count. |
| Less work per request | A deferred body is drained into a pooled buffer rather than a MemoryStream and a ToArray, and a query holds offsets into the path rather than a dictionary of strings. 3,450 โ 1,352 bytes allocated per request. |
| A response is not serialized to decide against compressing it | The compression middleware measured the body before asking whether the client had offered any coding. The cheap questions are asked first now. No outcome changes. |
Figures are medians over interleaved runs on a 20 core host, not on public benchmark hardware. See CHANGELOG.md.
๐ What's New in v2.7.0
| Change | Details |
|---|---|
| Rate limiting counted every client as one | HttpRequest.RemoteIpAddress was null on every HTTP/1.1 request, so the limiter's partition key was "unknown" for all callers and one noisy client could exhaust everyone's allowance. X-Forwarded-For never applied either. Present since 2.5.0. |
| 304 and HEAD no longer send content | Both paths cleared only one of the four ways a response can hold content, so an endpoint returning an object had it sent anyway. Since neither response carries a length, the peer read that content as the start of the next one and the connection desynchronised. |
| HTTP/3 field names | The QPACK decoder began reading one byte late, corrupting any header name outside the static table and every field after it. The codec now has tests. |
| Requests are reused per connection | Behaviour change. A connection parses all of its requests into one HttpRequest, as it already did for responses. A reference kept past the end of a handler will be seen to change. Copy what you need rather than passing the request into background work. |
| HTTP/2 advertises less per peer | SETTINGS_MAX_CONCURRENT_STREAMS 256 โ 100 and SETTINGS_INITIAL_WINDOW_SIZE 1 MB โ 96 KB, matching Kestrel. One peer's exposure drops from 256 MB per connection to under 32 MB. |
| Less work per request | HTTP/1.1 allocates about a third less, 1,452 โ 1,030 bytes end to end. HTTP/3 throughput is about 1.6x higher, 158,621 โ 253,800 req/s on sixteen pinned cores. |
See CHANGELOG.md.
๐ What's New in v2.6.0
| Feature | Details |
|---|---|
| Multiple listeners | AddListener() adds a socket beyond UsePort() and UseHttpsPort(), each with its own certificate and its own ALPN list. One server can offer HTTP/2 and HTTP/1.1 on one port while offering HTTP/1.1 alone on another. |
| ALPN belongs to the listener | Per RFC 7301 ยง3.2 the server selects from what the client advertised, and its own preference governs, so the list is what decides the protocol a port actually serves. |
| Cleartext HTTP/2 | UseHttp2Cleartext serves h2c with prior knowledge (RFC 9113 ยง3.3). The connection preface is validated as on the TLS path, so a client speaking HTTP/1.1 on such a port is rejected rather than served over the wrong protocol. |
| Certificate rotation | TlsOptions.ReloadOnChange resolves the certificate per handshake, so a renewal on disk takes effect without a restart. Established connections keep the certificate they negotiated with. |
close_notify on close |
TLS connections send the alert before closing the write side (RFC 8446 ยง6.1), so a client can tell a complete response from a truncated one. |
Fixes: a header line whose CRLF was split across two TCP reads is now carried
rather than rejected with 400, and a WebSocket reply is no longer held back by
a partly-arrived following frame. See CHANGELOG.md.
๐ What's New in v2.5.0
| Feature | Details |
|---|---|
| Rate limiting | UseRateLimiting() โ token-bucket allowance per client IP, returning 429 with Retry-After. Works across HTTP/1.1, HTTP/2 and HTTP/3. |
| Applied before routing | Static files, the OpenAPI document, and floods at nonexistent paths are all covered. |
| Per-endpoint overrides | [RateLimit(PermitLimit = 5, WindowSeconds = 60)] tightens one endpoint; [DisableRateLimit] exempts health checks entirely. |
| Reverse-proxy aware | AddTrustedProxy() opts into X-Forwarded-For; without it the header is ignored, since a client-supplied header would otherwise bypass the limit. |
| Bounded memory | MaxTrackedClients caps tracked allowances, so rotating source addresses cannot exhaust memory. |
See docs/RateLimiting.md.
๐ What's New in v2.4.0
| Feature | Details |
|---|---|
| OpenAPI document | UseOpenApi() serves an OpenAPI 3.0.3 spec at /openapi/v1.json, generated once at startup from the route table. |
| Swagger UI | Rendered at /swagger, with a configurable asset base URL for self-hosted or air-gapped use. |
| Zero-config description | Routes, path parameter types, request bodies, response schemas, and content types are all inferred from metadata the builder already resolved. |
| Documentation attributes | [OpenApiOperation], [OpenApiResponse], [OpenApiParameter], and [OpenApiIgnore] for what can't be inferred. |
| Schemas from your types | Naming follows the server's JsonSerializerOptions; DataAnnotations become schema constraints; $ref components with cycle safety. |
See docs/OpenApi.md.
๐ What's New in v2.3.0
| Feature | Details |
|---|---|
| Response caching | UseResponseCaching() + [ResponseCache(Duration = 30)] โ repeat GET/HEAD requests are served from a bounded in-process store without running the endpoint. |
| Cache headers | Cache-Control (public/private, max-age), Vary for declared headers and query keys, and Age on a hit. |
| Invalidation | TTL, plus automatic eviction of a path when a successful POST/PUT/PATCH/DELETE targets it (RFC 9111 ยง4.4). |
| Revalidation | Cached entries carry a strong ETag, so If-None-Match returns 304 โ on HTTP/1.1, HTTP/2 and HTTP/3. |
๐ What's New in v2.0.0
| Feature | Details |
|---|---|
| WebSocket | RFC 6455 โ MapWebSocket() or WebSocketEndpointBase. Fragmentation, ping/pong, close handshake. |
| HTTP/3 / QUIC | RFC 9114 + QPACK (RFC 9204). Auto-starts on .NET 10 alongside HTTPS. |
| Static files | Pre-loads wwwroot into FrozenDictionary at startup โ zero per-request I/O. |
| Gzip compression | UseResponseCompression() โ single-pass serialize+compress via pooled buffers. |
| Transport layer | IOQueue/SocketSenderPool matching Kestrel's architecture for maximum throughput. |
| Dual-target package | Ships net8.0 + net10.0 targets in a single NuGet package. |
See RELEASE_NOTES_v2.0.0.md for the full release notes and CHANGELOG.md for the complete version history.
๐ Comparison with FastEndpoints
| Feature | EffinitiveFramework | FastEndpoints |
|---|---|---|
| Routing Engine | Custom zero-allocation | ASP.NET Core |
| Endpoint Definition | Class-based | Class-based |
| Request Binding | JSON deserialization | Multiple strategies |
| Performance Focus | Maximum | High |
| Dependencies | Minimal | More features |
๐ง Roadmap
-
Route parameter extraction (e.g.,โ IMPLEMENTED/users/{id}) -
Query string bindingโ IMPLEMENTED (API Key auth) -
Header/cookie bindingโ IMPLEMENTED (Auth handlers) -
Request validationโ IMPLEMENTED (Routya.ResultKit integration) -
Middleware pipelineโ IMPLEMENTED (High-performance pipeline) -
Dependency injection integrationโ IMPLEMENTED (Full DI support) -
Server-Sent Events (SSE)โ IMPLEMENTED v1.1.0 (Real-time streaming) -
Response compression (gzip)โ IMPLEMENTED v2.0.0 (Single-pass serialize+compress) -
WebSocket supportโ IMPLEMENTED v2.0.0 (RFC 6455, full framing) -
Static file servingโ IMPLEMENTED v2.0.0 (Zero per-request I/O) -
HTTP/3 / QUIC protocolโ IMPLEMENTED v2.0.0 (Experimental, .NET 10+) -
Response cachingโ IMPLEMENTED v2.3.0 (Opt-in in-memory store + client cache headers) -
OpenAPI/Swagger integrationโ IMPLEMENTED v2.4.0 (OpenAPI 3.0.3 document + Swagger UI, generated at startup) -
Rate limitingโ IMPLEMENTED v2.5.0 (Token bucket per client IP, with per-endpoint overrides)
๐ค Contributing
Contributions are welcome! Please ensure:
- All benchmarks pass with improved or comparable performance
- Code follows existing patterns
- Tests are included for new features
- Performance-critical code includes comments explaining optimizations
๐ License
MIT License - see LICENSE file for details
๐ Acknowledgments
- Inspired by FastEndpoints
- Performance techniques from GenHTTP
- Built on ASP.NET Core
Note: This is a performance-focused framework. Always benchmark your specific use case to ensure it meets your requirements.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | 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 was computed. 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 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
- Microsoft.Extensions.ObjectPool (>= 10.0.0)
- Routya.ResultKit (>= 2.1.0)
- System.IdentityModel.Tokens.Jwt (>= 8.16.0)
-
net8.0
- Microsoft.Extensions.ObjectPool (>= 8.0.0)
- Routya.ResultKit (>= 2.1.0)
- System.IdentityModel.Tokens.Jwt (>= 8.16.0)
- System.IO.Pipelines (>= 8.0.0)
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories (1)
Showing the top 1 popular GitHub repositories that depend on EffinitiveFramework.Core:
| Repository | Stars |
|---|---|
|
MDA2AV/HttpArena
The most complete HTTP open source benchmarking platform. Don't just say you're fast, prove it.
|
| Version | Downloads | Last Updated | |
|---|---|---|---|
| 2.8.0 | 155 | 10/26/2026 | |
| 2.7.1 | 119 | 10/13/2026 | |
| 2.7.0 | 125 | 10/13/2026 | |
| 2.6.0 | 150 | 9/2/2026 | |
| 2.5.0 | 180 | 7/31/2026 | |
| 2.3.0 | 140 | 7/29/2026 | |
| 2.2.0 | 185 | 6/22/2026 | |
| 2.1.3 | 179 | 6/19/2026 | |
| 2.1.2 | 578 | 6/19/2026 | |
| 2.1.1 | 176 | 6/9/2026 | |
| 2.1.0 | 194 | 6/2/2026 | |
| 2.0.0 | 228 | 5/19/2026 | |
| 1.3.1 | 217 | 4/9/2026 | |
| 1.3.0 | 140 | 4/9/2026 | |
| 1.2.0 | 477 | 1/21/2026 | |
| 1.1.0 | 701 | 12/1/2025 | |
| 1.0.0 | 251 | 11/27/2025 |
v2.8.0: a request no longer crosses a thread twice before it is parsed, and a WebSocket connection no longer shares the server's cancellation source.
Fixed. A WebSocket handler was given the server-wide shutdown token and passes it to a pipe read on every message. A suspended read registers a callback against the source behind its token, so every connection on every core registered against one registration list and its lock landed on the path each message follows. The cost grew with core count rather than with the work. Each connection now gets a source linked to the server's, so a stop still releases a handler parked on a read. Per-message processor time 26.3 to 16.3 microseconds, p99 6.56 to 3.31ms, and the cost no longer rises with core count.
Changed. The receive completed on an I/O queue and the pipe then handed its reader continuation to the thread pool; the second crossing bought nothing. The receive now completes on the pool and the reader runs on that same thread. At 4096 connections: 463,221 to 732,706 requests per second, 37.95 to 24.43 microseconds of processor time per request, p99 41.70 to 17.40ms. The handler runs on a pool thread either way, so a handler that blocks costs the same resource as before. Set ServerOptions.InlineRequestProcessing to false to restore the previous path.
Changed. Request bodies and query strings no longer allocate a copy: a deferred body is drained into a pooled buffer rather than a MemoryStream and a ToArray, and a query holds offsets into the path rather than a dictionary of strings. 3,450 to 1,352 bytes allocated per request. A plus in a query is still left as itself, per RFC 3986 section 3.4.
Measured on a 20 core host rather than the public board's hardware. Arena validation passes 112 checks with none failing, and the WebSocket suite reports the same 301 cases as 2.7.1 with no failures.