eeCLOUD.SDK 1.2.0

eeCLOUD C# SDK

Official C# SDK for eeCLOUD DaaS.

This SDK provides a 1:1 mapping with the eeCLOUD 4.1 REST API so you can work with memories, time-series data, object graphs, references, and updates without building an HTTP integration from scratch.

Each API key is bound to a single eeCLOUD Application, so the SDK automatically works inside the correct tenant context.

Installation

dotnet add package eeCLOUD.SDK

Requirements

• .NET 6.0 or higher
• An active eeCLOUD API key
• An eeCLOUD API base URL, defaulting to https://api.eecloud.io

Create a client

using eeCLOUD.SDK;

using var ee = new eeCloudClient(
    apiKey: "YOUR_API_KEY",
    baseUrl: "https://api.eecloud.io"
);

Notes:

• baseUrl is optional. If omitted, the SDK uses https://api.eecloud.io.
• The SDK automatically sends the X-API-Key header on every request.
• Memory("name") returns a scoped client for a single eeCLOUD memory.

Quick Start

using eeCLOUD.SDK;

using var ee = new eeCloudClient("YOUR_API_KEY");

var memory = ee.Memory("temperature");

await memory.WriteAsync(new
{
    deviceId = "sensor-01",
    value = 23.4m,
    timestamp = DateTime.UtcNow
});

var latest = await memory.ReadAsync();

var lastDay = await memory.ReadAllAsync(
    DateTime.UtcNow.AddDays(-1),
    DateTime.UtcNow,
    entries: 100
);

Core Concepts

Application

Resolved automatically from the API key.

Memory

A logical container comparable to a table or collection.

var events = ee.Memory("events");

Data

Stored as flexible JSON-shaped payloads.

Object Graph

