Type.DeclaringMethod プロパティとは？ わかりやすく解説

Weblio 辞書 > コンピュータ > .NET Framework クラス ライブラリ リファレンス > Type.DeclaringMethod プロパティの意味・解説 
.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引
日本マイクロソフト株式会社日本マイクロソフト株式会社

Type.DeclaringMethod プロパティ

メモ : このプロパティは、.NET Framework version 2.0 で新しく追加されたものです。

現在の Type がジェネリック メソッドの型パラメータを表している場合に、宣言するメソッドを表す MethodBase を取得します。

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
Public Overridable ReadOnly
 Property DeclaringMethod As MethodBase
Visual Basic (使用法)
Dim instance As Type
Dim value As MethodBase

value = instance.DeclaringMethod
C#
public virtual MethodBase DeclaringMethod { get;
 }
C++
public:
virtual property MethodBase^ DeclaringMethod {
    MethodBase^ get ();
}
J#
/** @property */
public MethodBase get_DeclaringMethod ()
JScript
public function get DeclaringMethod
 () : MethodBase

プロパティ値
現在の Type がジェネリック メソッドの型パラメータを表している場合は、宣言メソッドを表す MethodBase。それ以外の場合は null 参照 (Visual Basic では Nothing)。

解説解説

宣言メソッドは、ジェネリック メソッド定義です。つまり、DeclaringMethod が null 参照 (Visual Basic では Nothing) を返さない場合、DeclaringMethod.IsGenericMethodDefinition は true を返します。

DeclaringType プロパティおよび DeclaringMethod プロパティは、ジェネリック型パラメータが最初に定義されたジェネリック型定義またはジェネリック メソッド定義を識別します。

DeclaringMethod プロパティによって返される MethodBase は、ジェネリック メソッドの場合は MethodInfo であり、ジェネリック コンストラクタの場合は ConstructorInfo です。

メモメモ

.NET Framework Version 2.0 では、ジェネリック コンストラクタはサポートされていません。

ジェネリック リフレクションで使用される用語の一定の条件の一覧については、IsGenericType のプロパティの解説を参照してください。

使用例使用例

ジェネリック メソッドを保持して型引数をメソッドに割り当て、結果の構築されたジェネリック メソッドを呼び出すクラスを定義するコード例を次に示します。この例では、ジェネリック メソッド定義および構築されたメソッドに関する情報も示します。ジェネリック メソッド定義の型パラメータに関する情報を DisplayGenericMethodInfo に表示する場合、このコード例では、メソッドのジェネリック型パラメータの DeclaringMethod プロパティの値を示しています。

Visual Basic
Imports System
Imports System.Reflection

' Define a class with a generic method.
Public Class Example
    Public Shared Sub Generic(Of
 T)(ByVal toDisplay As T)
        Console.WriteLine(vbCrLf & "Here it is: {0}",
 toDisplay)
    End Sub
End Class

Public Class Test
    Public Shared Sub Main()
 
        Console.WriteLine(vbCrLf & "--- Examine a generic
 method.")
        
        ' Create a Type object representing class Example, and
        ' get a MethodInfo representing the generic method.
        '
        Dim ex As Type = GetType(Example)
        Dim mi As MethodInfo = ex.GetMethod("Generic")
        
        DisplayGenericMethodInfo(mi)
        
        ' Assign the Integer type to the type parameter of the Example
 
        ' method.
        '
        Dim arguments() As Type = { GetType(Integer)
 }
        Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)
        
        DisplayGenericMethodInfo(miConstructed)

        ' Invoke the method.
        Dim args() As Object
 = { 42 }
        miConstructed.Invoke(Nothing, args)
        
        ' Invoke the method normally.
        Example.Generic(Of Integer)(42)
        
        ' Get the generic type definition from the constructed method
