Shiny.Extensions.Stores 1.0.0

Shiny Extensions

Dependency Injection Extensions

• Source generate all attributed classes to a single add file - saves you the boilerplate
• Extension methods for registering a dependency against multiple interfaces
• Extension methods for startup tasks (different to hosted services that don't work on mobile)
• Supports multiple interfaces
• Supports open generics
• Supports keyed services

The Results

THIS:

using Microsoft.Extensions.DependencyInjection;
using Shiny.Extensions.DependencyInjection;

// 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.Extensions.DependencyInjection;

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

Stores

• Key/value store with support for
  • Android/iOS/Windows - Preferences & Secure Storage
  • Web - Local Storage & Session Storage
  • In Memory
• Object binder binds INotifyPropertyChanged against a key/value store to persist object changes across sessions
• Simply implement IKeyValueStore to create your own store

Setup

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

// during your app startup - use your service collection 

builder.Services.AddPersistentService<MyNotifyPropertyChangedObject>("secure"); // optional: default to `settings`

3. Inject the MyNotifyPropertyChangedObject into your view model or service. Set properties and they will be persisted automatically.
4. To bypass reflection and make binding super fast - use Shiny Reflector to remove the need for reflection. It is already built into the Shiny.Extensions.Stores package, so you can use it directly. Just mark [Reflector] on your class and make your class partial.

Available Stores Per Platform

Web Hosting Extensions

• Merges service container build and post build scenarios into a single class
• All IInfrastructureModule implementations are automatically detected and run

Setup

1. Install the NuGet package Shiny.Extensions.WebHosting
2. Add an infrastructure module by implementing IInfrastructureModule:

   using Shiny.Extensions.WebHosting;
   
   public class MyInfrastructureModule : IInfrastructureModule
   {
       public void Add(WebApplicationBuilder builder)
       {
           // Register your services here
       }
   
       public void Configure(WebApplication app)
       {
           // Configure your application here
       }
   }
   

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

   using Shiny.Extensions.WebHosting;
   
   var builder = WebApplication.CreateBuilder(args);
   builder.AddInfrastructure(params Assembly[] assemblies)(); // this scans the assemblies for IInfrastructureModule implementations and runs Add methods
   // OR
   builder.AddInfrastructureModules(params IInfrastructureModule[] modules); // this doesn't use reflection
   
   var app = builder.Build();
   app.UseInfrastructure(); // this runs all IInfrastructureModule.Use methods
   

Additional Libraries Used

• Shiny Reflector - Reflection without the actual reflection