.net समय असेंबली विशेषताओं को कैसे पढ़ा जाए




विषय याद करने का तरीका (5)

मेरे कार्यक्रम में, मैं 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("")]

मैं इन कार्यक्रमों में से कुछ को अपने प्रोग्राम के उपयोगकर्ता को प्रदर्शित करना चाहता हूं, इसलिए मैं जानना चाहता हूं कि उन्हें मुख्य कार्यक्रम से और कॉम्पोनेंट असेंबली से कैसे लोड किया जा रहा है।


यह काफी आसान है। आपको प्रतिबिंब का उपयोग करना होगा। आपको असेंबली का एक उदाहरण चाहिए जो उन गुणों के साथ असेंबली का प्रतिनिधित्व करता है जिन्हें आप पढ़ना चाहते हैं। ऐसा करने का एक आसान तरीका है:

typeof(MyTypeInAssembly).Assembly

फिर आप यह कर सकते हैं, उदाहरण के लिए:

object[] attributes = assembly.GetCustomAttributes(typeof(AssemblyProductAttribute), false);

AssemblyProductAttribute attribute = null;
if (attributes.Length > 0)
{
   attribute = attributes[0] as AssemblyProductAttribute;
}

संदर्भ प्रस्तुत करना। उत्पाद अब आपको आपके विधानसभाInfo.cs में विशेषता में पारित मान देगा। बेशक, यदि आप जिस विशेषता को खोजते हैं, वह एक से अधिक बार हो सकता है, तो आपको GetCustomAttributes द्वारा लौटाए गए सरणी में कई उदाहरण मिल सकते हैं, लेकिन यह आमतौर पर असेंबली स्तर विशेषताओं के लिए एक समस्या नहीं है जैसे आप पुनर्प्राप्त करना चाहते हैं।


मैं व्यक्तिगत रूप से वास्तव में लांस लार्सन और उनकी स्थिर असेंबलीइन्फो कक्षा के कार्यान्वयन को पसंद करता हूं।

एक मूल रूप से अपनी असेंबली में कक्षा को चिपकाता है (मैं आम तौर पर पहले से ही मौजूदा असेंबलीइन्फो फ़ाइल का उपयोग करता हूं क्योंकि यह नामकरण सम्मेलन में फिट बैठता है)

पेस्ट करने के लिए कोड है:

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<AssemblyDescriptionAttribute>(a => a.Description); } }
    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;
}

लार्सेंस वेबसाइट (एमवीपी) पर एक नज़र डालें, उसके पास प्रेरणा आकर्षित करने के लिए अच्छी चीजें हैं।


मैंने इस एक्सटेंशन विधि को बनाया है जो लिंक का उपयोग करता है:

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);

मैं इसका उपयोग करता हूं:

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;
            }
        }

    }

}

ठीक है, मुझे Assembly.LoadFrom(path) लिए .dll विशेषताओं को निकालने के लिए एक विधि खोजने के लिए कई संसाधनों के माध्यम से जाने का प्रयास किया गया है। लोडफ्रॉम Assembly.LoadFrom(path) । लेकिन दुर्भाग्य से मुझे कोई अच्छा संसाधन नहीं मिला। और यह सवाल c# get assembly attributes (कम से कम मेरे लिए) पर खोज के लिए सबसे अधिक परिणाम था इसलिए मैंने अपना काम साझा करने के बारे में सोचा।

मैंने संघर्ष के कई घंटों के बाद सामान्य असेंबली विशेषताओं को पुनः प्राप्त करने के लिए निम्नलिखित सरल कंसोल प्रोग्राम लिखा था। यहां मैंने कोड प्रदान किया है ताकि कोई भी आगे संदर्भ कार्य के लिए इसका उपयोग कर सके।

मैं इसके लिए CustomAttributes प्रॉपर्टी का उपयोग करता हूं। इस दृष्टिकोण पर टिप्पणी करने के लिए स्वतंत्र महसूस करें

संहिता:

using System;
using System.Reflection;

namespace MetaGetter
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly asembly = Assembly.LoadFrom("Path to assembly");

            foreach (CustomAttributeData atributedata in asembly.CustomAttributes)
            {
                Console.WriteLine(" Name : {0}",atributedata.AttributeType.Name);

                foreach (CustomAttributeTypedArgument argumentset in atributedata.ConstructorArguments)
                {
                    Console.WriteLine("   >> Value : {0} \n" ,argumentset.Value);
                }
            }

            Console.ReadKey();
        }
    }
}

नमूना आउटपुट:

Name : AssemblyTitleAttribute
   >> Value : "My Product"




attributes