通用扩展方法的歧义

Question

我定义了两个接口：

// IVector.cs
public interface IVector
{
    int Size { get; }

    float this[int index] { get; set; }
}

// IMatrix.cs
public interface IMatrix
{
    int Size { get; }

    float this[int row, int column] { get; set; }
}

以及这些接口的扩展方法

// VectorExtensions.cs
public static T Add<T>(this T vector, T value) where T : struct, IVector
{
    var output = default(T);

    for (int i = 0; i < output.Size; i++)
        output[i] = vector[i] + value[i];

    return output;
}

// MatrixExtensions.cs
public static T Add<T>(this T matrix, T value) where T : struct, IMatrix
{
    var output = default(T);

    for (int i = 0; i < output.Size; i++)
        for (int j = 0; j < output.Size; j++)
            output[i, j] = vector[i, j] + value[i, j];

    return output;
}

所有类型都在同一个命名空间中。

由于某些原因，当对从IVector派生的对象调用Add（）时，编译器无法确定是使用MatrixExtensions类还是VectorExtensions类中的定义。 将扩展类之一移至其他名称空间可停止错误...但是我有点希望它们在同一名称空间中：D

为什么会这样呢？

编辑：（我不敢相信我忘记添加这个）
我应该怎么做才能解决这个问题？

Answer 1

我刚刚发现了一种使用带有默认参数的技巧在.NET 4.5中工作的奇怪方法。

/// <summary>Simple base class. Can also be an interface, for example.</summary>
public abstract class MyBase1
{
}

/// <summary>Simple base class. Can also be an interface, for example.</summary>
public abstract class MyBase2
{
}

/// <summary>Concrete class 1.</summary>
public class MyClass1 :
    MyBase1
{
}

/// <summary>Concrete class 2.</summary>
public class MyClass2 :
    MyBase2
{
}

/// <summary>Special magic class that can be used to differentiate generic extension methods.</summary>
public class Magic<TBase, TInherited>
    where TInherited : TBase
{
    private Magic()
    {
    }
}

// Extensions
public static class Extensions
{
    // Rainbows and pink unicorns happens here.
    public static T Test<T>(this T t, Magic<MyBase1, T> x = null)
        where T : MyBase1
    {
        Console.Write("1:" + t.ToString() + " ");
        return t;
    }

    // More magic, other pink unicorns and rainbows.
    public static T Test<T>(this T t, Magic<MyBase2, T> x = null)
        where T : MyBase2
    {
        Console.Write("2:" + t.ToString() + " ");
        return t;
    }
}

class Program
{
    static void Main(string[] args)
    {

        MyClass1 t1 = new MyClass1();
        MyClass2 t2 = new MyClass2();

        MyClass1 t1result = t1.Test();
        Console.WriteLine(t1result.ToString());

        MyClass2 t2result = t2.Test();
        Console.WriteLine(t2result.ToString());
    }
}

我很好奇这是否适用于MONO编译器（Mcs）有人想尝试吗？ :)

Answer 2

您有两种扩展方法，每种方法都具有相同的签名。

// VectorExtensions.cs
public static T Add<T>(this T vector, T value)

// MatrixExtensions.cs 
public static T Add<T>(this T matrix, T value)

是的，您已经在代码中提供了约束，但是约束不是签名的一部分。 因此，您有两种具有相同签名的方法，因此，两种方法都不比另一种更好，并且存在歧义性问题。

将静态扩展方法类之一移至其他名称空间的结果不同的原因是，编译器将在扩展搜索之前首先在最接近的包含名称空间中查找匹配的扩展方法。 （请参阅：C＃语言规范的7.5.5.2节[下方]。）例如，如果将MatrixExtensions移到另一个名称空间中，则现在原始名称空间中的扩展方法调用将明确解析为VectorExtensions方法，因为它是就名称空间而言最接近。 但是，这不能完全解决您的问题。 因为如果VectorExtensions是最接近的扩展方法，您仍然可以让IMatrix尝试使用VectorExtensions实现，因为同样， 约束也不是签名的一部分。

为了您的方便起见，语言规范。

7.5.5.2扩展方法调用

在以下形式之一的方法调用（第7.5.5.1节）中

