Shiny.Extensions.DependencyInjection 5.1.6

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.

   AddShinyStores() registers IKeyValueStore keyed under StoreKeys.Default and StoreKeys.Secure, plus the default store unkeyed. The unkeyed registration exists for third-party container adapters that predate .NET 8 keyed services — Prism's DryIoc container, for example, still sits on DryIoc 5.x, silently ignores [FromKeyedServices], and resolves the plain IKeyValueStore instead. On those containers, use the static Shiny.Stores.Secure / Shiny.Stores.Keyed(...) accessor when you need a non-default store, since the key will be dropped.

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