MethodInfo.GetBaseDefinition Metódus

Definíció

Névtér:

System.Reflection

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

MethodInfo.cs

Ha egy származtatott osztályban felül van bírálva, a MethodInfo metódus objektumát adja vissza azon a közvetlen vagy közvetett alaposztályon, amelyben a példány által képviselt metódus először deklarálva lett.

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

Válaszok

MethodInfo

A MethodInfo metódus első implementációjának objektuma.

Példák

Az alábbi példa a metódus viselkedését GetBaseDefinition mutatja be.

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

Megjegyzések

A GetBaseDefinition metódus a megadott metódus első definícióját adja vissza az osztályhierarchiában. A metódus első definíciójának típusát a visszaadott DeclaringType objektum tulajdonságának értékének MethodInfo beolvasásával határozhatja meg.

A GetBaseDefinition metódus a következőképpen viselkedik:

• Ha az aktuális MethodInfo objektum egy felületi implementációt jelöl, a GetBaseDefinition metódus az aktuális MethodInfo objektumot adja vissza.

• Ha az aktuális MethodInfo objektum egy olyan metódust jelöl, amely felülbírál egy virtuális definíciót egy alaposztályban, a GetBaseDefinition metódus egy MethodInfo olyan objektumot ad vissza, amely a virtuális definíciót jelöli.

• Ha az aktuális MethodInfo objektum a C# new kulcsszójával vagy a Shadows kulcsszóval megadott metódust jelöli a Visual Basic (newslot, a Common típusú rendszer) szerint a GetBaseDefinition metódus az aktuális MethodInfo objektumot adja vissza.

• Ha az aktuális MethodInfo objektum öröklött metódust jelöl (vagyis az aktuális metódus nem biztosítja a saját implementációját), a GetBaseDefinition metódus egy MethodInfo olyan objektumot ad vissza, amely az osztályhierarchiában a legalacsonyabb metódust képviseli. Ha például felülbírálások Base.ToStringés Object.ToString felülbírálásokDerived.ToString, a Base.ToString metódus meghívása egy GetBaseDefinition olyan objektumon történik, amely egy MethodInfo olyan objektumot ad visszaDerived.ToString, amely a függvényt jelöliMethodInfo.Object.ToString

• Ha az aktuális MethodInfo objektum olyan metódust jelöl, amely egyik alaposztályban sem szerepel, a GetBaseDefinition metódus az aktuális MethodInfo objektumot adja vissza.

A metódus meghívásával meghatározhatja, hogy az aktuális metódus felülbírál-e egy metódust egy GetBaseDefinition alaposztályban. Az alábbi példa egy IsOverride metódust implementál, amely ezt teszi.

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

A metódus meghívása GetBaseDefinition :

1. Type Szerezze be a tulajdonságot tartalmazó típust (osztályt vagy struktúrát) képviselő objektumot. Ha objektummal (egy típuspéldánysal) dolgozik, meghívhatja annak metódusát GetType . Ellenkező esetben használhatja a C# operátort vagy a Visual Basic GetType operátort, amint azt a példa szemlélteti.

2. MethodInfo Szerezze be azt az objektumot, amely az önt érdeklő metódust jelöli. Ehhez lekérheti a Type.GetMethods metódus összes metódusát tartalmazó tömböt, majd iterálja a tömb elemeit, vagy közvetlenül a metódus meghívásával MethodInfo és a metódus nevének megadásával lekérheti Type.GetMethod(String) a metódust jelképező objektumot.

3. Hívja meg a metódust GetBaseDefinition az alapmetódus definícióját képviselő objektum értékének MethodInfo lekéréséhez.

Lásd még

• Közös Típus Rendszer