expr。 标识符（）

expr。 标识符（args）

expr。 标识符<typeargs>（）

expr。 标识符<typeargs>（args）

如果调用的正常处理未找到适用的方法，则尝试将构造作为扩展方法调用进行处理。 目的是找到最佳的类型名称C，以便可以进行相应的静态方法调用：

C 。 标识符（expr）

C 。 标识符（expr，args）

C 。 标识符<typeargs>（expr）

C 。 标识符<typeargs>（expr，args）

对C的搜索如下：

• 从最接近的封闭名称空间声明开始，再到每个封闭的名称空间声明开始，以包含的编译单元结束，将连续尝试查找扩展方法候选集：
  • 如果给定的名称空间或编译单元直接包含具有扩展名Mj的非通用类型声明Ci，扩展名Mj具有名称标识符并且对于上述所需的静态方法调用是可访问的并且适用，则这些扩展方法的集合为候选集。 。
  • 如果通过使用给定名称空间或编译单元中的名称空间指令导入的名称空间直接包含具有扩展名Mj的非通用类型声明Ci，该扩展方法具有名称标识符，并且相对于上述所需的静态方法调用而言是可访问的，则适用这些扩展方法是候选集。
• 如果在任何封闭的名称空间声明或编译单元中未找到候选集，则会发生编译时错误。
• 否则，将按（第7.4.3节）中所述对候选集应用重载解析。 如果找不到单个最佳方法，则会发生编译时错误。
• C是将最佳方法声明为扩展方法的类型。 使用C作为目标，然后将方法调用作为静态方法调用处理（第7.4.4节）。 前述规则意味着实例方法优先于扩展方法，内部命名空间声明中可用的扩展方法优先于外部命名空间声明中可用的扩展方法，并且直接在命名空间中声明的扩展方法优先于导入到同一方法中的扩展方法使用using名称空间指令的名称空间

Answer 3

之所以发生这种情况，是因为在评估两种方法是否具有相同签名时未考虑泛型约束。 您实际上是在定义两个相同的添加方法。

试试这个方法：

// VectorExtensions.cs
public static T Add<T>(this T vector, IVector value) where T : struct, IVector
{
    var output = default(T);

    for (int i = 0; i < output.Size; i++)
        output[i] = vector[i] + value[i];

    return output;
}

// MatrixExtensions.cs
public static T Add<T>(this T matrix, IMatrix value) where T : struct, IMatrix
{
    var output = default(T);

    for (int i = 0; i < output.Size; i++)
        for (int j = 0; j < output.Size; j++)
            output[i, j] = vector[i, j] + value[i, j];

    return output;
}

Answer 4

约束不是签名的一部分，签名是用来确定使用哪个重载的。 在不考虑约束的情况下，您可以看到两种方法都具有相同的签名，因此模棱两可。 请参阅此处的Eric Lippert的文章： 约束不是签名的一部分 。

Answer 5

为什么会这样呢？

重载解析不会考虑约束（ IVector ， IMatrix ），因为这是您的扩展方法之间唯一的不同，它们都是模棱两可的-它们具有相同的名称和相同的通用参数。

Answer 6

再次找到我自己的答案（有点hack）：

// IVector.cs
public interface IVector<T>
    where T : IVector<T>
{
    int Size { get; }

    float this[int index] { get; set; }
}

// IMatrix.cs
public interface IMatrix<T>
    where T : IMatrix<T>
{
    int Size { get; }

    float this[int row, int column] { get; set; }
}

// VectorExtensions.cs
public T Add<T>(this IVector<T> vector, T value)
    where T : struct, IVector<T>
{
    var output = default(T);

    for (int i = 0; i < output.Size; i++)
        output[i] = vector[i] + value[i];

    return output;
}

// MatrixExtensions.cs
public static T Add<T>(this IMatrix<T> matrix, T value)
    where T : struct, IMatrix<T>
{
    var output = default(T);

    for (int i = 0; i < output.Size; i++)
        for (int j = 0; j < output.Size; j++)
            output[i, j] = vector[i, j] + value[i, j];

    return output;
}

它工作得很漂亮。 对于CRTP ：D