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.
2. Dot Net Training
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.
3. Dot Net Training
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”;
}
}
4. Dot Net Training
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.
6. Dot Net Training
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.
7. Dot Net Training
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; }
}
8. Dot Net Training
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.
9. Dot Net Training
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”);
}
10. Dot Net Training
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.
11. Dot Net Training
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.
12. Dot Net Training
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.
13. Dot Net Training
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.
14. Dot Net Training
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")]
15. Dot Net Training
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
