MethodBase.GetCurrentMethod Metod

Definition

Namnområde:: System.Reflection

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Returnerar ett MethodBase objekt som representerar metoden som körs just nu.

public:
 static System::Reflection::MethodBase ^ GetCurrentMethod();

public static System.Reflection.MethodBase GetCurrentMethod();

static member GetCurrentMethod : unit -> System.Reflection.MethodBase

Public Shared Function GetCurrentMethod () As MethodBase

Returer

MethodBase

GetCurrentMethod() är en statisk metod som anropas inifrån en körningsmetod och som returnerar information om metoden.

Ett MethodBase objekt som representerar metoden som körs just nu.

Undantag

TargetException

Den här medlemmen anropades med en mekanism för sen bindning.

Exempel

I följande exempel definieras två typer. Den första är en icke-generisk klass, TestClass, innehåller en konstruktor, en metod med namnet GetValueoch en skrivskyddad egenskap med namnet GetValue. Den andra är en generisk klass med namnet TestClass<T> som innehåller en konstruktor, en GetValue metod och en generisk metod, ConvertValue<Y>. Varje konstruktor, metod och egenskapsåtkomst innehåller ett anrop till GetCurrentMethod metoden.

using System;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      var t = new TestClass();  
      Console.WriteLine(t.GetValue());
      t.Value = 10;
      Console.WriteLine(t.Value);
      Console.WriteLine();
      
      var tg =new Test<int>(200);
      Console.WriteLine(tg.GetValue());
      var b = tg.ConvertValue<Byte>();
      Console.WriteLine("{0} -> {1} ({2})", tg.GetValue().GetType().Name,
                        b, b.GetType().Name);
   }
}        

public class TestClass
{
   private Nullable<int> _value;
   
