MethodInfo.GetBaseDefinition Método

Referência

Definição

Namespace:: System.Reflection

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: System.Reflection.dll

Assembly:: mscorlib.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Quando substituído em uma classe derivada, retorna o objeto MethodInfo para o método sobre a classe base direta ou indireta em que o método representado por esta instância foi declarado.

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

Retornos

MethodInfo

Um objeto MethodInfo para a primeira implementação deste método.

Implementações

GetBaseDefinition()

Exemplos

O exemplo a seguir demonstra o comportamento do 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

Comentários

O GetBaseDefinition método retorna a primeira definição do método especificado na hierarquia de classes. Você pode determinar o tipo no qual a primeira definição do método é encontrada, recuperando o valor da DeclaringType propriedade no MethodInfo objeto retornado.

O GetBaseDefinition método se comporta da seguinte maneira:

Se o MethodInfo objeto atual representar uma implementação de interface, o GetBaseDefinition método retornará o MethodInfo objeto atual.
Se o MethodInfo objeto atual representar um método que substitui uma definição virtual em uma classe base, o GetBaseDefinition método retornará um MethodInfo objeto que representa a definição virtual.
se o MethodInfo objeto atual representar um método que é especificado com a new palavra-chave em C# ou Shadows com a palavra-chave em Visual Basic (como no newslot , conforme descrito em sistema de tipos comum), o GetBaseDefinition método retorna o MethodInfo objeto atual.
Se o MethodInfo objeto atual representa um método herdado (ou seja, o método atual não fornece sua própria implementação), o GetBaseDefinition método retorna um MethodInfo objeto que representa o método mais baixo na hierarquia de classes. Por exemplo, se Base.ToString substituições Object.ToString e Derived.ToString substituições Base.ToString , chamar o GetBaseDefinition método em um MethodInfo objeto que representa Derived.ToString retorna um MethodInfo objeto que representa Object.ToString .
Se o MethodInfo objeto atual representar um método que não está presente em nenhuma classe base, o GetBaseDefinition método retornará o MethodInfo objeto atual.

Você pode determinar se o método atual substitui um método em uma classe base chamando o GetBaseDefinition método. O exemplo a seguir implementa um IsOverride método que faz isso.

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 chamar o GetBaseDefinition método:

Obtém um Type objeto que representa o tipo (a classe ou estrutura) que contém a propriedade. Se você estiver trabalhando com um objeto (uma instância de um tipo), poderá chamar seu GetType método. caso contrário, você pode usar o operador C# ou o operador Visual Basic GetType , como ilustra o exemplo.
Obtenha um MethodInfo objeto que representa o método no qual você está interessado. Você pode fazer isso obtendo uma matriz de todos os métodos do Type.GetMethods método e, em seguida, iterando os elementos na matriz, ou pode recuperar o MethodInfo objeto que representa o método diretamente chamando o Type.GetMethod(String) método e especificando o nome do método.
Chame o GetBaseDefinition método para obter o valor do MethodInfo objeto que representa a definição do método base.

Aplica-se a

Confira também

Common Type System