MethodInfo.GetBaseDefinition Methode

public:
 abstract System::Reflection::MethodInfo ^ GetBaseDefinition();

public abstract System.Reflection.MethodInfo GetBaseDefinition();

abstract member GetBaseDefinition : unit -> System.Reflection.MethodInfo

Public MustOverride Function GetBaseDefinition () As MethodInfo

Gibt zurück

Ein MethodInfo Objekt für die erste Implementierung dieser Methode.

Implementiert

Beispiele

Im folgenden Beispiel wird das Verhalten der GetBaseDefinition Methode veranschaulicht.

using System;
using System.Reflection;

interface Interf
{
   string InterfaceImpl(int n);
}

public class BaseClass
{
   public override string ToString()
   {
      return "Base";
   }

   public virtual void Method1()
   {
      Console.WriteLine("Method1");
   }

   public virtual void Method2()
   {
      Console.WriteLine("Method2");
   }

   public virtual void Method3()
   {
      Console.WriteLine("Method3");
   }
}

public class DerivedClass : BaseClass, Interf
{
   public string InterfaceImpl(int n)
   {
      return n.ToString("N");
   }

   public override void Method2()
   {
      Console.WriteLine("Derived.Method2");
   }

   public new void Method3()
   {
      Console.WriteLine("Derived.Method3");
   }
}

public class Example
{
   public static void Main()
   {
      Type t = typeof(DerivedClass);
      MethodInfo m, mb;
      string[] methodNames = { "ToString", "Equals", "InterfaceImpl",
                               "Method1", "Method2", "Method3" };

      foreach (var methodName in methodNames) {
         m = t.GetMethod(methodName);
         mb = m.GetBaseDefinition();
         Console.WriteLine("{0}.{1} --> {2}.{3}", m.ReflectedType.Name,
                           m.Name, mb.ReflectedType.Name, mb.Name);
      }
   }
}
// The example displays the following output:
//       DerivedClass.ToString --> Object.ToString
//       DerivedClass.Equals --> Object.Equals
//       DerivedClass.InterfaceImpl --> DerivedClass.InterfaceImpl
//       DerivedClass.Method1 --> BaseClass.Method1
//       DerivedClass.Method2 --> BaseClass.Method2
//       DerivedClass.Method3 --> DerivedClass.Method3

Imports System.Reflection

Interface Interf
   Function InterfaceImpl(n As Integer) As String
End Interface

Public Class BaseClass
   Public Overrides Function ToString() As String
      Return "Base"
   End Function

   Public Overridable Sub Method1()
      Console.WriteLine("Method1")
   End Sub

   Public Overridable Sub Method2()
      Console.WriteLine("Method2")
   End Sub

   Public Overridable Sub Method3()
      Console.WriteLine("Method3")
   End Sub
End Class

Public Class DerivedClass : Inherits BaseClass : Implements Interf
   Public Function InterfaceImpl(n As Integer) As String _
                   Implements Interf.InterfaceImpl
      Return n.ToString("N")
   End Function

   Public Overrides Sub Method2()
      Console.WriteLine("Derived.Method2")
   End Sub

   Public Shadows Sub Method3()
      Console.WriteLine("Derived.Method3")
   End Sub
End Class

Module Example
   Public Sub Main()
      Dim t As Type = GetType(DerivedClass)
      Dim m, mb As MethodInfo
      Dim methodNames() As String = { "ToString", "Equals",
                                      "InterfaceImpl", "Method1",
                                      "Method2", "Method3" }

      For Each methodName In methodNames
         m = t.GetMethod(methodName)
         mb = m.GetBaseDefinition()
         Console.WriteLine("{0}.{1} --> {2}.{3}", m.ReflectedType.Name,
                           m.Name, mb.ReflectedType.Name, mb.Name)
      Next
   End Sub
End Module
' The example displays the following output:
'       DerivedClass.ToString --> Object.ToString
'       DerivedClass.Equals --> Object.Equals
'       DerivedClass.InterfaceImpl --> DerivedClass.InterfaceImpl
'       DerivedClass.Method1 --> BaseClass.Method1
'       DerivedClass.Method2 --> BaseClass.Method2
'       DerivedClass.Method3 --> DerivedClass.Method3

Hinweise

Die GetBaseDefinition Methode gibt die erste Definition der angegebenen Methode in der Klassenhierarchie zurück. Sie können den Typ bestimmen, für den die erste Definition der Methode gefunden wird, indem Sie den Wert der DeclaringType Eigenschaft für das zurückgegebene MethodInfo Objekt abrufen.

