IEnumerable 的转换对于扩展方法问题

Question

我有以下类和扩展类（对于本例）：

public class Person<T>
{
    public T Value { get; set; }
}

public static class PersonExt
{
    public static void Process<TResult>(this Person<IEnumerable<TResult>> p)
    {
        // Do something with .Any().
        Console.WriteLine(p.Value.Any());
    }
}

我期望我可以编写类似以下内容的内容并且它会起作用，但它不起作用：

var x = new Person<List<String>>();
x.Process();

由于 List 在继承树中比 IEnumerable 更低，所以不应该这样有效吗？当然，如果我新建一个 Person> ，它就会起作用，因为那是直接类型。

我正在尝试使用一种扩展方法，只要 T 实现 IEnumerable，就可以应用于所有 Person，因为我需要使用.Any() 方法。

编辑：也许我对协方差的理解不正确？我知道 IEnumerable 应该转换为 IEnumerable

EDIT2：忘记提及我正在使用 .net 4.0。

Answer 1

我知道 IEnumerable 应该
转换为 IEnumerable

IList 可以转换为 IEnumerable。问题是您试图将 Person> 转换为 Person>，这是非法的。例如，这样写是完全有效的：

var x = new Person<IEnumerable<String>>();
x.Value = new string[0];

因为 Value 的类型是 IEnumerable，而字符串数组是 IEnumerable。但是，您不能编写：

var x = new Person<List<String>>();
x.Value = new string[0];

因为 Value 的类型为 List。由于您不能在所有可以使用 Person> 的地方使用 Person>，因此它不是合法的投掷。

请注意，如果您向扩展方法添加第二个类型参数，您可以执行类似于您想要的操作：

public static void Process<TResult, TList>(this Person<TList> p)
    where TList : IEnumerable<TResult>
{
    Console.WriteLine(p.Value.Any());
}

不幸的是，编译器将无法推断这两个类型参数，因此您必须像这样调用它：

var x = new Person<List<String>>();
x.Process<String, List<String>>();

如果您使用 C# 4.0 并且可以使用协变，那么您可以为 person 定义一个协变接口：

public interface IPerson<out T>
{
    T Value { get; }
}

public class Person<T>
    : IPerson<T>
{
    public T Value { get; set; }
}

然后将您的扩展方法编写为：

public static void Process<TResult>(this IPerson<IEnumerable<TResult>> p)
{
    // Do something with .Any().
    Console.WriteLine(p.Value.Any());
}

由于 IPerson.Value 被读取-仅，IPerson> 可以在 IPerson> 可以使用的任何地方使用，并且转换有效。

Answer 2

我不确定您是否已经完全掌握了泛型的正确用法。无论如何......

唯一不正确的是你的扩展方法的声明，以及你试图约束扩展方法的方式。

public static class ThingExtensions
{
    public static void Process<T>(this Thing<T> p)
        where T : IEnumerable<string>
    {
        // Do something with .Any().
        Console.WriteLine(p.Value.Any());
    }
}

我真正所做的就是将 Person 重命名为 Thing，这样我们就不会纠结于 Person>确实是。

public class Thing<T>
{
    public T Value { get; set; }
}

class ListOfString : List<string>
{ }

class Program
{
    static void Main(string[] args)
    {
        var x = new Thing<ListOfString>();
        x.Value = new ListOfString();
        x.Process();

        x.Value.Add("asd");
        x.Process();


        var x2 = new Thing<int>();
        // Error    1   The type 'int' cannot be used as type parameter 'T' 
        // in the generic type or method 
        // 'ThingExtensions.Process<T>(Thing<T>)'. 
        // There is no boxing conversion from 'int' to 
        // 'System.Collections.Generic.IEnumerable<string>'.    
        //x2.Process();

        Console.Read();
    }
}

如果更适用，您还可以将通用约束移至 Thing。

Answer 3

您提到了协方差，但实际上并没有使用它。您必须在通用参数上指定 in 或 out。请注意，协/逆变不适用于类类型；它们必须应用于接口。

因此，引入一个接口并使其协变：

public interface IPerson<out T>
{
  T Value { get; }
}

public class Person<T> : IPerson<T>
{
  public T Value { get; set; }
}

public static class PersonExt
{
  public static void Process<TResult>(this IPerson<IEnumerable<TResult>> p)
  {
    // Do something with .Any(). 
    Console.WriteLine(p.Value.Any());
  }
}

允许此代码编译：

var x = new Person<List<String>>();  
x.Process();