C# 如何创建接受T或IEnumerable的泛型类型<；T>；？

假设我有一种类型：

public class Transformer<T, TResult>
    where T : IMessage
    where TResult : IMessage
{
    private Func<T, IEnumerable<TResult>> _transformer;

    public Transformer(Func<T, TResult> transformer)
    {
        _transformer = null // ?
    }

    public Transformer(Func<T, IEnumerable<TResult>> transformer)
    {
        _transformer = transformer;
    }
}

公共类转换器
其中T:IMessage
结果：IMessage
{
专用功能变压器；
公共变压器（Func变压器）
{
_transformer=null/？
}
公共变压器（Func变压器）
{
_变压器=变压器；
}
}

本质上，我想在第一个构造函数中将

Func

转换为

Func

我尝试创建一个私有内部类，该类接受

Func

，并定义了一个返回IEnumerable的方法，如下所示：

private class TransformerWrapper
{
    private readonly Func<T, TResult> _func;

    public TransformerWrapper(Func<T, TResult> func)
    {
        _func = func;
    }

    public IEnumerable<TResult> Transform<T>(T message) where T : IMessage
    {
        yield return _func(message);
    }
}

私有类TransformerRapper
{
私有只读函数_Func；
公共TransformerRapper（Func-Func）
{
_func=func；
}
公共IEnumerable转换（T消息），其中T:IMessage
{
收益返回函数（消息）；
}
}

但它并没有真正起作用。我收到一个错误，说委托有一个无效的参数-无法从T转换为T

首先，编译器错误发生了什么，其次，还有其他方法吗

更新

发布后几分钟，我找到了一个解决方案：

public Transformer(Func<T, TResult> transformer)
{
    _transformer = new TransformerWrapper<T, TResult>(transformer).Transform;
}

公共变压器（Func变压器）
{
_transformer=新的TransformerRapper（transformer）.Transform；
}

以及

私有类TransformerRapper
{
私有只读函数_Func；
公共TransformerRapper（Func-Func）
{
_func=func；
}
公共IEnumerable转换（T消息）
{
收益返回函数（消息）；
}
}

---

我仍然无法理解为什么第一个解决方案不起作用。我需要考虑一下这一点…

您正在

Transform

函数中指定一个新的泛型类型

T

。由于父类中已经定义了

T

和

TResult

，因此子类中不需要任何泛型

从方法签名中删除

和泛型限定符，它应该编译

public IEnumerable<TResult> Transform(T message)
{
    yield return _func(message);
}

public IEnumerable转换（T消息）
{
收益返回函数（消息）；
}

将内部类更改为：

    private class TransformerWrapper
    {
        private readonly Func<T, TResult> _func;

        public TransformerWrapper(Func<T, TResult> func)
        {
            _func = func;
        }

        public IEnumerable<TResult> Transform(T message)
        {
            yield return _func(message);
        }
    }
}

私有类TransformerRapper
{
私有只读函数_Func；
公共TransformerRapper（Func-Func）
{
_func=func；
}
公共IEnumerable转换（T消息）
{
收益返回函数（消息）；
}
}
}

Compile已经知道T是什么，您不需要再次约束该方法。

尝试以下方法：

public Transformer(Func<T, TResult> transformer)
{
    _transformer = t => Convert(t, transformer);
}

private static IEnumerable<TResult> Convert(T value, Func<T, TResult> transformer)
{
    yield return transformer(t);
}

公共变压器（Func变压器）
{
_变压器=t=>转换（t，变压器）；
}
专用静态IEnumerable转换（T值，Func转换器）
{
回程变压器（t）；
}

谢谢！我喜欢这种方法，因为我不需要创建包装器类。

public Transformer(Func<T, TResult> transformer)
{
    _transformer = t => Convert(t, transformer);
}

private static IEnumerable<TResult> Convert(T value, Func<T, TResult> transformer)
{
    yield return transformer(t);
}