Skip to content
Back to search

https://github.com/SnowBankSDK/foundationdb-dotnet-client

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/SnowBankSDK/foundationdb-dotnet-client with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/SnowBankSDK/foundationdb-dotnet-client'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/snowbanksdk--foundationdb-dotnet-client/badge.svg)](/listings/snowbanksdk--foundationdb-dotnet-client)

HTML

<a href="/listings/snowbanksdk--foundationdb-dotnet-client"><img src="/api/listings/snowbanksdk--foundationdb-dotnet-client/badge.svg" alt="findsafeskills safety rating" /></a>

Install

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 12 lines
  1. {
  2. "name": "snowbank",
  3. "owner": { "name": "SnowBank SAS", "url": "https://github.com/SnowBankSDK" },
  4. "plugins": [
  5. {
  6. "name": "foundationdb-dotnet-skills",
  7. "source": "./plugins/foundationdb-skills",
  8. "description": "Agent Skills for the FoundationDB .NET client: keys & layers, transactions, advanced/distributed layers, the Slice binary toolkit, the CrystalJson stack and its source generator, running/connecting (Aspire hosting & client, the native client), outbound HTTP with BetterHttpClient (per-client policy, TLS, HttpWebRequest migration), and writing/diagnosing multi-node integration tests (the SnowBank distributed-test framework & its unified journal), plus argument guards and assertions with Contract (Contract.NotNull / Positive / Debug.Requires).",
  9. "version": "0.4.44"
  10. }
  11. ]
  12. }
