檢測一個方法是使用反射（C＃）

Question

說我有一個基類TestBase其中I定義虛擬方法TESTME（）中重寫

class TestBase 
{ 
    public virtual bool TestMe() { } 
} 

現在我繼承這個類：

class Test1 : TestBase 
{ 
    public override bool TestMe() {} 
} 

現在，使用Reflection，我需要查找TestMe方法是否在子類中被覆蓋 - 是否有可能？

我需要什麼 - 我正在寫一個類型爲「object」的設計器可視化工具來顯示繼承的整個層次結構，並顯示在哪個級別重寫哪些虛擬方法。

Answer 1

鑑於類型Test1，可以判斷它是否有自己的 實施 聲明TestMe：

typeof(Test1).GetMethod("TestMe").DeclaringType == typeof(Test1) 

如果聲明從基類來了，這將評估假。

注意，因爲這是測試聲明，沒有真正實現，這將如果是Test1也是抽象和TestMe是抽象的返回true，因爲Test1將有自己的聲明。如果你想排除這種情況下，添加&& !GetMethod("TestMe").IsAbstract

Answer 2

有一個更好，更安全，更快的方式來做到這一點。 如果您的類實例將具有較長的壽命並且IsOverridden檢查必須執行多次，此技術纔有意義。

爲了解決這個問題，我們可以使用緩存和C＃委託，比反射快得多！

// Author: Salvatore Previti - 2011. 

/// <summary>We need a delegate type to our method to make this technique works.</summary> 
delegate int MyMethodDelegate(string parameter); 

/// <summary>An enum used to mark cache status for IsOverridden.</summary> 
enum OverriddenCacheStatus 
{ 
    Unknown, 
    NotOverridden, 
    Overridden 
} 

public class MyClassBase 
{ 
    /// <summary>Cache for IsMyMethodOverridden.</summary> 
    private volatile OverriddenCacheStatus pMyMethodOverridden; 

    public MyClassBase() 
    { 
     // Look mom, no overhead in the constructor! 
    } 

    /// <summary> 
    /// Returns true if method MyMethod is overridden; False if not. 
    /// We have an overhead the first time this function is called, but the 
    /// overhead is a lot less than using reflection alone. After the first time 
    /// this function is called, the operation is really fast! Yeah! 
    /// This technique works better if IsMyMethodOverridden() should 
    /// be called several times on the same object. 
    /// </summary> 
    public bool IsMyMethodOverridden() 
    { 
     OverriddenCacheStatus v = this.pMyMethodOverridden; 
     switch (v) 
     { 
      case OverriddenCacheStatus.NotOverridden: 
       return false; // Value is cached! Faaast! 

      case OverriddenCacheStatus.Overridden: 
       return true; // Value is cached! Faaast! 
     } 

     // We must rebuild cache. 
     // We use a delegate: also if this operation allocates a temporary object 
     // it is a lot faster than using reflection! 

     // Due to "limitations" in C# compiler, we need the type of the delegate! 
     MyMethodDelegate md = this.MyMethod; 

     if (md.Method.DeclaringType == typeof(MyClassBase)) 
     { 
      this.pMyMethodOverridden = OverriddenCacheStatus.NotOverridden; 
      return false; 
     } 

     this.pMyMethodOverridden = OverriddenCacheStatus.Overridden; 
     return true; 
    } 

    /// <summary>Our overridable method. Can be any kind of visibility.</summary> 
    protected virtual int MyMethod(string parameter) 
    { 
     // Default implementation 
     return 1980; 
    } 

    /// <summary>Demo function that calls our method and print some stuff.</summary> 
    public void DemoMethod() 
    { 
     Console.WriteLine(this.GetType().Name + " result:" + this.MyMethod("x") + " overridden:" + this.IsMyMethodOverridden()); 
    } 
} 

public class ClassSecond : 
    MyClassBase 
{ 
} 

public class COverridden : 
    MyClassBase 
{ 
    protected override int MyMethod(string parameter) 
    { 
     return 2011; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     MyClassBase a = new MyClassBase(); 
     a.DemoMethod(); 

     a = new ClassSecond(); 
     a.DemoMethod(); 

     a = new COverridden(); 
     a.DemoMethod(); 

     Console.ReadLine(); 
    } 
} 

當你運行這個程序作爲一個控制檯應用程序，它會打印：

MyClassBase result:1980 overridden:False 
ClassSecond result:1980 overridden:False 
COverridden result:2011 overridden:True 

測試與Visual Studio 2010，C＃4.0。 應該也適用於以前的版本，但是由於在新版本中對代表進行了優化，所以它在C＃上的速度可能會稍微慢一點，所以關於這方面的測試將不勝感激:) 但是它仍然比使用反射更快！

Answer 3

