Architecture

Shiny is built around three core concepts: Services, Delegates, and Observables. These form the foundation of every Shiny library and understanding them will help you use Shiny effectively.

Shiny is designed as a unified framework — not a collection of independent plugins. Under the hood, it manages storage, logging, platform lifecycle hooks, and cross-platform utilities so you don’t have to.

Core Concepts

Services

Services are the primary API you interact with. They are registered with dependency injection and provide the interface for controlling platform features.

// Inject and use services directly
IGpsManager gpsManager; // injected
await gpsManager.StartListener(new GpsRequest
{
    UseBackground = true
});

Services follow standard .NET DI patterns — register once, inject anywhere.

Delegates

Delegates are your callback handlers for background events. They are registered at startup and called by Shiny when platform events fire — even when your app isn’t in the foreground.

public class MyGpsDelegate : IGpsDelegate
{
    public Task OnReading(IGpsReading reading)
    {
        // Handle GPS reading in background
    }
}

Delegates support full dependency injection and are treated as singletons.

Observables

Shiny uses Reactive Extensions (Rx) for real-time event streams. Observables give you powerful composition, filtering, and lifecycle management for platform events.

gpsManager
    .WhenReading()
    .Where(x => x.Speed > 10)
    .Subscribe(reading => {
        // Reactive GPS stream
    });

Observables are ideal for UI binding and foreground scenarios.

How It All Fits Together

1

RegisterAdd services and delegates to your DI container at startup

2

InteractInject services and call methods to start/stop platform features

3

ReactDelegates handle background callbacks; Observables stream foreground events

// 1. Register at startup
services.UseGps<MyGpsDelegate>();

// 2. Interact via injected service
await gpsManager.StartListener(new GpsRequest { UseBackground = true });

// 3. React — foreground via observable
gpsManager.WhenReading().Subscribe(reading => { /* update UI */ });

// 3. React — background via delegate (called by Shiny automatically)
public class MyGpsDelegate : IGpsDelegate
{
    public Task OnReading(IGpsReading reading) => /* handle */;
}

Frequently Asked Questions

Why delegates instead of .NET events?

Delegates solve three problems with traditional events:

1. Guaranteed hookup — delegates are registered at startup, so they’re always connected before events fire
2. Correct timing — events were often subscribed too late and missed critical callbacks
3. Testability — delegates are clean, injectable classes that are easy to unit test

Why not depend on MAUI directly?

Shiny is framework-agnostic by design. While it integrates beautifully with MAUI, it doesn’t depend on it. This means Shiny can move with the .NET ecosystem — whether that’s MAUI, Uno Platform, Blazor Hybrid, or whatever comes next.

Why Reactive Extensions?

Observables are more powerful and memory-safe than .NET events. They provide built-in operators for filtering, throttling, combining, and disposing of event streams. Even the C# team has acknowledged the limitations of the language’s event model.