MethodInfo.GetBaseDefinition Méthode

Référence

Définition

Espace de noms:: System.Reflection

Assembly:: System.Runtime.dll

Assembly:: System.Reflection.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: MethodInfo.cs

Source:: MethodInfo.cs

Source:: MethodInfo.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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.

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

MethodInfo

Objet MethodInfo pour la première implémentation de cette méthode.

Implémente

GetBaseDefinition()

Exemples

L’exemple suivant illustre le comportement de la GetBaseDefinition méthode.

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. Vous pouvez déterminer le type sur lequel la première définition de la méthode est trouvée en récupérant la valeur de la DeclaringType propriété sur l’objet retourné MethodInfo .

La GetBaseDefinition méthode se comporte comme suit :

Si l’objet actuel MethodInfo représente une implémentation d’interface, la GetBaseDefinition méthode retourne l’objet actif MethodInfo .
Si l’objet actuel MethodInfo représente une méthode qui remplace une définition virtuelle dans une classe de base, la GetBaseDefinition méthode retourne un MethodInfo objet qui représente la définition virtuelle.
Si l’objet actuel MethodInfo représente une méthode spécifiée avec le new mot clé en C# ou le Shadows mot clé en Visual Basic (comme dans newslot, comme décrit dans Common Type System), la GetBaseDefinition méthode retourne l’objet actifMethodInfo.
Si l’objet actuel MethodInfo représente une méthode héritée (autrement dit, la méthode actuelle ne fournit pas sa propre implémentation), la GetBaseDefinition méthode retourne un MethodInfo objet qui représente la méthode la plus basse de la hiérarchie de classes. Par exemple, si Base.ToString remplace Object.ToString, et Derived.ToString remplace Base.ToString, l’appel de la GetBaseDefinition méthode sur un MethodInfo objet qui représente Derived.ToString renvoie un MethodInfo objet qui représente Object.ToString.
Si l’objet actuel MethodInfo représente une méthode qui n’est présente dans aucune classe de base, la GetBaseDefinition méthode retourne l’objet actif MethodInfo .

Vous pouvez déterminer si la méthode actuelle remplace une méthode dans une classe de base en appelant la GetBaseDefinition méthode . L’exemple suivant implémente une IsOverride méthode qui effectue cette opération.

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 :

Obtient un Type objet qui représente le type (la classe ou la structure) qui contient la propriété . Si vous travaillez avec un objet (un instance d’un type), vous pouvez appeler sa GetType méthode. Sinon, vous pouvez utiliser l’opérateur C# ou l’opérateur Visual Basic GetType , comme l’illustre l’exemple.
Obtenez un MethodInfo objet qui représente la méthode qui vous intéresse. Pour ce faire, vous pouvez obtenir un tableau de toutes les méthodes à partir de la Type.GetMethods méthode, puis itérer les éléments dans le tableau, ou vous pouvez récupérer l’objet MethodInfo qui représente la méthode directement en appelant la Type.GetMethod(String) méthode et en spécifiant le nom de la méthode.
Appelez la GetBaseDefinition méthode pour obtenir la valeur de l’objet MethodInfo qui représente la définition de la méthode de base.

S’applique à

Voir aussi

Système de type commun

Partager via