README.md · README · 329 lines
  1. FoundationDB .NET Client
  2. =======================
  3. C#/.NET binding for the [FoundationDB](https://www.foundationdb.org/) client library.
  4. [![License](https://img.shields.io/github/license/SnowBankSDK/foundationdb-dotnet-client)](LICENSE.md)
  5. [![NuGet version](https://img.shields.io/nuget/v/FoundationDB.Client.svg)](https://www.nuget.org/packages/FoundationDB.Client/)
  6. ![Platform](https://img.shields.io/badge/platform-windows%20%7C%20linux%20%7C%20macos-blue)
  7. [![Build](https://img.shields.io/github/actions/workflow/status/SnowBankSDK/foundationdb-dotnet-client/dotnetcore.yml)](https://github.com/SnowBankSDK/foundationdb-dotnet-client/actions/workflows/dotnetcore.yml)
  8. [![Last Commit](https://img.shields.io/github/last-commit/SnowBankSDK/foundationdb-dotnet-client)](https://github.com/SnowBankSDK/foundationdb-dotnet-client/commits/master/)
  9. > **New to FoundationDB, or just trying it out?** The [documentation](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/introduction.html) walks you through it end to end: [Prerequisites](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/prerequisites.html), [How it connects](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/foundationdb-101.html), [Cluster setup](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/cluster-setup.html), then [Getting Started](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/getting-started.html). It covers installing .NET and a local cluster, plus the one pitfall (matching the `FoundationDB.Client.Native` package to your cluster version) that otherwise shows up as mysterious timeouts.
  10. >
  11. > Already know FoundationDB? The steps below get you running, and [Getting Started](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/getting-started.html) has the first read and write.
  12. # How to use
  13. Install the managed binding and the native client. Pin the native package to your cluster's `major.minor` version (see [Cluster setup](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/cluster-setup.html)); it is the piece that must match your cluster:
  14. ```console
  15. dotnet add package FoundationDB.Client
  16. dotnet add package FoundationDB.Client.Native --version "7.4.*" # match your cluster's version
  17. ```
  18. Register FoundationDB with the dependency-injection container in your `Program.cs`. This adds an `IFdbDatabaseProvider` singleton. Point it at a cluster one of three ways, most-preferred first:
  19. ```csharp
  20. // 1. Recommended: with the .NET Aspire integration, the AppHost supplies the connection.
  21. // Reference the FoundationDB.Aspire package, then:
  22. builder.AddFoundationDb("fdb");
  23. // 2. Manual, from an fdb.cluster file on disk:
  24. builder.Services.AddFoundationDb(740, options =>
  25. options.ConnectionOptions.ClusterFile = "/etc/foundationdb/fdb.cluster");
  26. // 3. Manual, from the cluster's connection string:
  27. builder.Services.AddFoundationDb(740, options =>
  28. options.ConnectionOptions.ConnectionString = "docker:docker@127.0.0.1:4500");
  29. ```
  30. The recommended path is [.NET Aspire](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/aspire/), which provisions a local cluster and injects the connection for you.
  31. Inject that provider (it arrives as the `db` parameter below) and go through the retry loop. Here are two Minimal API endpoints: one lists every greeting, the other adds one.
  32. ```csharp
  33. // GET /greetings : read them all back
  34. app.MapGet("/greetings", (IFdbDatabaseProvider db, CancellationToken ct) =>
  35. db.ReadAsync(async tr =>
  36. {
  37. // resolve the subspace where the Greetings collection's keys are stored
  38. var subspace = await db.Root["Examples"]["Greetings"].Resolve(tr);
  39. // scan every key under that subspace and decode each value back to text
  40. return await tr.GetRange(subspace.ToRange())
  41. .Select(kv => kv.Value.ToStringUtf8())
  42. .ToListAsync();
  43. }, ct));
  44. // POST /greetings?text=... : add a new one
  45. app.MapPost("/greetings", async (IFdbDatabaseProvider db, string text, CancellationToken ct) =>
  46. {
  47. await db.WriteAsync(async tr =>
  48. {
  49. // resolve the Greetings subspace, creating the directory the first time
  50. // (a plain Resolve would only open one that already exists)
  51. var subspace = await db.Root["Examples"]["Greetings"].CreateOrOpenAsync(tr);
  52. // store the greeting under a fresh, unique key
  53. tr.Set(subspace.Key(Guid.NewGuid()), FdbValue.ToTextUtf8(text));
  54. }, ct);
  55. });
  56. ```
  57. Keys are built with `subspace.Key(...)` and stay lazily tuple-encoded until the transaction runs, the retry loop handles FoundationDB's conflict-and-retry model, and the Directory layer (`db.Root[...]`) maps readable paths to short binary prefixes so your keyspace stays tidy.
  58. **Full walkthrough:** the [documentation](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/introduction.html) takes you from zero (installing .NET, running a local cluster) to your first read and write, then into modeling data with the Directory layer and Layers, and running it all with [.NET Aspire](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/aspire/).
  59. **Upgrading?** The [7.4.5 release notes](https://snowbanksdk.github.io/foundationdb-dotnet-client/releases/7.4.5.html) list every change from 7.4.4 and the breaking changes to review before you upgrade the package version.
  60. What you get:
  61. - **Strongly-typed, lazy keys**: `subspace.Key("user", 123)` tuple-encodes itself only when handed to a transaction. No manual byte wrangling.
  62. - **A retry loop**: `ReadAsync` / `WriteAsync` / `ReadWriteAsync` handle FoundationDB's conflict-and-retry model for you.
  63. - **The Directory layer**: map readable paths to short, dense key prefixes.
  64. - **Layers**: a small contract (`IFdbLayer<TState>`) for reusable, composable data access.
  65. - **Allocation-consciousness**: `Slice`, pooled buffers, and `struct` keys/values keep the hot path free of needless `byte[]`.
  66. - **.NET Aspire**: start a local cluster and inject the connection automatically. See [Aspire](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/aspire/).
  67. # Deployment
  68. ## Docker containers
  69. The easiest way to deploy is to use one of the [ASP.NET Core Runtime docker images](https://hub.docker.com/r/microsoft/dotnet-aspnet/) provided by Microsoft, such as `mcr.microsoft.com/dotnet/aspnet:10.0` or newer.
  70. In order to function, the FoundationDB Native client library (`fdb_c.dll` on Windows, `libfdb_c.so`) needs to be present in the container image. The easiest way is to simply copy them from the [FoundationDB Docker image](https://hub.docker.com/r/foundationdb/foundationdb) that contains these files.
  71. Example of a `Dockerfile` that will grab v7.4.x binaries and inject them into your application container:
  72. ```Dockerfile
  73. # Version of the FoundationDB Client Library
  74. ARG FDB_VERSION=7.4.6
  75. # We will need the official fdb docker image to obtain the client binaries
  76. FROM foundationdb/foundationdb:${FDB_VERSION} as fdb
  77. FROM mcr.microsoft.com/dotnet/aspnet:10.0
  78. # copy the binary from the official fdb image into our target image.
  79. COPY --from=fdb /usr/lib/libfdb_c.so /usr/lib
  80. WORKDIR /App
  81. COPY . /App
  82. ENTRYPOINT ["dotnet", "MyWebApp.dll"]
  83. ```
  84. ## Manual deployment
  85. The easiest solution is to install the `foundationdb-clients-X.Y.Z` packages from `https://apple.github.io/foundationdb/downloads.html`. Only the client packages should be installed, unless you also intend to run the cluster locally.
  86. If you are manually copying your application files to the destination, either by unzipping into a folder, or using a single-exe deployment, it is still necessary to also copy the `fdb_c.dll` or `libfdb_c.so` binaries to the destination.
  87. If, for any reason, you cannot copy the client binary to the default platform location (ex: `/usr/lib` on Linux), you can specify the full path to the library by setting the `NativeLibraryPath` option, or setting the `Aspire:FoundationDb:Client:NativeLibraryPath` key in the `appSettings.json` file (see the `FdbClientSettings` class for the other available settings).
  88. If you need to troubleshoot the connection to the FoundationDB cluster, from the point of view of your application, it is also recommended to install `fdbcli` (comes with the `foundationdb-clients` package, needs to be manually deployed if not).
  89. # AI-assisted development (Claude Code / Agent Skills)
  90. This repository ships a set of **Agent Skills** that teach AI coding agents how to use this library *correctly*, the parts that are easy to get wrong when "vibe-coded": key/value encoding, subspaces and the Directory layer, writing custom Layers, the transaction retry loop, advanced/distributed patterns (change feeds, leases, retention, fencing), and the `Slice` binary toolkit. They live under [`.claude/skills/`](.claude/skills/) and follow the open [Agent Skills](https://agentskills.io) `SKILL.md` format, so they also work with other agents that support it.
  91. The skills are **not** included in the NuGet packages. The easiest way to get them into your own projects (whether you consume this library via NuGet or as a submodule) is to install them as a **Claude Code plugin** from this repository, which doubles as a plugin marketplace:
  92. ```text
  93. /plugin marketplace add SnowBankSDK/foundationdb-dotnet-client
  94. /plugin install foundationdb-dotnet-skills@snowbank
  95. ```
  96. Update later with `/plugin update foundationdb-dotnet-skills@snowbank`.
  97. ## Which version of the skills you get
  98. The skills describe the version of the library they were written against, and they are versioned by **git tag**, the same tag that produced the NuGet packages. Every feature added in a given release is marked in the text, for example *(7.4.3+)*.
  99. `/plugin marketplace add` with no ref tracks this repository's **default branch**, so it gives you the skills for the version under development, which is ahead of the latest published package. That is the right default while you are following the library, and the wrong one if you are pinned to an older release: the skills will describe APIs your package does not have.
  100. To get the skills that match the package version you actually reference, pin the marketplace to that tag in your `.claude/settings.json`:
  101. ```json
  102. {
  103. "extraKnownMarketplaces": {
  104. "snowbank": {
  105. "source": {
  106. "source": "github",
  107. "repo": "SnowBankSDK/foundationdb-dotnet-client",
  108. "ref": "7.4.2"
  109. }
  110. }
  111. }
  112. }
  113. ```
  114. Change `ref` to the tag matching your package (`7.4.2`, `7.4.1`, ...) and run `/plugin install foundationdb-dotnet-skills@snowbank`. A marketplace source accepts a branch or a tag; it does not accept a commit SHA. When you upgrade the package, move the `ref` in the same commit, so the skills and the package never disagree.
  115. Alternatives, if you'd rather not use the plugin system (all of them work at a tag: check the repository out at that tag first):
  116. - **Personal (all your projects):** copy the skill folders into `~/.claude/skills/`.
  117. - **Per-project:** copy them into your app's `.claude/skills/` and commit them.
  118. - **Submodule users:** point Claude at the checked-out submodule with `claude --add-dir path/to/foundationdb-dotnet-client` (or `/add-dir`), which loads its `.claude/skills/`. A submodule is already pinned to a commit, so this matches your version by construction.
  119. The same material is available as human-readable documentation in [the guide](https://snowbanksdk.github.io/foundationdb-dotnet-client/fdb/guide/) for developers (and agents that don't support Agent Skills).
  120. # How to build
  121. This section is for contributors who build and test this repository. To use the packages in an application, see [How to use](#how-to-use).
  122. ## Prerequisites
  123. - The .NET SDK version pinned in [`global.json`](global.json). It is a .NET 11 preview, so Linux distribution packages do not ship it. Install it with the [install script](https://learn.microsoft.com/dotnet/core/install/linux-scripted-manual): `./dotnet-install.sh --jsonfile global.json`.
  124. - The .NET 10 and .NET 8 runtimes, to run the `net10.0` and `net8.0` test targets (`./dotnet-install.sh --channel 10.0 --runtime aspnetcore`, then the same with `8.0`).
  125. - A Docker engine that the current user can reach without `sudo`, for the tests that need a real cluster (see [How to test](#how-to-test)).
  126. - On Linux and macOS, `curl` and `python3`, for `FoundationDB.Client.Native/DownloadBinaries.sh`.
  127. Node.js is needed only to render the documentation site (`SnowBank.DocGen`). An IDE is optional, and must support the SDK version in `global.json`.
  128. ## From the command line
  129. - `dotnet build FoundationDB.Client.slnx` builds every project in Debug, for every target framework: `net8.0`, `net10.0`, `net11.0`, `netstandard2.0`, and the `net472` test targets. The `net472` targets also build on Linux and macOS, but only Windows runs them.
  130. The `scripts/` folder contains helpers for common tasks:
  131. - `scripts/build.ps1` / `scripts/build.sh`: run a fully isolated **standalone** restore, clean and build (this repo's complete target set), even when it is checked out as a sub-module (see the *As a sub-module* section below). Add `Release` for a Release build.
  132. - `scripts/pack.ps1` / `scripts/pack.sh`: build and validate the NuGet packages (they do not push to any feed).
  133. ## As a sub-module
  134. Most projects in this repository are targeting multiple frameworks, meaning that each project will be built several times, one for each target.
  135. When consuming this repository as a sub-module inside another repository, all the included projects will still want to build for all these targets, even if your parent solution only targets one framework (or a different subset).
  136. This can also cause issues if your application is targeting an older .NET runtime and SDK (for example `net10.0` using the .NET 10.0.x SDK), which do not support more recent targets from this repo (ex: `net11.0`).
  137. By default, the `Directory.Build.props` will attempt to detect when it is inside a git sub-module, and import any `Directory.Build.props` in the parent directory.
  138. > **Note:** Some CI build environments may check out sub-modules in a non-standard way. If this happens, you can set the environment variable `FDB_BUILD_PROPS_OVERRIDE` to `1` in order to bypass the check.
  139. This parent props file can then override a series of msbuild variables that are injected in the `TargetFrameworks` property of all `.csproj` in this repo:
  140. - `CoreSdkVersions`: overrides the value of all the other variables at once. Use this if you are single-targeting.
  141. If you are multi-targeting and need more fine-grained precision, you can use the following variables:
  142. - `CoreSdkRuntimeVersions`: targets for all the core libraries (FoundationDB.Client.dll, ...) that are redistributed
  143. - `CoreSdkToolsVersions`: targets for all the tools and executables (FdbShell, FdbTop, ...) that are redistributed
  144. - `CoreSdkUtilityVersions`: targets for all the internal tools and executables that are only used for building and testing, and are not expected to be redistributed.
  145. - `CloudSdkRuntimeVersions`: targets for all libraries that reference .NET Aspire (which only supports .NET 8 or later).
  146. If your parent repository is also multi-targeting, you can specify several targets, like for example `net10.0;net11.0`. Note that if you target a more recent framework that this repo does not support, the build may fail.
  147. An example of a parent `Directory.Build.props` that overrides the build to only target `net10.0`:
  148. ```xml
  149. <Project>
  150. <PropertyGroup>
  151. <!-- Force all projects in the FoundationDB sub-module to target net10.0 -->
  152. <CoreSdkVersions>net10.0</CoreSdkVersions>
  153. </PropertyGroup>
  154. </Project>
  155. ```
  156. An example of a parent `Directory.Build.props` that multi-targets `net10.0` and `net11.0`, but only wants to build the tools for `net11.0`:
  157. ```xml
  158. <Project>
  159. <PropertyGroup>
  160. <!-- If you are using FoundationDB.Client, SnowBank.Core, etc... -->
  161. <CoreSdkRuntimeVersions>net10.0;net11.0</CoreSdkRuntimeVersions>
  162. <!-- If you are using the FoundationDB .NET Aspire Integration -->
  163. <CloudSdkRuntimeVersions>net10.0;net11.0</CloudSdkRuntimeVersions>
  164. <!-- If you are using any of the tools (FdbShell, FdbTop) -->
  165. <CoreSdkToolsVersions>net11.0</CoreSdkToolsVersions>
  166. </PropertyGroup>
  167. </Project>
  168. ```
  169. ## Building this repository on its own (standalone)
  170. When you want to build, test, or package **this repository on its own** while it is still checked out inside such a parent (for example to validate the `net8.0` or `netstandard2.0` targets that a target-trimming parent would otherwise hide, or to produce a complete NuGet package), force a **standalone** build with the `CORESDK_STANDALONE_BUILD` property set to `true`. This makes the `Directory.Build.props` ignore the parent overrides entirely and restore this repo's own complete target set.
  171. Pass it as an MSBuild property, not as an environment variable, so that it stays scoped to a single command and does not leak into your shell:
  172. ```
  173. dotnet build FoundationDB.Client.slnx -p:CORESDK_STANDALONE_BUILD=true
  174. ```
  175. Or use the helper scripts, which run a consistent `restore`, `clean` and `build` in standalone mode (add `Release` for a Release configuration):
  176. ```
  177. ./scripts/build.ps1
  178. ./scripts/build.sh
  179. ```
  180. > **Important:** the restore step writes the shared `artifacts/obj/**/project.assets.json` files for the standalone (complete) target set, which is a superset of what the parent restores. Because the restore state is shared, the next build **from the parent** must re-run `dotnet restore` first, otherwise it fails with `NETSDK1005` (the assets file has no target for the parent's framework). Keep `restore`, `build` and `clean` on the same mode; when you switch modes, re-run `dotnet restore`.
  181. # How to test
  182. The test projects use NUnit 4 with the Microsoft.Testing.Platform runner. The test runner must run as a 64-bit process (32-bit is not supported).
  183. Run one test project and one target framework at a time; `dotnet test` on the whole solution is not supported. Exclude the benchmark categories from normal runs:
  184. ```bash
  185. dotnet test FoundationDB.Tests/FoundationDB.Tests.csproj -f net11.0 --filter "TestCategory!=LongRunning&TestCategory!=Benchmark"
  186. ```
  187. What each test project needs:
  188. - `SnowBank.*.Tests` and `FoundationDB.FakeDb.Tests` need nothing more than the SDK.
  189. - `FoundationDB.Tests`, and the real-cluster fixtures of `FoundationDB.Layers.Tests`, need Docker and the native client library (`fdb_c.dll`, `libfdb_c.so` or `libfdb_c.dylib`).
  190. Download the native client library before the first build: the build copies it into each test output folder. On Windows, run `FoundationDB.Client.Native/DownloadBinaries.ps1`. On Linux and macOS, run `FoundationDB.Client.Native/DownloadBinaries.sh --rid <rid>` (for example `linux-x64`). After a late download, build again.
  191. The Docker-backed tests start a `foundationdb/foundationdb` container, one per FoundationDB version and .NET runtime. The first run pulls the image (about 2 GB), and the test fixture allows 20 seconds for the container to start, pull included. On a slow network, run `docker pull` for the image first. Set `FDB_TEST_DOCKER_TAG` to test another image tag, and `FDB_TEST_API_VERSION` to select another API version (for FoundationDB 8.0: `FDB_TEST_DOCKER_TAG=8.0.0` and `FDB_TEST_API_VERSION=800`, with an 8.0 native client). Without a reachable Docker daemon, these tests fail within seconds with "Could not reach a Docker daemon".
  192. On Linux, a user added to the `docker` group needs a new login before `docker ps` works without `sudo`. Reboot if a logout is not enough: background processes (for example the MSBuild worker nodes that `dotnet build` keeps alive) can keep the old session running.
  193. You can also run the tests from an IDE (Visual Studio, Visual Studio Code, Rider, or ReSharper).
  194. > WARNING: All the tests try to run in a dedicated subspace, but there is a possibility of data corruption if they are running against a test or staging cluster! You should run the tests against a local cluster where all the data is considered expendable!
  195. # Implementation Notes
  196. Please refer to https://apple.github.io/foundationdb/ to get an overview of the FoundationDB API, if you haven't already.
  197. This .NET binding has been modeled to be as close as possible to the other bindings (Python especially), while still having a '.NET' style API.
  198. There were a few design goals that you may agree with or not:
  199. * Reducing the need to allocate `byte[]` as much as possible. To achieve that, I'm using a `Slice` struct that is the logical equivalent of `ReadOnlyMemory<byte>`, but more versatile.
  200. * Mapping FoundationDB's Future into `Task<T>` to be able to use `async`/`await`.
  201. * Reducing the risks of memory leaks in long running server processes by wrapping all FDB_xxx handles with .NET `SafeHandle`. This adds a little overhead when P/Invoking into native code, but will guarantee that all handles get released at some time (during the next GC).
  202. * The Tuple layer has also been optimized to reduce the number of allocations required, and cache the packed bytes of often used tuples (in subspaces, for example).
  203. However, there are some key differences between Python and .NET that may cause problems:
  204. * Python's dynamic types and auto casting of Tuple values are difficult to model in .NET (without relying on the DLR). The Tuple implementation tries to be as dynamic as possible, but if you want to be safe, please try to only use strings, longs, bools and byte[] to be 100% compatible with other bindings. You should refrain from using the untyped `tuple[index]` indexer (that returns an object), and instead use the generic `tuple.Get<T>(index)` that will try to adapt the underlying type into a T.
  205. * The Tuple layer uses ASCII and Unicode strings, while .NET only has Unicode strings. That means that all strings in .NET will be packed with prefix type 0x02 and byte arrays with prefix type 0x01. An ASCII string packed in Python will be seen as a byte[] unless you use `ITuple.Get<string>()` that will automatically convert it to Unicode.
  206. * There is no dedicated 'UUID' type prefix, so that means that `System.Guid` would be serialized as byte arrays, and all instances of byte 0 would need to be escaped. Since `System.Guid` is frequently used as primary keys, I added a new custom type prefix (0x30) for 128-bit UUIDs and (0x31) for 64-bit UUIDs. This simplifies packing/unpacking and speeds up writing/reading/comparing Guid keys.
  207. The following files will be required by your application
  208. * `FoundationDB.Client.dll` : Contains the core types (FdbDatabase, FdbTransaction, ...) and infrastructure to connect to a FoundationDB cluster and execute basic queries, as well as the Tuple and Subspace layers.
  209. * `FoundationDB.Layers.Common.dll` : Contains common Layers that emulate Tables, Indexes, Document Collections, Blobs, ...
  210. * `fdb_c.dll`/`libfdb_c.so` : The native C client that you will need to obtain from the official FoundationDB Windows setup or Linux client packages.
  211. # Known Limitations
  212. * Since the native FoundationDB client is 64-bit only, this .NET library is also for 64-bit only applications! Even though it targets AnyCPU, it would fail at runtime. _Don't forget to disable the `Prefer 32-bit` option in your project Build properties, which is enabled by default!_
  213. * You cannot unload the fdb C native client from the process once the network thread has started. You can stop the network thread once, but it does not support being restarted. This can cause problems when running under ASP.NET.
  214. * FoundationDB does not support long-running batch or range queries if they take too much time. Such queries will fail with a 'past_version' error. The current maximum duration for read transactions is 5 seconds.
  215. * FoundationDB has a maximum allowed size of 100,000 bytes for values, and 10,000 bytes for keys. Larger values must be split into multiple keys.
  216. * FoundationDB has a maximum allowed size of 10,000,000 bytes for writes per transaction (sum of all keys and values that are mutated). You need multiple transactions if you need to store more data. There is a Bulk API (`Fdb.Bulk.*`) to help with the most common cases (import, export, backup/restore, ...)
  217. * See https://apple.github.io/foundationdb/known-limitations.html for other known limitations of the FoundationDB database.
  218. # License
  219. This code is licensed under the 3-clause BSD License.
  220. # Contributing
  221. * Yes, we use tabs! Get over it.
  222. * Style rules are encoded in `.editorconfig` which is supported by most IDEs (or via extensions).
  223. * You can visit the FoundationDB forums for generic questions (not .NET): https://forums.foundationdb.org/

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.