SpacetimeDB

spacetime login

using SpacetimeDB.Types;
using System.Linq;

private void SubscribeToTables(DbConnection conn)
{
    conn.SubscriptionBuilder()
        .OnApplied(on_subscription_applied)
        .OnError((errCtx, err) => {
            Console.WriteLine($"Subscription failed: {err.Message}");
        })
        .Subscribe(new string[] { "SELECT * FROM Player", "SELECT * FROM Message" });
}

private void OnSubscriptionApplied(SubscriptionEventContext ctx)
{
    // Access initial data via ctx.Db
    var messages = ctx.Db.Message.Iter().ToList();
    messages.Sort((a, b) => a.Sent.CompareTo(b.Sent));
}

# For .NET Console/Desktop Apps
dotnet new console -o my_csharp_client
cd my_csharp_client
dotnet add package SpacetimeDB.ClientSDK

# Generate module bindings
mkdir -p module_bindings
spacetime generate --lang csharp \ 
    --out-dir module_bindings \ 
    --module-path ../path/to/your/server_module

use spacetimedb::{table, reducer, ReducerContext, Timestamp, TimeDuration, ScheduleAt, Table};
use log::info;

#[table(accessor = send_message_schedule, scheduled(send_message))]
struct SendMessageSchedule {
    #[primary_key]
    #[auto_inc]
    scheduled_id: u64,
    scheduled_at: ScheduleAt,
    text: String,
}

#[reducer]
fn send_message(ctx: &ReducerContext, args: SendMessageSchedule) -> Result<(), String> {
    // Security check: ensure only the scheduler (the module itself) can call this
    if ctx.sender() != ctx.identity() {
        return Err("Reducer `send_message` may not be invoked by clients, only via scheduling.".into());
    }

    info!("Scheduled SendMessage: {}", args.text);
    Ok(())
}

#[reducer(init)]
fn init(ctx: &ReducerContext) -> Result<(), String> {
    let ten_seconds = TimeDuration::from_micros(10_000_000);
    
    // Schedule one-off
    let future_timestamp: Timestamp = ctx.timestamp + ten_seconds;
    ctx.db.send_message_schedule().insert(SendMessageSchedule {
        scheduled_id: 0,
        text: "One-time message".to_string(),
        scheduled_at: future_timestamp.into()
    });

    // Schedule periodic (every 10 seconds)
    ctx.db.send_message_schedule().insert(SendMessageSchedule {
        scheduled_id: 0,
        text: "Periodic message".to_string(),
        scheduled_at: ten_seconds.into()
    });

    Ok(())
}

# Build and publish from source to 'my-database-name' on the default server
spacetime publish --module-path my_server_module my-database-name

# Publish a pre-compiled wasm to Maincloud, clearing existing data
spacetime publish --bin-path ./my_module/target/wasm32-wasi/debug/my_module.wasm -s maincloud -c my-cloud-db-identity

// Registering callbacks
this.conn.db.User.onInsert((ctx, user) => {
    if (ctx) {
        console.log(`${user.name} connected (Live Update).`);
    } else {
        console.log(`Loaded user: ${user.name} (Initial Load).`);
    }
});

// Manually iterating initial cache
for (const user of this.conn.db.User.iter()) {
    // Process user
}

using SpacetimeDB;
using System;

public static partial class Module
{
    [Table(Accessor = "send_message_schedule", Scheduled = nameof(SendMessage), ScheduledAt = nameof(ScheduledAt))]
    public partial struct SendMessageSchedule
    {
        [PrimaryKey]
        [AutoInc]
        public ulong Id;
        public ScheduleAt ScheduledAt;
        public string Message;
    }

    [Reducer]
    public static void SendMessage(ReducerContext ctx, SendMessageSchedule scheduleArgs)
    {
        // Security check: ensure only the scheduler can call this
        if (!ctx.Sender.Equals(ctx.Identity))
        {
            throw new Exception("Reducer SendMessage may not be invoked by clients, only via scheduling.");
        }
        Log.Info($"Scheduled SendMessage: {scheduleArgs.Message}");
    }

    [Reducer(ReducerKind.Init)]
    public static void Init(ReducerContext ctx)
    {
        var tenSeconds = new TimeDuration { Microseconds = 10_000_000 };
        var futureTimestamp = ctx.Timestamp + tenSeconds;

        // One-off execution
        ctx.Db.send_message_schedule.Insert(new SendMessageSchedule
        {
            Id = 0, 
            ScheduledAt = new ScheduleAt.Time(futureTimestamp),
            Message = "One-time message!"
        });

        // Periodic execution
        ctx.Db.send_message_schedule.Insert(new SendMessageSchedule
        {
            Id = 0, 
            ScheduledAt = new ScheduleAt.Interval(tenSeconds),
            Message = "Periodic message every 10s!"
        });
    }
}