Ces.Shared 1.0.0

CES.Shared Documentation

Overview

Ces.Shared is a lightweight state-sharing and binding system for .NET applications.
It allows objects to synchronize properties dynamically using string-based keys and shared states.

The package provides:

• Dynamic property storage
• State synchronization
• Reactive bindings
• Shared object management
• Automatic property update notifications

Namespace

Ces.Shared

Classes

CesObjectState

Represents a shared state object that stores dynamic properties.

Implements:

INotifyPropertyChanged

Features

• Dynamic property dictionary
• Typed value retrieval
• Property change notifications
• Shared reactive updates

Properties

Id

Unique identifier of the state object.

public string Id { get; init; }

Properties

Internal dictionary containing all stored values.

public Dictionary<string, object> Properties { get; }

Events

SetChanged

Triggered whenever a value is updated.

event Action<string, object>

Parameters:

GetChanged

Triggered when a value is retrieved using Get<T>().

event Action

PropertyChanged

Standard .NET property change notification event.

event PropertyChangedEventHandler

Methods

Set

Stores or updates a value.

void Set(string key, object value)

Example:

state.Set("Health", 100);

Get<T>

Gets a value from the state.

T Get<T>(string key)

Example:

int health = state.Get<int>("Health");

GetOrDefault<T>

Gets a value or returns a default value if the key does not exist.

T GetOrDefault<T>(string key, T defaultValue = default!)

Example:

int hp = state.GetOrDefault("HP", 0);

TryGet<T>

Safely tries to retrieve a value.

bool TryGet<T>(string key, out T value)

Example:

if(state.TryGet<int>("Coins", out var coins))
{
    Console.WriteLine(coins);
}

CesBindable

Abstract class used to bind local properties to a shared state.

Features

• Dynamic property binding
• Automatic synchronization
• State reallocation
• Reactive updates

Protected Methods

Bind<T>

Creates a binding between a property and a shared state key.

protected void Bind<T>(
    string key,
    Func<T> getter,
    Action<T> setter
)

Example:

Bind(
    "Health",
    () => Health,
    value => Health = value
);

Public Methods

Attach

Attaches the object to a CesObjectState.

void Attach(CesObjectState state)

This enables:

• automatic updates
• synchronization
• reactive bindings

Apply

Applies all bindings manually.

void Apply(CesObjectState state)

Reallocate

Rewrites current values back into the shared state.

void Reallocate(CesObjectState state)

CesShared

Main container for all shared objects and global values.

Properties

Objects

Stores all created shared objects.

Dictionary<string, CesObjectState>

Globals

Stores global shared values.

Dictionary<string, object>

Methods

Create

Creates a new shared object state.

CesObjectState Create(string id)

Example:

var player = shared.Create("player");

Get

Gets an existing shared object by id.

CesObjectState Get(string id)

Example:

var player = shared.Get("player");

Full Example

using Ces.Shared;

public class Player : CesBindable
{
    public int Health { get; set; }

    public Player()
    {
        Bind(
            "Health",
            () => Health,
            value => Health = value
        );
    }
}

var shared = new CesShared();

var state = shared.Create("player");

var player = new Player();

player.Attach(state);

state.Set("Health", 150);

Console.WriteLine(player.Health);

Use Cases

Ces.Shared can be used for:

• Game entity synchronization
• UI binding systems
• Shared application state
• Multiplayer replication prototypes
• Dynamic runtime properties
• Plugin communication
• Reactive architectures

Advantages

• Lightweight
• Dynamic
• Easy integration
• Reactive event system
• Minimal dependencies
• Generic typed access
• Runtime extensibility

Package Structure

Ces.Shared
├── CesObjectState
├── CesBindable
└── CesShared

License

MIT License.