kurrent-io/KurrentDB-Client-Dotnet

This system is the KurrentDB .NET Client SDK, a library for connecting to and interacting with a KurrentDB event-streaming database. It provides core capabilities for appending and reading events, managing persistent subscriptions, and controlling projections, while supporting secure TLS connections and distributed tracing via OpenTelemetry. The client is designed for modern .NET environments, offering multi-targeting support and integration patterns such as dependency injection.

7 changes.

The project replaced the legacy EventStore gRPC client with the new KurrentDB .NET Client SDK, targeting modern .NET versions. This migration involved removing all old gRPC protocol definitions, client implementations, and associated test suites. Documentation tooling was also updated to use VuePress and Vite to support the new client library.

11 changes.

The samples directory was rebranded from EventStore to KurrentDB and updated to target .NET 8 and 9, introducing modern language features. Comprehensive new examples were added to demonstrate core client operations, including event appending, reading, subscriptions, and projection management. The updates also cover secure TLS connections, dependency injection integration, and server-side filtering.

10 changes.

This period focused on the initial release of the KurrentDB .NET client library, establishing core infrastructure for cluster connectivity, TLS handling, and OpenTelemetry tracing. A comprehensive test suite was simultaneously developed to validate client operations, security enforcement, persistent subscriptions, and distributed tracing behavior.

A new C\# sample program has been added to demonstrate how to read events using the KurrentDB client. The code illustrates connecting via a connection string, appending events to a stream, and reading from specific streams in both forward and backward directions. It also covers reading from the global all-stream and handling stream messages to manage positions and detect stream states.

samples/reading-events · high confidence

The server-side-filtering sample now demonstrates the KurrentDB client, showing how to subscribe to all events with filters for event type prefixes, regex patterns, stream prefixes, and regex patterns, as well as how to exclude system events and handle checkpoints.

samples/server-side-filtering · high confidence

The samples/persistent-subscriptions directory now includes a Program.cs file demonstrating how to use the KurrentDB client for persistent subscriptions. The sample covers creating, updating, and deleting subscriptions to both specific streams and the global stream, as well as connecting to these subscriptions to process events. It illustrates both automatic acknowledgment (where the client handles acks) and manual acknowledgment modes, including handling unrecoverable errors by parking events. The sample also shows how to retrieve subscription info, list existing subscriptions, and replay parked events.

samples/persistent-subscriptions · high confidence

A new sample application has been added to demonstrate the KurrentDB projection management features. This .NET console app connects to a local KurrentDB instance and exercises the full lifecycle of projection management, including creating, enabling, disabling, aborting, resetting, and listing continuous projections, as well as handling not-found scenarios.

samples/projection-management · high confidence

This change introduces the KurrentDB .NET Client SDK, establishing the foundational project structure and configuration. It sets up the solution with multi-targeting for .NET Framework 4.8, .NET 8.0, .NET 9.0, and .NET 10.0, and enables C\# nullable reference types and implicit usings. The repository is initialized with standard development tooling, including an EditorConfig for code formatting, .gitattributes for line-ending normalization, and a .gitignore, alongside the Apache 2.0 license and initial documentation.

(repo-wide) · high confidence

This change introduces the KurrentDB .NET client, providing the core infrastructure for connecting to and interacting with a KurrentDB cluster. The library includes gRPC channel management with support for both single-node and cluster topologies, TLS certificate handling (including PEM file loading), and comprehensive OpenTelemetry tracing for client operations. It also provides shims for modern C\# features (like Index/Range) to ensure compatibility with older .NET Framework versions.

src/KurrentDB.Client · high confidence

A new quick-start sample has been added for the KurrentDB client, demonstrating core event-streaming operations in .NET 8. The sample includes a Docker Compose configuration to spin up a local EventStore instance and a C\# program that illustrates how to create a client using a connection string, write events to a stream, read events back, and override user credentials for specific operations.

samples/quick-start · high confidence

This location introduces a new sample demonstrating how to connect a .NET client to EventStoreDB using gRPC with TLS. The sample includes a Dockerfile (based on .NET 8.0) that installs the CA certificate into the container's trust store, and a Program.cs that uses the KurrentDB client to append events over a secure connection. It provides a complete local development workflow via docker-compose files: docker-compose.certs.yml uses the es-gencert-cli to generate self-signed CA and node certificates, while helper scripts (create-certs.sh, create-certs.ps1) automate certificate generation and installation on the host machine for local testing.

samples/secure-with-tls · high confidence

