Assembly.GetExportedTypes Methode

Referenz

Definition

Namespace:: System.Reflection

Assembly:: System.Runtime.dll

Assembly:: System.Reflection.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: Assembly.cs

Quelle:: Assembly.cs

Quelle:: Assembly.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ruft die in dieser Assembly definierten öffentlichen Typen ab, die außerhalb der Assembly sichtbar sind.

public:
 virtual cli::array <Type ^> ^ GetExportedTypes();

public virtual Type[] GetExportedTypes ();

abstract member GetExportedTypes : unit -> Type[]
override this.GetExportedTypes : unit -> Type[]

Public Overridable Function GetExportedTypes () As Type()

Gibt zurück

Type[]

Ein Array, das die in dieser Assembly definierten Typen darstellt, die außerhalb der Assembly sichtbar sind.

Implementiert

GetExportedTypes()

Ausnahmen

NotSupportedException

Die Assembly ist eine dynamische Assembly.

FileNotFoundException

Eine abhängige Assembly konnte nicht geladen werden.

Beispiele

Das folgende Codebeispiel definiert eine Reihe von Klassen mit verschiedenen Zugriffsebenen und Aufrufe GetExportedTypes , um diejenigen anzuzeigen, die von außerhalb der Assembly sichtbar sind.

using namespace System;
using namespace System::Reflection;

namespace ExportedClassExample
{
    public ref class Example sealed
    {
    private:
        Example() 
        {
        }

    public:
        void static EnumerateExportedTypes()
        {
            for each (Type^ exportedType in 
                Example::typeid->Assembly->GetExportedTypes())
            {
                Console::WriteLine(exportedType);
            }
        }
    };

    public ref class PublicClass
    {
    public:
        ref class PublicNestedClass 
        { 
        };

    protected:
        ref class ProtectedNestedClass 
        { 
        };

    internal:
        ref class FriendNestedClass 
        { 
        };

    private:
        ref class PrivateNestedClass
        { 
        };
    };

    ref class FriendClass
    {
    public:
        ref class PublicNestedClass
        { 
        };

    protected:
        ref class ProtectedNestedClass 
        { 
        };

    internal:
        ref class FriendNestedClass 
        { 
        };

    private:
        ref class PrivateNestedClass 
        { 
        };
    };
}

int main()
{
    ExportedClassExample::Example::EnumerateExportedTypes();

    return 0;
}

using System;
using System.Reflection;

public class Example
{
    public static void Main()
    {
        foreach (Type t in typeof(Example).Assembly.GetExportedTypes())
        {
            Console.WriteLine(t);
        }
    }
}

public class PublicClass
{
    public class PublicNestedClass {}

    protected class ProtectedNestedClass {}

    internal class FriendNestedClass {}

    private class PrivateNestedClass {}
}

internal class FriendClass
{
    public class PublicNestedClass {}

    protected class ProtectedNestedClass {}

    internal class FriendNestedClass {}

    private class PrivateNestedClass {}
}

Imports System.Reflection

Public Class Example
    Public Shared Sub Main()
        For Each t As Type In GetType(Example).Assembly.GetExportedTypes()
            Console.WriteLine(t)
        Next
    End Sub
End Class

Public Class PublicClass
    Public Class PublicNestedClass
    End Class

    Protected Class ProtectedNestedClass
    End Class

    Friend Class FriendNestedClass
    End Class

    Private Class PrivateNestedClass
    End Class
End Class

Friend Class FriendClass
    Public Class PublicNestedClass
    End Class

    Protected Class ProtectedNestedClass
    End Class

    Friend Class FriendNestedClass
    End Class

    Private Class PrivateNestedClass
    End Class
End Class

Hinweise

Die einzigen Typen, die außerhalb einer Assembly sichtbar sind, sind öffentliche Typen und öffentliche Typen, die in anderen öffentlichen Typen geschachtelt sind. Verwenden Sie die -Methode, um alle Typen innerhalb einer Assembly abzurufen, einschließlich der typen, die GetTypes nicht öffentlich sind.

Gilt für:

Freigeben über