MethodBase.IsAssembly-Eigenschaft

Ruft einen Wert ab, der angibt, ob diese Methode von anderen Klassen in derselben Assembly aufgerufen werden kann.

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

Syntax

'Declaration
Public ReadOnly Property IsAssembly As Boolean
'Usage
Dim instance As MethodBase
Dim value As Boolean

value = instance.IsAssembly

public bool IsAssembly { get; }

public:
virtual property bool IsAssembly {
    bool get () sealed;
}

/** @property */
public final boolean get_IsAssembly ()

public final function get IsAssembly () : boolean

Eigenschaftenwert

true, wenn diese Methode von anderen Klassen in derselben Assembly aufgerufen werden kann, andernfalls false.

Hinweise

Wenn festgelegt, kann diese Methode von anderen Klassen in derselben Assembly abgerufen werden.

Rufen Sie zuerst den Typ ab, um MethodBase abzurufen. Rufen Sie die Methode aus dem Typ ab. Rufen Sie MethodBase aus der Methode ab. Wenn MethodBase oder der Konstruktor nicht öffentlich sind, sind sie geschützt, und der Zugriff darauf ist nicht ohne weiteres möglich. Legen Sie die BindingFlags-Maske in GetMethod auf NonPublic fest, um auf eine nicht öffentliche Methode zugreifen zu können.

Beispiel

Im folgenden Beispiel wird bestimmt, ob eine angegebene Methode von anderen Klassen in derselben Assembly aufgerufen werden kann, und das Ergebnis wird angezeigt.

Imports System
Imports System.Reflection
Imports Microsoft.VisualBasic

Class methodbase1
    Friend Sub f()
    End Sub

    Public Shared Function Main() As Integer
        Console.WriteLine(ControlChars.CrLf + "Reflection.MethodBase")
        
        'Get the types.
        Dim MyType1 As Type = _
           Type.GetType("System.Runtime.Serialization.Formatter")
        Dim MyType2 As Type = _
           Type.GetType("methodbase1")

        ' Get and display the methods and the IsAssembly property value.
        Dim Mymethodbase1 As MethodBase = _
           MyType1.GetMethod("WriteInt32", BindingFlags.NonPublic Or BindingFlags.Instance)
        Dim Mymethodbase2 As MethodBase = _
           MyType2.GetMethod("f", BindingFlags.NonPublic Or BindingFlags.Instance)
       
        Console.Write(ControlChars.CrLf _
           + "Mymethodbase = " + Mymethodbase1.ToString())
        If Mymethodbase1.IsAssembly Then
            Console.Write(ControlChars.CrLf _
               + "Mymethodbase is an assembly method.")
        Else
            Console.Write(ControlChars.CrLf _
               + "Mymethodbase is not an assembly method.")
        End If 
        Console.Write(ControlChars.CrLf + ControlChars.CrLf _
           + "Mymethodbase = " + Mymethodbase2.ToString())
        If Mymethodbase2.IsAssembly Then
            Console.Write(ControlChars.CrLf + _
               "Mymethodbase is an assembly method.")
        Else
            Console.Write(ControlChars.CrLf + _
               "Mymethodbase is not an assembly method.")
        End If 
        Return 0
    End Function
End Class

using System;
using System.Reflection;

class methodbase
{
    internal void f() { }
    public static int Main(string[] args)
    { 
        Console.WriteLine ("\nReflection.MethodBase");
       
        // Get the MethodBase of two methods.
 
        // Get the types.
        Type MyType1 = Type.GetType("System.Runtime.Serialization.Formatter");
        Type MyType2 = Type.GetType("methodbase");
 
        // Get and display the methods and the IsAssembly property value.
        MethodBase Mymethodbase1 = 
            MyType1.GetMethod("WriteInt32",BindingFlags.NonPublic|BindingFlags.Instance);
        MethodBase Mymethodbase2 = 
            MyType2.GetMethod("f", BindingFlags.NonPublic|BindingFlags.Instance);
 
        Console.Write("\nMymethodbase = " + Mymethodbase1.ToString());
        if (Mymethodbase1.IsAssembly)
            Console.Write ("\nMymethodbase is an assembly method.");
        else
            Console.Write ("\nMymethodbase is not an assembly method.");
 
        Console.Write("\n\nMymethodbase = " + Mymethodbase2.ToString());
        if (Mymethodbase2.IsAssembly)
            Console.Write ("\nMymethodbase is an assembly method.");
        else
            Console.Write ("\nMymethodbase is not an assembly method.");
       
        return 0;
    }
}

using namespace System;
using namespace System::Reflection;
public ref class methodbase
{
public private:
   void f(){}

};

int main()
{
   Console::WriteLine( "\nReflection.MethodBase" );
   
   // Get the MethodBase of two methods.
   // Get the types.
   Type^ MyType1 = Type::GetType( "System.Runtime.Serialization.Formatter" );
   Type^ MyType2 = Type::GetType( "methodbase" );
   
   // Get and display the methods and the IsAssembly property value.
   MethodBase^ Mymethodbase1 = MyType1->GetMethod( "WriteInt32", static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance) );
   MethodBase^ Mymethodbase2 = MyType2->GetMethod( "f", static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance) );
   Console::Write( "\nMymethodbase = {0}", Mymethodbase1 );
   if ( Mymethodbase1->IsAssembly )
      Console::Write( "\nMymethodbase is an assembly method." );
   else
      Console::Write( "\nMymethodbase is not an assembly method." );

   Console::Write( "\n\nMymethodbase = {0}", Mymethodbase2 );
   if ( Mymethodbase2->IsAssembly )
      Console::Write( "\nMymethodbase is an assembly method." );
   else
      Console::Write( "\nMymethodbase is not an assembly method." );

   return 0;
}

import System.*;
import System.Reflection.*;

class Methodbase
{
    void F()
    {
    } //F

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

        // Get the MethodBase of two methods.
        // Get the types.
        Type myType1 = Type.GetType("System.Runtime.Serialization.Formatter");
        Type myType2 = Type.GetType("Methodbase");

        // Get and display the methods and the IsAssembly property value.
        MethodBase myMethodBase1 = myType1.GetMethod("WriteInt32", 
            BindingFlags.NonPublic | BindingFlags.Instance);
        MethodBase myMethodBase2 = myType2.GetMethod("F",
            BindingFlags.NonPublic | BindingFlags.Instance|
            BindingFlags.Public);
        Console.Write(("\nmyMethodBase = " + myMethodBase1.ToString()));
        if ( myMethodBase1.get_IsAssembly()  ) {
            Console.Write("\nmyMethodBase is an assembly method.");
        }
        else {
            Console.Write("\nmyMethodBase is not an assembly method.");
        } 
        Console.Write(("\n\nmyMethodBase = " + myMethodBase2.ToString()));
        if ( myMethodBase2.get_IsAssembly()  ) {
            Console.Write("\nmyMethodBase is an assembly method.");
        }
        else {
            Console.Write("\nmyMethodBase is not an assembly method.");
        } 

    } //main
} //methodbase

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.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

MethodBase-Klasse
MethodBase-Member
System.Reflection-Namespace
FieldAttributes-Enumeration
Boolean
BindingFlags-Enumeration