MethodInfo.GetBaseDefinition Metod

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

Returer

Ett MethodInfo objekt för den första implementeringen av den här metoden.

Implementeringar

Exempel

I följande exempel visas metodens GetBaseDefinition beteende.

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

Kommentarer

Metoden GetBaseDefinition returnerar den första definitionen av den angivna metoden i klasshierarkin. Du kan fastställa vilken typ som den första definitionen av metoden finns i genom att hämta värdet DeclaringType för egenskapen för det returnerade MethodInfo objektet.

Metoden GetBaseDefinition fungerar på följande sätt:

• Om det aktuella MethodInfo objektet representerar en gränssnittsimplementering GetBaseDefinition returnerar metoden det aktuella MethodInfo objektet.

• Om det aktuella MethodInfo objektet representerar en metod som åsidosätter en virtuell definition i en basklass GetBaseDefinition returnerar metoden ett MethodInfo objekt som representerar den virtuella definitionen.

• Om det aktuella objektet MethodInfo representerar en metod som anges med nyckelordet new i C# eller nyckelordet Shadows i Visual Basic (som i newslot, enligt beskrivningen i Common Type System) returnerar metoden GetBaseDefinition det aktuella objektet MethodInfo.

• Om det aktuella MethodInfo objektet representerar en ärvd metod (dvs. den aktuella metoden inte tillhandahåller en egen implementering) GetBaseDefinition returnerar metoden ett MethodInfo objekt som representerar den lägsta metoden i klasshierarkin. Om till exempel åsidosätter Object.ToString, och Derived.ToString åsidosätter , anropar Base.ToStringGetBaseDefinition metoden på ett MethodInfo objekt som representerar Derived.ToString returnerar ett MethodInfo objekt som representerar Object.ToString.Base.ToString

• Om det aktuella MethodInfo objektet representerar en metod som inte finns i någon basklass GetBaseDefinition returnerar metoden det aktuella MethodInfo objektet.

Du kan avgöra om den aktuella metoden åsidosätter en metod i en basklass genom att anropa GetBaseDefinition metoden. I följande exempel implementeras en IsOverride metod som gör detta.

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

GetBaseDefinition Anropa metoden:

1. Hämta ett Type objekt som representerar den typ (klassen eller strukturen) som innehåller egenskapen. Om du arbetar med ett objekt (en instans av en typ) kan du anropa dess GetType metod. Annars kan du använda C#-operatorn eller operatorn Visual Basic GetType som exemplet illustrerar.

2. Hämta ett MethodInfo objekt som representerar den metod som du är intresserad av. Du kan göra detta genom att hämta en matris med alla metoder från Type.GetMethods metoden och sedan iterera elementen i matrisen, eller så kan du hämta MethodInfo objektet som representerar metoden direkt genom att anropa Type.GetMethod(String) metoden och ange metodnamnet.

3. GetBaseDefinition Anropa metoden för att hämta värdet för objektet MethodInfo som representerar basmetoddefinitionen.

Se även

• Common Type System