0

我很难解决 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的 s 类型中获取它。让我澄清一下。我想要这样的东西：（注意这不是有效的 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);
    }
}

但是， - 正如预期的那样 - 由于具有那个奇怪的通用参数，这不起作用。

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

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

我不想BaseConsumer每次使用 with 时都检查 -for example- 的基本类型，因为当我使用withMiddleConsumer时编译器只能查看它。请注意，可能有几十个不同的类。ConsumerMiddleConsumerConsumer

我的问题是：有没有办法让 C# 编译器MiddleConsumer从它的泛型参数中推断出可消耗的类型？

谢谢您的帮助！

4

1 回答 1

0

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());
于 2015-07-01T16:10:43.373 回答