Question

我很难解决C＃中的问题。

在我正在进行的项目中，有一些consumable类存储信息，有consumer个类使用这些消耗类。

我以这样简单的方式复制了这件事：

using System;
using System.Collections.Generic;

interface IBase
{
    int x {get;}
}

class BaseClass : IBase
{
    public int x {get; set;}
}

interface IDerived : IBase
{
    int y {get;}
}

class DerivedClass : BaseClass, IDerived
{
    public int y {get; set;}
}

interface IConsumer<in T> where T: class, IBase
{
    void Feed(T arg);
}

class BaseConsumer : IConsumer<IBase>
{
    public void Feed(IBase arg)
    {
        Console.WriteLine(arg.x);
    }
}

class DerivedConsumer : IConsumer<IDerived>
{
    public void Feed(IDerived arg)
    {
        Console.WriteLine(arg.y);       
    }
}

public class Program
{
    public static void Main()
    {
        List<IConsumer<IDerived>> consumers = new List<IConsumer<IDerived>>();
        consumers.Add(new BaseConsumer());
        consumers.Add(new DerivedConsumer());

        DerivedClass d = new DerivedClass() { x = 3, y = 5};

        foreach (IConsumer<IDerived> consumer in consumers)
            consumer.Feed(d);
    }
}

这完全没问题。但是，我也希望有一些middle个使用者，它在构造函数（或其他方法）中使用另一个consumer对象，它将Feed调用重定向到对象。例如：

class MiddleConsumer<T> : IConsumer<T> where T : class, IBase
{
    private IConsumer<T> _consumer;
    public MiddleConsumer(IConsumer<T> consumer)
    {
        _consumer = consumer;
    }

    public void Feed(T arg)
    {
        _consumer.Feed(arg);
    }
}

我会像这样使用它：

consumers.Add(new MiddleConsumer<IBase>(new BaseConsumer());
consumers.Add(new MiddleConsumer<IDerived>(new DerivedConsumer());

但我会将MiddleConsumer与其他具体Consumer类一起使用，例如BaseConsumer和DerivedConsumer。因此，我不必明确指定T参数，它可以从实际的Consumer类型中获取它。让我澄清一下。我想要这样的东西:(注意这不是有效的C＃代码）

class MiddleConsumer<IConsumer<T>> : IConsumer<T>
{
    private IConsumer<T> _consumer;
    public MiddleConsumer(IConsumer<T> consumer)
    {
        _consumer = consumer;
    }

    public void Feed(IDerived arg)
    {
        _consumer.Feed(arg);
    }
}

然而， - 按预期 - 由于具有奇怪的通用参数，这不起作用。

我希望能够使用消费者创建一个MiddleConsumer对象，我不知道它的基本类型。我的意思是，我希望能够做到这一点：

consumers.Add(new MiddleConsumer<BaseConsumer>(new BaseConsumer());
consumers.Add(new MiddleConsumer<DerivedConsumer>(new DerivedConsumer());

我不希望每次要将其与BaseConsumer一起使用时检查基本类型 - 例如MiddleConsumer，因为编译器可以在我使用时查看它带有Consumer的{{1}}。请注意，可能有许多不同的MiddleConsumer类。

我的问题是：有没有办法让C＃编译器从其通用参数中推断Consumer的消耗类型？

感谢您的帮助！

Answer 1

C＃不支持构造函数的类型推断，但你可以做的是通过静态方法委托对构造函数的调用：

public static class MiddleConsumer
{
    public static MiddleConsumer<T> Create<T>( IConsumer<T> consumer ) where T : class, IBase
    {
        return new MiddleConsumer<T>( consumer );
    }
}

现在你根本不需要指定泛型参数：

consumers.Add(MiddleConsumer.Create(new BaseConsumer());

访问泛型参数的泛型参数？

1 个答案: