Question

Assembly.GetEntryAssembly（）不适用于网络应用程序。

但是......我真的需要这样的东西。我使用了一些在Web和非Web应用程序中使用的深层嵌套代码。

我目前的解决方案是浏览StackTrace以找到第一个被调用的程序集。

/// <summary>
/// Version of 'GetEntryAssembly' that works with web applications
/// </summary>
/// <returns>The entry assembly, or the first called assembly in a web application</returns>
public static Assembly GetEntyAssembly()
{
    // get the entry assembly
    var result = Assembly.GetEntryAssembly();

    // if none (ex: web application)
    if (result == null)
    {
        // current method
        MethodBase methodCurrent = null;
        // number of frames to skip
        int framestoSkip = 1;


        // loop until we cannot got further in the stacktrace
        do
        {
            // get the stack frame, skipping the given number of frames
            StackFrame stackFrame = new StackFrame(framestoSkip);
            // get the method
            methodCurrent = stackFrame.GetMethod();
            // if found
            if ((methodCurrent != null)
                // and if that method is not excluded from the stack trace
                && (methodCurrent.GetAttribute<ExcludeFromStackTraceAttribute>(false) == null))
            {
                // get its type
                var typeCurrent = methodCurrent.DeclaringType;
                // if valid
                if (typeCurrent != typeof (RuntimeMethodHandle))
                {
                    // get its assembly
                    var assembly = typeCurrent.Assembly;

                    // if valid
                    if (!assembly.GlobalAssemblyCache
                        && !assembly.IsDynamic
                        && (assembly.GetAttribute<System.CodeDom.Compiler.GeneratedCodeAttribute>() == null))
                    {
                        // then we found a valid assembly, get it as a candidate
                        result = assembly;
                    }
                }
            }

            // increase number of frames to skip
            framestoSkip++;
        } // while we have a working method
        while (methodCurrent != null);
    }
    return result;
}

为确保装配符合我们的要求，我们有三个条件：

程序集不在GAC中
装配不动态
未生成程序集（以避免临时的asp.net文件

我遇到的最后一个问题是何时在单独的程序集中定义基页。（我使用ASP.Net MVC，但ASP.Net也是如此）。在这种特殊情况下，它是返回的单独程序集，而不是包含页面的程序集。

我现在正在寻找的是：

1）我的装配验证条件是否足够？（我可能已经忘记了案件）

2）有没有办法从ASP.Net临时文件夹中的给定代码生成的程序集获取有关包含该页面/视图的项目的信息？（我想不是，但谁知道......）

Answer 1

这似乎是一种可靠，简单的方法来获取Web应用程序的“条目”或主要程序集。

如果您将控制器放在一个单独的项目中，您可能会发现ApplicationInstance的基类与包含Views的MVC项目不在同一个程序集中 - 但是，这个设置似乎非常罕见（我提到它因为我'我曾经尝试过这种设置，有一段时间后，一些博客支持这个想法。

    static private Assembly GetWebEntryAssembly()
    {
        if (System.Web.HttpContext.Current == null ||
            System.Web.HttpContext.Current.ApplicationInstance == null) 
        {
            return null;
        }

        var type = System.Web.HttpContext.Current.ApplicationInstance.GetType();
        while (type != null && type.Namespace == "ASP") {
            type = type.BaseType;
        }

        return type == null ? null : type.Assembly;
    }

Answer 2

在我的情况下，我需要获得＆＃34;条目汇编＆＃34;初始化System.Web.HttpContext.Current.ApplicationInstance之前的Web应用程序。此外，我的代码需要适用于各种应用程序类型（窗口服务，桌面应用程序等），并且我不想用Web问题污染我的公共代码。

我创建了一个自定义程序集级属性，可以在要指定为入口点程序集的程序集的AssembyInfo.cs文件中声明。然后，您只需调用属性的静态GetEntryAssembly方法来获取条目程序集。如果Assembly.GetEntryAssembly返回非null，则使用该null，否则它将在已加载的程序集中搜索具有custom属性的程序集。结果缓存在Lazy＆lt; T＆gt;。

中

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

namespace EntryAssemblyAttributeDemo
{
    /// <summary>
    /// For certain types of apps, such as web apps, <see cref="Assembly.GetEntryAssembly"/> 
    /// returns null.  With the <see cref="EntryAssemblyAttribute"/>, we can designate 
    /// an assembly as the entry assembly by creating an instance of this attribute, 
    /// typically in the AssemblyInfo.cs file.
    /// <example>
    /// [assembly: EntryAssembly]
    /// </example>
    /// </summary>
    [AttributeUsage(AttributeTargets.Assembly)]
    public sealed class EntryAssemblyAttribute : Attribute
    {
        /// <summary>
        /// Lazily find the entry assembly.
        /// </summary>
        private static readonly Lazy<Assembly> EntryAssemblyLazy = new Lazy<Assembly>(GetEntryAssemblyLazily);

