MethodInfo.GetBaseDefinition Methode

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

Retouren

Een MethodInfo object voor de eerste implementatie van deze methode.

Implementeringen

Voorbeelden

In het volgende voorbeeld ziet u het gedrag van de GetBaseDefinition methode.

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

Opmerkingen

De GetBaseDefinition methode retourneert de eerste definitie van de opgegeven methode in de klassehiërarchie. U kunt het type bepalen waarop de eerste definitie van de methode wordt gevonden door de waarde van de DeclaringType eigenschap op te halen voor het geretourneerde MethodInfo object.

De GetBaseDefinition methode gedraagt zich als volgt:

• Als het huidige MethodInfo object een interface-implementatie vertegenwoordigt, retourneert de GetBaseDefinition methode het huidige MethodInfo object.

• Als het huidige MethodInfo object een methode vertegenwoordigt die een virtuele definitie in een basisklasse overschrijft, retourneert de GetBaseDefinition methode een MethodInfo object dat de virtuele definitie vertegenwoordigt.

• Als het huidige MethodInfo-object een methode vertegenwoordigt die is opgegeven met het trefwoord new in C# of het trefwoord Shadows in Visual Basic (zoals in newslot, zoals beschreven in Common Type System), retourneert de methode GetBaseDefinition het huidige MethodInfo-object.

• Als het huidige MethodInfo object een overgenomen methode vertegenwoordigt (dat wil zeggen dat de huidige methode geen eigen implementatie biedt), retourneert de GetBaseDefinition methode een MethodInfo object dat de laagste methode in de klassehiërarchie vertegenwoordigt. Als Base.ToString bijvoorbeeld onderdrukkingen en Derived.ToString onderdrukkingen Object.ToStringBase.ToStringworden aangeroepen, wordt de GetBaseDefinition methode aangeroepen voor een MethodInfo object dat een MethodInfo object vertegenwoordigt dat een object vertegenwoordigt Derived.ToStringObject.ToString.

• Als het huidige MethodInfo object een methode vertegenwoordigt die niet aanwezig is in een basisklasse, retourneert de GetBaseDefinition methode het huidige MethodInfo object.

U kunt bepalen of de huidige methode een methode in een basisklasse overschrijft door de methode aan te GetBaseDefinition roepen. In het volgende voorbeeld wordt een IsOverride methode geïmplementeerd die dit doet.

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

De methode aanroepen GetBaseDefinition :

1. Haal een Type object op dat het type (de klasse of structuur) vertegenwoordigt dat de eigenschap bevat. Als u met een object werkt (een exemplaar van een type), kunt u de GetType methode aanroepen. Anders kunt u de C#-operator of de operator Visual Basic GetType gebruiken, zoals in het voorbeeld wordt geïllustreerd.

2. Haal een MethodInfo object op dat de methode vertegenwoordigt waarin u geïnteresseerd bent. U kunt dit doen door een matrix van alle methoden op te halen uit de Type.GetMethods methode en vervolgens de elementen in de matrix te herhalen, of u kunt het MethodInfo object ophalen dat de methode rechtstreeks vertegenwoordigt door de methode aan Type.GetMethod(String) te roepen en de naam van de methode op te geven.

3. Roep de GetBaseDefinition methode aan om de waarde op te halen van het MethodInfo object dat de definitie van de basismethode vertegenwoordigt.

Zie ook

• Algemeen typesysteem