ASP.NET

HTTP Request in ASP.NET

December 3, 2014 by ashish Leave a Comment

In ASP.NET to process requests a pipeline model is used which consists of HTTPModules and HTTPHnadler objects. This pipeline model forms the low level framework which is used by web pages and web services. Here we will see a high level overview of asp.net request processing.

When we request a URL from a Web browser, the request is sent to the web server. The web server maps the file extensions with the dll’s that will handle the request called as ISAPI extension mappings. We can also configure the mappings in IIS.

For ASP.NET pages the extension is aspx. So when request for an ASP.NET page comes to the web server, the web server passes the request to the asp.net dll which passes the request to the worker process.The following diagram illustrates the process. This diagram is based on the IIS 5 processing model.

Once the request reaches the worker process it is processed by the pipeline which runs within asp.net worker process. The httpRequest is received by an instance of HTTPRuntime class which creates an instance of HTTPApplication class to process the request.

HTTPApplication class contains number of HTTPModules to which request and response are passed on its way to the HTTPHandler.

HTTPModules are filters that can examine and modify the contents of request and response.

The end of the pipeline is HTTPHandler which is an object of the class that implements IHTTPHandler interface.Asp.net page and web services are examples of HTTPHandlers.

We can create our own HTTPHandlers by following the following steps

Implementing the IHTTPHandler
Copying the compiled dlls to the bin directory of the application
Registering the handlers in the web.config.

We can register the HTTPHandlers in the web.config file by using the following web.config file element.

<add verb=”*” path=”*.Test ”

type=”ClassName, AssemblyName” />

</httpHandlers>

Above verb is the method used Get Or Post .Type is the className and assembly name and path is the URL .

ashish

Follow on:

Understanding HTML Helper Methods in MVC

December 3, 2014 by ashish Leave a Comment

HTML Helper methods are used to generate HTML in ASP.NET MVC.

Helper methods are used to render HTML in the view. Helper methods generates HTML output that is part of the view. They provide an advantage over using the HTML elements since they can be reused across the views and also requires less coding. There are several builtin helper methods that are used to generate the HTML for some commonly used HTML elements, like form, checkbox, dropdownlist etc. Also we can create our own helper methods to generate custom HTML. First we will see how to use the builtin helper methods and then we will see how to create custom helper methods.

Standard HtmlHelper methods

Some of the standard helper methods are:

ActionLink :Renders an anchor.
BeginForm :Renders HTML form tag
CheckBox : Renders check box.
DropDownList : Renders drop-down list.
Hidden :Renders hidden field
ListBox :Renders list box.
Password :Renders TextBox for password input
RadioButton :Renders radio button.
TextArea :Renders text area.
TextBox :Renders text box.

Since these helper methods are defined in the HtmlHelper class we need to qualify these methods using the HTML property of the view. For example to use the BeginForm method we need to qualify it with the HTML property and pass in the required arguments. HTML is a property of the view that points to the HtmlHelper class instance. All extension methods are defined in the System.Web.Mvc.Html namespace. There is a strongly typed version of the HtmlHelper class defined as HtmlHelper<T>. HtmlHelper<T> is a subclass of the HtmlHelper class.

@using (Html.BeginForm(“Login”, “Home”))
{
}

The elements we defined between the braces above will be part of the form tag and will be posted to the server on the form submit. The following code will generate a TextBox element inside a form element. When the submit button is clicked the form will be posted to the Login method of the Home controller.

@using (Html.BeginForm(“Login”, “Home”))
{
@Html.TextBox(“name”);
<input type=”submit” value=”submit” />
}

If we want to retrieve the value entered by the user in the name TextBox in our action method we just need to declare an action method with an argument with the same name as the TextBox. The action method below is called after the submit button is clicked on the form and we can see that the name argument contains the user entered value, in this case ashish. It is important to note that the argument’s name should be the same as the name of the HTML element.

Creating custom HTML Helpers.

Using Extension methods

Helper methods return strings or any other output so we can create new helper methods if the existing helper methods are not sufficient for our requirement(s). The extension method below renders the label having the background color as blue. We have defined a static Label method inside a static class CustomExtensions. So Label is an extension method on the HtmlHelper class.

