MethodInfo.GetBaseDefinition Método

Definição

Namespace:

System.Reflection

Assembly:

System.Runtime.dll

Origem:

MethodInfo.cs

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.

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 classe. Você pode determinar o tipo no qual a primeira definição do método é encontrada recuperando o valor da DeclaringType propriedade no objeto retornado MethodInfo .

O GetBaseDefinition método se comporta da seguinte maneira:

• Se o objeto atual MethodInfo representar uma implementação de interface, o GetBaseDefinition método retornará o objeto atual MethodInfo .

• Se o objeto atual MethodInfo 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 objeto atual MethodInfo representar um método especificado com o new palavra-chave em C# ou o Shadows palavra-chave no Visual Basic (como em , conforme descrito em newslotCommon Type System), o GetBaseDefinition método retornará o objeto atualMethodInfo.

• Se o objeto atual MethodInfo 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 classe. Por exemplo, se substituir e substituir , chamar o GetBaseDefinition método em um MethodInfo objeto que representa Derived.ToString retornará um MethodInfo objeto que representa Object.ToString.Base.ToStringDerived.ToStringObject.ToStringBase.ToString

• Se o objeto atual MethodInfo representar um método que não está presente em nenhuma classe base, o GetBaseDefinition método retornará o objeto atual MethodInfo .

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 :

1. Obtenha 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 GetType do Visual Basic, como ilustra o exemplo.

2. 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 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.

3. Chame o GetBaseDefinition método para obter o valor do MethodInfo objeto que representa a definição do método base.

Confira também

• Common Type System