,
        ' and show that it's the same as the original definition.
        '
        Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
        Console.WriteLine(vbCrLf & "The definition is the
 same: {0}", _
            miDef Is mi)
    End Sub 'Main
      
    Private Shared Sub DisplayGenericMethodInfo(ByVal
 mi As MethodInfo) 
        Console.WriteLine(vbCrLf & mi.ToString())
        
        Console.WriteLine(vbTab _
            & "Is this a generic method definition? {0}",
 _
            mi.IsGenericMethodDefinition)

        Console.WriteLine(vbTab & "Is it a generic method?
 {0}", _
            mi.IsGenericMethod)

        Console.WriteLine(vbTab _
            & "Does it have unassigned generic parameters?
 {0}", _
            mi.ContainsGenericParameters)

        ' If this is a generic method, display its type arguments.
        '
        If mi.IsGenericMethod Then
            Dim typeArguments As Type() = mi.GetGenericArguments()
            
            Console.WriteLine(vbTab & "List type arguments
 ({0}):", _
                typeArguments.Length)
            
            For Each tParam As
 Type In typeArguments
                ' IsGenericParameter is true only for generic type
                ' parameters.
                '
                If tParam.IsGenericParameter Then
                    Console.WriteLine(vbTab & vbTab _
                        & "{0}  parameter position: {1}"
 _
                        & vbCrLf & vbTab & vbTab _
                        & "   declaring method: {2}",
 _
                        tParam,  _
                        tParam.GenericParameterPosition, _
                        tParam.DeclaringMethod)
                Else
                    Console.WriteLine(vbTab & vbTab & tParam.ToString())
                End If
            Next tParam
        End If
    End Sub 
End Class 

' This example produces the following output:
'
'--- Examine a generic method.
'
'Void Generic[T](T)
'        Is this a generic method definition? True
'        Is it a generic method? True
'        Does it have unassigned generic parameters? True
'        List type arguments (1):
'                T  parameter position: 0
'                   declaring method: Void Generic[T](T)
'
'Void Generic[Int32](Int32)
'        Is this a generic method definition? False
'        Is it a generic method? True
'        Does it have unassigned generic parameters? False
'        List type arguments (1):
'                System.Int32
'
'Here it is: 42
'
'Here it is: 42
'
'The definition is the same: True
'
C#
using System;
using System.Reflection;

