Shiny.Extensions.DependencyInjection 6.0.0-beta.2

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 ShinyHost.Services for accessing the service provider anywhere
• IAppSupport — browser/map launch, programmatic orientation lock, and live orientation change events. Device info, culture and time zone (with change events) and opening the app's settings live on Shiny's IPlatform in Shiny.Core, implemented natively without MAUI
• IAppStore moved to the Shiny.AppStore package (namespace Shiny.AppStore), registered with builder.Services.AddAppStore(...) — see https://shinylib.net/client/appstore/. Do not generate it against this library
• Launch at login moved to Shiny.Core as IAppStartupInstaller, registered with services.AddAppStartupInstaller(...) (docs) - never generate IStartupService / AddStartupService against this library
• Desktop backends from dotnet/maui-labs: macOS AppKit (net10.0-macos) is served by this package, Linux GTK4 by the companion Shiny.Extensions.MauiHosting.Linux package
• 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
   
   return builder.Build();
   

4. Access services anywhere via ShinyHost.Services

IAppSupport

public class MyVm(IAppSupport app)
{
    void Hook()
    {
        // Snapshot - device info, culture and time zone are on Shiny.Core's IPlatform
        var orientation = app.CurrentOrientation;

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

        // Programmatic orientation lock - call once a page has appeared: UIKit ignores a change
        // made while a navigation transition is animating
        var turned = await app.SetOrientation(DisplayOrientation.Landscape);
        _ = app.ResetOrientation();
    }
}

On iOS, SetOrientation turns the device, but UIKit asks the app delegate which orientations a window may take - so to hold it there, return IosOrientationLock.Supported from yours. Without this the device turns once and tilting it turns it straight back.

[Export("application:supportedInterfaceOrientationsForWindow:")]
public UIInterfaceOrientationMask GetSupportedInterfaceOrientations(UIApplication application, UIWindow? forWindow)
    => Shiny.IosOrientationLock.Supported;

IAppSupport needs extra setup on the desktop heads — see the desktop backend section below.

Desktop backends (macOS AppKit + Linux GTK4)

.NET MAUI has no first-party macOS (AppKit) or Linux head. dotnet/maui-labs ships both as experimental preview packages, and this library supports them.

macOS (AppKit)

The net10.0-macos asset of Shiny.Extensions.MauiHosting carries IAppSupport. On that head MAUI Essentials resolves its platform-neutral asset, where every member throws NotImplementedInReferenceAssembly, so the package depends on Microsoft.Maui.Platforms.MacOS.Essentials and AddAppSupport() calls AddMacOSEssentials() for you.

using Microsoft.Maui.Platforms.MacOS.Hosting;
using Shiny;

var builder = MauiApp.CreateBuilder();
builder
    .UseMauiAppMacOS<App>()
    .AddInfrastructureModules(new MyMauiModule())
    .AddAppSupport();     // wires the AppKit Essentials implementations in

return builder.Build();

Orientation comes through DeviceDisplay.MainDisplayInfoChanged (NSApplication.DidChangeScreenParametersNotification). SetOrientation/ResetOrientation return false — AppKit windows don't rotate.

Linux (GTK4)

Linux has no -linux TFM, so a GTK4 head is a plain net10.0 project. The base package's AddAppSupport() would resolve that same throwing Essentials asset, and AddLinuxGtk4Essentials() only redirects five of the static APIs — so Linux gets its own package, Shiny.Extensions.MauiHosting.Linux, whose implementations resolve the Essentials interfaces out of the container instead.

using Microsoft.Maui.Platforms.Linux.Gtk4.Hosting;
using Shiny;

var builder = MauiApp.CreateBuilder();
builder
    .UseMauiAppLinuxGtk4<App>()
    .AddInfrastructureModules(new MyMauiModule())
    .AddLinuxAppSupport();                           // IAppSupport over the GTK4 Essentials services

return builder.Build();

AddLinuxAppSupport() is named apart from the base AddAppSupport() on purpose — both packages put their extensions on MauiAppBuilder in the Shiny namespace, and only one of the two works on Linux.

Both backends are 0.1.0-preview packages from dotnet/maui-labs and are not covered by the .NET MAUI support policy. samples/Sample.Maui.MacOS and samples/Sample.Maui.Linux are runnable heads of the shared sample app for each.

Blazor WebAssembly Hosting Extensions

• IAppSupport for Blazor WebAssembly — screen and viewport dimensions. App version, the browser user agent and parsed browser version, and culture / time-zone change events are on Shiny.Core's IPlatform / NetPlatform
• Reads browser state synchronously through IJSInProcessRuntime (same approach as the Shiny.Extensions.Stores localStorage store)

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:

   using Shiny;
   
   builder.Services.AddAppSupport();
   

4. Inject IAppSupport anywhere:

   public class MyComponent(IAppSupport app)
   {
       void Hook()
       {
           var (w, h) = (app.BrowserWidth, app.BrowserHeight);   // viewport — read live
           var (sw, sh) = (app.ScreenWidth, app.ScreenHeight);   // physical screen
       }
   }
   

Additional Libraries Used

• Shiny Reflector - Reflection without the actual reflection

NuGet Packages