被类覆盖的扩展方法不会给出警告

Question

我在另一个线程中进行了讨论，发现类方法优先于具有相同名称和参数的扩展方法。这很好，因为扩展方法不会劫持方法，但假设您已向第三方库添加了一些扩展方法：

public class ThirdParty
{
}

public static class ThirdPartyExtensions
{
    public static void MyMethod(this ThirdParty test)
    {
        Console.WriteLine("My extension method");
    }
}

按预期工作：ThirdParty.MyMethod -> “我的扩展方法”

但随后 ThirdParty 更新了它的库并添加了一个与您的扩展方法完全相同的方法：

public class ThirdParty
{
    public void MyMethod()
    {
        Console.WriteLine("Third party method");
    }
}

public static class ThirdPartyExtensions
{
    public static void MyMethod(this ThirdParty test)
    {
        Console.WriteLine("My extension method");
    }
}

ThirdPart.MyMethod -> “第三方方法”

现在突然代码在运行时的行为会有所不同，因为第三方方法“劫持”了您的扩展方法！编译器不会给出任何警告。

有没有办法启用此类警告或以其他方式避免这种情况？

Answer 1

减少发生这种情况的可能性的一种可能方法是在扩展方法名称的末尾包含缩写 Ext。我知道，这非常丑陋，但它减少了发生这种情况的机会。

MyMethod_Ext

或者

MyMethodExt

Answer 2

我喜欢乔恩的回答，但还有另一种类似于丹尼尔的方法。如果您有很多扩展方法，您可以定义某种“命名空间”。如果您有一个稳定的工作界面（即，如果您知道 IThirdParty 不会改变），那么这种方法效果最好。但是，就您而言，您需要一个包装类。

我这样做是为了添加将字符串视为文件路径的方法。我定义了一个 FileSystemPath 类型，它包装了一个 string 并提供了 IsAbsolute 和 ChangeExtension 等属性和方法。

定义“扩展命名空间”时，您需要提供一种进入它的方法和一种离开它的方法，如下所示：

// Enter my special namespace
public static MyThirdParty AsMyThirdParty(this ThirdParty source) { ... }

// Leave my special namespace
public static ThirdParty AsThirdParty(this MyThirdParty source) { ... }

“离开”“命名空间”的方法作为实例方法而不是扩展方法可能会更好。我的 FileSystemPath 只是隐式转换为 string，但这并不在所有情况下都有效。

如果您希望 MyThirdParty 拥有 ThirdParty 当前定义的所有成员以及扩展方法（但不包含 ThirdParty 未来定义的成员） )，那么您必须将成员实现转发到包装的 ThirdParty 对象。这可能很乏味，但像 ReSharper 这样的工具可以半自动地完成它。

最后注意：进入/离开命名空间时的“As”前缀是一种不言而喻的准则。 LINQ 使用此系统（例如，AsEnumerable、AsQueryable、AsParallel 离开当前“命名空间”并输入另一个）。

今年年初，我写了一篇博客文章，内容涉及我所说的内容“基于扩展的类型。”除了无法重写实例方法之外，还有更多的陷阱。然而，这是一个非常有趣的概念。

Answer 3

不——这是扩展方法的一个已知缺点，需要非常小心。就我个人而言，我希望如果您声明了一个除了通过正常静态路由 (ExtensionClassName.MethodName(target, ...)) 之外永远不会被调用的扩展方法，C# 编译器会向您发出警告。

编写一个小工具来检查程序集中的所有扩展方法并以这种方式发出警告可能不会太难。一开始可能不需要非常精确：如果已经存在同名的方法（无需担心参数类型），只需发出警告即可是一个好的开始。

编辑：好的...这是一个非常粗糙的工具，至少可以提供一个起点。它似乎至少在某种程度上可以与泛型类型一起工作 - 但它并没有尝试对参数类型或名称执行任何操作......部分原因是这对于参数数组来说变得很棘手。它还“完全”加载程序集，而不是仅通过反射加载程序集，这会更好 - 我尝试了“正确的”路线，但遇到了一些无法立即解决的问题，因此又回到了快速而肮脏的路线： ）

无论如何，希望它对某个地方的某人有用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;

public class ExtensionCollisionDetector
{
    private static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine
                ("Usage: ExtensionCollisionDetector <assembly file> [...]");
            return;
        }
        foreach (string file in args)
        {
            Console.WriteLine("Testing {0}...", file);
            DetectCollisions(file);
        }
    }

    private static void DetectCollisions(string file)
    {
        try
        {
            Assembly assembly = Assembly.LoadFrom(file);
            foreach (var method in FindExtensionMethods(assembly))
            {
                DetectCollisions(method);
            }
        }
        catch (Exception e)
        {
            // Yes, I know catching exception is generally bad. But hey,
            // "something's" gone wrong. It's not going to do any harm to
            // just go onto the next file.
            Console.WriteLine("Error detecting collisions: {0}", e.Message);
        }
    }

    private static IEnumerable<MethodBase> FindExtensionMethods
        (Assembly assembly)
    {
        return from type in assembly.GetTypes()
               from method in type.GetMethods(BindingFlags.Static |
                                              BindingFlags.Public |
                                              BindingFlags.NonPublic)
               where method.IsDefined(typeof(ExtensionAttribute), false)
               select method;
    }


    private static void DetectCollisions(MethodBase method)
    {
        Console.WriteLine("  Testing {0}.{1}", 
                          method.DeclaringType.Name, method.Name);
        Type extendedType = method.GetParameters()[0].ParameterType;
        foreach (var type in GetTypeAndAncestors(extendedType).Distinct())
        {
            foreach (var collision in DetectCollidingMethods(method, type))
            {
                Console.WriteLine("    Possible collision in {0}: {1}",
                                  collision.DeclaringType.Name, collision);
            }
        }
    }

    private static IEnumerable<Type> GetTypeAndAncestors(Type type)
    {
        yield return type;
        if (type.BaseType != null)
        {
            // I want yield foreach!
            foreach (var t in GetTypeAndAncestors(type.BaseType))
            {
                yield return t;
            }
        }
        foreach (var t in type.GetInterfaces()
                              .SelectMany(iface => GetTypeAndAncestors(iface)))
        {
            yield return t;
        }        
    }

    private static IEnumerable<MethodBase>
        DetectCollidingMethods(MethodBase extensionMethod, Type type)
    {
        // Very, very crude to start with
        return type.GetMethods(BindingFlags.Instance |
                               BindingFlags.Public |
                               BindingFlags.NonPublic)
                   .Where(candidate => candidate.Name == extensionMethod.Name);
    }
}