👁 Image
Shiny.Extensions.Serialization 5.1.0

Shiny Extensions

Dependency Injection Extensions

• Source generate all attributed classes to a single add file - saves you the boilerplate
• Factory-form emission - generated registrations expand the constructor at compile time (no reflection, AOT-clean) so resolve chains like OnResolved compose naturally
• ActivatorUtilities-style constructor selection ([ActivatorUtilitiesConstructor] and [FromKeyedServices] honored)
• Optional/nullable constructor parameters are respected - resolved via GetService (no throw when unregistered) with fallback to the declared default value
• Multiple interfaces via explicit forwarders (no reflection)
• Supports open generics and keyed services
• OnResolved<T>(hook) chain extension for one-shot post-construction hooks

The Results

THIS:

using Microsoft.Extensions.DependencyInjection;
using Shiny;

// given the following code from a user
namespace Sample
{
 public interface IStandardInterface;

 public interface IStandardInterface2;

 [Service(ServiceLifetime.Singleton)]
 public class ImplementationOnly;

 [Service(ServiceLifetime.Transient, "ImplOnly")]
 public class KeyedImplementationOnly;


 [Service(ServiceLifetime.Singleton)]
 public class StandardImplementation : IStandardInterface;

 [Service(ServiceLifetime.Scoped, "Standard")]
 public class KeyedStandardImplementation : IStandardInterface;

 [Service(ServiceLifetime.Singleton)]
 public class MultipleImplementation : IStandardInterface, IStandardInterface2;

 [Service(ServiceLifetime.Scoped)]
 public class ScopedMultipleImplementation : IStandardInterface, IStandardInterface2;


 [Service(ServiceLifetime.Scoped, "KeyedGeneric")]
 public class TestGeneric<T1, T2>
 {
 public T1 Value1 { get; set; }
 public T2 Value2 { get; set; }
 }
}

GENERATES THIS:

// <auto-generated />
using global::Microsoft.Extensions.DependencyInjection;
using global::Shiny;

namespace Sample
{
 public static class __GeneratedRegistrations
 {
 public static global::Microsoft.Extensions.DependencyInjection.IServiceCollection AddGeneratedServices(
 this global::Microsoft.Extensions.DependencyInjection.IServiceCollection services
 )
 {
 services.AddSingleton<global::Sample.ImplementationOnly>();
 services.AddKeyedTransient<global::Sample.KeyedImplementationOnly>("ImplOnly");
 services.AddSingleton<global::Sample.IStandardInterface, global::Sample.StandardImplementation>();
 services.AddKeyedScoped<global::Sample.IStandardInterface, global::Sample.KeyedStandardImplementation>("Standard");
 services.AddSingletonAsImplementedInterfaces<global::Sample.MultipleImplementation>();
 services.AddScopedAsImplementedInterfaces<global::Sample.ScopedMultipleImplementation>();
 services.AddKeyedScoped(typeof(global::Sample.TestGeneric<,>), "KeyedGeneric");

 return services;
 }
 }
}

Setup

1. Install the NuGet package Shiny.Extensions.DependencyInjection
2. Add the following using directive:

   // during your app startup - use your service collection 
   builder.Services.AddGeneratedServices();
   

3. Add the [Service(ServiceLifetime.Singleton, "optional key")] attribute to your classes and specify the lifetime and optional key

Serialization

• Centralized ISerializer backed by source-generated JsonSerializerContexts, no reflection, AOT-clean
• Shiny.Json static accessor — self-bootstrapping, sibling to Shiny.Stores for mobile cold-start
• [ShinyJsonContext] on any user-declared JsonSerializerContext partial → source generator emits a [ModuleInitializer] that auto-registers it. No services.AddJsonContext(...) boilerplate needed
• [ShinyJsonInclude] on a type (or [assembly: ShinyJsonInclude(typeof(T))]) → AOT-safe collection wrappers for List<T>, T[], IEnumerable<T>, IReadOnlyList<T>, IList<T>, ICollection<T>, IAsyncEnumerable<T> — solves the "inline [JsonConverter] works but List<T> fails" trap
• Multiple contributing libraries chain cleanly via TypeInfoResolverChain. Element types from one context compose with collection wrappers from another
• services.AddJsonSerialization() / AddJsonContext(...) / ConfigureJsonSerializer(...) for DI-side wiring; Shiny.Json.CreateTestScope() for test isolation

