MethodInfo.GetBaseDefinition Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Reflection

Zestaw:: System.Runtime.dll

Zestaw:: System.Reflection.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Po zastąpieniu w klasie pochodnej zwraca MethodInfo obiekt dla metody w bezpośrednich lub pośrednich klasach bazowych, w której metoda reprezentowana przez to wystąpienie została po raz pierwszy zadeklarowana.

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

Zwraca

MethodInfo

MethodInfo Obiekt dla pierwszej implementacji tej metody.

Implementuje

GetBaseDefinition()

Przykłady

W poniższym przykładzie pokazano zachowanie GetBaseDefinition metody .

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

Uwagi

Metoda GetBaseDefinition zwraca pierwszą definicję określonej metody w hierarchii klas. Można określić typ, na którym znajduje się pierwsza definicja metody, pobierając wartość DeclaringType właściwości dla zwróconego MethodInfo obiektu.

Metoda GetBaseDefinition zachowuje się w następujący sposób:

Jeśli bieżący MethodInfo obiekt reprezentuje implementację interfejsu, GetBaseDefinition metoda zwraca bieżący MethodInfo obiekt.
Jeśli bieżący MethodInfo obiekt reprezentuje metodę, która zastępuje definicję wirtualną w klasie bazowej, GetBaseDefinition metoda zwraca MethodInfo obiekt reprezentujący definicję wirtualną.
Jeśli bieżący MethodInfo obiekt reprezentuje metodę określoną za pomocą słowa kluczowego new w języku C# lub Shadows słowa kluczowego w Visual Basic (jak opisano w newslotsekcji Common Type System), GetBaseDefinition metoda zwraca bieżący MethodInfo obiekt.
Jeśli bieżący MethodInfo obiekt reprezentuje metodę dziedziczona (czyli bieżąca metoda nie zapewnia własnej implementacji), GetBaseDefinition metoda zwraca obiekt reprezentujący najniższą MethodInfo metodę w hierarchii klas. Jeśli na przykład Base.ToString zastąpi metodę , i Derived.ToString Base.ToStringzastępuje metodę , wywołując GetBaseDefinition metodę w obiekcie reprezentującym Derived.ToString MethodInfo MethodInfo zwraca obiekt reprezentujący obiekt reprezentujący Object.ToStringobiekt .Object.ToString
Jeśli bieżący MethodInfo obiekt reprezentuje metodę, która nie istnieje w żadnej klasie bazowej, GetBaseDefinition metoda zwraca bieżący MethodInfo obiekt.

Można określić, czy bieżąca metoda zastępuje metodę w klasie bazowej, wywołując metodę GetBaseDefinition . Poniższy przykład implementuje metodę IsOverride , która to robi.

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

Aby wywołać metodę GetBaseDefinition :

Pobierz obiekt reprezentujący typ (klasę Type lub strukturę), który zawiera właściwość . Jeśli pracujesz z obiektem (wystąpieniem typu), możesz wywołać jego GetType metodę. W przeciwnym razie można użyć operatora C# lub operatora Visual Basic GetType, jak pokazano w przykładzie.
Pobierz obiekt reprezentujący metodę MethodInfo , w której cię interesuje. Można to zrobić, pobierając tablicę wszystkich metod z Type.GetMethods metody, a następnie iterując elementy w tablicy, lub możesz pobrać MethodInfo obiekt reprezentujący metodę bezpośrednio przez wywołanie Type.GetMethod(String) metody i określenie nazwy metody.
Wywołaj metodę , GetBaseDefinition aby uzyskać wartość MethodInfo obiektu reprezentującego definicję metody podstawowej.

Dotyczy

Zobacz też

System typu wspólnego