MemberInfo.DeclaringType-Eigenschaft

Artikel
08/20/2007

Ruft die Klasse ab, die diesen Member deklariert.

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public MustOverride ReadOnly Property DeclaringType As Type
'Usage
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

Eigenschaftenwert

Das Type-Objekt für die Klasse, in der dieser Member deklariert ist.

Hinweise

Die DeclaringType-Eigenschaft ruft einen Verweis auf das Type-Objekt für den Typ ab, der diesen Member deklariert. Ein Member eines Typs wird von einem Typ deklariert oder von einem Basistyp vererbt, sodass das von der DeclaringType-Eigenschaft zurückgegebene Type-Objekt möglicherweise nicht mit dem Type-Objekt identisch ist, das zum Abrufen von Informationen aus dem aktuellen MemberInfo-Objekt verwendet wird.

Wenn das Type-Objekt, von dem dieses MemberInfo-Objekt abgerufen wurde, diesen Member nicht deklariert hat, stellt DeclaringType einen seiner Basistypen dar.
Wenn das MemberInfo-Objekt ein globaler Member ist, d. h., es wurde von der Module.GetMethods-Methode abgerufen, wodurch globale Methoden für ein Modul zurückgegeben werden, hat der zurückgegebene DeclaringType-Typ den Wert NULL (Nothing in Visual Basic).

Beispiel

Das folgende Beispiel zeigt die Verwendung von DeclaringType mit Klassen und Schnittstellen. Außerdem werden die Membernamen der System.IO.BufferedStream-Klasse zusammen mit der Klasse abgerufen, in der diese Member deklariert sind. Beachten Sie auch, dass beim Überschreiben der virtuellen Methode M aus A durch B die Methode im Wesentlichen neu definiert bzw. neu deklariert wird. Deshalb meldet MethodInfo von B.M den Deklarationstyp als B und nicht als A, selbst wenn diese Methode ursprünglich in A deklariert wurde.

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  {}
}
}

Hinweis

DeclaringType gibt nur die Namen der Member und die Namen ihrer Deklarationstypen zurück. Um die Membernamen mit ihren Prototypen zurückzugeben, rufen Sie MemberInfo.ToString auf.

Plattformen

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

MemberInfo.DeclaringType-Eigenschaft

Syntax

Eigenschaftenwert

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen