Как я могу создать привязки DI для универсальных типов в Kotlin? - PullRequest
Новая
       11

Как я могу создать привязки DI для универсальных типов в Kotlin?

0 голосов
/ 21 ноября 2018

Я пытаюсь найти основанную на Kotlin систему внедрения зависимостей, которая позволила бы мне связывать универсальные типы, такие как Foo<T> и разрешать Foo<Int>, Foo<String> и т. Д. При необходимости.

Кодеинкажется, одна из самых популярных платформ DI, и я изучил это, но не понимаю, как это возможно. Выпуск # 83 в репозитории Kodein имеет некоторое обсуждение этой темы.

В моем случае я хотел бы иметь возможность сделать что-то вроде этого: 

import com.atpgroup.testmaster.domain.ExecutableNode
import kotlin.reflect.KClass

annotation class TypeClass
annotation class Instance

/**
 * Represents a catalog of nodes.
 *
 * Factory functions to generate nodes are initially registered to this catalog during setup and used to create
 * instances of nodes.
 */
interface NodeCatalog {
    fun <U : ExecutableNode> resolve(nodeType: KClass<U>, id: String): U
}

/**
 * Simplifies resolution of nodes from a reified context.
 */
inline fun <reified T : ExecutableNode> NodeCatalog.resolve(id: String) = resolve(T::class, id)

/**
 * Dummy implementation of a node catalog.
 */
class DummyNodeCatalog : NodeCatalog {
    override fun <U : ExecutableNode> resolve(nodeType: KClass<U>, id: String): U = TODO("not implemented")
}

/**
 * A type class representing the set of types that can behave like numbers.
 */
@TypeClass
interface Num<T>

// Int and Double both behave like numbers.
@Instance object IntNumInstance : Num<Int>
@Instance object DoubleNumInstance : Num<Double>

/**
 * An executable node that adds two numbers together.
 *
 * @param T the type of the numbers that will be added together
 */
class AddNode<T>(override val id: String, private val N: Num<T>) : ExecutableNode {
    override suspend fun execute() = TODO("not implemented")
}

// Resolve two "add nodes" that operate on different types of numbers.
val catalog = DummyNodeCatalog()
val addInts = catalog.resolve<AddNode<Int>>("integer adder")
val addDoubles = catalog.resolve<AddNode<Double>>("double adder")

В C # это довольно просто использовать Autofac.Приведенный ниже фрагмент является рабочей реализацией на C # того, что я хотел бы: 

using System;
using Autofac;

namespace Experiment
{
    internal class Program
    {
        public static void Main()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<IntNumInstance>().As<INum<int>>();
            builder.RegisterType<DoubleNumInstance>().As<INum<double>>();
            builder.RegisterGeneric(typeof(Add<>));

            var container = builder.Build();
            var addA = container.Resolve<Add<int>.Factory>()("add integers");
            var addB = container.Resolve<Add<double>.Factory>()("add doubles");
            Console.WriteLine(addA);
            Console.WriteLine(addB);
            Console.ReadLine();
        }
    }

    interface INum<T> {}
    class IntNumInstance : INum<int> {}
    class DoubleNumInstance : INum<double> {}

    class Add<T>
    {
        public delegate Add<T> Factory(string id);

        public Add(string id, INum<T> N)
        {
            Id = id;
            this.N = N;
        }

        public string Id { get; }

        private INum<T> N { get; }

        public override string ToString() => $"Add Node ({Id} - {N})";
    }
}

Вывод 

Add Node (add integers - Experiment.IntNumInstance)
Add Node (add doubles - Experiment.DoubleNumInstance)
...