Assembly.GetExportedTypes Método

  • Referencia

Definición

Espacio de nombres:
System.Reflection
Ensamblado:
System.Runtime.dll
Ensamblado:
System.Reflection.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll
Source:
Assembly.cs
Source:
Assembly.cs
Source:
Assembly.cs

Obtiene los tipos públicos definidos en este ensamblado que se pueden ver desde fuera del ensamblado.

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

Devoluciones

Type[]

Matriz que representa los tipos definidos en este ensamblado y que se pueden ver desde fuera del ensamblado.

Implementaciones

GetExportedTypes()

Excepciones

NotSupportedException

El ensamblado es un ensamblado dinámico.

FileNotFoundException

No se puede cargar un ensamblado dependiente.

Ejemplos

En el ejemplo de código siguiente se definen varias clases con varios niveles de acceso y se llama GetExportedTypes a para mostrar las que están visibles desde fuera del ensamblado.

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

Comentarios

Los únicos tipos visibles fuera de un ensamblado son tipos públicos y tipos públicos anidados dentro de otros tipos públicos. Para recuperar todos los tipos de un ensamblado, incluidos los que no son públicos, use el GetTypes método .

Se aplica a