MethodInfo.GetBaseDefinition Método

Referencia

Definición

Espacio de nombres:: System.Reflection

Ensamblado:: System.Runtime.dll

Ensamblado:: System.Reflection.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Source:: MethodInfo.cs

Source:: MethodInfo.cs

Source:: MethodInfo.cs

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Cuando se reemplaza en una clase derivada, se devuelve el objeto MethodInfo del método en la clase base directa o indirecta en la que se declaró por primera vez el método representado mediante esta instancia.

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

Devoluciones

MethodInfo

Objeto MethodInfo para la primera implementación de este método.

Implementaciones

GetBaseDefinition()

Ejemplos

En el ejemplo siguiente se muestra el comportamiento del GetBaseDefinition método .

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

Comentarios

El GetBaseDefinition método devuelve la primera definición del método especificado en la jerarquía de clases. Puede determinar el tipo en el que se encuentra la primera definición del método recuperando el valor de la DeclaringType propiedad en el objeto devuelto MethodInfo .

El GetBaseDefinition método se comporta de la siguiente manera:

Si el objeto actual MethodInfo representa una implementación de interfaz, el GetBaseDefinition método devuelve el objeto actual MethodInfo .
Si el objeto actual MethodInfo representa un método que invalida una definición virtual en una clase base, el GetBaseDefinition método devuelve un MethodInfo objeto que representa la definición virtual.
Si el objeto actual MethodInfo representa un método especificado con la new palabra clave en C# o la Shadows palabra clave en Visual Basic (como en newslot, como se describe en Common Type System), el GetBaseDefinition método devuelve el objeto actual MethodInfo .
Si el objeto actual MethodInfo representa un método heredado (es decir, el método actual no proporciona su propia implementación), el GetBaseDefinition método devuelve un MethodInfo objeto que representa el método más bajo de la jerarquía de clases. Por ejemplo, si Base.ToString invalida Object.ToStringy Derived.ToString invalida Base.ToString, llamando al GetBaseDefinition método en un MethodInfo objeto que representa Derived.ToString devuelve un MethodInfo objeto que representa Object.ToString.
Si el objeto actual MethodInfo representa un método que no está presente en ninguna clase base, el GetBaseDefinition método devuelve el objeto actual MethodInfo .

Puede determinar si el método actual invalida un método en una clase base llamando al GetBaseDefinition método . En el ejemplo siguiente se implementa un IsOverride método que lo hace.

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

Para llamar al GetBaseDefinition método :

Obtiene un Type objeto que representa el tipo (la clase o estructura) que contiene la propiedad . Si está trabajando con un objeto (una instancia de un tipo), puede llamar a su GetType método . De lo contrario, puede usar el operador de C# o el operador GetType de Visual Basic, como se muestra en el ejemplo.
Obtenga un MethodInfo objeto que represente el método en el que está interesado. Para ello, puede obtener una matriz de todos los métodos del Type.GetMethods método y, a continuación, iterar los elementos de la matriz, o puede recuperar el MethodInfo objeto que representa el método directamente llamando al Type.GetMethod(String) método y especificando el nombre del método.
Llame al GetBaseDefinition método para obtener el valor del MethodInfo objeto que representa la definición del método base.

Se aplica a

Consulte también

Sistema de tipos comunes

Compartir a través de