A new sample application in the diagnostics folder demonstrates how to integrate the KurrentDB client with OpenTelemetry for distributed tracing. The sample configures a .NET host to create an ActivitySource, registers the KurrentDB client instrumentation via AddKurrentDBClientInstrumentation, and sets up trace exporters to console and Jaeger, allowing users to observe trace data generated during stream append operations.

samples/diagnostics · high confidence

The 'samples/appending-events' directory now contains a new Program.cs file that serves as a comprehensive guide for using the KurrentDB .NET client. This sample demonstrates various event appending patterns, including single and multi-stream appends, operations with consistency checks (such as verifying stream state before writing), and handling concurrency scenarios like duplicate event detection and no-stream validation. It replaces the previous 'Writing events' sample to align with the new 'Appending events' naming convention.

samples/appending-events · high confidence

Added a new sample application in the \samples/subscribing-to-streams\ directory that illustrates how to use the KurrentDB client to subscribe to individual streams and the global all-stream. The code demonstrates various subscription modes, including subscribing from a specific position, subscribing to live events, resolving link-tos, handling dropped subscriptions with checkpointing, and overriding user credentials.

samples/subscribing-to-streams · high confidence

A new sample project has been added to the \samples/setting-up-dependency-injection\ location to illustrate how to integrate the KurrentDB client into an ASP.NET Core application using dependency injection. The sample includes a \Startup\ class that registers the \KurrentDBClient\ via a connection string (\esdb://...\) and an \EventStoreController\ that consumes the client through constructor injection to read events. This provides a concrete reference for wiring the client library within a standard web host lifecycle.

samples/setting-up-dependency-injection · high confidence

The shared test utilities for the gRPC module have been removed, including the \EventStoreGrpcFixture\ base class, \TestVNodeBuilder\, \TestCredentials\, and related helper classes. This eliminates the previous mechanism for spinning up in-memory gRPC test servers and managing test-specific node configurations and credentials within this library.

src/EventStore.Grpc.Tests.Common · high confidence

The legacy \EventStoreGrpcClient\ and its associated types (including \AnyStreamRevision\, \StreamRevision\, \EventData\, \EventRecord\, and filter structs) have been removed from the \src/EventStore.Grpc\ directory. This deletion eliminates the previous client API surface, indicating a shift to a new client implementation or protocol version.

src/EventStore.Grpc · high confidence

The legacy gRPC protocol buffer definitions for persistent subscriptions (\persistent.proto\) and stream operations (\streams.proto\) have been removed from the \src/Protos/Grpc\ directory. This change eliminates the old service contracts and message types (such as \PersistentSubscriptions\ and \Streams\ services) that were previously defined in these files, indicating a migration away from these specific proto-based interfaces.

src/Protos · high confidence

The samples directory has been rebranded from EventStore to KurrentDB, updating the solution and project references to use the KurrentDB.Client library. The sample projects now target .NET 8.0 and .NET 9.0, enabling nullable reference types and implicit usings for a modern development experience. New samples have been added to demonstrate secure connections using user certificates (TLS with client authentication) and persistent subscriptions, alongside existing examples for appending, reading, and subscribing to events.

samples · high confidence

The samples in the connecting-to-a-single-node and connecting-to-a-cluster directories have been updated to use the KurrentDB.Client library instead of the previous EventStoreDB client. The code now demonstrates connecting via connection strings (using both 'kurrentdb://' and 'esdb://' schemes) and includes examples for configuring interceptors and custom HTTP message handlers.

samples/connecting-to-a-single-node · high confidence

Added idiomatic assertions and test helper assemblies for client-side type validation; Added integration tests for KurrentDB Client operations and security; Added tests for KurrentDB Client Streams operations; Added tests for KurrentDB Client persistent subscriptions; Added tests for projection management operations; Added tracing instrumentation tests for client operations; Initial test suite for KurrentDB Client; New test infrastructure and utilities for KurrentDB Client; Removal of gRPC Persistent Subscriptions test suite; Removed obsolete gRPC test suite.

This change introduces the new \KurrentDB.Client\ project, a GRPC-based client library for the Kurrent Platform, replacing the legacy \EventStore.Grpc\ project. The new client targets .NET 8.0 and .NET Framework 4.8, utilizing modern dependencies such as \Grpc.Net.Client\ 2.67.0, \Google.Protobuf\ 3.32.1, and \OpenTelemetry.Api\ 1.15.3. To support this, numerous sample projects (e.g., \quick-start\, \persistent-subscriptions\) have been added or updated to reference the new client, and legacy EventStore GRPC test projects have been removed. Additionally, the documentation build system has been migrated to a Node.js environment using VuePress 2.0.0-rc.19, Vite, and Vue 3, with a new \docs/package.json\ and \pnpm-lock.yaml\ defining the tooling stack.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 56 → 56 (+0.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 91 → 80 (-11.1)
• Architecture 97 → 97 (+0.1)
• Maturity 47 → 47 (-0.3)
• Readiness 50 → 56 (+5.7)
• Security 70 → 69 (-1.7)
• Performance 70 → 70 (+0.2)

• Ambiguous naming for stream-specific vs. all-streams creation. 'CreateAsync' is ambiguous about whether it targets a specific stream or all streams, whereas 'CreateToStreamAsync' is explicit. This forces users to guess the scope of 'CreateAsync'.
• BarePragmaDisable (src/KurrentDB.Client/Core/Certificates/X509Certificates.cs)
• BarePragmaDisable (src/KurrentDB.Client/Core/ChannelInfo.cs)
• BarePragmaDisable (src/KurrentDB.Client/Core/HashCode.cs)
• BarePragmaDisable (src/KurrentDB.Client/Core/ServerCapabilities.cs)
• BarePragmaDisable (src/KurrentDB.Client/Core/StreamIdentifier.cs)
• BarePragmaDisable (src/KurrentDB.Client/Streams/Streams/Model/SchemaDataFormat.cs)
• Bounded contexts not declared
• Change coupling clique: KurrentDBOperationsClientServiceCollectionExtensions.cs, KurrentDBProjectionManagementClientCollectionExtensions.cs, KurrentDBUserManagementClientCollectionExtensions.cs (src/KurrentDB.Client/Operations/KurrentDBOperationsClientServiceCollectionExtensions.cs)
• Duplicated block (13 lines × 2) (src/KurrentDB.Client/ProjectionManagement/KurrentDBProjectionManagementClient.State.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• IL efficiency: 1 authored method(s) exceed the IL budget (src/KurrentDB.Client/Core/KurrentDBClientSettings.ConnectionString.cs)
• …and 15 more

• Change coupling: ChannelFactory.cs ↔ KurrentDBClientConnectivitySettings.cs (src/KurrentDB.Client/Core/ChannelFactory.cs)
• CommentedOutCode (test/KurrentDB.Client.Tests/PersistentSubscriptions/SubscribeToAll/Obsolete/SubscribeToAllObsoleteTests.cs)
• CommentedOutCode (test/KurrentDB.Client.Tests/PersistentSubscriptions/SubscribeToAll/Obsolete/SubscribeToAllObsoleteTests.cs)
• CommentedOutCode (test/KurrentDB.Client.Tests/PersistentSubscriptions/SubscribeToAll/SubscribeToAllTests.cs)
• CommentedOutCode (test/KurrentDB.Client.Tests/Streams/AppendTests.cs)
• Dependency advisory scan runs only on code events
• Documentation: no installation or build instructions (README.md)
• Duplicated block (11 lines × 2) (src/KurrentDB.Client/PersistentSubscriptions/KurrentDBPersistentSubscriptionsClient.Read.cs)
• Duplicated block (12 lines × 2) (src/KurrentDB.Client/ProjectionManagement/KurrentDBProjectionManagementClient.State.cs)
• Duplicated block (12 lines × 3) (src/KurrentDB.Client/Streams/Streams/AppendReq.cs)
• Duplicated block (14–15 lines × 3) (src/KurrentDB.Client/ProjectionManagement/KurrentDBProjectionManagementClient.State.cs)
• Duplicated block (15–16 lines × 2) (src/KurrentDB.Client/ProjectionManagement/KurrentDBProjectionManagementClient.State.cs)
• Duplicated block (29 lines × 2) (src/KurrentDB.Client/Core/ChannelFactory.cs)
• Duplicated block (9 lines × 2) (src/KurrentDB.Client/Operations/KurrentDBOperationsClient.Scavenge.cs)
• FileScopedPragmaDisable (src/KurrentDB.Client/Core/Certificates/X509Certificates.cs)
• FileScopedPragmaDisable (src/KurrentDB.Client/Core/ChannelInfo.cs)
• FileScopedPragmaDisable (src/KurrentDB.Client/Core/HashCode.cs)
• FileScopedPragmaDisable (src/KurrentDB.Client/Core/ServerCapabilities.cs)
• FileScopedPragmaDisable (src/KurrentDB.Client/Core/StreamIdentifier.cs)
• FileScopedPragmaDisable (src/KurrentDB.Client/Streams/Streams/Model/SchemaDataFormat.cs)
• …and 87 more

• 1 commits — 0 feature/other, 1 fixes

• src/KurrentDB.Client — 1 commit

• fix: Fix UnobservedTaskException noise from internal client tasks (#422)

• Unchanged — 1 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

kurrent-io/KurrentDB-Client-Dotnet was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.