Setup

1. Install the NuGet package Shiny.Extensions.Serialization
2. Write a normal STJ source-generator context and decorate it with [Shiny.ShinyJsonContext]:

   using System.Text.Json.Serialization;
   using Shiny;
   
   [ShinyJsonContext]
   [JsonSerializable(typeof(MyDto))]
   [JsonSerializable(typeof(MyOtherDto))]
   internal partial class MyAppJsonContext : JsonSerializerContext;
   

3. Done. The generator emits a [ModuleInitializer] calling Shiny.Json.AddContext(MyAppJsonContext.Default) before Main, so both DI consumers and the static Shiny.Json.Default accessor see your types — no services.AddJsonContext(...) call needed.
4. (Optional) For collection support, mark element types with [ShinyJsonInclude]:

   [ShinyJsonInclude]
   public partial class MyDto { /* ... */ }
   

   List<MyDto>, MyDto[], IEnumerable<MyDto> and friends now serialize AOT-safely.

// Static access — works before DI exists (useful for mobile cold-start through Shiny.Stores)
var json = Shiny.Json.Default.Serialize(new MyDto { Name = "Allan" });

// DI access — same shared instance
public class MyService(ISerializer serializer) { /* ... */ }

Stores

• Cross-platform key/value store with support for
  • Android/iOS/Windows - Preferences & Secure Storage
  • Web - Local Storage
  • In Memory
• Source-generated [Bind] attribute on partial properties - emits getter/setter bodies that round-trip through the store (no INPC required, no runtime reflection, fully AOT)
• Static Shiny.Stores.Default/Secure/Keyed(...) accessor for direct ad-hoc reads/writes
• Implement IKeyValueStore to plug in your own store

Setup

1. Install the NuGet package Shiny.Extensions.Stores
2. Register at startup — the static Shiny.Stores accessor self-bootstraps on first use:

   builder.Services.AddShinyStores();
   var host = builder.Build();
   

   On Blazor WebAssembly (where LocalStorageKeyValueStore needs IJSRuntime), also call host.Services.UseShinyStores() after Build() to snapshot the DI-resolved store into the static accessor.
3. Define your settings as a partial class with [Bind] partial properties:

   using Shiny;
   
   [Singleton]
   public partial class AppSettings
   {
    [Bind] // default store
    public partial string Theme { get; set; }
   
    [Bind("secure")] // secure store
    public partial string Token { get; set; }
   }
   

4. Inject AppSettings anywhere. Set properties — they persist. Read properties — they come from the store.

Or skip the class and use the static accessor:

Shiny.Stores.Default.Set("theme", "dark");
var theme = Shiny.Stores.Default.Get<string>("theme");

Available Stores Per Platform

Web Hosting Extensions

• Merges service container build and post build scenarios into a single class using IWebModule

Setup

1. Install the NuGet package Shiny.Extensions.WebHosting
2. Add a web module by implementing IWebModule:

   using Shiny;
   
   public class MyWebModule : IWebModule
   {
    public void Add(WebApplicationBuilder builder)
    {
    // Register your services here
    }
   
    public void Use(WebApplication app)
    {
    // Configure your middleware/endpoints here
    }
   }
   

3. In your application hosting startup, add the following:

   using Shiny;
   
   var builder = WebApplication.CreateBuilder(args);
   builder.AddInfrastructureModules(new MyWebModule());
   
   var app = builder.Build();
   app.UseInfrastructureModules();
   

MAUI Hosting Extensions