   public TestClass()
   {
      MethodBase m = MethodBase.GetCurrentMethod();
      Console.WriteLine("Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name);
   }
   
   public TestClass(int value)
   {
      MethodBase m = MethodBase.GetCurrentMethod();
      Console.WriteLine("Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name);
      _value = value;
   }
   
   public int Value
   {  
      get {
         MethodBase m = MethodBase.GetCurrentMethod();
         Console.WriteLine("Executing {0}.{1}", 
                           m.ReflectedType.Name, m.Name);
         return _value.GetValueOrDefault();
      }
      set {
         MethodBase m = MethodBase.GetCurrentMethod();
         Console.WriteLine("Executing {0}.{1}", 
                           m.ReflectedType.Name, m.Name);
         _value = value;
      }
   }
   
   public int GetValue()
   {
      MethodBase m = MethodBase.GetCurrentMethod();
      Console.WriteLine("Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name);
      return this.Value;
   }
}

public class Test<T>
{
   private T value;
   
   public Test(T value)
   {
      MethodBase m = MethodBase.GetCurrentMethod();
      Console.WriteLine("Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name);
      this.value = value;
   }
   
   public T GetValue()
   {
      MethodBase m = MethodBase.GetCurrentMethod();
      Console.WriteLine("Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name);
      return value;
   }
   
   public Y ConvertValue<Y>() 
   {
      MethodBase m = MethodBase.GetCurrentMethod();
      Console.WriteLine("Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name);
      Console.Write("      Generic method: {0}, definition: {1}, Args: ", 
                        m.IsGenericMethod, m.IsGenericMethodDefinition);
      if (m.IsGenericMethod) {
         foreach (var arg in m.GetGenericArguments())
            Console.Write("{0} ", arg.Name);
      }
      Console.WriteLine();
      try {
         return (Y) Convert.ChangeType(value, typeof(Y));
      }
      catch (OverflowException) {
         throw; 
      }   
      catch (InvalidCastException) {
         throw;
      }   
   }   
}
// The example displays the following output:
//       Executing TestClass..ctor
//       Executing TestClass.GetValue
//       Executing TestClass.get_Value
//       0
//       Executing TestClass.set_Value
//       Executing TestClass.get_Value
//       10
//       
//       Executing Test`1..ctor
//       Executing Test`1.GetValue
//       200
//       Executing Test`1.ConvertValue
//             Generic method: True, definition: True, Args: Y
//       Executing Test`1.GetValue
//       Int32 -> 200 (Byte)

Imports System.Reflection

Module Example
   Public Sub Main()
      Dim t As New TestClass()  
      Console.WriteLine(t.GetValue())
      t.Value = 10
      Console.WriteLine(t.Value)
      Console.WriteLine()
      
      Dim tg As New Test(Of Integer)(200)
      Console.WriteLine(tg.GetValue())
      Dim b = tg.ConvertValue(Of Byte)()
      Console.WriteLine("{0} -> {1} ({2})", tg.GetValue().GetType().Name,
                        b, b.GetType().Name)
                                            
                                             
   End Sub
End Module

Public Class TestClass
   Private _value As Nullable(Of Integer)
   
   Public Sub New()
      Dim m As MethodBase = MethodBase.GetCurrentMethod()
      Console.WriteLine("   Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name)
   End Sub
   
   Public Sub New(value As Integer)
      Dim m As MethodBase = MethodBase.GetCurrentMethod()
      Console.WriteLine("   Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name)
      _value = value
   End Sub
   
   Public Property Value As Integer
      Get
         Dim m As MethodBase = MethodBase.GetCurrentMethod()
         Console.WriteLine("   Executing {0}.{1}", 
                           m.ReflectedType.Name, m.Name)
         Return _value.GetValueOrDefault()
      End Get
      Set
         Dim m As MethodBase = MethodBase.GetCurrentMethod()
         Console.WriteLine("   Executing {0}.{1}", 
                           m.ReflectedType.Name, m.Name)
         _value = value
      End Set
   End Property
   
   Public Function GetValue() As Integer
      Dim m As MethodBase = MethodBase.GetCurrentMethod()
      Console.WriteLine("   Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name)
      Return Me.Value
   End Function
End Class

Public Class Test(Of T)
   Private value As T
   
   Public Sub New(value As T)
      Dim m As MethodBase = MethodBase.GetCurrentMethod()
      Console.WriteLine("   Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name)
      Me.value = value
   End Sub
   
   Public Function GetValue() As T
      Dim m As MethodBase = MethodBase.GetCurrentMethod()
      Console.WriteLine("   Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name)
      Return value
   End Function
   
   Public Function ConvertValue(Of Y)() As Y
      Dim m As MethodBase = MethodBase.GetCurrentMethod()
      Console.WriteLine("   Executing {0}.{1}", 
                        m.ReflectedType.Name, m.Name)
      Console.Write("      Generic method: {0}, definition: {1}, Args: ", 
                        m.IsGenericMethod, m.IsGenericMethodDefinition)
      If m.IsGenericMethod Then
         For Each arg In m.GetGenericArguments()
            Console.Write("{0} ", arg.Name)
         Next
      End If
      Console.WriteLine()
      Try
         Return CType(Convert.ChangeType(value, GetType(Y)), Y)
      Catch e As OverflowException
         Throw 
      Catch e As InvalidCastException
         Throw
      End Try   
   End Function   
End Class
' The example displays the following output:
'       Executing TestClass..ctor
'       Executing TestClass.GetValue
'       Executing TestClass.get_Value
'       0
'       Executing TestClass.set_Value
'       Executing TestClass.get_Value
'       10
'       
'       Executing Test`1..ctor
'       Executing Test`1.GetValue
'       200
'       Executing Test`1.ConvertValue
'             Generic method: True, definition: True, Args: Y
'       Executing Test`1.GetValue
'       Int32 -> 200 (Byte)

Kommentarer

Om metoden som körs för närvarande definieras för en allmän typ hämtas den MethodInfo som returneras av GetCurrentMethod från den generiska typdefinitionen (d.ex. MethodBase.ContainsGenericParameters returnerar true). Därför återspeglar den inte de typargument som användes när metoden anropades. Om till exempel en metod M() definieras på en allmän typ C<T> (C(Of T) i Visual Basic) och GetCurrentMethod anropas från C<string>.M(), GetCurrentMethod returnerar sedan C<T>.M() (C(Of T).M() i Visual Basic).

Om metoden som körs för närvarande är en allmän metod GetCurrentMethod returnerar den generiska metoddefinitionen. Om den generiska metoden definieras för en allmän typ MethodInfo hämtas den från den generiska typdefinitionen.

Gäller för

Feedback

Var den här sidan till hjälp?