        /// <summary>
        /// Gets the entry assembly.
        /// </summary>
        /// <returns>The entry assembly.</returns>
        public static Assembly GetEntryAssembly()
        {
            return EntryAssemblyLazy.Value;
        }

        /// <summary>
        /// Invoked lazily to find the entry assembly.  We want to cache this value as it may 
        /// be expensive to find.
        /// </summary>
        /// <returns>The entry assembly.</returns>
        private static Assembly GetEntryAssemblyLazily()
        {
            return Assembly.GetEntryAssembly() ?? FindEntryAssemblyInCurrentAppDomain();
        }

        /// <summary>
        /// Finds the entry assembly in the current app domain.
        /// </summary>
        /// <returns>The entry assembly.</returns>
        private static Assembly FindEntryAssemblyInCurrentAppDomain()
        {
            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
            var entryAssemblies = new List<Assembly>();
            foreach (var assembly in assemblies)
            {
                // Note the usage of LINQ SingleOrDefault.  The EntryAssemblyAttribute's AttrinuteUsage 
                // only allows it to occur once per assembly; declaring it more than once results in 
                // a compiler error.
                var attribute =
                    assembly.GetCustomAttributes().OfType<EntryAssemblyAttribute>().SingleOrDefault();
                if (attribute != null)
                {
                    entryAssemblies.Add(assembly);
                }
            }

            // Note that we use LINQ Single to ensure we found one and only one assembly with the 
            // EntryAssemblyAttribute.  The EntryAssemblyAttribute should only be put on one assembly 
            // per application.
            return entryAssemblies.Single();
        }
    }
}

Answer 3

作为我自己问题的答案（这里的一些人对接受率非常敏感） =＆GT;我没有找到比问题中给出的代码更好的方法。

这意味着te解决方案并不完美，但只要您的基页在前端程序集中定义，它就可以正常工作。

Answer 4

问题中提出的算法确实对我有用，而使用System.Web.HttpContext.Current.ApplicationInstance的方法并不适用。我认为我的问题是我需要解决方案的旧式ASP.Net应用程序缺少global.asax处理程序。

这个较短的解决方案对我有用，我认为通常会在前端程序集中定义页面处理程序的条件下工作：

    private static Assembly GetMyEntryAssembly()
    {
      if ((System.Web.HttpContext.Current == null) || (System.Web.HttpContext.Current.Handler == null))
        return Assembly.GetEntryAssembly(); // Not a web application
      return System.Web.HttpContext.Current.Handler.GetType().BaseType.Assembly;
    }

我的应用程序是一个ASP.Net 4.x Web表单应用程序。对于此应用程序类型，HttpContext.Current.Handler是包含当前请求处理程序的入口点的代码模块。 Handler.GetType（）。程序集是一个临时的ASP.Net程序集，但是Handler.GetType（）。BaseType.Assembly是真正的＆＃34;条目程序集＆＃34;我的申请我很好奇，如果它适用于其他各种ASP.Net应用程序类型。

Answer 5

我能够使Web应用程序（至少在.NET 4.5.1中）一致地工作的唯一方法是在Web应用程序项目本身中执行Assembly.GetExecutingAssembly（）。

如果您尝试使用静态方法创建实用程序项目并在那里进行调用，您将从该程序集中获取程序集信息 - 对于GetExecutingAssembly（）和GetCallingAssembly（）。

GetExecutingAssembly（）是一个返回Assembly类型实例的静态方法。该方法在Assembly类本身的实例上不存在。

所以，我所做的是创建了一个在构造函数中接受Assembly类型的类，并创建了一个传递Assembly.GetExecutingAssembly（）结果的类的实例。

    public class WebAssemblyInfo
    {
        Assembly assy;

        public WebAssemblyInfo(Assembly assy)
        {
            this.assy = assy;
        }

        public string Description { get { return GetWebAssemblyAttribute<AssemblyDescriptionAttribute>(a => a.Description); } }


         // I'm using someone else's idea below, but I can't remember who it was
        private string GetWebAssemblyAttribute<T>(Func<T, string> value) where T : Attribute
        {
            T attribute = null;

            attribute = (T)Attribute.GetCustomAttribute(this.assy, typeof(T));

            if (attribute != null)
                return value.Invoke(attribute);
            else
                return string.Empty;
        }
    }
}

并使用它

string Description = new WebAssemblyInfo(Assembly.GetExecutingAssembly()).Description;

Web应用程序的GetEntryAssembly

5 个答案: