MethodInfo.GetBaseDefinition Metoda

Definicja

Przestrzeń nazw:

System.Reflection

Zestaw:

System.Runtime.dll

Źródło:

MethodInfo.cs

Po zastąpieniu w klasie pochodnej zwraca MethodInfo obiekt metody w bezpośrednich lub pośrednich klasach bazowych, w których 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.

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 zwróconego MethodInfo obiektu.

Metoda GetBaseDefinition działa 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 obiekt reprezentujący definicję wirtualną MethodInfo .

• Jeśli bieżący MethodInfo obiekt reprezentuje metodę określoną za pomocą słowa kluczowego new w języku C# lub słowa kluczowego Shadows w języku Visual Basic (tak jak w metodzie , zgodnie z opisem w newslotsystemie common type),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, który reprezentuje najniższą metodę MethodInfo w hierarchii klas. Jeśli na przykład Base.ToString zastępuje element , i Derived.ToString zastępuje Base.ToStringmetodę , wywołując GetBaseDefinition metodę MethodInfoMethodInfo w obiekcie, który reprezentujeDerived.ToString, zwraca obiekt, który reprezentuje Object.ToString.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 :

1. 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żesz użyć operatora C# lub operatora GetType języka Visual Basic, jak pokazano w przykładzie.

2. 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, wywołując Type.GetMethod(String) metodę i określając nazwę metody.

3. Wywołaj metodę , GetBaseDefinition aby uzyskać wartość MethodInfo obiektu reprezentującego definicję metody podstawowej.

Zobacz też

• Typowy system typów