扩展方法和编译时检查

Question

也许有点棘手，但我想知道为什么。在 System.Core.dll 的 System.Linq.Enumerable.cs 中，我们有：

public static int Count<TSource>(this IEnumerable<TSource> source);

在我的代码中，我正在做一些邪恶的事情：

namespace Test
{
   public static class Extensions
   {
     public static int Count<TSource>(this IEnumerable<TSource> source)
     {
        return -1; //evil code
     }
   }

   //commented temporarily
   //public static class CommentedExtensions
   //{
   //  public static int Count<TSource>(this IEnumerable<TSource> source)
   //  {
   //     return -2; //another evil code
   //  }
   //}

   public static void Main(string[] args)
   {
     Console.WriteLine(Enumerable.Range(0,10).Count());   // -1, evil code works
     Console.Read();
   }
}

如果我取消注释 CommentedExtensions，我会收到一个编译错误，如预期的那样显示“此调用不明确 blabla”。但为什么我第一次没有得到这个错误呢？也很暧昧啊！

编辑 经过另一次测试，我发现如果扩展方法位于不同的命名空间中，即使它们完全相同，也不会出现编译错误。为什么允许？它带来了 c# 中方法调用的不明确性。

EDIT2 我知道事实上这两个 Count 在 IL 中是不同的。事实上，它正在调用

Enumerable.Count(Enumerable.Range(0,10))

，而我的邪恶扩展方法正在调用：

MyExtension.Count(Enumerable.Range(0,10))

所以它们是不同的。但我还是觉得那味道很难闻。我们有“真正的”扩展方法吗？哪些可以阻止邪恶行为？

Answer 1

C# 语言规范 的第 7.6.5.2 节介绍了编译器如何确定哪个扩展方法在范围内，以及哪些扩展方法优先于其他方法：

搜索 C [（候选扩展方法）] 的过程如下：

• 从最接近的封闭命名空间声明开始，继续每个封闭命名空间声明，并以包含的编译单元结束，连续尝试查找扩展方法的候选集：
  • 如果给定的命名空间或编译单元直接包含具有合格扩展方法 Mj 的非泛型类型声明 Ci，则这些扩展方法的集合就是候选集
  • 如果在给定命名空间或编译单元中使用命名空间指令导入的命名空间直接包含具有合格扩展方法 Mj 的非泛型类型声明 Ci，则这些扩展方法的集合就是候选集合。

这意味着，如果您的扩展方法与调用它们的代码位于同一名称空间中，则会选择这些扩展方法。将选择封闭命名空间中的扩展方法，而不是已导入的其他命名空间。

Answer 2

看来 C# 首先在当前命名空间中查找

在本例中，IL 是

.method public hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       27 (0x1b)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldc.i4.0
  IL_0002:  ldc.i4.s   10
  IL_0004:  call       class [mscorlib]System.Collections.Generic.IEnumerable`1<int32> [System.Core]System.Linq.Enumerable::Range(int32,
                                                                                                                                  int32)
  IL_0009:  call       int32 Test.Extensions::Count<int32>(class [mscorlib]System.Collections.Generic.IEnumerable`1<!!0>)
  IL_000e:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_0013:  nop
  IL_0014:  call       int32 [mscorlib]System.Console::Read()
  IL_0019:  pop
  IL_001a:  ret
} // end of method Program::Main

如果我将 main 方法移至另一个命名空间 (XXX)，在这种情况下，编译器会将该方法解析为 System.Linq 版本

namespace Test
{
    public static class Extensions
    {
        public static int Count<TSource>(this IEnumerable<TSource> source)
        {
            return -1; //evil code
        }
    }

}

namespace XXX{

    public static class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine(Enumerable.Range(0, 10).Count());   // -1, evil code works
            Console.Read();
        }
   }
}


.method public hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       27 (0x1b)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldc.i4.0
  IL_0002:  ldc.i4.s   10
  IL_0004:  call       class [mscorlib]System.Collections.Generic.IEnumerable`1<int32> [System.Core]System.Linq.Enumerable::Range(int32,
                                                                                                                                  int32)
  IL_0009:  call       int32 [System.Core]System.Linq.Enumerable::Count<int32>(class [mscorlib]System.Collections.Generic.IEnumerable`1<!!0>)
  IL_000e:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_0013:  nop
  IL_0014:  call       int32 [mscorlib]System.Console::Read()
  IL_0019:  pop
  IL_001a:  ret
} // end of method Program::Main

要在后一个示例中显式使用您的方法，请使用

namespace XXX{
    using Test;
    public static class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine(Enumerable.Range(0, 10).Count());   // -1, evil code works
            Console.Read();
        }

    }
}

.method public hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       27 (0x1b)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldc.i4.0
  IL_0002:  ldc.i4.s   10
  IL_0004:  call       class [mscorlib]System.Collections.Generic.IEnumerable`1<int32> [System.Core]System.Linq.Enumerable::Range(int32,
                                                                                                                                  int32)
  IL_0009:  call       int32 Test.Extensions::Count<int32>(class [mscorlib]System.Collections.Generic.IEnumerable`1<!!0>)
  IL_000e:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_0013:  nop
  IL_0014:  call       int32 [mscorlib]System.Console::Read()
  IL_0019:  pop
  IL_001a:  ret
} // end of method Program::Main

Answer 3

如果您创建一个新类并将 using 添加到两个命名空间，然后使用在两个命名空间中定义的方法，则错误应该会再次出现。

扩展方法是通过命名空间来区分的，而不是通过声明它们的静态类来区分的。如果在同一命名空间中定义了两个扩展方法，则编译器可以知道采用哪两个方法。

Answer 4

我认为，您正在编写两个具有相同重载的方法，这违反了 OOP 的原则。

如果扩展方法与您使用的扩展方法位于相同的命名空间范围内，那么如果相同的扩展方法存在于 System.Core.dll 中，则它将优先于 System.Core.dll 方法（因为它是在使用位置找到的最接近的重载）。两个命名空间。

为了证明这一点，请将扩展方法名称更改为 MyCount1(...) & MyCount2(...) ，那么它应该适合你。