public static class CustomExtensions
{
public static IHtmlString Label(this HtmlHelper helper)
{
return new HtmlString(“<label style=”background-color:blue”>Name</label>”);
}
}

Since we have defined the extension method on the HtmlHelper class we can use it like a standard HTML helper method, we can call the Label() method on the HTML property of the view. To use the helper method we just need to use the line below in our view.

@Html.Label()

Using Static methods

We have used an extension method above. Instead of using an extension method we can use a static method to implement a helper method as in the following:

public class CustomExtensions
{
public static IHtmlString Label()
{
return new HtmlString(“<label style=”background-color:blue”>Name</label>”);
}
}

We can call it in the view as:

@CustomExtensions.Label()

ashish

Follow on:

Understanding Caching in ASP.NET

December 3, 2014 by ashish Leave a Comment

Caching can improve application performance. Caching is more important for web applications since performance is an important factor in the case of web applications. In this article we will see how caching in ASP.Net is used to improve application performance.

Creating web applications often requires storing items in-memory so that they are easier to retrieve the next time they are requested. For example suppose that a web page is generated the first time it is requested and if we can save the generated web page output then we don’t need to create the web page output again the next time it is requested thus saving time.

We can store the items on the web server or another location such as the web browser. ASP.NET provides many techniques for caching. If we have the ASP.Net page output that we want to store then we can use output caching. For storing the application data we can use application data caching. Both of these types of caching helps us create high-performance web applications since generated output or data doesn’t need to be recreated. And if the data or output is expensive to create then it is always better to cache such an item. Caching is more suitable for items that are changed infrequently.

Using Application Data Caching we can store any arbitrary data that we want to cache using name/value pairs. An application cache is similar to an application state but an application cache is managed by ASP.Net such that ASP.Net automatically removes the items from the application cache whenever they expire or when memory is low. Therefore we should always check if the item is in the cache before accessing it to ensure that it has not been removed from the cache.

Using the Output Cache we can store the generated output of the ASP.Net page so that the page doesn’t need to be processed again. This is especially beneficial if the page output is expensive to create, such as if the output fetches some values from the database. We can cache multiple versions of the page depending upon the request like the querystring values. To use output caching we use the OutputCache directive in the ASP.Net page. The following directive will store the various versions of the page output based on the querystring value for 60 seconds.

<%@ OutputCache VaryByParam=”name” Duration=”60″ %>

Other attributes we can use with the OutputCache directive are:

VaryByParam for storing multiple versions of the page output depending on the query string.
VaryByControl for storing multiple versions of the page output depending on control value.
VaryByHeader for storing multiple versions of the page output depending on the request’s HTTP header.
VaryByCustom for storing multiple versions of the page output depending on the custom string that you specify.This is useful for scenarios such as storing multiple versions of the page depending upon the browser.

ASP.NET can automatically remove the data from the cache depending on the following conditions:

Server memory is low.
The cache item has expired.
The Cache dependency has changed.

Cache Expiration

When adding an item to the cache we can set its expiration using two different modes.

Absolute expiration specifies that the item is to be removed at a fixed time.

Sliding expiration specifies when to remove an item after it was last accessed.
Cache dependency

When adding an item in the cache we can specify that the item’s lifetime is dependent on a different component such as a table in a database or a file. We can implement a dependency on the database using the SqlCacheDependency class and use the CacheDependency class for implementing the dependency on a file or any other component.

Fragment Caching

Sometimes there are scenarios where we want to store only parts of the ASP.Net page instead of the entire page. We can implement such kinds of scenarios using fragment caching or control caching. For such a scenario we identify parts of the page that are expensive to create and create user controls for them and mark the user controls as cacheable using the OutputCache directive.

Instead of specifying cache settings on every ASP.Net page we can specify them once in the web.config file in the outputCacheProfiles section and apply it to all the pages we want to specify the settings. We can apply the cacheprofile to individual pages using the CacheProfile attribute of the @OutputCache directive.

