Exportieren (0) Drucken
Alle erweitern

Gewusst wie: Laden von Assemblys in den reflektionsbezogenen Kontext

Mit dem reflektionsbezogenen Ladekontext können Assemblys untersucht werden, die für andere Plattformen oder für andere Versionen von .NET Framework kompiliert wurden. In diesen Kontext geladener Code kann nur untersucht, nicht jedoch ausgeführt werden. Dies bedeutet, dass keine Objekte erstellt werden können, da die Konstruktoren nicht ausgeführt werden können. Da der Code nicht ausgeführt werden kann, werden Abhängigkeiten nicht automatisch geladen. Wenn Sie die Abhängigkeiten untersucht werden sollen, müssen Sie diese selbst laden.

So laden Sie eine Assembly in den reflektionsbezogenen Ladekontext

  1. Laden Sie die Assembly mithilfe der ReflectionOnlyLoad-Methodenüberladung, sofern der Anzeigename angegeben ist, oder mithilfe der ReflectionOnlyLoadFrom-Methode, sofern der Pfad angegeben ist. Wenn es sich bei der Assembly um ein binäres Bild handelt, verwenden Sie die ReflectionOnlyLoad-Methodenüberladung.

    NoteHinweis

    Sie können mit dem reflektionsbezogenen Kontext keine Version der mscorlib.dll aus einer anderen Version von .NET Framework als der Version im Ausführungskontext laden.

  2. Wenn die Assembly über Abhängigkeiten verfügt, lädt die ReflectionOnlyLoad-Methode sie nicht. Wenn Sie die Abhängigkeiten untersuchen müssen, müssen Sie diese selbst laden.

  3. Mithilfe der ReflectionOnly-Eigenschaft der Assembly können Sie ermitteln, ob eine Assembly in den reflektionsbezogenen Kontext geladen ist.

  4. Wenn auf die Assembly oder die Typen in der Assembly Attribute angewendet wurden, untersuchen Sie diese Attribute mithilfe der CustomAttributeData-Klasse, um zu gewährleisten, dass nicht versucht wird, Code im reflektionsbezogenen Kontext auszuführen. Mit der entsprechenden Überladung der System.Reflection.CustomAttributeData.GetCustomAttributes(System.Reflection.Assembly)-Methode rufen Sie die CustomAttributeData-Objekte ab, die die Attribute darstellen, die auf eine Assembly, einen Member, ein Modul oder einen Parameter angewendet wurden.

    NoteHinweis

    Attribute, die auf die Assembly oder ihren Inhalt angewendet wurden, können in der Assembly oder in einer anderen Assembly definiert sein, die in den reflektionsbezogenen Kontext geladen ist. Es kann nicht vorausgesagt werden, wo die Attribute definiert werden.

Beispiel

Im folgenden Beispielcode wird veranschaulicht, wie Sie die Attribute untersuchen, die auf eine in den reflektionsbezogenen Kontext geladene Assembly angewendet wurden.

Im Codebeispiel wird ein benutzerdefiniertes Attribut mit zwei Konstruktoren und einer Eigenschaft definiert. Das Attribut wird auf die Assembly, einen in der Assembly deklarierten Typ, eine Methode des Typs und einen Parameter der Methode angewendet. Bei der Ausführung lädt die Assembly sich selbst in den reflektionsbezogenen Kontext und zeigt Informationen über die benutzerdefinierten Attribute an, die auf sie und die enthaltenen Typen und Member angewendet wurden.

NoteHinweis

Um das Codebeispiel zu vereinfachen, lädt und untersucht sich die Assembly selbst. Unter normalen Umständen würden Sie nicht erwarten, dass ein und dieselbe Assembly sowohl in den Ausführungskontext als auch in den reflektionsbezogenen Kontext geladen wird.

using System;
using System.Reflection;
using System.Collections.Generic;

// The example attribute is applied to the assembly.
[assembly:Example(ExampleKind.ThirdKind, Note="This is a note on the assembly.")]

// An enumeration used by the ExampleAttribute class.
public enum ExampleKind
{
    FirstKind, 
    SecondKind, 
    ThirdKind, 
    FourthKind
};

// An example attribute. The attribute can be applied to all
// targets, from assemblies to parameters.
//
[AttributeUsage(AttributeTargets.All)]
public class ExampleAttribute : Attribute
{
    // Data for properties.
    private ExampleKind kindValue;
    private string noteValue;

    // Constructors. The parameterless constructor (.ctor) calls
    // the constructor that specifies ExampleKind, and supplies the
    // default value.
    //
    public ExampleAttribute(ExampleKind initKind)
    {
        kindValue = initKind;
    }
    public ExampleAttribute() : this(ExampleKind.FirstKind) {}

    // Properties. The Note property must be read/write, so that it
    // can be used as a named parameter.
    //
    public ExampleKind Kind { get { return kindValue; }}
    public string Note    
    {
        get { return noteValue; }
        set { noteValue = value; }
    }
}

// The example attribute is applied to the test class.
//
[Example(ExampleKind.SecondKind, Note="This is a note on the class.")]
public class Test
{
    // The example attribute is applied to a method, using the
    // parameterless constructor and supplying a named argument.
    // The attribute is also applied to the method parameter.
    //
    [Example(Note="This is a note on a method.")]
    public void TestMethod([Example] object arg) { }

    // Main() gets objects representing the assembly, the test
    // type, the test method, and the method parameter. Custom
    // attribute data is displayed for each of these.
    //
    public static void Main()
    {
        Assembly asm = Assembly.ReflectionOnlyLoad("Source");
        Type t = asm.GetType("Test");
        MethodInfo m = t.GetMethod("TestMethod");
        ParameterInfo[] p = m.GetParameters();

        Console.WriteLine("\r\nAttributes for assembly: {0}", asm);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(asm));
        Console.WriteLine("\r\nAttributes for type: {0}", t);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(t));
        Console.WriteLine("\r\nAttributes for member: {0}", m);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(m));
        Console.WriteLine("\r\nAttributes for parameter: {0}", p);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(p[0]));
    }

    private static void ShowAttributeData(
        IList<CustomAttributeData> attributes)
    {
        foreach( CustomAttributeData cad in attributes )
        {
            Console.WriteLine("   {0}", cad);
            Console.WriteLine("      Constructor: {0}", cad.Constructor);

            Console.WriteLine("      Constructor arguments:");
            foreach( CustomAttributeTypedArgument cata 
                in cad.ConstructorArguments )
            {
                Console.WriteLine("         Type: {0} Value: {1}", 
                    cata.ArgumentType, cata.Value);
            }

            Console.WriteLine("      Named arguments:");
            foreach( CustomAttributeNamedArgument cana 
                in cad.NamedArguments )
            {
                CustomAttributeTypedArgument cata = cana.TypedValue;
                Console.WriteLine("         MemberInfo: {0}", 
                    cana.MemberInfo);
                Console.WriteLine("         Type: {0} Value: {1}", 
                    cata.ArgumentType, cata.Value);
            }
        }
    }
}

/* This code example produces output similar to the following:

Attributes for assembly: source, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
   [ExampleAttribute((ExampleKind)2, Note = "This is a note on the assembly.")]
      Constructor: Void .ctor(ExampleKind)
      Constructor arguments:
         Type: ExampleKind Value: 2
      Named arguments:
         MemberInfo: System.String Note
         Type: System.String Value: This is a note on the assembly.
   [System.Runtime.CompilerServices.CompilationRelaxationsAttribute((Int32)8)]
      Constructor: Void .ctor(Int32)
      Constructor arguments:
         Type: System.Int32 Value: 8
      Named arguments:

Attributes for type: Test
   [ExampleAttribute((ExampleKind)1, Note = "This is a note on the class.")]
      Constructor: Void .ctor(ExampleKind)
      Constructor arguments:
         Type: ExampleKind Value: 1
      Named arguments:
         MemberInfo: System.String Note
         Type: System.String Value: This is a note on the class.

Attributes for member: Void TestMethod(System.Object)
   [ExampleAttribute(Note = "This is a note on a method.")]
      Constructor: Void .ctor()
      Constructor arguments:
      Named arguments:
         MemberInfo: System.String Note
         Type: System.String Value: This is a note on a method.

Attributes for parameter: System.Object arg
   [ExampleAttribute()]
      Constructor: Void .ctor()
      Constructor arguments:
      Named arguments:
*/

Siehe auch

Anzeigen:
© 2015 Microsoft