MethodInfo.GetBaseDefinition Méthode

Définition

En cas de substitution dans une classe dérivée, retourne l'objet MethodInfo pour la méthode sur la classe de base directe ou indirecte dans laquelle la méthode représentée par cette instance a été déclarée initialement.When overridden in a derived class, returns the MethodInfo object for the method on the direct or indirect base class in which the method represented by this instance was first declared.

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

Retours

Objet MethodInfo pour la première implémentation de cette méthode.A MethodInfo object for the first implementation of this method.

Implémente

Exemples

L’exemple suivant illustre le comportement de la GetBaseDefinition méthode.The following example demonstrates the behavior of the GetBaseDefinition method.

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

Remarques

La GetBaseDefinition méthode retourne la première définition de la méthode spécifiée dans la hiérarchie de classes.The GetBaseDefinition method returns the first definition of the specified method in the class hierarchy. Vous pouvez déterminer le type sur lequel la première définition de la méthode est trouvée en extrayant la valeur de la DeclaringType propriété sur l’objet retourné. MethodInfoYou can determine the type on which the first definition of the method is found by retrieving the value of the DeclaringType property on the returned MethodInfo object.

La GetBaseDefinition méthode se comporte comme suit :The GetBaseDefinition method behaves as follows:

  • Si l’objet MethodInfo actuel représente une implémentation d’interface, GetBaseDefinition la méthode retourne l' MethodInfo objet actuel.If the current MethodInfo object represents an interface implementation, the GetBaseDefinition method returns the current MethodInfo object.

  • Si l’objet MethodInfo actuel représente une méthode qui substitue une définition virtuelle dans une classe de base, la GetBaseDefinition méthode retourne un MethodInfo objet qui représente la définition virtuelle.If the current MethodInfo object represents a method that overrides a virtual definition in a base class, the GetBaseDefinition method returns a MethodInfo object that represents the virtual definition.

  • Si l’objet MethodInfo actuel représente une méthode spécifiée avec le new mot clé dans C# ou Shadows le mot clé dans Visual Basic (comme dans newslot, comme décrit dans système de type commun), GetBaseDefinition la méthode retourne l' MethodInfo objet actuel.If the current MethodInfo object represents a method that is specified with the new keyword in C# or the Shadows keyword in Visual Basic (as in newslot, as described in Common Type System), the GetBaseDefinition method returns the current MethodInfo object.

  • Si l’objet MethodInfo actuel représente une méthode héritée (autrement dit, si la méthode actuelle ne fournit pas sa propre implémentation) GetBaseDefinition , la méthode MethodInfo retourne un objet qui représente la méthode la plus basse dans la hiérarchie de classes.If the current MethodInfo object represents an inherited method (that is, the current method does not provide its own implementation), the GetBaseDefinition method returns a MethodInfo object that represents the lowest method in the class hierarchy. Par exemple, si Base.ToString Object.ToStringSubstitue et Derived.ToString substitue Base.ToString, l’appel de la GetBaseDefinition méthode sur un MethodInfo objet qui représente Derived.ToString retourne un MethodInfo objet qui représente Object.ToString.For example, if Base.ToString overrides Object.ToString, and Derived.ToString overrides Base.ToString, calling the GetBaseDefinition method on a MethodInfo object that represents Derived.ToString returns a MethodInfo object that represents Object.ToString.

  • Si l’objet MethodInfo actuel représente une méthode qui n’est pas présente dans une classe de base GetBaseDefinition , la méthode retourne MethodInfo l’objet actuel.If the current MethodInfo object represents a method that is not present in any base class, the GetBaseDefinition method returns the current MethodInfo object.

Vous pouvez déterminer si la méthode actuelle se substitue à une méthode dans une classe de base en GetBaseDefinition appelant la méthode.You can determine whether the current method overrides a method in a base class by calling the GetBaseDefinition method. L’exemple suivant implémente une IsOverride méthode qui effectue cette.The following example implements an IsOverride method that does this.

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

Pour appeler la GetBaseDefinition méthode :To call the GetBaseDefinition method:

  1. Obtient un Type objet qui représente le type (la classe ou la structure) qui contient la propriété.Get a Type object that represents the type (the class or structure) that contains the property. Si vous utilisez un objet (une instance d’un type), vous pouvez appeler sa GetType méthode.If you are working with an object (an instance of a type), you can call its GetType method. Dans le cas contraire, vous C# pouvez utiliser l’opérateur ou l’opérateur Visual Basic GetType , comme l’illustre l’exemple.Otherwise, you can use the C# operator or the Visual Basic GetType operator, as the example illustrates.

  2. Obtient un MethodInfo objet qui représente la méthode qui vous intéresse.Get a MethodInfo object that represents the method in which you're interested. Pour ce faire, vous pouvez obtenir un tableau de toutes les méthodes Type.GetMethods à partir de la méthode, puis itérer les éléments du tableau, ou vous MethodInfo pouvez récupérer l’objet qui représente la méthode directement Type.GetMethod(String) en appelant la méthode et en spécifiant l’élément nom de la méthode.You can do this by getting an array of all methods from the Type.GetMethods method and then iterating the elements in the array, or you can retrieve the MethodInfo object that represents the method directly by calling the Type.GetMethod(String) method and specifying the method name.

  3. Appelez la GetBaseDefinition méthode pour récupérer la valeur de l' MethodInfo objet qui représente la définition de méthode de base.Call the GetBaseDefinition method to get the value of the MethodInfo object that represents the base method definition.

S’applique à

Voir aussi