To better understand why we will ever need to use ASP.NET MVC instead of the traditional, user friendly ASP.NET WebForm’s to develop ASP.NET applications we need to look into some of its shortcomings and how they are addressed in ASP.NET MVC applications.

ViewState Load

ViewState maintains the state across postbacks; it requires that the data be transferred back and forth between the client and the server. The data that is transferred can become so large that it consumes a heavy bandwidth, thus creating poor response for the user.

Mix of Presentation and Application Logic

Code behind frequently modifies the Web Form controls and also includes the application logic. This approach of mixing the presentation and application logic together results in code that is difficult to maintain.

Limited HTML control

Since the server controls render themselves, this could often be different from the HTML we want generated, like the client id created for the server controls (though this shortcoming has been fixed in version 4.0) and the automatically generated JavaScript.

Hiding of the true nature of the web creates problems

As we know, HTTP is a stateless protocol. Webforms hide this fact by creating an abstraction for us. Thus Web Forms are an abstraction and are meant to be used as such so that developing a web application has the same experience as developing a Windows application.

Now let us see how ASP.NET MVC addresses these shortcomings

There is no ViewState Load

ASP.NET MVC generated pages do not contain any view state data so the size of such pages is much less

ashish

Follow on:

Begining ASP.NET MVC

December 3, 2014 by ashish Leave a Comment

ViewState Load

Mix of Presentation and Application Logic

Limited HTML control

Hiding of the true nature of the web creates problems

Now let us see how ASP.NET MVC addresses these shortcomings

There is no ViewState Load

ASP.NET MVC generated pages do not contain any view state data so the size of such pages is much less than the same pages generated using the ASP.NET WebForm approach.

Does not Hides the true nature of the web

MVC does not hide the true nature of the web as a stateless protocol but still it provides a way to write code that is easier to maintain and that is free of complications.

Encourages to have More Control over the HTML

WebForms, while trying to abstract the fact that HTTP is a stateless protocol, does a lot of things hidden for us, like generating the JavaScript and CSS. If we create similar pages in ASP.NET MVC and WebForms and see the HTML source for the generated pages we will see that the ASP.NET MVC page does not change the control ids and there is no JavaScript and CSS generated while the similar WebForm page automatically generates a lot of JavaScript and CSS which we might not be aware of.

MVC architecture can be depicted by the following diagram

In the MVC architecture incoming requests are handled by the controller which works with the model, selects the view and prepares the View data which is rendered by the selected view.

In short MVC is separating three main responsibilities into three main layers.

Business Logic -> Model
Presentation Logic -> View
Application Logic -> Controller

Please note that Application logic and Presentation logic are most of the times mixed together in the WebForm’s in the event handlers.

Creating an MVC application in Visual Studio

Let us understand some of the concepts in an ASP.NET MVC application first.

Controller: In MVC incoming requests are handled by the controllers. A Controller is a class inheriting from the built-in Controller class which implements the IController interface.

Action: Each public method in the controller is an action that can be invoked using a URL.

View: Accepts the data in the ViewData objects passed to it by the Controller and renders them.

Model: Objects that are passed between controller and view.

Routing System: maps the URL’s to controllers and actions (To decouple the URLs from the web pages and also makes the URL search engine freindly).

While creating an ASP.NET MVC application in Visual Studio we have two choices of templates to choose from.

ASP.NET MVC 2 Web Application template

This creates a sample application preconfigured with things like authenctication, styles and navigation.

ASP.NET MVC 2 Empty Web Application template

Create only the files and folders required by every ASP.NET MVC application.

ashish

Follow on:

Brief Overview of Controller and Action Methods in MVC

December 3, 2014 by ashish Leave a Comment

In this article we will see details of how the controller and action methods works. Whenever a new request comes into an ASP.NET MVC application it is handled by the controller class. It decides how to handle the request. Normally it fetches (or updates) the data from the model and renders the appropriate view to display the results. Let’s see how the controller processes the request and produces the appropriate output. As we already know, controllers are in charge of the application logic. The application logic requires obtaining inputs from the user (or responding to other user actions) and fetching the data from the model for the user, which is displayed by the view.

