keyboard_arrow_up

Learning .NET Attributes

Learn about .NET Attributes




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]

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

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

}

}

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>

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

}

}

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

}

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