一個簡單的解決方案還將爲保護成員和屬性的作用如下：

var isDerived = typeof(Test1).GetMember("TestMe", 
       BindingFlags.NonPublic 
      | BindingFlags.Instance 
      | BindingFlags.DeclaredOnly).Length == 0; 

這就是我的回答here，而這又對這個問題做參考的重新發布。

Answer 4

也適用於一些不平凡例方法：

public bool Overrides(MethodInfo baseMethod, Type type) 
{ 
    if(baseMethod==null) 
     throw new ArgumentNullException("baseMethod"); 
    if(type==null) 
     throw new ArgumentNullException("type"); 
    if(!type.IsSubclassOf(baseMethod.ReflectedType)) 
     throw new ArgumentException(string.Format("Type must be subtype of {0}",baseMethod.DeclaringType)); 
    while(type!=baseMethod.ReflectedType) 
    { 
     var methods=type.GetMethods(BindingFlags.Instance| 
            BindingFlags.DeclaredOnly| 
            BindingFlags.Public| 
            BindingFlags.NonPublic); 
     if(methods.Any(m=>m.GetBaseDefinition()==baseMethod)) 
      return true; 
     type=type.BaseType; 
    } 
    return false; 
} 

而一些醜陋的測試：

public bool OverridesObjectEquals(Type type) 
{ 
    var baseMethod=typeof(object).GetMethod("Equals", new Type[]{typeof(object)}); 
    return Overrides(baseMethod,type); 
} 

void Main() 
{ 
    (OverridesObjectEquals(typeof(List<int>))==false).Dump(); 
    (OverridesObjectEquals(typeof(string))==true).Dump(); 
    (OverridesObjectEquals(typeof(Hider))==false).Dump(); 
    (OverridesObjectEquals(typeof(HiderOverrider))==false).Dump(); 
    (OverridesObjectEquals(typeof(Overrider))==true).Dump(); 
    (OverridesObjectEquals(typeof(OverriderHider))==true).Dump(); 
    (OverridesObjectEquals(typeof(OverriderNothing))==true).Dump(); 
} 

class Hider 
{ 
    public virtual new bool Equals(object o) 
    { 
     throw new NotSupportedException(); 
    } 
} 


class HiderOverrider:Hider 
{ 
    public override bool Equals(object o) 
    { 
     throw new NotSupportedException(); 
    } 
} 

class Overrider 
{ 
    public override bool Equals(object o) 
    { 
     throw new NotSupportedException(); 
    } 
} 


class OverriderHider:Overrider 
{ 
    public new bool Equals(object o) 
    { 
     throw new NotSupportedException(); 
    } 
} 

class OverriderNothing:Overrider 
{ 

} 

Answer 5

由於@CiprianBortos指出，接受的答案是不完整的，並且將導致如果您按原樣使用它，則會在代碼中出現令人討厭的錯誤。

他的評論提供了神奇的解決方案GetBaseDefinition()，但有沒有必要檢查​​如果你想要一個通用IsOverride檢查（我認爲這是這個問題的點），只是methodInfo.GetBaseDefinition() != methodInfo。

或者，作爲MethodInfo擴展方法提供的，我認爲這將這樣的伎倆：

public static class MethodInfoUtil 
{ 
    public static bool IsOverride(this MethodInfo methodInfo) 
    { 
     return (methodInfo.GetBaseDefinition() != methodInfo); 
    } 
} 

Answer 6

我無法得到Ken Beckett's proposed solution工作。這就是我所定下的：

public static bool IsOverride(MethodInfo m) { 
     return m.GetBaseDefinition().DeclaringType != m.DeclaringType; 
    } 

在the gist有測試。

Answer 7

根據this answer那裏也可以是一個簡單的方法來檢查一個虛擬方法重寫而無需使用用於測試的MethodAttributes.NewSlot屬性知道確切的衍生或基本類型：

public static bool HasOverride(this MethodInfo method) 
{ 
    return (method.Attributes & MethodAttributes.Virtual) != 0 && 
      (method.Attributes & MethodAttributes.NewSlot) == 0; 
} 

連同另一部分方法

private const BindingFlags Flags = BindingFlags.NonPublic | 
    BindingFlags.Public | BindingFlags.Instance; 

public static bool HasOverride(this Type type, string name, params Type[] argTypes) 
{ 
    MethodInfo method = type.GetMethod(name, Flags, null, CallingConventions.HasThis, 
     argTypes, new ParameterModifier[0]); 
    return method != null && method.HasOverride(); 
} 

然後你可以簡單地調用

bool hasOverride = GetType().HasOverride(nameof(MyMethod), typeof(Param1Type), 
    typeof(Param2Type), ...); 

檢查MyMethod是否在派生類中被覆蓋。

據我測試這個，它似乎工作正常（在我的機器上）。