Controllers in ASP.NET are classes implementing the IController interface. Most of the time we will not be interacting with this interface but rather deriving from the System.Web.Mvc. Controller which implements the IController Interface for us and also provides additional functionality. The action methods in the controller are provided by this base Controller class.

The following method is an action method:

The action method always returns an ActionResult type or type derived from this type. Also note that any public nonstatic method in the controller is an action method and can be invoked by the user using a URL. Also the URLs for each action method is different.

The above is just a default action method. Let us create a more useful action.

public ActionResult Index ()
{
string userIP = Request.UserHostAddress;
bool isSecure = Request.IsSecureConnection;
ViewData[“userIP”]=userIP;
ViewData[“isSecure”] = isSecure;
return View();
}

This action directly retrieves the values from the context objects.

Other properties we will be commonly using are:

Request.QueryString – For retrieving GET variables sent with this request
Request.Form – For retrieving POST variables sent with this request
Request.UserHostAddress – The IP address of the user making thisRequest
HttpContext.Cache – For storing cache information
HttpContext.Session – For storing session information

Though we are always free to directly retrieve the input values from the context objects, doing so is against the separation of concerns principle supported by MVC applications. So usually we will use the action method parameters to retrieve the input values.

So instead of this code:

public ActionResult Info()

{
string strName = (string) Request.Form[“UserName”];

We should be using this:

public ActionResult Info(string UserName)
{

If we use parameters then insensitive case name matching is used. So in the above code the parameter UserName would be populated from both.

Request.Form[“UserName”] (Camel case) and Request.Form[“username”] (Small case)

If we don’t supply any parameter value it will be null for reference types but for value types if we don’t supply a parameter value then an error will be thrown. To prevent this, we optionally can use parameters to supply default parameter values for the value types, as in:

public ActionResult Info(string UserName,int id = 001)

{

Once the controller has received and processed the input, it can react in various ways by:

Directly writing the output to the output stream
Rendering HTML using a view
Redirecting to another action method

Directly writing output to output stream

To directly write the output we can use the familiar Response.Write () as:

public void Index()
{
Response.Write(“Hello from MVC action method”);
}

Using ActionResult

Instead of directly writing the Respnse from the action method (which is against the separation of concerns supported by MVC) we usually return the ActionResult type from the action method which generates the appropriate response for us.

Notice that return View() generates the ViewResult which is derived from ActionResult. ViewResult renders the named view or default view (if none is specified).

Other commonly used ActionResult types are:

PartialViewResult – Renders partial views
RedirectToAction   – For redirecting to another action method
FileResult            – For writing binary file data
ContentResult      – For writing textual data

Please note that executing View() without any parameters calls the default view of the action. If we want, we can call any other view using the following:

return View(“VewName”);

As we saw in the last article, we can pass data to the view using the ViewData dictionary as:

ViewData[“Key1”] = “value1”;

Which we can access in the view as:

<%: ViewData[“Key1”] %>

Besides this approach we can pass the data to the view using the Model property of the ViewDataobject. For example the following code sets the Model property to the product object.

Product product=new Product();
product.Name = “Smart Cell Phone”;
ViewData.Model = product;

Now we can access it in the view as:

The Product is <%: ((Model.Entities.Product)Model).Name%>

The above code still uses the type casting to convert the Model object to the appropriate type. We can avoid this type casting by using the strongly typed views. When we create a new view we can create the strongly typed view. We just need to select the ViewData class.

We select the Product class for the Views Data Class:

Now we can directly access the Product object in the view without type casting as:

The Product is <%: Model.Name%>

Redirecting to a different Action method

We can redirect to another action method using the RedirectToAction method (which is of the ResultAction type).

To redirect to another action method we can use the code as:

public ViewResult Info()
{
//the following view displays the information about the saved data
return View();
}

public ActionResult Save()

{
//the following method saves the data
//logic to save the data
return RedirectToAction(“Info”);
}

The Save () method above could save the data in the database while the Info () method displays the result once the data is saved so that different methods could handle different tasks properly.

ashish

Follow on: