AppDomain.ReflectionOnlyGetAssemblies Methode

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

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

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

Public Function ReflectionOnlyGetAssemblies () As Assembly()

Gibt zurück

Ein Array von Assembly Objekten, die die Assemblys darstellen, die in den reinen Spiegelungskontext der Anwendungsdomäne geladen wurden.

Ausnahmen

Beispiele

Im folgenden Codebeispiel wird die System.dll Assembly in den Ausführungskontext und dann in den Kontext "Spiegelung" geladen. Die GetAssemblies Methoden ReflectionOnlyGetAssemblies und Methoden werden verwendet, um die assemblys anzuzeigen, die in jeden Kontext geladen wurden.

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

Hinweise

Diese Methode gibt die Assemblys zurück, die in den reinen Spiegelungskontext geladen wurden. Verwenden Sie die GetAssemblies Methode, um die Assemblys abzurufen, die für die Ausführung geladen wurden.

Weitere Informationen

• GetAssemblies()