Optionally generated service location API

[jnm2]

I have three real-world situations where an app can't avoid service location, yet 98% of each app has nothing to do with service location and would benefit from StrongInject's compile-time checking:

1. An app that tightly uses Prism for navigation, and Prism itself integrates with the DI system but also heavily uses service location, requiring you to implement object Resolve(Type) around whatever container you're using. Replacing Prism is an expensive endeavor and it's not clear that this would avoid the need for service location.

2. An app that instantiates a data-generating class given a serialized type name. It needs to be able to list the concrete types of available classes without instantiating them, then instantiate on demand when given the type name.

3. An app that has 40 structured menu items, where invoking a menu item must instantiate the corresponding view model, but none of these view models can be instantiated at the point where the menu item UI is built which shows them all.

All of these work with StrongInject today by building a service location bridge type that I'm calling a type catalog.

Current solution

Here's what the type catalog looks like for situation 2, with made up data source names. This looks small and easily manageable, but keep in mind that the same technique is required for situations 1 and 3 and those cases have dozens and hundreds of types to list in the catalog:

// Any time a new type is registered with StrongInject, it must be added as a constructor parameter.
// Types can be skipped if they will never be resolved by a service locator.
public sealed class DataSourceCatalog : CompileTimeTypeCatalog
{
    public DataSourceCatalog(
        IFactory<EntryDataSource> entry,
        IFactory<LakeDataSource> lake,
        IFactory<EngineeringDataSource> engineering,
        IFactory<VolumeDataSource> volume,
        IFactory<FlightDataSource> flight)
        : base(entry, lake, engineering, volume, flight)
    {
    }

    // Inherited from base class:
    // public IEnumerable<Type> RegisteredTypes { get; }
    // public IFactory<object> GetFactory(Type type)
}

Here is how the type catalog is used:

public sealed class SomeReportingService
{
    private readonly DataSourceCatalog dataSourceCatalog;

    public SomeReportingService(DataSourceCatalog dataSourceCatalog, ...)
    {
        this.dataSourceCatalog = dataSourceCatalog;
    }

    public GeneratedReport Generate(Models.ReportDefinition definition, ...)
    {
        IFactory<object> factory = dataSourceCatalog.GetFactory(definition.RequiredInstanceType);
        object instance = factory.Resolve();
        try
        {
            // Invoke async method on instance, passing parameters, etc to obtain data for the report
        }
        finally
        {
            factory.Release(instance);
        }
    }
}

This is how the type catalog is implemented (abstract base class):

Click to expand

```cs using System; using System.Collections.Generic; using System.Collections.Immutable; using System.Linq; public abstract class CompileTimeTypeCatalog { private readonly ImmutableDictionary> registrations; protected CompileTimeTypeCatalog(params object[] factoriesForAllRegisteredTypes) { var builder = ImmutableDictionary.CreateBuilder>(); foreach (var factory in factoriesForAllRegisteredTypes) { var factoryInterfaces = factory.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IFactory<>)); var hasFactoryInterface = false; foreach (var factoryInterface in factoryInterfaces) { var producedType = factoryInterface.GetGenericArguments().Single(); if (builder.ContainsKey(producedType)) throw new ArgumentException($"More than one factory was specified which creates the type {producedType.FullName}.", nameof(factoriesForAllRegisteredTypes)); builder.Add(producedType, (IFactory

[jnm2]

Great conversation at https://gitter.im/stronginject/community?at=610bfcc9933ee46b753fcec4 bringing up a number of concerns and ideas, but none of the ideas felt right yet.

[jnm2]

Also, the code examples above assumed that StrongInject provides automatic implementations for IFactory<T> which it does not, so the "today's solution" above will not work with StrongInject until https://github.com/YairHalberstadt/stronginject/issues/140 ships and IFactory<T> is replaced with Func<Owned<T>> in the examples above.