Die GetBaseDefinition Methode verhält sich wie folgt:

• Wenn das aktuelle MethodInfo Objekt eine Schnittstellenimplementierung darstellt, gibt die GetBaseDefinition Methode das aktuelle MethodInfo Objekt zurück.

• Wenn das aktuelle MethodInfo Objekt eine Methode darstellt, die eine virtuelle Definition in einer Basisklasse überschreibt, gibt die GetBaseDefinition Methode ein MethodInfo Objekt zurück, das die virtuelle Definition darstellt.

• Wenn das aktuelle MethodInfo Objekt eine Methode darstellt, die mit dem new Schlüsselwort in C# oder dem Shadows Schlüsselwort in Visual Basic angegeben wird (wie in newslot, wie in Common Type System beschrieben), gibt die GetBaseDefinition Methode das aktuelle MethodInfo Objekt zurück.

• Wenn das aktuelle MethodInfo Objekt eine geerbte Methode darstellt (d. h. die aktuelle Methode stellt keine eigene Implementierung bereit), gibt die GetBaseDefinition Methode ein MethodInfo Objekt zurück, das die niedrigste Methode in der Klassenhierarchie darstellt. Wenn z. BBase.ToString. überschrieben Object.ToStringund Derived.ToString außer Kraft gesetzt wirdBase.ToString, wird die GetBaseDefinition Methode für ein MethodInfo Objekt aufgerufen, das ein MethodInfo Objekt darstellt, Derived.ToString das darstelltObject.ToString.

• Wenn das aktuelle MethodInfo Objekt eine Methode darstellt, die in keiner Basisklasse vorhanden ist, gibt die GetBaseDefinition Methode das aktuelle MethodInfo Objekt zurück.

Sie können ermitteln, ob die aktuelle Methode eine Methode in einer Basisklasse überschreibt, indem Sie die GetBaseDefinition Methode aufrufen. Im folgenden Beispiel wird eine IsOverride Methode implementiert, die dies tut.

using System;
using System.Reflection;

public class ReflectionUtilities
{   
   public static bool IsOverride(MethodInfo method)
   {
      return ! method.Equals(method.GetBaseDefinition());
   }
}

public class Example
{
   public static void Main()
   {
      MethodInfo equals = typeof(Int32).GetMethod("Equals", 
                                        new Type[] { typeof(Object) } );
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals));
      
      equals = typeof(Object).GetMethod("Equals", 
                                        new Type[] { typeof(Object) } );
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals));
   }
}
// The example displays the following output:
//       Int32.Equals is inherited: True
//       Object.Equals is inherited: False

Imports System.Reflection

Public Class ReflectionUtilities
   Public Shared Function IsOverride(method As MethodInfo) As Boolean
      Return Not method.Equals(method.GetBaseDefinition())
   End Function
End Class

Module Example
   Public Sub Main()
      Dim equals As MethodInfo = GetType(Int32).GetMethod("Equals", 
                                         { GetType(Object) } )
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals))
      
      equals = GetType(Object).GetMethod("Equals", { GetType(Object) } )
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals))
   End Sub
End Module
' The example displays the following output:
'       Int32.Equals is inherited: True
'       Object.Equals is inherited: False

So rufen Sie die GetBaseDefinition Methode auf:

1. Ruft ein Type Objekt ab, das den Typ (die Klasse oder Struktur) darstellt, die die Eigenschaft enthält. Wenn Sie mit einem Objekt (einer Instanz eines Typs) arbeiten, können Sie dessen GetType Methode aufrufen. Andernfalls können Sie den C#-Operator oder den Visual Basic GetType-Operator verwenden, wie das Beispiel veranschaulicht.

2. Rufen Sie ein MethodInfo Objekt ab, das die Methode darstellt, an der Sie interessiert sind. Sie können dies tun, indem Sie ein Array aller Methoden aus der Type.GetMethods Methode abrufen und dann die Elemente im Array durchlaufen, oder Sie können das MethodInfo Objekt abrufen, das die Methode direkt darstellt, indem Sie die Type.GetMethod(String) Methode aufrufen und den Methodennamen angeben.

3. Rufen Sie die GetBaseDefinition Methode auf, um den Wert des MethodInfo Objekts abzurufen, das die Basismethodendefinition darstellt.

Weitere Informationen

• Allgemeines Typsystem