• Module-based MAUI app configuration with IMauiModule
• Static Host.Services for accessing the service provider anywhere
• IAppSupport — device info (manufacturer, model, platform, idiom, OS version), browser/map launch, programmatic orientation lock, and live change events for orientation, culture, and time zone (native listeners on iOS/Android/Windows, polling fallback elsewhere)
• IAppStore — cross-platform store version lookups + deep links for Apple App Store (iTunes Search API), Google Play (HTML scrape), and Microsoft Store (DisplayCatalog API)
• Opt-in registration: each capability is its own extension method so apps only pay for what they use

Setup

1. Install the NuGet package Shiny.Extensions.MauiHosting
2. Create a MAUI module by implementing IMauiModule:

   using Shiny;
   
   public class MyMauiModule : IMauiModule
   {
    public void Add(MauiAppBuilder builder)
    {
    // Register your services here
    }
   
    public void Use(IPlatformApplication app)
    {
    // Post-build initialization here (do NOT block)
    }
   }
   

3. In your MauiProgram.cs:

   using Shiny;
   
   var builder = MauiApp.CreateBuilder();
   builder
    .UseMauiApp<App>()
    .AddInfrastructureModules(new MyMauiModule()) // your IMauiModule list
    .AddAppSupport() // IAppSupport
    .AddAppStore(opts => // optional: IAppStore + config
    {
    opts.AppleAppId = "1234567890";
    opts.WindowsProductId = "9NBLGGH4NNS1";
    });
   
   return builder.Build();
   

4. Access services anywhere via Host.Services

IAppSupport

public class MyVm(IAppSupport app)
{
 void Hook()
 {
 // Snapshot
 var version = app.AppVersion;
 var platform = app.Platform; // "Android", "iOS", "WinUI", "macOS"
 var idiom = app.DeviceIdiom; // Phone, Tablet, Desktop, …
 var orientation = app.CurrentOrientation;
 var culture = app.CurrentCulture;

 // Live updates
 app.OrientationChanged += (s, e) => { /* new DisplayOrientation */ };
 app.CultureChanged += (s, e) => { /* new CultureInfo */ };
 app.TimeZoneChanged += (s, e) => { /* new TimeZoneInfo */ };

 // Programmatic orientation lock
 _ = app.SetOrientation(DisplayOrientation.Landscape);
 _ = app.ResetOrientation();
 }
}

IAppStore

public class UpdateChecker(IAppStore store)
{
 public async Task Check()
 {
 var result = await store.GetCurrent();
 if (result?.NeedsUpdate == true)
 await store.OpenStore();
 }

 public Task Review() => store.OpenReviewPage();
}

Blazor WebAssembly Hosting Extensions

• IAppSupport for Blazor WebAssembly — app version, browser user-agent (raw string + best-effort parsed browser Version), screen and viewport dimensions, plus live culture / time-zone change events
• Reads browser state synchronously through IJSInProcessRuntime (same approach as Shiny.Extensions.Stores.Web)

Setup

1. Install the NuGet package Shiny.Extensions.BlazorHosting
2. Reference the bundled script in wwwroot/index.html before blazor.webassembly.js:

   <script src="_content/Shiny.Extensions.BlazorHosting/shiny-appsupport.js"></script>
   

3. Register at startup, passing the head app's version (no reflection — use the source-generated ThisAssembly):

   using Shiny;
   
   builder.Services.AddAppSupport(ThisAssembly.AssemblyVersion);
   

4. Inject IAppSupport anywhere:

   public class MyComponent(IAppSupport app)
   {
    void Hook()
    {
    // Snapshot
    var version = app.AppVersion;
    var ua = app.UserAgent;
    var browser = app.UserAgentVersion;
    var (w, h) = (app.BrowserWidth, app.BrowserHeight); // viewport — read live
    var (sw, sh) = (app.ScreenWidth, app.ScreenHeight); // physical screen
   
    // Live updates
    app.CultureChanged += (s, e) => { /* new CultureInfo */ };
    app.TimeZoneChanged += (s, e) => { /* new TimeZoneInfo */ };
    }
   }
   

Additional Libraries Used

• Shiny Reflector - Reflection without the actual reflection

NuGet Packages