MethodInfo.GetBaseDefinition Methode

Referenz

Definition

Namespace:: System.Reflection

Assembly:: System.Runtime.dll

Assembly:: System.Reflection.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: MethodInfo.cs

Quelle:: MethodInfo.cs

Quelle:: MethodInfo.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Gibt beim Überschreiben in einer abgeleiteten Klasse das MethodInfo-Objekt für die Methode in der direkten oder indirekten Basisklasse zurück, in der die durch diese Instanz dargestellte Methode zuerst deklariert wurde.

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

MethodInfo

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

Implementiert

GetBaseDefinition()

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 -Eigenschaft für DeclaringType 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 (wie in newslotbeschrieben in Common Type System) angegeben wird, 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 Base.ToString beispielsweise überschrieben Object.ToStringund Derived.ToString überschrieben Base.ToStringwird, gibt der Aufruf der GetBaseDefinition -Methode für ein MethodInfo -Objekt, das darstellt Derived.ToString , ein MethodInfo -Objekt zurück, das darstellt Object.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 bestimmen, 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 -Methode auf GetBaseDefinition :

Rufen Sie ein Type -Objekt ab, das den Typ (die Klasse oder Struktur) darstellt, der 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 im Beispiel veranschaulicht.
Rufen Sie ein MethodInfo -Objekt ab, das die Methode darstellt, an der Sie interessiert sind. Hierzu können Sie ein Array aller Methoden aus der Type.GetMethods -Methode abrufen und dann die Elemente im Array durchlaufen, oder Sie können das Objekt, das MethodInfo die Methode darstellt, direkt abrufen, indem Sie die Type.GetMethod(String) -Methode aufrufen und den Methodennamen angeben.
Rufen Sie die GetBaseDefinition -Methode auf, um den Wert des MethodInfo Objekts abzurufen, das die Basismethodendefinition darstellt.

Gilt für:

Weitere Informationen

Allgemeines Typsystem