Assembly.GetExportedTypes Método

Definição

Namespace:

System.Reflection

Assembly:

System.Runtime.dll

Origem:

Assembly.cs

Obtém os tipos públicos definidos nesse assembly que são visíveis fora do assembly.

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()

Retornos

Type[]

Uma matriz que representa os tipos definidos nesse assembly que são visíveis fora do assembly.

Exceções

NotSupportedException

O assembly é um assembly dinâmico.

FileNotFoundException

Não é possível carregar um assembly dependente.

Exemplos

O exemplo de código a seguir define várias classes com vários níveis de acesso e chamadas GetExportedTypes para exibir as que estão visíveis de fora do assembly.

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

Comentários

Os únicos tipos visíveis fora de um assembly são tipos públicos e tipos públicos aninhados em outros tipos públicos. Para recuperar todos os tipos em um assembly, incluindo aqueles que não são públicos, use o GetTypes método .