// https://stackoverflow.com/q/69207420/1768303

#nullable enable

using System;

using System.Linq;

using Microsoft.Extensions.DependencyInjection;

​

namespace App

{

    static class Program

    {

        private static IServiceProvider BuildServices() => new ServiceCollection()

            .AddFactory<ISomething, Something>()

            .BuildServiceProvider();

​

        static void Main()

        {

            var serviceProvider = BuildServices();

​

            var something0 = serviceProvider.GetRequiredService<ISomething>();

​

            var something1 = serviceProvider.Inject<ISomething>();

​

            var something2 = serviceProvider.Inject<ISomething>(something1);

​

            var something3 = serviceProvider.Inject<ISomething>(Guid.NewGuid());

        }

    }

​

    /// <summary>

    /// A sample interface for DI

    /// </summary>

    public interface ISomething

    {

        void DoSomething() => Console.WriteLine(nameof(DoSomething));

    }

​

    public class Something : ISomething

    {

        public Something() =>

          Console.WriteLine($"{this.GetType()} created");

​

        public Something(Guid context) =>

          Console.WriteLine($"{this.GetType()} created with {context.GetType()}");

​

        public Something(ISomething source) =>

            Console.WriteLine($"{this.GetType()} created with {source.GetType()}");

​

        public Something(IServiceProvider sp) =>

            Console.WriteLine($"{this.GetType()} created with {sp.GetType()}");

​

        public Something(IServiceProvider sp, Guid context) =>

            Console.WriteLine($"{this.GetType()} created with {sp.GetType()}, {context.GetType()}");

​

        public Something(IServiceProvider sp, ISomething context) =>

            Console.WriteLine($"{this.GetType()} created with {sp.GetType()}, {context.GetType()}");

    }

​

    /// <summary>

    /// DependencyInjectionExtensions

    /// </summary>

    public static class DependencyInjectionExtensions

    {

        public delegate TService Factory<out TService>(IServiceProvider? serviceProvider, params object[] parameters);

​

        /// <summary>

        /// Add a factory for parametrized DI injections

        /// </summary>

        public static IServiceCollection AddFactory<TService, TInstance>(this IServiceCollection @this)

            where TService : class

            where TInstance : class, TService

        {

            return @this

                .AddSingleton<Factory<TService>>(factoryServiceProvider =>

                    (callerServiceProvider, parameters) =>

                        ActivatorUtilities.CreateInstance<TInstance>(

                            callerServiceProvider ?? factoryServiceProvider, parameters))

​

                .AddTransient<TService>(serviceProvider =>

                    ActivatorUtilities.CreateInstance<TInstance>(serviceProvider, serviceProvider));

        }

​

        /// <summary>

        /// Inject with parameters

        /// </summary>

        public static TService Inject<TService>(this IServiceProvider @this, params object[] parameters)

            where TService : class

        {

            var factory = @this.GetService<Factory<TService>>();

            if (factory != null)

            {

                if (!parameters.Any(p => p is IServiceProvider))

                {

                    // add the current IServiceProvider to the param list

                    return factory(@this, parameters.Prepend(@this).ToArray());

                }

                return factory(@this, parameters);

            }

            return @this.GetRequiredService<TService>();

        }

    }

}

​