MethodInfo.GetBaseDefinition Método

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

Devoluções

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

Implementações

Exemplos

O exemplo seguinte 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

Observações

O GetBaseDefinition método retorna a primeira definição do método especificado na hierarquia de classes. Pode determinar o tipo em que se encontra a primeira definição do método recuperando o valor da DeclaringType propriedade no objeto devolvido MethodInfo .

O GetBaseDefinition método comporta-se da seguinte forma:

• Se o objeto atual MethodInfo representa uma implementação de interface, o GetBaseDefinition método devolve o objeto atual MethodInfo .

• Se o objeto atual MethodInfo representa um método que sobrepõe uma definição virtual numa classe base, o GetBaseDefinition método devolve um MethodInfo objeto que representa a definição virtual.

• Se o objeto atual MethodInfo representar um método especificado com a palavra-chave new em C# ou a palavra-chave Shadows em Visual Basic (como em newslot, conforme descrito em Common Type System), o método GetBaseDefinition devolve o objeto atual MethodInfo.

• Se o objeto atual MethodInfo representa um método herdado (ou seja, o método atual não fornece a sua própria implementação), o GetBaseDefinition método devolve um MethodInfo objeto que representa o método mais baixo na hierarquia de classes. Por exemplo, se Base.ToString sobrescreve Object.ToString, e Derived.ToString sobrepõe Base.ToString, chamar o GetBaseDefinition método num MethodInfo objeto que representa Derived.ToString devolve um MethodInfo objeto que representa Object.ToString.

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

Pode determinar se o método atual sobrepõe um método numa classe base chamando o GetBaseDefinition método. O exemplo seguinte implementa um IsOverride método que faz isto.

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

1. Obtenha um Type objeto que represente o tipo (a classe ou estrutura) que contém a propriedade. Se estiver a trabalhar com um objeto (uma instância de um tipo), pode chamar o seu GetType método. Caso contrário, pode usar o operador C# ou o operador Visual Basic GetType, como o exemplo ilustra.

2. Escolhe um MethodInfo objeto que represente o método que te interessa. Pode fazer isto obtendo um array de todos os Type.GetMethods métodos do método e depois iterando os elementos do array, 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 base do método.

Ver também

• Sistema de tipo comum