Универсальный интерфейс с составными интерфейсами и несколькими конкретными реализациями

Question

Я хочу использовать универсальный интерфейс, который может принимать другие интерфейсы в качестве свойств, которые используют конкретную реализацию.Как создать шаблон, если это возможно, и как разрешить реализацию в коллекции сервисов.Это будет использоваться вместе с единицей работы и шаблоном репозитория.

Я пробовал разные методы и реализации через код.Некоторые были в состоянии скомпилировать, но во время выполнения они не смогли быть решены.Отчасти вопрос в том, можно ли сделать такой подход, с другой - я не решил это правильно.

public class GenericInterface<T, U> : IGenericInterface<T, U>
{
    public T InterfaceOne { get; set; }     // IInterfaceOne
    public U InterfaceTwo { get; set; }     // IInterfaceTwo
}

public interface IInterfaceOne
{
    void DoOne();
    void DoTwo();
}

public interface IInterfaceTwo
{
    void DoThree();
    void DoFour();
}

public class ConcreteImplementation : IInterfaceOne, IInterfaceTwo
{
    public void DoOne()
    {
        throw new System.NotImplementedException();
    }

    public void DoTwo()
    {
        throw new System.NotImplementedException();
    }

    public void DoThree()
    {
        throw new System.NotImplementedException();
    }

    public void DoFour()
    {
        throw new System.NotImplementedException();
    }
}

public class Resolver { 

    public void Resolve() {

        // Should be able to use the interfaces and reference the ConcreteImplementation....!?
        // How to resolve in a service collection?
        var genericComposedInterfaces = new GenericInterface<IInterfaceOne, IInterfaceTwo>();
    }
}

Желаемый результат заключается в том, что он должен сначала служить цели, а во-вторых, разрешаться в наборе служб / при его вызове.

Обновление

Спасибо за помощь.Так что я думаю, что попал в тупик того, чего я пытался достичь.Все, что я действительно хотел, это один класс поддержки, который был представлен через два интерфейса, которые можно было объединить в один общий интерфейс.Я думаю, что работает следующее:

Общий интерфейс использует два или несколько интерфейсов.

public interface ITestGenericInterface<T, U>
{
    T InterfaceOne { get; }
    U InterfaceTwo { get; }
}

public class TestGenericInterface<T, U> : ITestGenericInterface<T, U>
{
    public TestGenericInterface(T interfaceOne, U interfaceTwo)
    {
        InterfaceOne = interfaceOne;
        InterfaceTwo = interfaceTwo;
    }

    public T InterfaceOne { get; }
    public U InterfaceTwo { get; }
}

Интерфейсы с классом, который может использоваться с вышеуказанным интерфейсом.

public interface IInterfaceOne
{
    void DoOne();
    void DoTwo();
}

public interface IInterfaceTwo
{
    void DoThree();
    void DoFour();
}

public class ConcreteClass : IInterfaceOne, IInterfaceTwo
{
    public void DoOne()
    {
        Console.WriteLine("DoOne()");
    }
    public void DoTwo()
    {
        Console.WriteLine("DoTwo()");
    }

    public void DoThree()
    {
        Console.WriteLine("DoDoThreeOne()");
    }

    public void DoFour()
    {
        Console.WriteLine("DoFour()");
    }
}

Регистрация в сервисной коллекции.Я не думаю, что до этого правильно регистрировал интерфейс / реализацию, что могло быть проблемой.

  services.AddScoped<IInterfaceOne, ConcreteClass>();
  services.AddScoped<IInterfaceTwo, ConcreteClass>();
  services.AddScoped(typeof(ITestGenericInterface<,>), typeof(TestGenericInterface<,>));

Пробовать это

public interface ITestRunner
{
    void Start();
}

public class TestRunner : ITestRunner
{
    private readonly ITestGenericInterface<IInterfaceOne, IInterfaceTwo> _genericTest;

    public TestRunner(
        ITestGenericInterface<IInterfaceOne, IInterfaceTwo> genericTest
        )
    {
        _genericTest = genericTest;
    }

    public void Start()
    {
        // Interface One 
        _genericTest.InterfaceOne.DoOne();
        _genericTest.InterfaceOne.DoTwo();

        // Interface Two
        _genericTest.InterfaceTwo.DoThree();
        _genericTest.InterfaceTwo.DoFour();
    }
}

Я понимаю, что это, вероятно, было проще, чемэто прозвучало в моем первоначальном вопросе.Когда Флавио Франциско своим первым ответом поставил меня на правильный путь, я буду голосовать за него и отмечать как ответ.Надеюсь, это поможет кому-то еще.Большое спасибо.

Answer 1

Если вам нужен экземпляр класса, который реализует два интерфейса, вы можете сделать это также:

public interface IInterfaceOneAndTwo : IInterfaceOne, IInterfaceTwo
{

}

public interface IInterfaceOne
{
    void DoOne();
    void DoTwo();
}

public interface IInterfaceTwo
{
    void DoThree();
    void DoFour();
}

Ваш конкретный класс:

public class ConcreteClass : IInterfaceOneAndTwo
{
    public void DoFour()
    {
        throw new NotImplementedException();
    }

    public void DoOne()
    {
        throw new NotImplementedException();
    }

    public void DoThree()
    {
        throw new NotImplementedException();
    }

    public void DoTwo()
    {
        throw new NotImplementedException();
    }
}

и ваш преобразователь:

IInterfaceOneAndTwo concreteClass = new ConcreteClass();

concreteClass.DoOne();

Answer 2

Похоже, что вы пытаетесь сделать что-то вроде этого:

public interface IGeneric<T, U>
{
    T InterfaceOne { get; }

    U InterfaceTwo { get; }
}

public class GenericClass : IGeneric<IInterfaceOne, IInterfaceTwo>
{
    private readonly IInterfaceOne interfaceOne;
    private readonly IInterfaceTwo interfaceTwo;

    public GenericClass(IInterfaceOne interfaceOne, IInterfaceTwo interfaceTwo)
    {
        this.interfaceOne = interfaceOne;
        this.interfaceTwo = interfaceTwo;
    }

    public IInterfaceOne InterfaceOne { get { return this.interfaceOne; } }
    public IInterfaceTwo InterfaceTwo { get { return this.interfaceTwo; } }
}

public class ClassOne : IInterfaceOne
{
    public void DoOne()
    {
        throw new NotImplementedException();
    }

    public void DoTwo()
    {
        throw new NotImplementedException();
    }
}

public class ClassTwo : IInterfaceTwo
{
    public void DoFour()
    {
        throw new NotImplementedException();
    }

    public void DoThree()
    {
        throw new NotImplementedException();
    }
}

Резольвер:

       IGeneric<IInterfaceOne, IInterfaceTwo> genericClass = new GenericClass(new ClassOne(), new ClassTwo());

       genericClass.InterfaceOne.DoOne();

Надеюсь, что ты хочешь это.