Click here to Skip to main content
13,626,951 members
Click here to Skip to main content
Add your own
alternative version

Stats

75.8K views
1.2K downloads
24 bookmarked
Posted 8 Feb 2004
Licenced

Assembly Attributes

, 8 Feb 2004
Rate this:
Please Sign up or sign in to vote.
Programmatically inspecting assembly attributes.

Sample Image - Attributes.jpg

Introduction

Reflection allows you to programmatically inspect an assembly, and get information about the assembly, including all object types contained within. This information includes the attributes you have added to those types. The reflection objects reside within the System.Reflection namespace.

This demo program will inspect an assembly and display a list of all attributes defined on the assembly. The entire source code is downloadable and I will explain how it works.

Source Code Explanation

The code first checks the parameters passed to the command-line - if none are supplied, or if the user types FindAttributes /? then the Usage() method will be called, which will display a simple command usage summary:

if (args.Length == 0)
      Usage();
else if((args.Length == 1)&&(args[0] == "/?"))
      Usage();

Next, we reconstitute the command-line arguments into a single string. The reason for this is that it's common to have spaces in directory names, such as "Program Files", and this would be considered as two arguments by virtue of there being a space. So, we iterate through all the arguments stitching them back into a single string, and use this as the name of the assembly to load:

foreach(string arg in args)
      {
        if(assemblyName == null)
          assemblyName = arg;
        else
          assemblyName = string.Format("{0} {1}", assemblyName, arg);
      }

We then attempt to load the assembly, and retrieve all custom attributes defined on that assembly with the GetCustomAttributes() method:

Assembly a = Assembly.LoadFrom(assemblyName);

// Now find the attributes on the assembly
object[] attributes = a.GetCustomAttributes(true) ;

// If there were any attributes defined...
if(attributes.Length > 0)
   {
      Console.WriteLine("Assembly attributes for '{0}'...", assemblyName);
      // Dump them out...
      foreach(object o in attributes)
           Console.WriteLine("  {0}", o.ToString());
   }

Any attributes that are found are output to the console.

You can build the executable of the source code by using the command-line compiler like this:

>csc FindAttributes.cs

Running the Program

When you test the program against the FindAttributes.exe file, an attribute called DebuggableAttribute will be displayed, as shown in the screen shot. Although this attribute was not specified, it has been added by the C# compiler, and you will find that most of your executables have this attribute.

Additional Notes

You can alter the code as appropriate to add on as many assembly attributes as you wish. As an example, try modifying the source code by un-commenting the line after the using directives at the beginning of the listing.

//[assembly: AssemblyTitle("Title")]

When you recompile and run the code, you will see an additional attribute has been added to the list, the System.Reflection.AssemblyTitleAttribute.

Please check Karli Watson's Beginning Visual C# [ISBN 1-86100-758-2] by Wrox Press for more information.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Ahmed Alhosaini
Architect
United States United States
Ahmed had his M.S. Degree in Electrical and Computer Engineering in USA and the B.Sc. Degree in Automatic Control and Computer Systems Engineering in Egypt. He programmed with Assembly, Fortran77, Prolog, C/C++, Microsoft Visual Basic, Microsoft Visual C++, ATL/COM, Microsoft Visual C#, VB.NET, ASP.NET, AJAX, SharePoint 2007/2010, Microsoft Commerce Server, and MATLAB and Maple for technical computing. His programming experience is about 15+ years and he is a Microsoft Certified Professional. He also has a working experience in Database technologies and administration of SQL Server databases on Windows NT/2000/2003/2008 Windows Server platforms. Ahmed is interested in developing enterprise business solutions and has participated in many business, services and consultancy projects.

You may also be interested in...

Comments and Discussions

 
NewsHi Ahmad Pin
Candseeme25-Feb-06 7:45
memberCandseeme25-Feb-06 7:45 
GeneralGood job Pin
Ahmed Yassin26-Feb-06 8:52
memberAhmed Yassin26-Feb-06 8:52 
GeneralCustom Assembly Attributes Pin
dnh21-Apr-04 10:23
memberdnh21-Apr-04 10:23 
GeneralRe: Custom Assembly Attributes Pin
Ahmad Yassin21-Apr-04 11:27
memberAhmad Yassin21-Apr-04 11:27 
Hi,

A custom attribute is simply a special class that must comply with these two specifications:

- A custom attribute must derive from System.Attribute
- The Constructor(s) for an attribute may only contain types that can be resolved at compile time (such as strings and integers)

The restriction on the types of parameters allowable on the attribute constructor(s) is due to the way that attributes are persisted into the assembly metadata. When you use an attribute within code, you are using the attribute's constructor inline. For example:

[assembly: AssemblyKeyFile("Company.Public")]

In order to create a custom attribute class, we must:
- Create a class derived from System.Attribute
- Create the constructor(s) and public properties as required
- Attribute the class to define where it is valid to use your custom attribute

Here is an example code that may help you understand the idea:

using System;

public class TestCaseAttribute : Attribute
{
    // Constructor for the class
    public TestCaseAttribute(System.Type testCase)
    {
        TestCase = testCase;
    }

    // The test case object
    public readonly System.Type TestCase;

    // Perform a test
    public void Test()
    {
        // Instantiate the class under test
        object o = Activator.CreateInstance(TestCase);
    }
}



The last thing we need to do is attribute your attribute class to indicate where your attribute class can be used. For the test case attribute we want to say "this attribute is only valid on classes". We can decide where an attribute that we create is valid.

Add this line just before the attribute class definition:

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=true)]

Now we need an object to test with a test case:

[TestCase (typeof(TestAnObject))]
public class SomeCodeOrOther
{
    public SomeCodeOrOther()
    {
    }

    Public int Do()
    {
        return 999;
    }
}


Now we need to write a test class:

public class TestAnObject
{
    public TestAnObject()
    {
        //Exercise the class under test
        SomeCodeOrOther scooby = new SomeCodeOrOther();

        if(scooby.Do() != 999)
            throw new Exception("Ooops");
    }
}


You can use a simple Main() function to test your custom attribute. You need only to reference the System.Reflection namespace and write the following line just before the declaration of the SomeCodeOrOther class:

[TestCaseAttribute(typeof(TestAnObject))]

I hope this is helpful

Thank you.

AYH
GeneralRe: Custom Assembly Attributes Pin
dnh22-Apr-04 8:47
memberdnh22-Apr-04 8:47 
GeneralSome minor issues Pin
Victor Boctor9-Feb-04 12:23
memberVictor Boctor9-Feb-04 12:23 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Cookies | Terms of Use | Mobile
Web04 | 2.8.180712.1 | Last Updated 9 Feb 2004
Article Copyright 2004 by Ahmed Alhosaini
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid