MemberInfo.DeclaringType 属性

项目
08/17/2007

获取声明该成员的类。

**命名空间:**System.Reflection
**程序集:**mscorlib（在 mscorlib.dll 中）

语法

声明
Public MustOverride ReadOnly Property DeclaringType As Type
用法
Dim instance As MemberInfo
Dim value As Type

value = instance.DeclaringType

public abstract Type DeclaringType { get; }

public:
virtual property Type^ DeclaringType {
    Type^ get () abstract;
}

/** @property */
public abstract Type get_DeclaringType ()

public abstract function get DeclaringType () : Type

属性值

声明该成员的类的 Type 对象。

备注

DeclaringType 属性为声明此成员的类型检索对 Type 对象的引用。类型的成员由此类型声明或者从基类型继承，所以 DeclaringType 属性返回的 Type 对象可能与用于获取当前 MemberInfo 对象的 Type 对象不同。

如果从中获取此 MemberInfo 对象的 Type 对象未声明此成员，则 DeclaringType 表示其基类型之一。
如果 MemberInfo 对象是全局成员（即它是从返回某个模块上的全局方法的 Module.GetMethods 获取的），则返回的 DeclaringType 将为空引用（在 Visual Basic 中为 Nothing）。

示例

下面的示例显示 DeclaringType 如何使用类和接口，并检索 System.IO.BufferedStream 类的成员名称，以及这些成员在哪个类中声明。另请注意，当 B 重写来自 A 的虚方法 M 时，它将从本质上重新定义（或重新声明）此方法。因此，即使此方法最初是在 A 中声明的，B.M 的 MethodInfo 仍将声明类型报告为 B 而不是 A。

Imports System
Imports System.IO
Imports System.Reflection
Imports Microsoft.VisualBasic

Namespace MyNamespace1

    Interface i
        Function MyVar() As Integer
    End Interface
    ' DeclaringType for MyVar is i.

    Class A
        Implements i
        Function MyVar() As Integer Implements i.MyVar
            Return 0
        End Function
    End Class
    ' DeclaringType for MyVar is A.

    Class B
        Inherits A
        Function MyVars() As Integer
            Return 0
        End Function
    End Class
    ' DeclaringType for MyVar is B.

    Class C
        Inherits A
    End Class
    ' DeclaringType for MyVar is A.
End Namespace

Namespace MyNamespace2

    Class A
        Public Overridable Sub M()
        End Sub
    End Class

    Class B
        Inherits A
        Public Overrides Sub M()
        End Sub
    End Class
End Namespace
Class Mymemberinfo

    Public Shared Sub Main()

        Console.WriteLine(ControlChars.Cr & "Reflection.MemberInfo")

        'Get the Type and MemberInfo.
        Dim MyType As Type = Type.GetType("System.IO.BufferedStream")

        Dim Mymemberinfoarray As MemberInfo() = MyType.GetMembers()

        'Get and display the DeclaringType method.
        Console.WriteLine(ControlChars.Cr & "There are {0} members in {1}.", Mymemberinfoarray.Length, MyType.FullName)

        Dim Mymemberinfo As MemberInfo
        For Each Mymemberinfo In Mymemberinfoarray
            Console.WriteLine("The declaring type of {0} is {1}.", Mymemberinfo.Name, Mymemberinfo.DeclaringType.ToString())
        Next Mymemberinfo
    End Sub
End Class

using System;
using System.IO;
using System.Reflection;

namespace MyNamespace1 
{
    interface i 
    {
        int MyVar() ;
    };
    // DeclaringType for MyVar is i.
 
    class A : i 
    {
        public int MyVar() { return 0; }
    };
    // DeclaringType for MyVar is A.
 
    class B : A 
    {
        new int MyVar() { return 0; }
    };
    // DeclaringType for MyVar is B.
 
    class C : A 
    {
    };
    // DeclaringType for MyVar is A.

}

namespace MyNamespace2 
{
    class Mymemberinfo 
    { 
 
        public static void Main(string[] args) 
        { 
 
            Console.WriteLine ("\nReflection.MemberInfo");
 
            //Get the Type and MemberInfo. 
            Type MyType =Type.GetType("System.IO.BufferedStream");
            MemberInfo[] Mymemberinfoarray = MyType.GetMembers();
 
            //Get and display the DeclaringType method. 
            Console.WriteLine("\nThere are {0} members in {1}.", Mymemberinfoarray.Length, MyType.FullName); 
 
            foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) 
            {  
                Console.WriteLine("Declaring type of {0} is {1}.", Mymemberinfo.Name, Mymemberinfo.DeclaringType); 
            }
        }
    }
}

