Learning .NET Attributes

1

• Learning .NET Attributes

Dot Net Training
2

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 Metadata. .NET also
allows you to put additional information in the
metadata 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.
Dot Net Training
3

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, lets
take this example WebServicepublic class
WebService1 System.Web.Services.WebService
WebMethod 5. public string HelloWorld()
return Hello World
Dot Net Training
4
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.
Dot Net Training
5
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("CustomAttribute
Demo")assembly AssemblyDescription("") assemb
ly AssemblyConfiguration("") assembly
AssemblyCompany("") assembly
AssemblyProduct("CustomAttributeDemo") assembly
AssemblyCopyright("Copyright
2014") assembly AssemblyTrademark("") assembl
y AssemblyCulture("")
Dot Net Training
6
As you can see there are many attributes such as
AssemblyTitle, AssemblyDescription and
AssemblyVersion. Since their target is the hidden
assembly, they use assembly ltattribute_namegt
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.
Dot Net Training
7
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,MinimumLength5,ErrorMessage"Inv
alid company name!") public string CompanyName
get set
Dot Net Training
8
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.Dat
aAnnotations 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 doesnt meet the criteria.
To note that Required and StringLength
attributes are actually classes
RequiredAttribute and StringLengthAttribute
defined in the System.ComponentModel.DataAnnotatio
ns namespace.
Dot Net Training
9
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)
Dot Net Training
10
The Index() action method simply returns the
Index view. The Index.cshtml consists of a simple
ltformgt as given below ltform action/home/proces
sform methodpostgt ltspangtCustomer ID lt/spangt
ltinput typetext namecustomerid /gt
ltspangtCompany Name lt/spangt 5. ltinput
typetext namecompanyname /gt ltinput
typesubmit valueSubmit/gt lt/formgt ltstronggt_at_Vi
ewBag.Messagelt/stronggt ltstronggt_at_Html.ValidationSum
mary()lt/stronggt The values entered in the
customer ID text box and company name text box
are submitted to the ProcessForm() action method.
Dot Net Training
11
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 lets
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.
Dot Net Training
12
Lets 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(Attribut
eTargets.All) public class MyLicenseAttributeAt
tribute 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
dont 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.
Dot Net Training
13
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.
Dot Net Training
14
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 its 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")
Dot Net Training
15
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
.net do visit http//crbtech.in/Dot-Net-Training
Dot Net Training
16
Thank You..!
Dot Net Training