如何读取程序集属性

在我的程序中，如何读取AssemblyInfo.cs:中设置的属性

[assembly: AssemblyTitle("My Product")]
[assembly: AssemblyDescription("...")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Radeldudel inc.")]
[assembly: AssemblyProduct("My Product")]
[assembly: AssemblyCopyright("Copyright @ me 2008")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

我想向程序的用户显示其中的一些值，所以我想知道如何从主程序和我正在使用的组件程序集中加载它们。

这相当容易。你必须使用反射。您需要一个Assembly实例，该实例表示具有要读取的属性的程序集。实现这一点的一个简单方法是：

typeof(MyTypeInAssembly).Assembly

然后你可以这样做，例如：

object[] attributes = assembly.GetCustomAttributes(typeof(AssemblyProductAttribute), false);
AssemblyProductAttribute attribute = null;
if (attributes.Length > 0)
{
   attribute = attributes[0] as AssemblyProductAttribute;
}

现在，引用attribute.Product将为您提供在AssemblyInfo.cs中传递给属性的值。当然，如果您查找的属性可能出现多次，您可能会在数组中获得GetCustomAttributes返回的多个实例，但对于希望检索的程序集级属性来说，这通常不是问题。

我创建了这个使用Linq:的扩展方法

public static T GetAssemblyAttribute<T>(this System.Reflection.Assembly ass) where T :  Attribute
{
    object[] attributes = ass.GetCustomAttributes(typeof(T), false);
    if (attributes == null || attributes.Length == 0)
        return null;
    return attributes.OfType<T>().SingleOrDefault();
}

然后你就可以方便地使用它了：

var attr = targetAssembly.GetAssemblyAttribute<AssemblyDescriptionAttribute>();
if(attr != null)
     Console.WriteLine("{0} Assembly Description:{1}", Environment.NewLine, attr.Description);

好的，对于最初的问题，现在可能有点过时了，但我无论如何都会把它呈现出来供将来参考。

如果你想从组件内部进行操作，请使用以下方法：

using System.Runtime.InteropServices;
using System.Reflection;
object[] customAttributes = this.GetType().Assembly.GetCustomAttributes(false);

然后，您可以迭代所有自定义属性，以找到您需要的属性，例如

foreach (object attribute in customAttributes)
{
  string assemblyGuid = string.Empty;    
  if (attribute.GetType() == typeof(GuidAttribute))
  {
    assemblyGuid = ((GuidAttribute) attribute).Value;
    break;
  }
}

我个人非常喜欢lance Larsen和他的静态AssemblyInfo类的实现。

一个人基本上将类粘贴到他的程序集中（我通常使用已经存在的AssemblyInfo.cs文件，因为它符合命名约定）

要粘贴的代码是：

internal static class AssemblyInfo
{
    public static string Company { get { return GetExecutingAssemblyAttribute<AssemblyCompanyAttribute>(a => a.Company); } }
    public static string Product { get { return GetExecutingAssemblyAttribute<AssemblyProductAttribute>(a => a.Product); } }
    public static string Copyright { get { return GetExecutingAssemblyAttribute<AssemblyCopyrightAttribute>(a => a.Copyright); } }
    public static string Trademark { get { return GetExecutingAssemblyAttribute<AssemblyTrademarkAttribute>(a => a.Trademark); } }
    public static string Title { get { return GetExecutingAssemblyAttribute<AssemblyTitleAttribute>(a => a.Title); } }
    public static string Description { get { return GetExecutingAssemblyAttribute<AssemblyDescriptionAttribute>(a => a.Description); } }
    public static string Configuration { get { return GetExecutingAssemblyAttribute<AssemblyConfigurationAttribute>(a => a.Configuration); } }
    public static string FileVersion { get { return GetExecutingAssemblyAttribute<AssemblyFileVersionAttribute>(a => a.Version); } }
    public static Version Version { get { return Assembly.GetExecutingAssembly().GetName().Version; } }
    public static string VersionFull { get { return Version.ToString(); } }
    public static string VersionMajor { get { return Version.Major.ToString(); } }
    public static string VersionMinor { get { return Version.Minor.ToString(); } }
    public static string VersionBuild { get { return Version.Build.ToString(); } }
    public static string VersionRevision { get { return Version.Revision.ToString(); } }
    private static string GetExecutingAssemblyAttribute<T>(Func<T, string> value) where T : Attribute
    {
        T attribute = (T)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(T));
        return value.Invoke(attribute);
    }
}

您添加了一个正在使用的系统；到文件的顶部，你就可以走了。

对于我的应用程序，我使用这个类来设置/获取/使用我的本地用户设置，使用：

internal class ApplicationData
{
    DirectoryInfo roamingDataFolder;
    DirectoryInfo localDataFolder;
    DirectoryInfo appDataFolder;
    public ApplicationData()
    {
        appDataFolder = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), AssemblyInfo.Product,"Data"));
        roamingDataFolder = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),AssemblyInfo.Product));
        localDataFolder   = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), AssemblyInfo.Product));
        if (!roamingDataFolder.Exists)            
            roamingDataFolder.Create();
        if (!localDataFolder.Exists)
            localDataFolder.Create();
        if (!appDataFolder.Exists)
            appDataFolder.Create();
    }
    /// <summary>
    /// Gets the roaming application folder location.
    /// </summary>
    /// <value>The roaming data directory.</value>
    public DirectoryInfo RoamingDataFolder => roamingDataFolder;

    /// <summary>
    /// Gets the local application folder location.
    /// </summary>
    /// <value>The local data directory.</value>
    public DirectoryInfo LocalDataFolder => localDataFolder;
    /// <summary>
    /// Gets the local data folder location.
    /// </summary>
    /// <value>The local data directory.</value>
    public DirectoryInfo AppDataFolder => appDataFolder;
}

