Assembly.GetCallingAssembly Assembly.GetCallingAssembly Assembly.GetCallingAssembly Assembly.GetCallingAssembly Method

Definición

Devuelve el Assembly del método al que llamó el método actualmente en ejecución.Returns the Assembly of the method that invoked the currently executing method.

public:
 static System::Reflection::Assembly ^ GetCallingAssembly();
public static System.Reflection.Assembly GetCallingAssembly ();
static member GetCallingAssembly : unit -> System.Reflection.Assembly
Public Shared Function GetCallingAssembly () As Assembly

Devoluciones

Objeto Assembly del método al que llamó el método actualmente en ejecución.The Assembly object of the method that invoked the currently executing method.

Ejemplos

En el ejemplo siguiente se obtiene el ensamblado de llamada del método actual.The following example gets the calling assembly of the current method.

using namespace System;
using namespace System::Reflection;

void main()
{
   // Instantiate a target object.
   Int32 integer1 = 0;
   // Set the Type instance to the target class type.
   Type^ type1 = integer1.GetType();
   // Instantiate an Assembly class to the assembly housing the Integer type.
   Assembly^ sampleAssembly = Assembly::GetAssembly(integer1.GetType());
   // Display the name of the assembly that is calling the method.
   Console::WriteLine("GetCallingAssembly = {0}", Assembly::GetCallingAssembly()->FullName);
}
// The example displays output like the following:
//    GetCallingAssembly = Example, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// Assembly FirstAssembly
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace FirstAssembly
{
    public class InFirstAssembly
    {
        public static void Main()
        {
            FistMethod();
            SecondAssembly.InSecondAssembly.OtherMethod();
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static void FirstMethod()
        {
            Console.WriteLine("FirstMethod called from: " + Assembly.GetCallingAssembly().FullName);
        }
    }
}

// Assembly SecondAssembly
using System;
using System.Reflection;
using System.Runtime.CompilerServices;

namespace SecondAssembly
{
    class InSecondAssembly
    {
        [MethodImpl(MethodImplOptions.NoInlining)]
        public static void OtherMethod()
        {
            Console.WriteLine("OtherMehod executing assembly: " + Assembly.GetExecutingAssembly().FullName);
            Console.WriteLine("OtherMethod called from: " + Assembly.GetCallingAssembly().FullName);
        }
    }
}
// The example produces output like the following:
// "FirstMethod called from: FirstAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"
// "OtherMethod executing assembly: SecondAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"
// "OtherMethod called from: FirstAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Instantiate a target object.
      Dim int1 As Integer
      ' Set the Type instance to the target class type.
      Dim type1 As Type =int1.GetType()
      ' Instantiate an Assembly class to the assembly housing the Integer type.
      Dim sampleAssembly = Assembly.GetAssembly(int1.GetType())
      ' Display the name of the assembly that is calling the method.
      Console.WriteLine(("GetCallingAssembly = " + Assembly.GetCallingAssembly().FullName))
   End Sub
End Module
' The example displays output like the following:
'   GetCallingAssembly = Example, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null

Comentarios

Si el método que llama al GetCallingAssembly método se expande en línea mediante el compilador Just-in-Time (JIT) o si el llamador se expande en línea, el ensamblado devuelto GetCallingAssembly por puede diferir inesperadamente.If the method that calls the GetCallingAssembly method is expanded inline by the just-in-time (JIT) compiler, or if its caller is expanded inline, the assembly that is returned by GetCallingAssembly may differ unexpectedly. Por ejemplo, considere los siguientes métodos y ensamblados:For example, consider the following methods and assemblies:

  • Método M1 en llamadas A1 deensamblado.GetCallingAssemblyMethod M1 in assembly A1 calls GetCallingAssembly.

  • Método M2 en llamadas A2 deensamblado.M1Method M2 in assembly A2 calls M1.

  • Método M3 en llamadas A3 deensamblado.M2Method M3 in assembly A3 calls M2.

Cuando M1 no está insertado, GetCallingAssembly devuelve A2.When M1 is not inlined, GetCallingAssembly returns A2. Cuando M1 está insertado, GetCallingAssembly devuelve A3.When M1 is inlined, GetCallingAssembly returns A3. Del mismo modo M2 , cuando no está insertado GetCallingAssembly , A2devuelve.Similarly, when M2 is not inlined, GetCallingAssembly returns A2. Cuando M2 está insertado, GetCallingAssembly devuelve A3.When M2 is inlined, GetCallingAssembly returns A3.

Este efecto también se produce M1 cuando se ejecuta como una llamada de M2cola desde, M2 o cuando se ejecuta como una llamada M3de cola de.This effect also occurs when M1 executes as a tail call from M2, or when M2 executes as a tail call from M3. Puede evitar que el compilador JIT inlinee el método GetCallingAssemblyque llama a, MethodImplAttribute aplicando el MethodImplOptions.NoInlining atributo con la marca, pero no hay ningún mecanismo similar para evitar las llamadas de cola.You can prevent the JIT compiler from inlining the method that calls GetCallingAssembly, by applying the MethodImplAttribute attribute with the MethodImplOptions.NoInlining flag, but there is no similar mechanism for preventing tail calls.

Se aplica a