The obj/* routes return a wrapper containing:

• memory: eeCLOUD metadata
• data: the object graph payload

Response Models

Standard data endpoints

Methods such as WriteAsync, ReadAsync, ReadAllAsync, UpdateAsync, DeleteAsync, RestoreAsync, and EraseAsync return Memory.

var result = await ee.Memory("events").ReadAsync();

if (result?.result == true)
{
    foreach (var row in result.area)
    {
        Console.WriteLine($"{row.address} - {row.data}");
    }
}

Object graph endpoints

Methods such as ReadObjectAsync, ReadObjectByIndexAsync, and ReadAllObjectAsync return ObjectMemory or ObjectMemories.

var device = await ee.Memory("devices").ReadObjectByIndexAsync("sensor-01");

if (device?.memory.result == true)
{
    var payload = device.data;
    var metadata = device.memory.area;
}

Common Parameters

These parameters appear across many SDK methods:

• reference: points to the address of another memory record
• clusterized: enables clustered write/update behavior when supported
• date: business date used for time-series and range queries
• order: ASC or DESC
• deleted: includes soft-deleted records when true
• page: page offset for paged reads
• entries: page size
• mixed: enables mixed raw/object graph reads on object endpoints

Client Helpers

bool healthy = await ee.HealthAsync();
string version = await ee.VersionAsync();
string[] memories = await ee.GetMemoriesAsync();
long appSize = await ee.AppSizeAsync();

Common Operations

Write data

await ee.Memory("events").WriteAsync(new
{
    type = "login",
    userId = 123
});

Write data with ID

await ee.Memory("events").WriteAsync(
    id: "login",
    data: new { userId = 123, status = "ok" }
);

Write data with ID, index, and business date

await ee.Memory("events").WriteAsync(
    id: "login",
    index: Guid.NewGuid().ToString("N"),
    data: new { userId = 123 },
    date: DateTime.UtcNow
);

Batch write

await ee.Memory("events").WriteBatchAsync(new List<WriteBatchRequest>
{
    new("login", Guid.NewGuid().ToString("N"), DateTime.UtcNow, new { userId = 123 }),
    new("logout", Guid.NewGuid().ToString("N"), DateTime.UtcNow, new { userId = 123 })
});

Write object graph data

await ee.Memory("devices").WriteObjectAsync(
    id: "sensor",
    index: "sensor-01",
    data: new
    {
        meta = new { region = "eu-west" },
        telemetry = new[] { 23.4m, 23.7m }
    }
);

Object graph batch write

var batch = await ee.Memory("devices").WriteObjectBatchAsync(new List<WriteObjectBatchRequest>
{
    new("sensor", "sensor-01", DateTime.UtcNow, new { meta = new { region = "eu-west" } }),
    new("sensor", "sensor-02", DateTime.UtcNow, new { meta = new { region = "eu-central" } })
});

Read latest data

var latest = await ee.Memory("events").ReadAsync();

Read by address

var item = await ee.Memory("events").ReadByAddressAsync(10234);

Read by ID

var item = await ee.Memory("events").ReadByIdAsync("login", Order.DESC);

Read by index

var item = await ee.Memory("events").ReadByIndexAsync("evt-001");

Read by field

var item = await ee.Memory("events").ReadByFieldAsync("status", "processed");

Read by reference

var items = await ee.Memory("events").ReadByReferenceAsync(reference: 1500);

Read all data with paging

var page = await ee.Memory("events").ReadAllAsync(
    order: Order.ASC,
    page: 0,
    entries: 50
);

Read all data by ID

var page = await ee.Memory("events").ReadAllAsync(
    id: "login",
    entries: 100
);

Read all data by date range

var page = await ee.Memory("events").ReadAllAsync(
    DateTime.UtcNow.AddHours(-24),
    DateTime.UtcNow,
    entries: 100
);

Read all data by field and date range

var page = await ee.Memory("events").ReadAllAsync(
    field: "status",
    value: "processed",
    start: DateTime.UtcNow.AddDays(-7),
    end: DateTime.UtcNow,
    entries: 100
);

Read object graph pages

var objects = await ee.Memory("devices").ReadAllObjectAsync(
    page: 0,
    entries: 50,
    mixed: true
);

Read object graph payload

var device = await ee.Memory("devices").ReadObjectByIndexAsync("sensor-01");
var payload = device?.data;
var metadata = device?.memory;

Read object graph by date range

var objects = await ee.Memory("devices").ReadAllObjectAsync(
    DateTime.UtcNow.AddDays(-1),
    DateTime.UtcNow,
    entries: 50,
    mixed: true
);

Update a full record

await ee.Memory("events").UpdateAsync(
    address: 10234,
    data: new { type = "login", status = "processed" }
);

Update by field filter

await ee.Memory("events").UpdateAsync(
    field: "status",
    value: "pending",
    data: new { type = "login", status = "processed" }
);

Update object graph data

await ee.Memory("devices").UpdateObjectAsync(
    address: 10234,
    data: new
    {
        meta = new { region = "eu-west" },
        telemetry = new[] { 23.8m, 24.1m }
    }
);

Update a single value

await ee.Memory("events")
    .UpdateValueAsync(address: 10234, field: "status", value: "processed");

Update ID or index

await ee.Memory("events").UpdateIdAsync(10234, "login");
await ee.Memory("events").UpdateIndexAsync(10234, "evt-001");

Increase a numeric value

await ee.Memory("metrics")
    .IncreaseAsync(address: 5566, field: "counter", value: 1);

Count and size

long total = await ee.Memory("events").CountAsync();
long totalById = await ee.Memory("events").CountAsync("login");
long memorySize = await ee.Memory("events").SizeAsync();

Soft delete, restore, and erase

await ee.Memory("events").DeleteAsync(10234);
await ee.Memory("events").RestoreAsync(10234);
await ee.Memory("events").EraseAsync(10234);

Error Handling

The SDK uses EnsureSuccessStatusCode().

That means:

• 2xx responses are returned normally
• 4xx and 5xx responses throw HttpRequestException

Example:

try
{
    var result = await ee.Memory("events").ReadAsync();
}
catch (HttpRequestException ex)
{
    Console.WriteLine(ex.Message);
}

If the API returns a successful response with eeCLOUD-level errors, inspect the returned Memory payload:

var result = await ee.Memory("events").ReadAsync();

if (result?.result != true)
{
    foreach (var error in result?.errors ?? Array.Empty<string>())
        Console.WriteLine(error);
}

Route Coverage

The SDK maps the current eeCLOUD API surface for:

• write
• write batch
• object graph write and read
• read by address, ID, index, field, and reference
• paged and date-range reads
• full updates and single-value updates
• increase operations
• delete, restore, and erase
• count, size, health, version, and memory listing

Compatibility Notes

• The SDK targets net6.0.
• It is aligned with eeCLOUD API 4.1.
• Object graph methods are intended for eeCLOUD backends that support object graph persistence.

License

MIT License

Links

• eeCLOUD
• NuGet