MethodBase.GetCurrentMethod メソッド

定義

名前空間:

System.Reflection

アセンブリ:

netstandard.dll, System.Runtime.dll

ソース:

MethodBase.CoreCLR.cs

現在実行中のメソッドを表す MethodBase オブジェクトを返します。

C#

public static System.Reflection.MethodBase? GetCurrentMethod();

戻り値

MethodBase

GetCurrentMethod() は、実行中のメソッド内から呼び出され、そのメソッドに関する情報を返す、静的メソッドです。

現在実行中のメソッドを表す MethodBase オブジェクト。

例外

TargetException

このメンバーは、遅延バインディング メカニズムで呼び出されました。

例

次の例では、2 つの型を定義します。 1 つ目は非ジェネリック クラスです。これには、 TestClassコンストラクター、、 という名前のメソッド、および という名前 GetValueの読み取り/書き込みプロパティが GetValue含まれます。 2 つ目は、 という名前 TestClass<T> のジェネリック クラスで、コンストラクター、 GetValue メソッド、ジェネリック メソッド ConvertValue<Y>を含みます。 各コンストラクター、メソッド、およびプロパティ アクセサーには、 メソッドの呼び出しが GetCurrentMethod 含まれています。

C#

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)

注釈

現在実行中のメソッドがジェネリック型で定義されている場合、 MethodInfo によって GetCurrentMethod 返される はジェネリック型定義から取得されます (つまり、 MethodBase.ContainsGenericParameters は を返します true)。 そのため、メソッドの呼び出し時に使用された型引数は反映されません。 たとえば、メソッドM()がジェネリック型 C<T> (C(Of T) Visual Basic では ) で定義されGetCurrentMethod、 からC<string>.M()呼び出された場合、 は Visual Basic で (C(Of T).M() を返C<T>.M()しますGetCurrentMethod)。

現在実行中のメソッドがジェネリック メソッドの場合は、 GetCurrentMethod ジェネリック メソッド定義を返します。 ジェネリック メソッドがジェネリック型で定義されている場合、 MethodInfo はジェネリック型定義から取得されます。

適用対象