AppDomain.ReflectionOnlyGetAssemblies Metodo

Definizione

Restituisce gli assembly caricati nel contesto ReflectionOnly del dominio applicazione.

public:
 cli::array <System::Reflection::Assembly ^> ^ ReflectionOnlyGetAssemblies();
public System.Reflection.Assembly[] ReflectionOnlyGetAssemblies ();
member this.ReflectionOnlyGetAssemblies : unit -> System.Reflection.Assembly[]
Public Function ReflectionOnlyGetAssemblies () As Assembly()

Restituisce

Matrice di oggetti Assembly che rappresentano gli assembly caricati nel contesto ReflectionOnly del dominio applicazione.

Eccezioni

Si è tentato di effettuare un'operazione su un dominio applicazione non caricato.

Esempio

Nell'esempio di codice seguente viene caricato l'assembly di System.dll nel contesto di esecuzione e quindi nel contesto di sola reflection. I GetAssemblies metodi e ReflectionOnlyGetAssemblies vengono usati per visualizzare gli assembly caricati in ogni contesto.

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 ReflectionOnlySnippet
{
    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

Commenti

Questo metodo restituisce gli assembly caricati nel contesto di sola reflection. Per ottenere gli assembly caricati per l'esecuzione, usare il GetAssemblies metodo .

Si applica a

Vedi anche