// Define a class with a generic method.
public class Example
{
    public static void Generic<T>(T
 toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }
}

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Examine a generic method.");

        // Create a Type object representing class Example, and
        // get a MethodInfo representing the generic method.
        //
        Type ex = typeof(Example);
        MethodInfo mi = ex.GetMethod("Generic");

        DisplayGenericMethodInfo(mi);

        // Assign the int type to the type parameter of the Example
 
        // method.
        //
        MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));

        DisplayGenericMethodInfo(miConstructed);

        // Invoke the method.
        object[] args = {42};
        miConstructed.Invoke(null, args);

        // Invoke the method normally.
        Example.Generic<int>(42);

        // Get the generic type definition from the closed method,
        // and show it's the same as the original definition.
        //
        MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
        Console.WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
    }
        
    private static void
 DisplayGenericMethodInfo(MethodInfo mi)
    {
        Console.WriteLine("\r\n{0}", mi);

        Console.WriteLine("\tIs this a generic method definition?
 {0}", 
            mi.IsGenericMethodDefinition);

        Console.WriteLine("\tIs it a generic method? {0}", 
            mi.IsGenericMethod);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}",
 
            mi.ContainsGenericParameters);

        // If this is a generic method, display its type arguments.
        //
        if (mi.IsGenericMethod)
        {
            Type[] typeArguments = mi.GetGenericArguments();

            Console.WriteLine("\tList type arguments ({0}):", 
                typeArguments.Length);

            foreach (Type tParam in typeArguments)
            {
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam.IsGenericParameter)
                {
                    Console.WriteLine("\t\t{0}  parameter position {1}"
 +
                        "\n\t\t   declaring method: {2}",
                        tParam,
                        tParam.GenericParameterPosition,
                        tParam.DeclaringMethod);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Examine a generic method.

Void Generic[T](T)
        Is this a generic method definition? True
        Is it a generic method? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                T  parameter position 0
                   declaring method: Void Generic[T](T)

Void Generic[Int32](Int32)
        Is this a generic method definition? False
        Is it a generic method? True
        Does it have unassigned generic parameters? False
        List type arguments (1):
                System.Int32

Here it is: 42

Here it is: 42

The definition is the same: True

 */
C++
using namespace System;
using namespace System::Reflection;

// Define a class with a generic method.
ref class Example
{
public:
    generic<typename T> static void Generic(T
 toDisplay)
    {
        Console::WriteLine("\r\nHere it is: {0}", toDisplay);
    }
};

void DisplayGenericMethodInfo(MethodInfo^ mi)
{
    Console::WriteLine("\r\n{0}", mi);

    Console::WriteLine("\tIs this a generic method definition?
 {0}", 
        mi->IsGenericMethodDefinition);

    Console::WriteLine("\tIs it a generic method? {0}", 
        mi->IsGenericMethod);

    Console::WriteLine("\tDoes it have unassigned generic parameters? {0}",
 
        mi->ContainsGenericParameters);

    // If this is a generic method, display its type arguments.
    //
    if (mi->IsGenericMethod)
    {
        array<Type^>^ typeArguments = mi->GetGenericArguments();

        Console::WriteLine("\tList type arguments ({0}):", 
            typeArguments->Length);

        for each (Type^ tParam in typeArguments)
        {
            // IsGenericParameter is true only for generic type
            // parameters.
            //
            if (tParam->IsGenericParameter)
            {
                Console::WriteLine("\t\t{0}  parameter position {1}" +
                    "\n\t\t   declaring method: {2}",
                    tParam,
                    tParam->GenericParameterPosition,
                    tParam->DeclaringMethod);
            }
            else
            {
                Console::WriteLine("\t\t{0}", tParam);
            }
        }
    }
};

void main()
{
    Console::WriteLine("\r\n--- Examine a generic method.");

    // Create a Type object representing class Example, and
    // get a MethodInfo representing the generic method.
    //
    Type^ ex = Example::typeid;
    MethodInfo^ mi = ex->GetMethod("Generic");

    DisplayGenericMethodInfo(mi);

    // Assign the int type to the type parameter of the Example 
    // method.
    //
    MethodInfo^ miConstructed = mi->MakeGenericMethod(int::typeid);

    DisplayGenericMethodInfo(miConstructed);

    // Invoke the method.
    array<Object^>^ args = { 42 };
    miConstructed->Invoke((Object^) 0, args);

    // Invoke the method normally.
    Example::Generic<int>(42);

    // Get the generic type definition from the closed method,
    // and show it's the same as the original definition.
    //
    MethodInfo^ miDef = miConstructed->GetGenericMethodDefinition();
    Console::WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
};
        
/* This example produces the following output:

--- Examine a generic method.

Void Generic[T](T)
        Is this a generic method definition? True
        Is it a generic method? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                T  parameter position 0
                   declaring method: Void Generic[T](T)

Void Generic[Int32](Int32)
        Is this a generic method definition? False
        Is it a generic method? True
        Does it have unassigned generic parameters? False
        List type arguments (1):
                System.Int32

Here it is: 42

Here it is: 42

The definition is the same: True

 */
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0
参照参照
関連項目
Type クラス
Type メンバ
System 名前空間
IsGenericParameter
その他の技術情報
リフレクションとジェネリック型
方法 : リフレクションを使用してジェネリック型をチェックおよびインスタンス化する

英和和英テキスト翻訳

英語⇒日本語日本語⇒英語

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「Type.DeclaringMethod プロパティ」の関連用語

1
MethodBase.IsGenericMethodDefinition プロパティ
.NET Framework クラス ライブラリ リファレンス
34% |||||

2
MethodInfo.IsGenericMethodDefinition プロパティ
.NET Framework クラス ライブラリ リファレンス
16% |||||

Type.DeclaringMethod プロパティのお隣キーワード

Type.DeclaringMethod プロパティ

Type.DeclaringType プロパティ

Type.DefaultBinder プロパティ

TypeDecimalSchemaImporterExtension クラス

TypeDecimalSchemaImporterExtension コンストラクタ

TypeDecimalSchemaImporterExtension メソッド

TypeDecimalSchemaImporterExtension メンバ

   

 英語⇒日本語
日本語⇒英語		    


Type.DeclaringMethod プロパティのページの著作権

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2026 Microsoft.All rights reserved.

©2026 GRAS Group, Inc.RSS