An assembly in .NET is a collection of types and resources that form a logical unit. Assemblies can contain metadata about types using attributes. Attributes provide additional information that can be attached to classes, methods, and other members. There are built-in attributes in .NET and custom attributes can be created by deriving from the Attribute base class. Built-in attributes like Required and StringLength are used to validate model data in ASP.NET MVC. A custom MyLicenseAttribute was created to require a license key by applying the attribute to assemblies. Attributes help add metadata and customize behavior.

1. Learn about .NET Attributes
July 26, 2016.net training institute, Computer Training .net certification in pune, .net classes, .net courses, .net courses
in pune, .net jobs, .net technology, .net training, .net training institute pune, ASP.net courses
Assemblies are the building blocks of .NET Framework ; they form the basic unit of deployment, reuse, version control,
reuse, activation scoping and security permissions. An assembly is a collection of types and resources that are created to
work together and form a functional and logical unit.
.NET assemblies are self-describing, i.e. information about an assembly is stored in the assembly itself. This
information is called Meta data. .NET also allows you to put additional information in the meta data via Attributes.
Attributes are used in many places within the .NET framework.
This page discusses what attributes are, how to use inbuilt attributes and how to customize attributes.
Define .NET Attributes
A .NET attribute is information that can be attached with a class, an assembly, property, method and other members. An
attribute bestows to the metadata about an entity that is under consideration. An attribute is actually a class that is either
inbuilt or can be customized. Once created, an attribute can be applied to various targets including the ones mentioned
above.
For better understanding, let’s take this example:
[WebService]public class WebService1 : System.Web.Services.WebService
{
[WebMethod]

2. 5. public string HelloWorld()
{
return “Hello World”;
}
}
The above code depicts a class named WebService1 that contains a method: HelloWorld(). Take note of the class and
method declaration. The WebService1 class is decorated with [WebService] and HelloWorld() is decorated with
[WebMethod].
Both of them – [WebService] and [WebMethod] – are features. The [WebService] attribute indicates that the target of
the feature (WebService1 class) is a web service. Similarly, the [WebMethod] feature indicates that the target under
consideration (HelloWorld() method) is a web called method. We are not going much into details of these specific
attributes, it is sufficient to know that they are inbuilt and bestow to the metadata of the respective entities.
Two broad ways of classification of attributes are : inbuilt and custom. The inbuilt features are given by .NET
framework and are readily usable when required. Custom attributes are developer created classes.
On observing a newly created project in Visual Studio, you will find a file named AssemblyInfo.cs. This file constitute
attributes that are applicable to the entire project assembly.
For instance, consider the following AssemblyInfo.cs from an ASP.NET Web Application
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.[assembly: AssemblyTitle("CustomAttributeDemo")][assembly:
AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CustomAttributeDemo")]
[assembly: AssemblyCopyright("Copyright © 2014")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number

3. // Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the ‘*’ as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
As you can see there are many attributes such as AssemblyTitle, AssemblyDescription and AssemblyVersion. Since
their target is the hidden assembly, they use [assembly: <attribute_name>] syntax.
Information about the features can be obtained through reflection. Most of the inbuilt attributes are handled by .NET
framework internally but for custom features you may need to create a mechanism to observe the metadata emitted by
them.
Inbuilt Attributes
In this section you will use Data Annotation Attributes to prove model data. Nees to start by creating a new ASP.NET
MVC Web Application. Then add a class to the Models folder and name it as Customer. The Customer class contains
two public properties and is shown below:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
5. using System.ComponentModel.DataAnnotations;
namespace CustomAttributesMVCDemo.Models
{
public class Customer
10. {
[Required]
public string CustomerID { get; set; }
[Required]
15. [StringLength(20,MinimumLength=5,ErrorMessage="Invalid company name!")]
public string CompanyName { get; set; }
}
}

4. Take note of the above code. The Customer class comprise of two string properties – CustomerID and CompanyName.
Its important to note that these properties are decorated with data annotation features residing in the
System.ComponentModel.DataAnnotations namespace.
The [Required] features points that the CustomerID property must be given some value in order to consider it to be a
valid model. Similarly, the CompanyName property is designed with [Required] and [StringLength] attributes. The
[StringLength] feature is used to specify that the CompanyName should be a at least five characters long and at max
twenty characters long. An error message is also specified in case the value given to the CompanyName property
doesn’t meet the criteria. To note that [Required] and [StringLength] attributes are actually classes – RequiredAttribute
and StringLengthAttribute – defined in the System.ComponentModel.DataAnnotations namespace.
Now, add the HomeController class to the Controllers folder and write the following action methods:
public ActionResult Index()
{
return View();
}
5.
public ActionResult ProcessForm()
{
Customer obj = new Customer();
bool flag = TryUpdateModel(obj);
10. if(flag)
{
ViewBag.Message = “Customer data received successfully!”;
}
else
15. {
ViewBag.Message = “Customer data validation failed!”;
}
return View(“Index”);
}
The Index() action method simply returns the Index view. The Index.cshtml consists of a simple <form> as given
below:
<form action=”/home/processform” method=”post”>
<span>Customer ID : </span>

5. <input type=”text” name=”customerid” />
<span>Company Name : </span>
5. <input type=”text” name=”companyname” />
<input type=”submit” value=”Submit”/>
</form>
<strong>@ViewBag.Message</strong>
<strong>@Html.ValidationSummary()</strong>
The values entered in the customer ID text box and company name text box are submitted to the ProcessForm() action
method.
The ProcesssForm() action method uses TryUpdateModel() method to allot the characteristics of the Customer model
with the form field values. The TryUpdateModel() method returns true if the model properties contain proven data as
per the condition given by the data annotation features, otherwise it returns false. The model errors are displayed on the
page using ValidationSummary() Html helper.
Then run the application and try submitting the form without entering Company Name value. The following figure
shows how the error message is shown:
Thus data notation attributes are used by ASP.NET MVC to do model validations.
Creating Custom Attributes
In the above example, some inbuilt attributes were used. This section will teach you to create a custom attribute and
then apply it. For the sake of this example let’s assume that you have developed a class library that has some complex
business processing. You want that this class library should be consumed by only those applications that got a valid
license key given by you. You can devise a simple technique to accomplish this task.
Let’s begin by creating a new class library project. Name the project LicenseKeyAttributeLib. Modify the default class
from the class library to resemble the following code:
namespace LicenseKeyAttributeLib
{
[AttributeUsage(AttributeTargets.All)]
public class MyLicenseAttribute:Attribute
5. { public string Key { get; set; }
}
}

6. As you can see the MyLicenseAttribute class is created by taking it from the Attribute base class is provided by the
.NET framework. By convention all the attribute classes end with “Attribute”. But while using these attributes you don’t
need to write “Attribute”.
Thus MyLicenseAttribute class will be used as [MyLicense] on the target.
The MyLicenseAttribute class contains just one property – Key – that represents a license key.
The MyLicenseAttribute itself is decorated with an inbuilt attribute – [AttributeUsage]. The [AttributeUsage] feature is
used to set the target for the custom attribute being created.
Now, add another class library to the same solution and name it ComplexClassLib. The ComplexClassLib represents the
class library doing some complex task and consists of a class as shown below:
public class ComplexClass1
{
public string ComplexMethodRequiringKey()
{
5. //some code goes here
return “Hello World!”;
}
}
The ComplexMethodRequiringKey() method of the ComplexClass1 is supposed to be doing some complex operation.
Applying Custom Attributes
Next need to add an ASP.NET Web Forms Application to the same solution.
Then use the ComplexMethodRequiringKey() inside the Page_Load event handler:
protected void Page_Load(object sender, EventArgs e)
{
ComplexClassLib.ComplexClass1 obj = new ComplexClassLib.ComplexClass1();
Label1.Text = obj.ComplexMethodRequiringKey();
}

7. The return value from ComplexMethodRequiringKey() is assigned to a Label control.
Now it’s time to use the MyLicenseAttribute class that was created earlier. Open the AssemblyInfo.cs file from the web
application and add the following code to it:
using System.Reflection;
…
using LicenseKeyAttributeLib;
5. …
[assembly: MyLicense(Key = "4fe29aba")]
The AssemblyInfo.cs file now uses MyLicense custom attribute to specify a license key. Notice that although the
attribute class name is MyLicenseAttribute, while using the attribute you just mention it as MyLicense.
Summary
Attributes help you to add metadata to their target. The .NET framework though provides several inbuilt attributes ,
there are chances to customize a few more. You knew to use inbuilt data notation features to validate model data; create
a custom attribute and used it to design an assembly. A custom feature is a class usually derived from the Attribute base
class and members can be added to the custom attribute class just like you can do for any other class.
If you are considering to take ASP.Net training then our CRB Tech .Net Training center would be very helpful in
fulfilling your aspirations. We update ourself with the ongoing generation so you can learn ASP.Net with us.
Stay connected to this page of CRB Tech reviews for more technical up-gradation and other resources.
For more information on dot net do visit : http://crbtech.in/Dot-Net-Training