surrealdb/surrealdb.net

dotnet add package SurrealDb.Net

await using var clientHttp = new SurrealDbClient("http://127.0.0.1:8000");
await using var clientHttps = new SurrealDbClient("https://127.0.0.1:8000");
await using var clientWs = new SurrealDbClient("ws://127.0.0.1:8000/rpc");
await using var clientWss = new SurrealDbClient("wss://127.0.0.1:8000/rpc");

// Now you can call other methods including Signin & Use

var options = SurrealDbOptions
  .Create()
  .WithEndpoint("http://127.0.0.1:8000")
  .WithNamespace("test")
  .WithDatabase("test")
  .WithUsername("root")
  .WithPassword("root")
  .Build();

services.AddSurreal(options); // Access `SurrealDbSession` scoped to the request

public class MyClass
{
  private readonly ISurrealDbSession _db;

  public MyClass(ISurrealDbSession db)
  {
    _db = db;
  }

  // ...
}

services.AddSurreal(options, ServiceLifetime.Scoped);

{
  "AllowedHosts": "*",
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "ConnectionStrings": {
    "SurrealDB": "Server=http://127.0.0.1:8000;Namespace=test;Database=test;Username=root;Password=root"
  }
}

services.AddSurreal(configuration.GetConnectionString("SurrealDB"));

services.AddSurreal(configuration.GetConnectionString("SurrealDB.Main"));
services.AddKeyedSurreal("backup", configuration.GetConnectionString("SurrealDB.Backup"));
services.AddKeyedSurreal("monitoring", configuration.GetConnectionString("SurrealDB.Monitoring"));

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
  private const string Table = "weatherForecast";

  private readonly ISurrealDbSession _db;

  public WeatherForecastController(ISurrealDbSession db)
  {
    _db = db;
  }

  [HttpGet]
  public Task<IEnumerable<WeatherForecast>> GetAll(CancellationToken cancellationToken)
  {
    return _db.Select<WeatherForecast>(Table, cancellationToken);
  }

  [HttpGet("{id}")]
  public async Task<IActionResult> Get(string id, CancellationToken cancellationToken)
  {
    var weatherForecast = await _db.Select<WeatherForecast>((Table, id), cancellationToken);

    if (weatherForecast is null)
      return NotFound();

    return Ok(weatherForecast);
  }

  [HttpPost]
  public Task<WeatherForecast> Create(CreateWeatherForecast data, CancellationToken cancellationToken)
  {
    var weatherForecast = new WeatherForecast
    {
      Date = data.Date,
      Country = data.Country,
      TemperatureC = data.TemperatureC,
      Summary = data.Summary
    };

    return _db.Create(Table, weatherForecast, cancellationToken);
  }

  [HttpPut]
  public Task<WeatherForecast> Update(WeatherForecast data, CancellationToken cancellationToken)
  {
    return _db.Upsert(data, cancellationToken);
  }

  [HttpPatch]
  public Task<IEnumerable<WeatherForecast>> PatchAll(
    JsonPatchDocument<WeatherForecast> patches,
    CancellationToken cancellationToken
  )
  {
    return _db.Patch(Table, patches, cancellationToken);
  }

  [HttpPatch("{id}")]
  public Task<WeatherForecast> Patch(
    string id,
    JsonPatchDocument<WeatherForecast> patches,
    CancellationToken cancellationToken
  )
  {
    return _db.Patch((Table, id), patches, cancellationToken);
  }

  [HttpDelete]
  public Task DeleteAll(CancellationToken cancellationToken)
  {
    return _db.Delete(Table, cancellationToken);
  }

  [HttpDelete("{id}")]
  public async Task<IActionResult> Delete(string id, CancellationToken cancellationToken)
  {
    bool success = await _db.Delete((Table, id), cancellationToken);

    if (!success)
      return NotFound();

    return Ok();
  }
}

dotnet add package SurrealDb.Embedded.InMemory

using SurrealDb.Embedded.InMemory;

await using var db = new SurrealDbMemoryClient();

await db.Use("test", "test");

var created = await db.Create("person", new { Name = "John", Age = 30 });
var results = await db.Select<Person>("person");