看看拉森的网站（MVP），他有很酷的东西可以从中汲取灵感。

好吧，我试着浏览了很多资源，找到了一种提取Assembly.LoadFrom(path)的.dll属性的方法。但不幸的是，我找不到任何好的资源。这个问题是c# get assembly attributes上搜索最多的结果（至少对我来说），所以我想分享我的工作。

经过数小时的努力，我编写了以下简单的控制台程序来检索通用程序集属性。在这里，我提供了代码，以便任何人都可以使用它进行进一步的参考工作。

我对此使用CustomAttributes属性。请随意评论这种方法

代码：

using System;
using System.Reflection;
namespace MetaGetter
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly assembly = Assembly.LoadFrom("Path to assembly");
            foreach (CustomAttributeData attributedata in assembly.CustomAttributes)
            {
                Console.WriteLine(" Name : {0}",attributedata.AttributeType.Name);
                foreach (CustomAttributeTypedArgument argumentset in attributedata.ConstructorArguments)
                {
                    Console.WriteLine("   >> Value : {0} n" ,argumentset.Value);
                }
            }
       
            Console.ReadKey();
        }
    }
}

样本输出：

Name : AssemblyTitleAttribute
   >> Value : "My Product"

这是在一行代码中检索特定属性的好方法。不需要特殊级别。

string company = ((AssemblyCompanyAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyCompanyAttribute), false)).Company;

我使用这个：

public static string Title
{
    get
    {
        return GetCustomAttribute<AssemblyTitleAttribute>(a => a.Title);
    }
}

供参考：

using System;
using System.Reflection;
using System.Runtime.CompilerServices;

namespace Extensions
{

    public static class AssemblyInfo
    {

        private static Assembly m_assembly;
        static AssemblyInfo()
        {
            m_assembly = Assembly.GetEntryAssembly();
        }

        public static void Configure(Assembly ass)
        {
            m_assembly = ass;
        }

        public static T GetCustomAttribute<T>() where T : Attribute
        {
            object[] customAttributes = m_assembly.GetCustomAttributes(typeof(T), false);
            if (customAttributes.Length != 0)
            {
                return (T)((object)customAttributes[0]);
            }
            return default(T);
        }
        public static string GetCustomAttribute<T>(Func<T, string> getProperty) where T : Attribute
        {
            T customAttribute = GetCustomAttribute<T>();
            if (customAttribute != null)
            {
                return getProperty(customAttribute);
            }
            return null;
        }
        public static int GetCustomAttribute<T>(Func<T, int> getProperty) where T : Attribute
        {
            T customAttribute = GetCustomAttribute<T>();
            if (customAttribute != null)
            {
                return getProperty(customAttribute);
            }
            return 0;
        }

        public static Version Version
        {
            get
            {
                return m_assembly.GetName().Version;
            }
        }

        public static string Title
        {
            get
            {
                return GetCustomAttribute<AssemblyTitleAttribute>(
                    delegate(AssemblyTitleAttribute a)
                    {
                        return a.Title;
                    }
                );
            }
        }
        public static string Description
        {
            get
            {
                return GetCustomAttribute<AssemblyDescriptionAttribute>(
                    delegate(AssemblyDescriptionAttribute a)
                    {
                        return a.Description;
                    }
                );
            }
        }

        public static string Product
        {
            get
            {
                return GetCustomAttribute<AssemblyProductAttribute>(
                    delegate(AssemblyProductAttribute a)
                    {
                        return a.Product;
                    }
                );
            }
        }

        public static string Copyright
        {
            get
            {
                return GetCustomAttribute<AssemblyCopyrightAttribute>(
                    delegate(AssemblyCopyrightAttribute a)
                    {
                        return a.Copyright;
                    }
                );
            }
        }

        public static string Company
        {
            get
            {
                return GetCustomAttribute<AssemblyCompanyAttribute>(
                    delegate(AssemblyCompanyAttribute a)
                    {
                        return a.Company;
                    }
                );
            }
        }

        public static string InformationalVersion
        {
            get
            {
                return GetCustomAttribute<AssemblyInformationalVersionAttribute>(
                    delegate(AssemblyInformationalVersionAttribute a)
                    {
                        return a.InformationalVersion;
                    }
                );
            }
        }

        public static int ProductId
        {
            get
            {
                return GetCustomAttribute<AssemblyProductIdAttribute>(
                    delegate(AssemblyProductIdAttribute a)
                    {
                        return a.ProductId;
                    }
                );
            }
        }

        public static string Location
        {
            get
            {
                return m_assembly.Location;
            }
        }
    }
}

如果您知道要查找的属性是唯一的，那么使用Attribute类的这个经常被忽视的静态辅助方法会容易得多：

var attribute = Attribute.GetCustomAttribute(assembly, typeof(AssemblyTitleAttribute))

这更容易，因为您不需要处理数组，也不需要担心那个烦人的inherit参数。您只需直接获取单个属性值，如果不存在，则直接获取null。

相关内容

最新更新

热门标签：