namespace MyNamespace3 
{
    class A 
    {
        virtual public void M () {}
    }
    class B: A 
    {
        override public void M () {}
    }
}

using namespace System;
using namespace System::IO;
using namespace System::Reflection;

namespace MyNamespace1
{
   interface class i
   {
      int MyVar();
   };

   // DeclaringType for MyVar is i.
   ref class A: public i
   {
   public:
      virtual int MyVar()
      {
         return 0;
      }

   };

   // DeclaringType for MyVar is A.
   ref class B: public A
   {
   private:
      int MyVar() new
      {
         return 0;
      }
   };

   // DeclaringType for MyVar is B.
   ref class C: public A{};
}

// DeclaringType for MyVar is A.
int main()
{
   Console::WriteLine( "\nReflection.MemberInfo" );

   //Get the Type and MemberInfo. 
   Type^ MyType = Type::GetType( "System.IO.BufferedStream" );
   array<MemberInfo^>^Mymemberinfoarray = MyType->GetMembers();

   //Get and display the DeclaringType method. 
   Console::WriteLine( "\nThere are {0} members in {1}.", Mymemberinfoarray->Length, MyType->FullName );
   System::Collections::IEnumerator^ enum0 = Mymemberinfoarray->GetEnumerator();
   while ( enum0->MoveNext() )
   {
      MemberInfo^ Mymemberinfo = safe_cast<MemberInfo^>(enum0->Current);
      Console::WriteLine( "Declaring type of {0} is {1}.", Mymemberinfo->Name, Mymemberinfo->DeclaringType );
   }
}

namespace MyNamespace3
{
   ref class A
   {
   public:
      virtual void M(){}

   };

   ref class B: public A
   {
   public:
      virtual void M() override {}
   };
}

package MyNamespace2;
import System.*;
import System.IO.*;
import System.Reflection.*;

class MyMemberInfo
{
    public static void main(String[] args)
    {
        Console.WriteLine("\nReflection.MemberInfo");

        //Get the Type and MemberInfo. 
        Type myType = Type.GetType("System.IO.BufferedStream");
        MemberInfo myMemberInfoArray[] = myType.GetMembers();

        //Get and display the DeclaringType method. 
        Console.WriteLine("\nThere are {0} members in {1}.", 
            String.valueOf(myMemberInfoArray.length),myType.get_FullName());
        
        for(int iCtr=0; iCtr < myMemberInfoArray.length; iCtr++) {  
            MemberInfo myMemberInfo = myMemberInfoArray[iCtr];
            Console.WriteLine("Declaring type of {0} is {1}.", 
                myMemberInfo.get_Name(),myMemberInfo.get_DeclaringType());
        }
    } //main
} //MyMemberInfo

package MyPackage1 {

 interface i {
 function MyVar() : int ;
 };
 // DeclaringType for MyVar is i.
 
 class A implements i {
 public function MyVar() : int { return 0; }
 };
 // DeclaringType for MyVar is A.
 
 class B extends A {
 hide function MyVar() :  int{ return 0; }
 };
 // DeclaringType for MyVar is B.
 
 class C extends A {
 };
 // DeclaringType for MyVar is A.
}

import System;
import System.IO;
import System.Reflection;

class Mymemberinfo { 
 
   public static function Main() : void  { 
 
    Console.WriteLine ("\nReflection.MemberInfo");
 
    //Get the Type and MemberInfo. 
    var MyType : Type =Type.GetType("System.IO.BufferedStream");
    var Mymemberinfoarray : MemberInfo[] = MyType.GetMembers();
 
    //Get and display the DeclaringType method. 
    Console.Write("\nThere are {0} members in ", Mymemberinfoarray.Length); 
    Console.Write("{0}.", MyType.FullName); 
 
    for (var i : int in Mymemberinfoarray) {
      var Mymemberinfo : MemberInfo = Mymemberinfoarray[i];  
      Console.Write("\n" + Mymemberinfo.Name + " declaring type - "
        + Mymemberinfo.DeclaringType); 
    }
   }
}
Mymemberinfo.Main();


package MyPackage3 {
class A {
    public function M () : void  {}
}
class B extends A {
    override public function M () : void  {}
}
}

提示

DeclaringType 仅返回成员名称及其声明类型的名称。若要返回带原型的成员名称，请调用 MemberInfo.ToString。

平台

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 并不是对每个平台的所有版本都提供支持。有关受支持版本的列表，请参见系统要求。

通过

MemberInfo.DeclaringType 属性

语法

属性值

备注

示例

平台

版本信息

.NET Framework

.NET Compact Framework

请参见

参考

其他资源