AppDomain.ReflectionOnlyGetAssemblies Método

public:
 cli::array <System::Reflection::Assembly ^> ^ ReflectionOnlyGetAssemblies();

public System.Reflection.Assembly[] ReflectionOnlyGetAssemblies ();

member this.ReflectionOnlyGetAssemblies : unit -> System.Reflection.Assembly[]

Public Function ReflectionOnlyGetAssemblies () As Assembly()

Devoluciones

Assembly[]

Matriz de objetos Assembly que representan los ensamblados cargados en el contexto de solo reflexión del dominio de aplicación.

Excepciones

Ejemplos

En el ejemplo de código siguiente se carga el ensamblado System.dll en el contexto de ejecución y, a continuación, en el contexto de solo reflexión. Los GetAssemblies métodos y ReflectionOnlyGetAssemblies se usan para mostrar los ensamblados cargados en cada contexto.

using namespace System;
using namespace System::Reflection;

#using <System.dll>

using namespace System::Timers;
using namespace System::Collections;
int main()
{
   
   // Get the assembly display name for System.dll, the assembly 
   // that contains System.Timers.Timer. Note that this causes
   // System.dll to be loaded into the execution context.
   //
   String^ displayName = Timer::typeid->Assembly->FullName;
   
   // Load System.dll into the reflection-only context. Note that 
   // if you obtain the display name (for example, by running this
   // example program), and enter it as a literal string in the 
   // preceding line of code, you can load System.dll into the 
   // reflection-only context without loading it into the execution 
   // context.
   Assembly::ReflectionOnlyLoad( displayName );
   
   // Display the assemblies loaded into the execution and 
   // reflection-only contexts. System.dll appears in both contexts.
   //
   Console::WriteLine( L"------------- Execution Context --------------" );
   IEnumerator^ myEnum = AppDomain::CurrentDomain->GetAssemblies()->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Assembly^ a = safe_cast<Assembly^>(myEnum->Current);
      Console::WriteLine( L"\t{0}", a->GetName() );
   }

   Console::WriteLine( L"------------- Reflection-only Context --------------" );
   IEnumerator^ myEnum1 = AppDomain::CurrentDomain->ReflectionOnlyGetAssemblies()->GetEnumerator();
   while ( myEnum1->MoveNext() )
   {
      Assembly^ a = safe_cast<Assembly^>(myEnum1->Current);
      Console::WriteLine( L"\t{0}", a->GetName() );
   }
}

using System;
using System.Reflection;
using System.Timers;

public class Example
{
    public static void Main()
    {
        // Get the assembly display name for System.dll, the assembly
        // that contains System.Timers.Timer. Note that this causes
        // System.dll to be loaded into the execution context.
        //
        string displayName = typeof(Timer).Assembly.FullName;

        // Load System.dll into the reflection-only context. Note that
        // if you obtain the display name (for example, by running this
        // example program), and enter it as a literal string in the
        // preceding line of code, you can load System.dll into the
        // reflection-only context without loading it into the execution
        // context.
        Assembly.ReflectionOnlyLoad(displayName);

        // Display the assemblies loaded into the execution and
        // reflection-only contexts. System.dll appears in both contexts.
        //
        Console.WriteLine("------------- Execution Context --------------");
        foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
        {
            Console.WriteLine("\t{0}", a.GetName());
        }
        Console.WriteLine("------------- Reflection-only Context --------------");
        foreach (Assembly a in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies())
        {
            Console.WriteLine("\t{0}", a.GetName());
        }
    }
}

open System
open System.Reflection
open System.Timers

// Get the assembly display name for System.dll, the assembly
// that contains System.Timers.Timer. Note that this causes
// System.dll to be loaded into the execution context.
let displayName = typeof<Timer>.Assembly.FullName

// Load System.dll into the reflection-only context. Note that
// if you obtain the display name (for example, by running this
// example program), and enter it as a literal string in the
// preceding line of code, you can load System.dll into the
// reflection-only context without loading it into the execution
// context.
Assembly.ReflectionOnlyLoad displayName |> ignore

// Display the assemblies loaded into the execution and
// reflection-only contexts. System.dll appears in both contexts.
printfn "------------- Execution Context --------------"
for a in AppDomain.CurrentDomain.GetAssemblies() do
    printfn $"\t{a.GetName()}"
printfn "------------- Reflection-only Context --------------"
for a in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies() do
    printfn $"\t{a.GetName()}"

Imports System.Reflection
Imports System.Timers

Public Class Example
    
    Public Shared Sub Main() 
        ' Get the assembly display name for System.dll, the assembly 
        ' that contains System.Timers.Timer. Note that this causes
        ' System.dll to be loaded into the execution context.
        '
        Dim displayName As String = GetType(Timer).Assembly.FullName
        
        ' Load System.dll into the reflection-only context. Note that 
        ' if you obtain the display name (for example, by running this
        ' example program), and enter it as a literal string in the 
        ' preceding line of code, you can load System.dll into the 
        ' reflection-only context without loading it into the execution 
        ' context.
        Assembly.ReflectionOnlyLoad(displayName)
        
        ' Display the assemblies loaded into the execution and 
        ' reflection-only contexts. System.dll appears in both contexts.
        '
        Dim ad As AppDomain = AppDomain.CurrentDomain
        Console.WriteLine("------------- Execution Context --------------")
        For Each a As Assembly In ad.GetAssemblies()
            Console.WriteLine(vbTab + "{0}", a.GetName())
        Next a
        Console.WriteLine("------------- Reflection-only Context --------------")
        For Each a As Assembly In ad.ReflectionOnlyGetAssemblies()
            Console.WriteLine(vbTab + "{0}", a.GetName())
        Next a
    
    End Sub
End Class

Comentarios

Este método devuelve los ensamblados que se han cargado en el contexto de solo reflexión. Para obtener los ensamblados que se han cargado para su ejecución, use el GetAssemblies método .

Se aplica a

Consulte también

• GetAssemblies()