Using Asynchronous Methods in ASP.NET 4.5

CheapASPNETHostingReview.com | Best and cheap ASP.NET 4.5 hosting. This tutorial will teach you the basics of building an asynchronous ASP.NET Web Forms application using Visual Studio Express 2012 for Web, which is a free version of Microsoft Visual Studio. You can also use Visual Studio 2012.

ASP.NET 4.5 Web Pages in combination .NET 4.5 enables you to register asynchronous methods that return an object of type Task. The .NET Framework 4 introduced an asynchronous programming concept referred to as a Task and ASP.NET 4.5 supports Task. Tasks are represented by the Task type and related types in the System.Threading.Tasks namespace. The .NET Framework 4.5 builds on this asynchronous support with the await and async keywords that make working with Task objects much less complex than previous asynchronous approaches. The awaitkeyword is syntactical shorthand for indicating that a piece of code should asynchronously wait on some other piece of code. The async keyword represents a hint that you can use to mark methods as task-based asynchronous methods. The combination of await, async, and the Taskobject makes it much easier for you to write asynchronous code in .NET 4.5. The new model for asynchronous methods is called the Task-based Asynchronous Pattern (TAP). This tutorial assumes you have some familiarity with asynchronous programing using await and asynckeywords and the Task namespace.

How Requests Are Processed by the Thread Pool

On the web server, the .NET Framework maintains a pool of threads that are used to service ASP.NET requests. When a request arrives, a thread from the pool is dispatched to process that request. If the request is processed synchronously, the thread that processes the request is busy while the request is being processed, and that thread cannot service another request.

This might not be a problem, because the thread pool can be made large enough to accommodate many busy threads. However, the number of threads in the thread pool is limited (the default maximum for .NET 4.5 is 5,000). In large applications with high concurrency of long-running requests, all available threads might be busy. This condition is known as thread starvation. When this condition is reached, the web server queues requests. If the request queue becomes full, the web server rejects requests with an HTTP 503 status (Server Too Busy). The CLR thread pool has limitations on new thread injections. If concurrency is bursty (that is, your web site can suddenly get a large number of requests) and all available request threads are busy because of backend calls with high latency, the limited thread injection rate can make your application respond very poorly. Additionally, each new thread added to the thread pool has overhead (such as 1 MB of stack memory). A web application using synchronous methods to service high latency calls where the thread pool grows to the .NET 4.5 default maximum of 5, 000 threads would consume approximately 5 GB more memory than an application able the service the same requests using asynchronous methods and only 50 threads. When you’re doing asynchronous work, you’re not always using a thread. For example, when you make an asynchronous web service request, ASP.NET will not be using any threads between the asyncmethod call and the await. Using the thread pool to service requests with high latency can lead to a large memory footprint and poor utilization of the server hardware.

Processing Asynchronous Requests

In web applications that see a large number of concurrent requests at start-up or has a bursty load (where concurrency increases suddenly), making web service calls asynchronous will increase the responsiveness of your application. An asynchronous request takes the same amount of time to process as a synchronous request. For example, if a request makes a web service call that requires two seconds to complete, the request takes two seconds whether it is performed synchronously or asynchronously. However, during an asynchronous call, a thread is not blocked from responding to other requests while it waits for the first request to complete. Therefore, asynchronous requests prevent request queuing and thread pool growth when there are many concurrent requests that invoke long-running operations.

Choosing Synchronous or Asynchronous Methods

This section lists guidelines for when to use synchronous or asynchronous Methods. These are just guidelines; examine each application individually to determine whether asynchronous methods help with performance.

In general, use synchronous methods for the following conditions:

The operations are simple or short-running.
Simplicity is more important than efficiency.
The operations are primarily CPU operations instead of operations that involve extensive disk or network overhead. Using asynchronous methods on CPU-bound operations provides no benefits and results in more overhead.
In general, use asynchronous methods for the following conditions:
You’re calling services that can be consumed through asynchronous methods, and you’re using .NET 4.5 or higher.
The operations are network-bound or I/O-bound instead of CPU-bound.
Parallelism is more important than simplicity of code.
You want to provide a mechanism that lets users cancel a long-running request.
When the benefit of switching threads out weights the cost of the context switch. In general, you should make a method asynchronous if the synchronous method blocks the ASP.NET request thread while doing no work. By making the call asynchronous, the ASP.NET request thread is not blocked doing no work while it waits for the web service request to complete.
Testing shows that the blocking operations are a bottleneck in site performance and that IIS can service more requests by using asynchronous methods for these blocking calls.
The downloadable sample shows how to use asynchronous methods effectively. The sample provided was designed to provide a simple demonstration of asynchronous programming in ASP.NET 4.5. The sample is not intended to be a reference architecture for asynchronous programming in ASP.NET. The sample program calls ASP.NET Web APImethods which in turn call Task.Delay to simulate long-running web service calls. Most production applications will not show such obvious benefits to using asynchronous Methods.

Few applications require all methods to be asynchronous. Often, converting a few synchronous methods to asynchronous methods provides the best efficiency increase for the amount of work required.

The Sample Application

You can download the sample application from https://github.com/RickAndMSFT/Async-ASP.NETon the GitHub site. The repository consists of three projects:

WebAppAsync: The ASP.NET Web Forms project that consumes the Web API WebAPIpwgservice. Most of the code for this tutorial is from the this project.
WebAPIpgw: The ASP.NET MVC 4 Web API project that implements the Products, Gizmos and Widgets controllers. It provides the data for the WebAppAsyncproject and the Mvc4Async project.
Mvc4Async: The ASP.NET MVC 4 project that contains the code used in another tutorial. It makes Web API calls to the WebAPIpwg service.

The Gizmos Synchronous Page

The following code shows the Page_Load synchronous method that is used to display a list of gizmos. (For this article, a gizmo is a fictional mechanical device.)

<span class="hljs-keyword">public</span> <span class="hljs-keyword">partial</span> <span class="hljs-keyword">class</span> <span class="hljs-title">Gizmos</span> : <span class="hljs-title">System</span>.<span class="hljs-title">Web</span>.<span class="hljs-title">UI</span>.<span class="hljs-title">Page</span>
{
    <span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Page_Load</span>(<span class="hljs-params"><span class="hljs-keyword">object</span> sender, EventArgs e</span>)
    </span>{
        <span class="hljs-keyword">var</span> gizmoService = <span class="hljs-keyword">new</span> GizmoService();
        GizmoGridView.DataSource = gizmoService.GetGizmos();
        GizmoGridView.DataBind();
    }
}

public partial class Gizmos : System.Web.UI.Page

{

protected void Page_Load(object sender, EventArgs e)

{

var gizmoService = new GizmoService();

GizmoGridView.DataSource = gizmoService.GetGizmos();

GizmoGridView.DataBind();

}

The following code shows the GetGizmos method of the gizmo service.

<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">GizmoService</span>
{
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">async</span> Task&lt;List&lt;Gizmo&gt;&gt; GetGizmosAsync(
        <span class="hljs-comment">// Implementation removed.</span>
       
    <span class="hljs-function"><span class="hljs-keyword">public</span> List&lt;Gizmo&gt; <span class="hljs-title">GetGizmos</span>()
    </span>{
        <span class="hljs-keyword">var</span> uri = Util.getServiceUri(<span class="hljs-string">"Gizmos"</span>);
        <span class="hljs-keyword">using</span> (WebClient webClient = <span class="hljs-keyword">new</span> WebClient())
        {
            <span class="hljs-keyword">return</span> JsonConvert.DeserializeObject&lt;List&lt;Gizmo&gt;&gt;(
                webClient.DownloadString(uri)
            );
        }
    }
}

public class GizmoService

{

public async Task<List<Gizmo>> GetGizmosAsync(

// Implementation removed.

public List<Gizmo> GetGizmos()

{

var uri = Util.getServiceUri("Gizmos");

using (WebClient webClient = new WebClient())

{

return JsonConvert.DeserializeObject<List<Gizmo>>(

webClient.DownloadString(uri)

);

}

The GizmoService GetGizmos method passes a URI to an ASP.NET Web API HTTP service which returns a list of gizmos data. The WebAPIpgw project contains the implementation of the Web API gizmos, widget and product controllers.
The following image shows the gizmos page from the sample project.

Creating an Asynchronous Gizmos Page

The sample uses the new async and await keywords (available in .NET 4.5 and Visual Studio 2012) to let the compiler be responsible for maintaining the complicated transformations necessary for asynchronous programming. The compiler lets you write code using the C#’s synchronous control flow constructs and the compiler automatically applies the transformations necessary to use callbacks in order to avoid blocking threads.

ASP.NET asynchronous pages must include the Page directive with the Async attribute set to “true”. The following code shows the Page directive with the Async attribute set to “true” for the GizmosAsync.aspx page.

&lt;%@ Page Async="true"  Language="C#" AutoEventWireup="true" 
    CodeBehind="GizmosAsync.aspx.cs" Inherits="WebAppAsync.GizmosAsync" %&gt;

1 2	<%@ Page Async="true" Language="C#" AutoEventWireup="true" CodeBehind="GizmosAsync.aspx.cs" Inherits="WebAppAsync.GizmosAsync" %>

The following code shows the Gizmos synchronous Page_Load method and the GizmosAsyncasynchronous page. If your browser supports the HTML 5 element, you’ll see the changes in GizmosAsync in yellow highlight.

protected void Page_Load(object sender, EventArgs e)
{
   var gizmoService = new GizmoService();
   GizmoGridView.DataSource = gizmoService.GetGizmos();
   GizmoGridView.DataBind();
}

protected void Page_Load(object sender, EventArgs e)

{

var gizmoService = new GizmoService();

GizmoGridView.DataSource = gizmoService.GetGizmos();

GizmoGridView.DataBind();

}

The asynchronous version:

protected void Page_Load(object sender, EventArgs e)
{
    RegisterAsyncTask(new PageAsyncTask(GetGizmosSvcAsync));
}

private async Task GetGizmosSvcAsync()
{
    var gizmoService = new GizmoService();
    GizmosGridView.DataSource = await gizmoService.GetGizmosAsync();
    GizmosGridView.DataBind();
}

protected void Page_Load(object sender, EventArgs e)

{

RegisterAsyncTask(new PageAsyncTask(GetGizmosSvcAsync));

}

private async Task GetGizmosSvcAsync()

{

var gizmoService = new GizmoService();

GizmosGridView.DataSource = await gizmoService.GetGizmosAsync();

GizmosGridView.DataBind();

}

The following changes were applied to allow the GizmosAsync page be asynchronous.

The Page directive must have the Async attribute set to “true”.
The RegisterAsyncTask method is used to register an asynchronous task containing the code which runs asynchronously.
The new GetGizmosSvcAsync method is marked with the async keyword, which tells the compiler to generate callbacks for parts of the body and to automatically create a Taskthat is returned.
“Async” was appended to the asynchronous method name. Appending “Async” is not required but is the convention when writing asynchronous methods.
The return type of the new new GetGizmosSvcAsync method is Task. The return type of Task represents ongoing work and provides callers of the method with a handle through which to wait for the asynchronous operation’s completion.
The await keyword was applied to the web service call.
The asynchronous web service API was called (GetGizmosAsync).

Inside of the GetGizmosSvcAsync method body another asynchronous method, GetGizmosAsync is called. GetGizmosAsync immediately returns a Task<List<Gizmo>> that will eventually complete when the data is available. Because you don’t want to do anything else until you have the gizmo data, the code awaits the task (using the await keyword). You can use the await keyword only in methods annotated with the async keyword.

The await keyword does not block the thread until the task is complete. It signs up the rest of the method as a callback on the task, and immediately returns. When the awaited task eventually completes, it will invoke that callback and thus resume the execution of the method right where it left off. For more information on using the await and async keywords and the Task namespace, see the async references section.

The following code shows the GetGizmos and GetGizmosAsync methods.

<span class="hljs-function"><span class="hljs-keyword">public</span> List&lt;Gizmo&gt; <span class="hljs-title">GetGizmos</span>()
</span>{
	<span class="hljs-keyword">var</span> uri = Util.getServiceUri(<span class="hljs-string">"Gizmos"</span>);
	<span class="hljs-keyword">using</span> (WebClient webClient = <span class="hljs-keyword">new</span> WebClient())
	{
        <span class="hljs-keyword">return</span> JsonConvert.DeserializeObject&lt;List&lt;Gizmo&gt;&gt;(
            webClient.DownloadString(uri)
        );
	}
}

public List<Gizmo> GetGizmos()

{

var uri = Util.getServiceUri("Gizmos");

using (WebClient webClient = new WebClient())

{

return JsonConvert.DeserializeObject<List<Gizmo>>(

webClient.DownloadString(uri)

);

}

<span class="line-highlight"><span class="hljs-keyword">public</span> <span class="hljs-keyword">async</span> Task&lt;List&lt;Gizmo&gt;&gt; GetGizmosAsync()</span>
{
    <span class="hljs-keyword">var</span> uri = Util.getServiceUri(<span class="hljs-string">"Gizmos"</span>);
<span class="line-highlight">    <span class="hljs-keyword">using</span> (HttpClient httpClient = <span class="hljs-keyword">new</span> HttpClient())
    {
        <span class="hljs-keyword">var</span> response = <span class="hljs-keyword">await</span> httpClient.GetAsync(uri);
        <span class="hljs-keyword">return</span> (<span class="hljs-keyword">await</span> response.Content.ReadAsAsync&lt;List&lt;Gizmo&gt;&gt;());
    }</span>
}

public async Task<List<Gizmo>> GetGizmosAsync()

{

var uri = Util.getServiceUri("Gizmos");

using (HttpClient httpClient = new HttpClient())

{

var response = await httpClient.GetAsync(uri);

return (await response.Content.ReadAsAsync<List<Gizmo>>());

}

}

The asynchronous changes are similar to those made to the GizmosAsync above.

The method signature was annotated with the async keyword, the return type was changed to Task<List<Gizmo>>, and Async was appended to the method name.
The asynchronous HttpClient class is used instead of the synchronous WebClient class.
The await keyword was applied to the HttpClientGetAsync asynchronous method.

The following image shows the asynchronous gizmo view.

The browsers presentation of the gizmos data is identical to the view created by the synchronous call. The only difference is the asynchronous version may be more performant under heavy loads.

RegisterAsyncTask Notes

Methods hooked up with RegisterAsyncTask will run immediately after PreRender. You can also use async void page events directly, as shown in the following code:

<span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Page_Load</span>(<span class="hljs-params"><span class="hljs-keyword">object</span> sender, EventArgs e</span>) </span>{
    <span class="hljs-keyword">await</span> ...;
    <span class="hljs-comment">// do work</span>
}

protected async void Page_Load(object sender, EventArgs e) {

await ...;

// do work

}

The downside to async void events is that developers no longer has full control over when events execute. For example, if both an .aspx and a .Master define Page_Load events and one or both of them are asynchronous, the order of execution can’t be guaranteed. The same indeterminiate order for non event handlers (such as async void Button_Click ) applies. For most developers this should be acceptable, but those who require full control over the order of execution should only use APIs like RegisterAsyncTask that consume methods which return a Task object.

Performing Multiple Operations in Parallel

Asynchronous Methods have a significant advantage over synchronous methods when an action must perform several independent operations. In the sample provided, the synchronous page PWG.aspx(for Products, Widgets and Gizmos) displays the results of three web service calls to get a list of products, widgets, and gizmos. The ASP.NET Web API project that provides these services uses Task.Delay to simulate latency or slow network calls. When the delay is set to 500 milliseconds, the asynchronous PWGasync.aspx page takes a little over 500 milliseconds to complete while the synchronous PWG version takes over 1,500 milliseconds. The synchronous PWG.aspx page is shown in the following code.

<span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Page_Load</span>(<span class="hljs-params"><span class="hljs-keyword">object</span> sender, EventArgs e</span>)
</span>{
    Stopwatch stopWatch = <span class="hljs-keyword">new</span> Stopwatch();
    stopWatch.Start();

    <span class="hljs-keyword">var</span> widgetService = <span class="hljs-keyword">new</span> WidgetService();
    <span class="hljs-keyword">var</span> prodService = <span class="hljs-keyword">new</span> ProductService();
    <span class="hljs-keyword">var</span> gizmoService = <span class="hljs-keyword">new</span> GizmoService();

    <span class="hljs-keyword">var</span> pwgVM = <span class="hljs-keyword">new</span> ProdGizWidgetVM(
        widgetService.GetWidgets(),
        prodService.GetProducts(),
        gizmoService.GetGizmos()
       );
    WidgetGridView.DataSource = pwgVM.widgetList;
    WidgetGridView.DataBind();
    ProductGridView.DataSource = pwgVM.prodList;
    ProductGridView.DataBind();
    GizmoGridView.DataSource = pwgVM.gizmoList;
    GizmoGridView.DataBind();

    stopWatch.Stop();
    ElapsedTimeLabel.Text = String.Format(<span class="hljs-string">"Elapsed time: {0}"</span>, 
        stopWatch.Elapsed.Milliseconds / <span class="hljs-number">1000.0</span>);
}

{

Stopwatch stopWatch = new Stopwatch();

stopWatch.Start();

var widgetService = new WidgetService();

var prodService = new ProductService();

var gizmoService = new GizmoService();

var pwgVM = new ProdGizWidgetVM(

widgetService.GetWidgets(),

prodService.GetProducts(),

gizmoService.GetGizmos()

);

WidgetGridView.DataSource = pwgVM.widgetList;

WidgetGridView.DataBind();

ProductGridView.DataSource = pwgVM.prodList;

ProductGridView.DataBind();

GizmoGridView.DataSource = pwgVM.gizmoList;

GizmoGridView.DataBind();

stopWatch.Stop();

ElapsedTimeLabel.Text = String.Format("Elapsed time: {0}",

stopWatch.Elapsed.Milliseconds / 1000.0);

}

The asynchronous PWGasync code behind is shown below.

<span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Page_Load</span>(<span class="hljs-params"><span class="hljs-keyword">object</span> sender, EventArgs e</span>)
</span>{
    Stopwatch stopWatch = <span class="hljs-keyword">new</span> Stopwatch();
    stopWatch.Start();
<span class="line-highlight">    RegisterAsyncTask(<span class="hljs-keyword">new</span> PageAsyncTask(GetPWGsrvAsync));</span>
    stopWatch.Stop();
    ElapsedTimeLabel.Text = String.Format(<span class="hljs-string">"Elapsed time: {0}"</span>,
        stopWatch.Elapsed.Milliseconds / <span class="hljs-number">1000.0</span>);
}

<span class="line-highlight"><span class="hljs-function"><span class="hljs-keyword">private</span> <span class="hljs-keyword">async</span> Task <span class="hljs-title">GetPWGsrvAsync</span>()</span>
</span>{
    <span class="hljs-keyword">var</span> widgetService = <span class="hljs-keyword">new</span> WidgetService();
    <span class="hljs-keyword">var</span> prodService = <span class="hljs-keyword">new</span> ProductService();
    <span class="hljs-keyword">var</span> gizmoService = <span class="hljs-keyword">new</span> GizmoService();

    <span class="hljs-keyword">var</span> widgetTask = widgetService.GetWidgetsAsync();
    <span class="hljs-keyword">var</span> prodTask = prodService.GetProductsAsync();
    <span class="hljs-keyword">var</span> gizmoTask = gizmoService.GetGizmosAsync();

<span class="line-highlight">    <span class="hljs-keyword">await</span> Task.WhenAll(widgetTask, prodTask, gizmoTask);</span>

    <span class="hljs-keyword">var</span> pwgVM = <span class="hljs-keyword">new</span> ProdGizWidgetVM(
       widgetTask.Result,
       prodTask.Result,
       gizmoTask.Result
       );

    WidgetGridView.DataSource = pwgVM.widgetList;
    WidgetGridView.DataBind();
    ProductGridView.DataSource = pwgVM.prodList;
    ProductGridView.DataBind();
    GizmoGridView.DataSource = pwgVM.gizmoList;
    GizmoGridView.DataBind();           
}

{

Stopwatch stopWatch = new Stopwatch();

stopWatch.Start();

RegisterAsyncTask(new PageAsyncTask(GetPWGsrvAsync));

stopWatch.Stop();

ElapsedTimeLabel.Text = String.Format("Elapsed time: {0}",

stopWatch.Elapsed.Milliseconds / 1000.0);

}

private async Task GetPWGsrvAsync()

{

var widgetService = new WidgetService();

var prodService = new ProductService();

var gizmoService = new GizmoService();

var widgetTask = widgetService.GetWidgetsAsync();

var prodTask = prodService.GetProductsAsync();

var gizmoTask = gizmoService.GetGizmosAsync();

await Task.WhenAll(widgetTask, prodTask, gizmoTask);

var pwgVM = new ProdGizWidgetVM(

widgetTask.Result,

prodTask.Result,

gizmoTask.Result

);

WidgetGridView.DataSource = pwgVM.widgetList;

WidgetGridView.DataBind();

ProductGridView.DataSource = pwgVM.prodList;

ProductGridView.DataBind();

GizmoGridView.DataSource = pwgVM.gizmoList;

GizmoGridView.DataBind();

}

Using a Cancellation Token

Asynchronous Methods returning Taskare cancelable, that is they take a CancellationTokenparameter when one is provided with the AsyncTimeout attribute of the Page directive. The following code shows the GizmosCancelAsync.aspx page with a timeout of on second.

<span class="line-highlight">&lt;%@<span class="hljs-built_in"> Page </span> <span class="hljs-attribute">Async</span>=<span class="hljs-string">"true"</span>  <span class="hljs-attribute">AsyncTimeout</span>=<span class="hljs-string">"1"</span> </span>
    <span class="hljs-attribute">Language</span>=<span class="hljs-string">"C#"</span> <span class="hljs-attribute">AutoEventWireup</span>=<span class="hljs-string">"true"</span> 
    <span class="hljs-attribute">CodeBehind</span>=<span class="hljs-string">"GizmosCancelAsync.aspx.cs"</span> 
    <span class="hljs-attribute">Inherits</span>=<span class="hljs-string">"WebAppAsync.GizmosCancelAsync"</span> %&gt;

<%@ Page Async="true" AsyncTimeout="1"

Language="C#" AutoEventWireup="true"

CodeBehind="GizmosCancelAsync.aspx.cs"

Inherits="WebAppAsync.GizmosCancelAsync" %>

The following code shows the GizmosCancelAsync.aspx.cs file.

<span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Page_Load</span>(<span class="hljs-params"><span class="hljs-keyword">object</span> sender, EventArgs e</span>)
</span>{
    RegisterAsyncTask(<span class="hljs-keyword">new</span> PageAsyncTask(GetGizmosSvcCancelAsync));
}

<span class="line-highlight"><span class="hljs-function"><span class="hljs-keyword">private</span> <span class="hljs-keyword">async</span> Task <span class="hljs-title">GetGizmosSvcCancelAsync</span>(<span class="hljs-params">CancellationToken cancellationToken</span>)</span>
</span>{
    <span class="hljs-keyword">var</span> gizmoService = <span class="hljs-keyword">new</span> GizmoService();
<span class="line-highlight">    <span class="hljs-keyword">var</span> gizmoList = <span class="hljs-keyword">await</span> gizmoService.GetGizmosAsync(cancellationToken);</span>
    GizmosGridView.DataSource = gizmoList;
    GizmosGridView.DataBind();
}
<span class="hljs-function"><span class="hljs-keyword">private</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Page_Error</span>(<span class="hljs-params"><span class="hljs-keyword">object</span> sender, EventArgs e</span>)
</span>{
    Exception exc = Server.GetLastError();

    <span class="hljs-keyword">if</span> (exc <span class="hljs-keyword">is</span> TimeoutException)
    {
        <span class="hljs-comment">// Pass the error on to the Timeout Error page</span>
        Server.Transfer(<span class="hljs-string">"TimeoutErrorPage.aspx"</span>, <span class="hljs-literal">true</span>);
    }
}

{

RegisterAsyncTask(new PageAsyncTask(GetGizmosSvcCancelAsync));

}

private async Task GetGizmosSvcCancelAsync(CancellationToken cancellationToken)

{

var gizmoService = new GizmoService();

var gizmoList = await gizmoService.GetGizmosAsync(cancellationToken);

GizmosGridView.DataSource = gizmoList;

GizmosGridView.DataBind();

}

private void Page_Error(object sender, EventArgs e)

{

Exception exc = Server.GetLastError();

if (exc is TimeoutException)

{

// Pass the error on to the Timeout Error page

Server.Transfer("TimeoutErrorPage.aspx", true);

}

In the sample application provided, selecting the GizmosCancelAsync link calls the GizmosCancelAsync.aspx page and demonstrates the cancelation (by timing out) of the asynchronous call. Because the delay time is within a random range, you might need to refresh the page a couple times to get the time out error message.

Server Configuration for High Concurrency/High Latency Web Service Calls

To realize the benefits of an asynchronous web application, you might need to make some changes to the default server configuration. Keep the following in mind when configuring and stress testing your asynchronous web application.

Windows 7, Windows Vista, Window 8, and all Windows client operating systems have a maximum of 10 concurrent requests. You’ll need a Windows Server operating system to see the benefits of asynchronous methods under high load.
Register .NET 4.5 with IIS from an elevated command prompt using the following command:
%windir%\Microsoft.NET\Framework64 \v4.0.30319\aspnet_regiis -i
See ASP.NET IIS Registration Tool (Aspnet_regiis.exe)
You might need to increase the HTTP.sys queue limit from the default value of 1,000 to 5,000. If the setting is too low, you may see HTTP.sys reject requests with a HTTP 503 status. To change the HTTP.sys queue limit:
- Open IIS manager and navigate to the Application Pools pane.
- Right click on the target application pool and select Advanced Settings.

If your application is using web services or System.NET to communicate with a backend over HTTP you may need to increase the connectionManagement/maxconnection element. For ASP.NET applications, this is limited by the autoConfig feature to 12 times the number of CPUs. That means that on a quad-proc, you can have at most 12 * 4 = 48 concurrent connections to an IP end point. Because this is tied to autoConfig, the easiest way to increase maxconnection in an ASP.NET application is to set System.Net.ServicePointManager.DefaultConnectionLimit programmatically in the from Application_Start method in the global.asax file. See the sample download for an example.
In .NET 4.5, the default of 5000 for MaxConcurrentRequestsPerCPU should be fine.

jQuery Tooltip Validation Using Twitter Bootstrap

CheapASPNETHostingReview.com | Generally, we use a jQuery unobtrusive validation plugin in ASP.NET MVC Applications.We are going to discuss the following topics in this article:

Disadvantages of jQuery unobtrusive validation in MVC.
jQuery tooltip validation

There are some disadvantages of using this plugin. When using the jQuery unobtrusive validation plugin, it creates a span tag to display error messages. If you have, for example, a horizontal form on top of the other controls, then this behavior might not be working for you, since they will break the page layout. It was the case for me and as such, I decided to change the default behavior of the jQuery unobtrusive validation library and instead of using a span to show the error message, I decided to use a tooltip. I am going to show you how I achieved this, using a tooltip with the help of a bootstrap.

Before going to the tooltip validation, first look at the traditional jQuery unobtrusive example.

The following is an example of an application of unobtrusive validation.

When I click the Register button, the error message comes, as shown below:

If I increase the length of the error message, the layout will be broken like this. In the same way, when I place the same length error message below, the Textbox controls come as shown in the screenshot. The same layout-change problem occurs. Hence, this is a bad idea of using a default behavior of the jQuery Unobtrusive validation plugin. I replaced the error type with a tooltip. It won’t change the layout structure.

Now the jQuery tooltip validation article begins from here,

jQuery tooltip validation using Twitter Bootstrap

Step 1

Create ASP.NET MVC Application.

Create Application with MVC template.

2. Add the following files.

3. Create HomeController.cs.

Right click->Controllers folder->Add->Controller->name it as HomeController.cs.

4. Add Index Method to the Controller.

5. Add View to Index Action method.

Right click->Index Method->Add View->click OK.

Index view is created.

6. Now, replace the Index.cshtml code with the code given below:

&lt;!DOCTYPE html&gt;  
&lt;html&gt;  
&lt;head&gt;  
    &lt;title&gt;Bootstrap tooltip Example&lt;/title&gt;  
  
    &lt;!-----------------resource files-------------&gt;  
    &lt;link href="~/Content/bootstrap.min.css" rel="stylesheet" /&gt;  
    &lt;script src="~/Scripts/jquery-1.9.1.min.js"&gt;&lt;/script&gt;  
    &lt;script src="~/Scripts/bootstrap.min.js"&gt;&lt;/script&gt;  
    &lt;script src="~/Scripts/jquery.validate.min.js"&gt;&lt;/script&gt;  
    &lt;script src="~/Scripts/jquery-validate.bootstrap-tooltip.min.js"&gt;&lt;/script&gt;  
    &lt;script src="~/Scripts/myscript.js"&gt;&lt;/script&gt;  
  
&lt;/head&gt;  
&lt;body&gt;  
&lt;div id="main"&gt;  
    @using (Html.BeginForm("Index", "Home", FormMethod.Post, new { name = "RegistrationForm", id = "RegistrationForm" }))  
    {  
        &lt;fieldset style="padding-left: 100px; box-shadow: 2px 2px 2px 2px #000;margin-top:30px;height:500px;"&gt;  
            &lt;legend style="font-size:larger;font-weight:bold;"&gt;Registration page&lt;/legend&gt;  
            &lt;div id="left-part" align="left" style="float:left;margin-left:20px;"&gt;  
                @Html.Label("FirstName", new { required = "required" })&lt;br /&gt;  
                @Html.TextBox("FirstName")&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("LastName")&lt;br /&gt;  
                @Html.TextBox("LastName")&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("UserName")&lt;br /&gt;  
                @Html.TextBox("UserName")&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("Gender")&lt;br /&gt;  
                @Html.RadioButton("Gender", "Male", false, new { id = "rbnMale", name = "rbnMale" })Male  
                @Html.RadioButton("Gender", "Female", false, new { id = "rbnFemale", name = "rbnFemale" })Female  
                &lt;br /&gt;&lt;br /&gt;  
                @Html.Label("Email Id:")  &lt;br /&gt;  
                @Html.TextBox("Email", null, new { type = "email" })&lt;br /&gt;&lt;br /&gt;  
            &lt;/div&gt;  
            &lt;div id="right-side" style="margin-left:400px;"&gt;  
                @Html.Label("Password")&lt;br /&gt;  
                @Html.Password("Password")&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("ConfirmPassword")&lt;br /&gt;  
                @Html.Password("ConfirmPassword")&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("MobileNo")&lt;br /&gt;  
                @Html.TextBox("MobileNo", null, new { type = "number" })&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("State")&lt;br /&gt;  
                @Html.TextBox("State")&lt;br /&gt;&lt;br /&gt;  
                @Html.Label("Country")&lt;br /&gt;  
                @Html.DropDownList("CountryDropdownlst", new List&lt;SelectListItem&gt;()  
                         {  
                            new SelectListItem(){Text="India",Value="0"},  
                            new SelectListItem(){Text="China",Value="1"},  
                            new SelectListItem(){Text="USA",Value="2"},  
                            new SelectListItem(){Text="Russia",Value="3"}  
                         }, "--select--", new { id = "CountryDropdownlst" })  
                &lt;br /&gt;&lt;br /&gt;  
                &lt;input type="submit" value="Register" id="btnSubmit" name="btnSubmit" class="btn btn-primary"/&gt;  
            &lt;/div&gt;  
        &lt;/fieldset&gt;  
    }  
    &lt;br /&gt;  
&lt;/div&gt;  
&lt;/body&gt;  
&lt;/html&gt;

<!DOCTYPE html>

<html>

<head>

<title>Bootstrap tooltip Example</title>

</head>

<body>

@using (Html.BeginForm("Index", "Home", FormMethod.Post, new { name = "RegistrationForm", id = "RegistrationForm" }))

{

<legend style="font-size:larger;font-weight:bold;">Registration page</legend>

@Html.Label("FirstName", new { required = "required" })

@Html.TextBox("FirstName")

@Html.Label("LastName")

@Html.TextBox("LastName")

@Html.Label("UserName")

@Html.TextBox("UserName")

@Html.Label("Gender")

@Html.RadioButton("Gender", "Male", false, new { id = "rbnMale", name = "rbnMale" })Male

@Html.RadioButton("Gender", "Female", false, new { id = "rbnFemale", name = "rbnFemale" })Female

@Html.Label("Email Id:")

@Html.TextBox("Email", null, new { type = "email" })

</div>

@Html.Label("Password")

@Html.Password("Password")

@Html.Label("ConfirmPassword")

@Html.Password("ConfirmPassword")

@Html.Label("MobileNo")

@Html.TextBox("MobileNo", null, new { type = "number" })

@Html.Label("State")

@Html.TextBox("State")

@Html.Label("Country")

@Html.DropDownList("CountryDropdownlst", new List<SelectListItem>()

{

new SelectListItem(){Text="India",Value="0"},

new SelectListItem(){Text="China",Value="1"},

new SelectListItem(){Text="USA",Value="2"},

new SelectListItem(){Text="Russia",Value="3"}

}, "--select--", new { id = "CountryDropdownlst" })

</div>

</fieldset>

}

</div>

</body>

</html>

Step 2

Add the script for the validation,

Add myscript.js to the script folder.
myscript.js

//if no errors form will be submited  
$.validator.setDefaults({  
    submitHandler: function () {  
        alert("form submited!");  
    }  
});  
debugger;  
$(document).ready(function () {  
    $("#RegistrationForm").validate({  
        rules: {  
            FirstName: {  
                required: true,  
                minlength: 4,  
                maxlength: 15  
            },  
            LastName: {  
                required: true,  
                minlength: 4,  
                maxlength: 15  
            },  
            UserName: {  
                required: true,  
                minlength: 5  
            },  
            Gender: { required: true },  
            Email: {  
                required: true,  
                email: true  
            },  
            Password: {  
                required: true,  
                minlength: 5,  
                maxlength: 20  
            },  
            ConfirmPassword:{  
                required: true,  
                equalTo:"#Password"  
            },  
            MobileNo: {  
                required: true,  
                number: true,  
                minlength: 10,  
                maxlength:12  
            },  
            State: { required: true ,minlength:5},  
            CountryDropdownlst: {  
                required:true  
            }  
        },  
        messages: {  
            Gender: "Pls Select the Gender!",  
            FirstName: {  
                required: "Firstname required Firstname required Firstname required Firstname required ",  
                minlength: "pls enter min 4 chars",  
                maxlength:"only 15 chars are allowed"  
            },  
            LastName: {  
                required: "Lastname required",  
                minlength: "pls enter min 4 chars",  
                maxlength: "only 15 chars are allowed"  
            },  
            UserName: {  
                required: "Username is mandatory",  
                minlength:"pls enter min 5 chars"  
            },  
            Password: {  
                required: "Password is mandatory",  
                minlength:"pls enter min 5 chars"  
            },  
            ConfirmPassword: {  
                required: "Pls confirm password",  
                equalTo:"password does not match"  
            },  
            MobileNo: {  
                required: "pls enter mobile no",  
                minlength: "pls enter valid mobile no"  
            },  
            State:"Pls enter valid state",  
            CountryDropdownlst:"pls select your country"  
  
        },  
        //tooltip options to change position of tooltip..  
        tooltip_options: {  
            FirstName: { trigger: 'focus' },  
            Gender: { placement: 'top', html: true }    //placement:'bottom'for bottom  
        },  
        //submitHandler: function (form) {  
        //    $("#validity_label").html('  
  
No errors.  Like a boss.  
');  
        //},  
        invalidHandler: function (form, validator) {  
            $("#validity_label").html('  
  
There be ' + validator.numberOfInvalids() + ' error' + (validator.numberOfInvalids() &gt; 1 ? 's' : '') + ' here.  OH NOES!!!!!  
');  
        }  
    });  
});

100

//if no errors form will be submited

$.validator.setDefaults({

submitHandler: function () {

alert("form submited!");

}

});

debugger;

$(document).ready(function () {

$("#RegistrationForm").validate({

rules: {

FirstName: {

required: true,

minlength: 4,

maxlength: 15

LastName: {

required: true,

minlength: 4,

maxlength: 15

UserName: {

required: true,

minlength: 5

Gender: { required: true },

Email: {

required: true,

email: true

Password: {

required: true,

minlength: 5,

maxlength: 20

ConfirmPassword:{

required: true,

equalTo:"#Password"

MobileNo: {

required: true,

number: true,

minlength: 10,

maxlength:12

State: { required: true ,minlength:5},

CountryDropdownlst: {

required:true

}

messages: {

Gender: "Pls Select the Gender!",

FirstName: {

required: "Firstname required Firstname required Firstname required Firstname required ",

minlength: "pls enter min 4 chars",

maxlength:"only 15 chars are allowed"

LastName: {

required: "Lastname required",

minlength: "pls enter min 4 chars",

maxlength: "only 15 chars are allowed"

UserName: {

required: "Username is mandatory",

minlength:"pls enter min 5 chars"

Password: {

required: "Password is mandatory",

minlength:"pls enter min 5 chars"

ConfirmPassword: {

required: "Pls confirm password",

equalTo:"password does not match"

MobileNo: {

required: "pls enter mobile no",

minlength: "pls enter valid mobile no"

State:"Pls enter valid state",

CountryDropdownlst:"pls select your country"

//tooltip options to change position of tooltip..

tooltip_options: {

FirstName: { trigger: 'focus' },

Gender: { placement: 'top', html: true } //placement:'bottom'for bottom

//submitHandler: function (form) {

// $("#validity_label").html('

No errors. Like a boss.

');

//},

invalidHandler: function (form, validator) {

$("#validity_label").html('

There be ' + validator.numberOfInvalids() + ' error' + (validator.numberOfInvalids() > 1 ? 's' : '') + ' here. OH NOES!!!!!

');

}

});

Step 3

Add styles for the error display.

. tooltip{  
       margin-left:100px;             
   }  
   .tooltip-inner {  
       background: #ff3333; /*tooltip text background color*/  
       border-radius: 0px;  
       font-weight: bolder;  
       box-shadow: 1px 1px 1px 1px black;  
   }  
   .tooltip.top .tooltip-arrow {  
       border-top-color: red;  
       margin-left: -55px;             
   }  
   input[type="text"],input[type="password"],input[type="number"],input[type="email"], #CountryDropdownlst {  
       box-shadow: 1px 1px 1px 1px grey;  
       width: 200px;  
   }  
   #CountryDropdownlst{  
       height:27px;  
   }  
   /*.tooltip-inner tooltip-arrow { 
       margin-left: 200px;

. tooltip{

margin-left:100px;

}

.tooltip-inner {

background: #ff3333; /*tooltip text background color*/

border-radius: 0px;

font-weight: bolder;

box-shadow: 1px 1px 1px 1px black;

}

.tooltip.top .tooltip-arrow {

border-top-color: red;

margin-left: -55px;

}

input[type="text"],input[type="password"],input[type="number"],input[type="email"], #CountryDropdownlst {

box-shadow: 1px 1px 1px 1px grey;

width: 200px;

}

#CountryDropdownlst{

height:27px;

}

/*.tooltip-inner tooltip-arrow {

margin-left: 200px;

Now run the Application and you will get the Window as shown below:

Without entering anything into the fields, just click on the Register button and see what happens.

How To Logging with Microsoft.NET

CheapASPNETHostingReview.com | Best and cheap ASP.NET Hosting. Through this article, we will explain in depth logging in .NET applications. We will explain this through two steps:

Introduction to System.Diagnostics (prebuilt logging namespace in .NET)
Introduction to Log4net

I. System.Diagnostics Namespace

The System.Diagnostics namespace provides classes that allow you to interact with system processes, event logs, and performance counters, Classes like EventLog which provides functionality to write to event logs, read event log entries, and create and delete event logs and event sources on the network. TraceSource which also provides a set of methods and properties that enable applications to trace the execution of code and associate trace messages with their source. In this paragraph, we will implement a tracing/Logging library based on the TraceSource Class. This library enable users to:

trace different scenarios inside applications [Start, Stop, Error, Information, Critical, Warning]
The Trace destination is configurable, it can be a file, it can be a console application and it supports also sending Log Message by mail.

To do so, this logging utility contains:

Interface called Logger.cs
Interface called ILogger.cs
Enumeration called LogType which presents the destination of trace messages

/// &lt;summary&gt;
/// Trace manager contract for trace instrumentation
/// &lt;/summary&gt;
///
public interface ILogger
{
        /// &lt;summary&gt;
        /// Send "start" flag to trace repository
        /// &lt;/summary&gt;
        void TraceStart(string message);

        /// &lt;summary&gt;
        /// Send "stop" flag to trace repository
        /// &lt;/summary&gt;
        void TraceStop(string message);

        /// &lt;summary&gt;
        /// Trace information message to trace repository
        /// &lt;param name="message"&gt;Information message to trace&lt;/param&gt;
        /// &lt;/summary&gt;
        void TraceInfo(string message);

        /// &lt;summary&gt;
        /// Trace warning message to trace repository
        /// &lt;/summary&gt;
        /// &lt;param name="message"&gt;Warning message to trace&lt;/param&gt;
        void TraceWarning(string message);

        /// &lt;summary&gt;
        /// Trace error message to trace repository
        /// &lt;/summary&gt;
        /// &lt;param name="message"&gt;Error message to trace&lt;/param&gt;
        void TraceError(string message);

        /// &lt;summary&gt;
        /// Trace critical message to trace repository
        /// &lt;/summary&gt;
        /// &lt;param name="message"&gt;Critical message to trace&lt;/param&gt;
        void TraceCritical(string message);
}

/// &lt;summary&gt;
/// The destination of the trace messages [FileSystem or Emails]
/// &lt;/summary&gt;
public enum LogType
{
    File,
    Email,
}

/// <summary>

/// Trace manager contract for trace instrumentation

/// </summary>

///

public interface ILogger

{

/// <summary>

/// Send "start" flag to trace repository

/// </summary>

void TraceStart(string message);

/// <summary>

/// Send "stop" flag to trace repository

/// </summary>

void TraceStop(string message);

/// <summary>

/// Trace information message to trace repository

/// <param name="message">Information message to trace</param>

/// </summary>

void TraceInfo(string message);

/// <summary>

/// Trace warning message to trace repository

/// </summary>

/// <param name="message">Warning message to trace</param>

void TraceWarning(string message);

/// <summary>

/// Trace error message to trace repository

/// </summary>

/// <param name="message">Error message to trace</param>

void TraceError(string message);

/// <summary>

/// Trace critical message to trace repository

/// </summary>

/// <param name="message">Critical message to trace</param>

void TraceCritical(string message);

}

/// <summary>

/// The destination of the trace messages [FileSystem or Emails]

/// </summary>

public enum LogType

{

File,

Email,

}

The class that implements the interface ILogger.cs:

public class Logger : ILogger
{
    #region Members

    TraceSource source;
    LogType logType;

    #endregion

    #region  Constructor

    /// &lt;summary&gt;
    /// Create a new instance of this trace manager
    /// &lt;/summary&gt;
    public Logger(LogType logType)

    {
        // Create default source
        source = new TraceSource("Code Project : ");
        this.logType = logType;
    }

    #endregion

    #region Private Methods
    /// &lt;summary&gt;
    /// Trace internal message in configured listeners
    /// &lt;/summary&gt;
    /// &lt;param name="eventType"&gt;Event type to trace&lt;/param&gt;
    /// &lt;param name="message"&gt;Message of event&lt;/param&gt;
    void TraceInternal(TraceEventType eventType, string message)
    {
        if (source != null)
        {
            try
            {
                if (this.logType == LogType.File)
                {
                    source.TraceEvent(eventType, (int)eventType, message);
                    foreach (TraceListener item in source.Listeners)
                    {
                        item.IndentSize = 4;
                        item.Flush();
                    }
                }
                else

                {
                    Console.WriteLine("Send Mail");
                  //You just need a function that send Email to someone
                }
            }
            catch (SecurityException)
            {
                //Cannot access to file listener or cannot have
                //privileges to write in event log
                //do not propagate this :-(
            }
        }
    }
    #endregion

    #region Public Methods
    /// &lt;summary&gt;
    /// &lt;see cref=" Logging.ILogger"/&gt;
    /// &lt;/summary&gt;
    public void TraceStart(string message)
    {
        TraceInternal(TraceEventType.Start, message);
    }

    /// &lt;summary&gt;
    /// &lt;see cref=" Logging.ILogger"/&gt;
    /// &lt;/summary&gt;
    public void TraceStop(string message)
    {
        TraceInternal(TraceEventType.Stop, message);
    }

    /// &lt;summary&gt;
    /// &lt;see cref=" Logging.ILogger"/&gt;
    /// &lt;/summary&gt;
    /// &lt;param name="message"&gt;&lt;see cref=" Logging.ILogger"/&gt;&lt;/param&gt;
    public void TraceInfo(string message)
    {
        if (String.IsNullOrEmpty(message))
            throw new ArgumentNullException(message);

        TraceInternal(TraceEventType.Information, message);
    }

    /// &lt;summary&gt;
    /// &lt;see cref=" Logging.ILogger"/&gt;
    /// &lt;/summary&gt;
    /// &lt;param name="message"&gt;&lt;see cref=" Logging.ILogger"/&gt;&lt;/param&gt;
    public void TraceWarning(string message)
    {
        if (String.IsNullOrEmpty(message))
            throw new ArgumentNullException(message);
        TraceInternal(TraceEventType.Warning, message);
    }

    /// &lt;summary&gt;
    /// &lt;see cref=" Logging.ILogger"/&gt;
    /// &lt;/summary&gt;
    /// &lt;param name="message"&gt;&lt;see cref=" Logging.ILogger"/&gt;&lt;/param&gt;
    public void TraceError(string message)
    {
        if (String.IsNullOrEmpty(message))
            throw new ArgumentNullException(message);

        TraceInternal(TraceEventType.Error, message);
    }

    /// &lt;summary&gt;
    /// &lt;see cref=" Logging.ILogger"/&gt;
    /// &lt;/summary&gt;
    /// &lt;param name="message"&gt;&lt;see cref=" Logging.ILogger"/&gt;&lt;/param&gt;
    public void TraceCritical(string message)
    {
        if (String.IsNullOrEmpty(message))
            throw new ArgumentNullException(message);

        TraceInternal(TraceEventType.Critical, message);
    }
    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

public class Logger : ILogger

{

#region Members

TraceSource source;

LogType logType;

#endregion

#region Constructor

/// <summary>

/// Create a new instance of this trace manager

/// </summary>

public Logger(LogType logType)

{

// Create default source

source = new TraceSource("Code Project : ");

this.logType = logType;

}

#endregion

#region Private Methods

/// <summary>

/// Trace internal message in configured listeners

/// </summary>

/// <param name="eventType">Event type to trace</param>

/// <param name="message">Message of event</param>

void TraceInternal(TraceEventType eventType, string message)

{

if (source != null)

{

try

{

if (this.logType == LogType.File)

{

source.TraceEvent(eventType, (int)eventType, message);

foreach (TraceListener item in source.Listeners)

{

item.IndentSize = 4;

item.Flush();

}

else

{

Console.WriteLine("Send Mail");

//You just need a function that send Email to someone

}

catch (SecurityException)

{

//Cannot access to file listener or cannot have

//privileges to write in event log

//do not propagate this :-(

}

#endregion

#region Public Methods

/// <summary>

/// <see cref=" Logging.ILogger"/>

/// </summary>

public void TraceStart(string message)

{

TraceInternal(TraceEventType.Start, message);

}

/// <summary>

/// <see cref=" Logging.ILogger"/>

/// </summary>

public void TraceStop(string message)

{

TraceInternal(TraceEventType.Stop, message);

}

/// <summary>

/// <see cref=" Logging.ILogger"/>

/// </summary>

/// <param name="message"><see cref=" Logging.ILogger"/></param>

public void TraceInfo(string message)

{

if (String.IsNullOrEmpty(message))

throw new ArgumentNullException(message);

TraceInternal(TraceEventType.Information, message);

}

/// <summary>

/// <see cref=" Logging.ILogger"/>

/// </summary>

/// <param name="message"><see cref=" Logging.ILogger"/></param>

public void TraceWarning(string message)

{

if (String.IsNullOrEmpty(message))

throw new ArgumentNullException(message);

TraceInternal(TraceEventType.Warning, message);

}

/// <summary>

/// <see cref=" Logging.ILogger"/>

/// </summary>

/// <param name="message"><see cref=" Logging.ILogger"/></param>

public void TraceError(string message)

{

if (String.IsNullOrEmpty(message))

throw new ArgumentNullException(message);

TraceInternal(TraceEventType.Error, message);

}

/// <summary>

/// <see cref=" Logging.ILogger"/>

/// </summary>

/// <param name="message"><see cref=" Logging.ILogger"/></param>

public void TraceCritical(string message)

{

if (String.IsNullOrEmpty(message))

throw new ArgumentNullException(message);

TraceInternal(TraceEventType.Critical, message);

}

#endregion

}

Now let’s see how to configure the library through the configuration file. The configuration file will determine:

The name of the source
The type of destination message [a text file, a console file, etc…]
The trace option output, in our case, the output of any trace containing this message
- The type of trace [information, Error, warning, etc…]
- Date Time of the trace
- Thread ID
- Process ID
- TimeStamp

&lt;system.diagnostics&gt;
    &lt;sources&gt; 
      &lt;source name="CodeProject : " switchName="sourceSwitch" 

      switchType="System.Diagnostics.SourceSwitch"&gt;
        &lt;listeners&gt;
          &lt;remove name="Default" /&gt;
          &lt;add name="console" type="System.Diagnostics.ConsoleTraceListener" 

          traceOutputOptions="DateTime,ThreadId,ProcessId,Timestamp"&gt;
            &lt;filter type="System.Diagnostics.EventTypeFilter" 

            initializeData="All"/&gt;
          &lt;/add&gt;      
        &lt;/listeners&gt;
      &lt;/source&gt;
    &lt;/sources&gt;
    &lt;switches&gt;
      &lt;add name="sourceSwitch" value="All"/&gt;
    &lt;/switches&gt;
  &lt;/system.diagnostics&gt;

<system.diagnostics>

<source name="CodeProject : " switchName="sourceSwitch"

switchType="System.Diagnostics.SourceSwitch">

<add name="console" type="System.Diagnostics.ConsoleTraceListener"

traceOutputOptions="DateTime,ThreadId,ProcessId,Timestamp">

<filter type="System.Diagnostics.EventTypeFilter"

initializeData="All"/>

</add>

</listeners>

</source>

</sources>

</switches>

</system.diagnostics>

Testing the library:

Logger Logger = new Logger(LogType.File);//in case when we do not want to send log by Email.
Logger.TraceStart("start Operation");
Logger.TraceInfo("Trace Operation");
Logger.TraceWarning("Warning Operation");
Logger.TraceError("Error Operation");
Logger.TraceCritical("Critical Operation");
Logger.TraceStop("Stop Operation");

Logger Logger = new Logger(LogType.File);//in case when we do not want to send log by Email.

Logger.TraceStart("start Operation");

Logger.TraceInfo("Trace Operation");

Logger.TraceWarning("Warning Operation");

Logger.TraceError("Error Operation");

Logger.TraceCritical("Critical Operation");

Logger.TraceStop("Stop Operation");

If we want to customize the destination of trace messages, for example, display the trace message in a file system, we just add a ‘TextWriterTraceListener‘ to the configuration file:

 &lt;add name="myListener" type="System.Diagnostics.TextWriterTraceListener" 

initializeData="E:\TextWriterOutput.log"

               traceOutputOptions="DateTime,ThreadId,ProcessId,Timestamp"&gt;
            &lt;filter type="System.Diagnostics.EventTypeFilter" initializeData="All"/&gt;
         
 &lt;/add&gt;

<add name="myListener" type="System.Diagnostics.TextWriterTraceListener"

initializeData="E:\TextWriterOutput.log"

traceOutputOptions="DateTime,ThreadId,ProcessId,Timestamp">

</add>

Displaying trace messages in Bloc Notes.

You can customize the tracing output’s target by adding or removing TraceListener instances to or from the collection stored in the TraceSource.Listeners property. By default, trace output is produced using an instance of the DefaultTraceListener class. The preceding configuration file example demonstrates removing the DefaultTraceListener and adding a TextWriterTraceListener/ConsoleTraceListener to produce the trace output for the trace source.
As a Microsoft developer, I have always been more comfortable when implementing my own libraries based on .NET prebuilt namespaces because I want to have absolute control on my source code, but I have seen many projects using Logging with third party libraries, for example, Log4Net. In the next paragraph, we will learn how to integrate this library into our applications.

II. Logging with Log4NET

The Apache log4net library is a tool to help the programmer output log statements to a variety of output targets. Log4net is a port of the log4j framework to Microsoft.NET platform. To integrate this library, you must use nuget package manager.

Like the TraceSource class, Log4net library enables the developer to customize message tracing (changing the log destinations and the format of messages). We will write two scenarios:

Default Configuration [Console Configuration]

private static readonly ILog log = LogManager.GetLogger(typeof(Program));
static void Main(string[] args)
{
// Default Configuration [Console Configuration]
BasicConfigurator.Configure();
log.Info("Hi ");
log.Warn("Thanks Code Project");
Console.ReadLine();
}

private static readonly ILog log = LogManager.GetLogger(typeof(Program));

static void Main(string[] args)

{

// Default Configuration [Console Configuration]

BasicConfigurator.Configure();

log.Info("Hi ");

log.Warn("Thanks Code Project");

Console.ReadLine();

}

Using custom configuration [saving messages into a text file].

private static readonly ILog log = LogManager.GetLogger(typeof(Program));
static void Main(string[] args)
       {
           //The Logging configuration
           String configFilePath = AppDomain.CurrentDomain.BaseDirectory + @"\Log4NET.config";

           if (File.Exists(configFilePath))
           {
               //Load the configuration from the XML File
               XmlConfigurator.Configure(new FileInfo(configFilePath));
               log.Info("Hi ");
               log.Warn("Thanks Code Project");
           }
           Console.ReadLine();
       }

private static readonly ILog log = LogManager.GetLogger(typeof(Program));

static void Main(string[] args)

{

//The Logging configuration

String configFilePath = AppDomain.CurrentDomain.BaseDirectory + @"\Log4NET.config";

if (File.Exists(configFilePath))

{

//Load the configuration from the XML File

XmlConfigurator.Configure(new FileInfo(configFilePath));

log.Info("Hi ");

log.Warn("Thanks Code Project");

}

Console.ReadLine();

}

XML Configuration file

&lt;log4net&gt;
   &lt;!--FileAppender --&gt;
   &lt;appender name="FileAppender" type="log4net.Appender.FileAppender"&gt;
     &lt;file value="E:\log-file.txt" /&gt;
     &lt;appendToFile value="true" /&gt;
     &lt;encoding value="utf-8" /&gt;
     &lt;layout type="log4net.Layout.SimpleLayout" /&gt;
   &lt;/appender&gt;

   &lt;!-- On définit le logger root au niveau DEBUG et
   on l'associe à l'appender A1 --&gt;
   &lt;root&gt;
     &lt;level value="DEBUG" /&gt;
     &lt;appender-ref ref="FileAppender" /&gt;
   &lt;/root&gt;
 &lt;/log4net&gt;

</appender>

<!-- On définit le logger root au niveau DEBUG et

on l'associe à l'appender A1 -->

<root>

<appender-ref ref="FileAppender" />

</root>

</log4net>

Displaying trace messages in Bloc Notes.

Summary

Log4net is a port of Log4j to the .NET universe, Log4j is a popular logging framework and that’s why log4net has rapidly grown. The class System.Diagnostics.TraceSource provides high performance logging and tracing for applications but both use nearly the same mechanism.

I hope that you appreciated my effort. Thank you for viewing my blog post, try to download the source code and do not hesitate to leave your questions.

Using Web.Config customErrors for ASP.NET

CheapASPNETHostingReview.com | Best and cheap ASSP.NET Hosting. The ASP.NET framework provides built-in settings to control how to respond when an application error occurs. This functionality is part of the Web.Config customErrors section.

Configuration Options for Web.Config <customErrors>

Like most web.config settings, customErrors can be configured within the Machine.config, root web.config or your application web.config file. Usually, it is set per application.

CustomErrors supports the following modes:

On – If defaultRedirect is specified, they will see that content. Otherwise the default error screen with fewer details.
Off – Detailed error details will be shown to the user. (the “yellow screen of death screen”)
RemoteOnly – Default value. Detailed errors only are shown to local users. Remote users receive custom error screens or fewer details.

Example configuration:

<configuration>
  <system.web>
    <customErrors defaultRedirect="YourErrorPage.aspx"
                  mode="RemoteOnly">
      <error statusCode="500"
             redirect="InternalErrorPage.aspx"/>
    </customErrors>
  </system.web>
</configuration>

<system.web>

<customErrors defaultRedirect="YourErrorPage.aspx"

mode="RemoteOnly">

<error statusCode="500"

redirect="InternalErrorPage.aspx"/>

</customErrors>

</system.web>

</configuration>

How to View Full ASP.NET Error Details, Disabling Custom Errors

If your application is throwing errors, but you cannot see the full error message, you can disable customErrors.

To do this, you will want to set customErrors mode to “Off” as shown below. Be careful though as this could expose sensitive information shown in error messages as well as detailed stack traces.

<configuration>
  <system.web>
    <customErrors mode="Off"/>
  </system.web>
</configuration>

<system.web>

</system.web>

</configuration>

Other Ways to View ASP.NET Exceptions

There are other ways to track, find, and view application errors besides the ASP.NET yellow screen of death. Ideally, your application should be logging all of your errors to a log file and error monitoring service. You can also check Windows Event Viewer, and you may be able to see your exceptions. Although, be warned that exceptions are rate limited to Event Viewer and it does not record all of them.

How to Log All Application Errors

Depending on your type of application, there are potentially multiple ways to do this. If your application has a Global.asax file, you can subscribe to unhandled exceptions as shown below:

public class WebApiApplication : System.Web.HttpApplication
{
	log4net.ILog log = log4net.LogManager.GetLogger(typeof(WebApiApplication));

	public override void Init()
	{
		base.Init();
		this.Error += WebApiApplication_Error;  
	}

	void WebApiApplication_Error(object sender, EventArgs e)
	{
		var ex = Server.GetLastError();		
		log.Error(ex);            
	}
}

public class WebApiApplication : System.Web.HttpApplication

{

log4net.ILog log = log4net.LogManager.GetLogger(typeof(WebApiApplication));

public override void Init()

{

base.Init();

this.Error += WebApiApplication_Error;

}

void WebApiApplication_Error(object sender, EventArgs e)

{

var ex = Server.GetLastError();

log.Error(ex);

}

How to View All Application Exceptions With Retrace

Retrace provides code-level performance monitoring for your application. Part of that includes collecting all application exceptions. Retrace can collect unhandled exceptions, exceptions explicitly logged to it, or every single exception ever is thrown (first chance exceptions).

To make the most of your application errors, you should use an error monitoring service, like Retrace. Benefits of an error monitoring service:

Real-time alerts – know immediately when a new error happens
Centralized repository – one place your team can access everything
Error rates – quickly identify large spikes in error rates
Improve productivity – find root cause of problems much faster

Use An Area In ASP.NET Core

CheapASPNETHostingReview.com | Best and cheap ASP.NET Core hosting. In order to include an Area in an ASP.NET Core app, first we need to include a conventional route in the Startup.cs file (It’s best to place it before any non-area route).

In Startup.cs, configure the method.

app.UseMvc(routes =&gt;  
{  
    routes.MapRoute("areaRoute", "{area:exists}/{controller=Admin}/{action=Index}/{id?}");  
    routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}");  
});

app.UseMvc(routes =>

{

routes.MapRoute("areaRoute", "{area:exists}/{controller=Admin}/{action=Index}/{id?}");

routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}");

});

Then, make a folder named Areas in the app root and make another directory named Admin inside the former. Inside the admin folder, create the following folders (ViewComponent is optional).

Now, we will create a Controller inside the Controllers folder named AdminController.

Now, in order for that to work, you’ll need to create Views for all actions that return one. The hierarchy for Views is just like what you have in a non-area Views folder.

Question – What if I want to have another Controller inside my Area?

Answer

Just add another Controller beside AdminController and make sure the routes are like the following,

[Area("Admin")]  
[Route("admin/[controller]")]  
public class ProductsController: Controller {  
    publicProductsController() {  
            //  
        }  
        [Route("{page:int?}")]  
    publicIActionResult Index() {  
        returnView();  
    }  
}

[Area("Admin")]

[Route("admin/[controller]")]

public class ProductsController: Controller {

publicProductsController() {

}

[Route("{page:int?}")]

publicIActionResult Index() {

returnView();

}

The important part is [Route(“admin/[controller]”)]. With that, you can keep the style of routing to admin /controller/ action/.

Cross-platform ASP.NET Core Debugging with Visual Studio Code

CheapASPNETHostingReview.com | Best and cheap ASP.NET Core 2.0 hosting. It’s been a year since ASP.NET Core and Visual Studio Code became available and early adopters have endured CLI changes and RC changes. If you’ve held off getting into ASP.NET Core for these reasons you are probably now curious about the cross-platform capabilities of Visual Studio Code. It appears as if things are (mostly) stable before RTM for .NET Core and ASP.NET Core later this month. So, how hard is ASP.NET Core debugging in Visual Studio Code on both Windows and OS X? As it turns out, it is not that difficult. There are a few minor details involved, but I’ve written this post to show you how easy it is to get started. There are plenty of screenshots to document the process. You’ll need Visual Studio 2015. You’ll also need Visual Studio Code installed on both a Windows machine and a Mac to get started. I’m assuming you have a minimum amount of experience with Visual Studio Code.

Code sharing steps

Since we will be sharing the same code between platforms, set up a common location using your favorite source code control. I like to use Git and Bitbucket for this purpose.

Creating the solution from a template

To get up and running fast, I chose the Visual Studio 2015 template “ASP.NET Core Web Application (.NET Core)” because of the ease of use in creating a project. Yes, this seems like cheating, but at the moment there isn’t a comparable feature for Visual Studio Code. Yes, there are Yeoman generators for ASP.NET Core but I felt the basic template in Visual Studio 2015 was more accessible to a .NET developer and didn’t require installing Yeoman.

Step 1: Open Visual Studio 2015, add a new project type “ASP.NET Core Web Application (.NET Core)” and give the project a name.

Step 2: Select “Web Application” and choose the type of Authentication.

Authentication Choices:

No Authentication – this is the option we will be choosing for this post since we are focused on setting up debugging.
Individual User Accounts – this adds the ASP.NET Identity Framework and EntityFramework.

Using this cross-platform will be the subject of another post.

Work and School Accounts – this uses Windows Active Directory. We won’t be using it for this post. There is advice to be found online for adding your Mac to AD if you want to pursue this option.
Windows Authentication – This will not work for our cross-platform debugging.

The resulting folder structure as seen in Visual Studio 2015. We can now open the project folder under “src” in Visual Studio Code.

Setting up ASP.NET Core debugging in Visual Studio Code on Windows

If you haven’t installed the C# Debugger extension for Visual Studio Code, do that now. The extension and installation instructions can be found here.
In Visual Studio Code, open the project folder under “src” that contains the code. For the demo this folder is “Tag.AspNetCore”.
When you first open the folder, or the first time you try to debug, you will be prompted to add required assets.

Select Yes and a “.vscode” folder will be added with a tasks.json file. This is the “Task Runner” file. We will edit that in a few steps.

Now, Select the Start Debug button and you will notice the message that we have “No Configuration” and there is a red notification symbol on the Settings button.

Select the Settings button and you will be prompted to “select environment” – choose “.NET Core”.

This will create a launch.json file for you that contains the confugrations for debugging.

Edit the json file. It contains three configurations: “.NET Core Launch (console)”, “.NET Core Launch (web)”, and “.NET Core Attach”. We won’t need the console configuration so you can remove it if you wish. We do need to update the web configuration’s “program” entry to point at the .dll that will be built.

Note: If you forget to edit this and try to debug, you will receive the following error:

Once you change the program path and save this file, these configurations will be presented in a dropdown to the right of the “Start Debugging (F5) button”. Select “.NET Core Launch (web):

If you set breakpoints and try to debug again, you will find that your breakpoints will not be hit and you get the message:

To fix this we will need to update the project.json file to tell the build process to produce a .NET Core compatible output.

Edit the json file to add “debugType”: “portable” to “buildOptions”.

*Note: this step is one that may change by RTM as project.json will be going away and it’s features added to a csproj file. This is somewhat controversial. You can read up about that here.

After following those steps, you should be able to repeat step #3 above to start the debugger and the project will launch and open a window in your default browser. Now, we are debugging ASP.NET Core code in Visual Studio Code!

Upload your code to your source code control (GitHub, Bitbucket, etc.) where we will be able to access it for the next section.

Setting up ASP.NET Core debugging in Visual Studio Code on OS X

If you haven’t installed the C# Debugger extension for Visual Studio Code, do that now. The extension and installation instructions can be found here.
Download the code you placed in source code control in the last section into a repository location. Then, open the project folder under “src” in Visual Studio Code.
Select Debug View:

Make sure the configuration “.NET Core Launch (web)” is selected. Start a debugging session by pressing the Start Debug button:

At this point, the web page should launch for you successfully, and you can debug the project just like you can on Windows.

ADDING PACKAGES AS YOU DEVELOP: A DIFFERENT APPROACH WITH VISUAL STUDIO CODE

Visual Studio developers have become accustomed to the NuGet Package Manager interface and the Package Manager Console. That isn’t available in Visual Studio Code. Here is what you would have to do:

To add a new package, you will have to add the package name and version number in the pjson file.

*Note: this step is one that may change by RTM as project.json will be going away and it’s features added to a csproj file. This is somewhat controversial. You can read up about that here.

Use the dotnet CLI command “dotnet restore”.

Final thoughts

Overall, cross-platform ASP.NET Core debugging using Visual Studio Code works well. The only disappointment seems to be the lack of support for NuGet packages within Visual Studio Code. I would like to see the dotnet CLI support package installation.

My only question for the development community is; now that you know cross-platform development and ASP.NET Core debugging can be done, do you want to do it for an ASP.NET Core website? Or, does it seem that all this was made possible just to prove it could be done? Let me know in the comments.

How To Displaying Google Maps in ASP.NET Application

CheapASPNETHostingReview.com | Best and cheap ASP.NET hosting. In this article I am going to explain toyou about Google Maps and how to integrate it to search any location in ASP.NET. Google Maps is a Web-based service that provides detailed information about geographical regions and sites around the world.

Nowadays Google Maps is used in every application for various requirements. Here in this article I am going to discuss how to integrate Google Maps to search any location in ASP.NET.

First of all, to integrate Google Maps create a new project in Visual studio. Add a new webform as follows.

Design the webform as in the following:

Add the following script in the head section

    &lt;head runat="server"&gt;  
        &lt;title&gt;&lt;/title&gt;  
      
         &lt;!DOCTYPE link href="https://maps/documentation/javascript/examples/default.css" rel="stylesheet" /&gt;  
    &lt;html&gt;  
        &lt;script src="https://maps.googleapis.com/maps/api/js?v=3.exp&amp;sensor=false" type="text/javascript"&gt;&lt;/script&gt;  
        &lt;script&gt;  
            var mapcode;  
            var diag;  
            function initialize() {  
                mapcode = new google.maps.Geocoder();  
                var lnt = new google.maps.LatLng(26.45, 82.85);  
                var diagChoice = {  
                    zoom: 9,  
                    center: lnt,  
                    diagId: google.maps.MapTypeId.ROADMAP  
                }  
                diag = new google.maps.Map(document.getElementById('map_populate'), diagChoice);  
            }  
            function getmap() {  
                var completeaddress = document.getElementById('txt_location').value;  
                mapcode.geocode({ 'address': completeaddress }, function (results, status) {  
                    if (status == google.maps.GeocoderStatus.OK) {  
                        diag.setCenter(results[0].geometry.location);  
                        var hint = new google.maps.Marker({  
                            diag: diag,  
                            position: results[0].geometry.location  
                        });  
                    } else {  
                        alert('Location Not Tracked. ' + status);  
                    }  
                });  
            }  
            google.maps.event.addDomListener(window, 'load', initialize);  
        &lt;/script&gt;  
      
        &lt;/html&gt;  
    &lt;/head&gt;

<!DOCTYPE link href="https://maps/documentation/javascript/examples/default.css" rel="stylesheet" />

<html>

var mapcode;

var diag;

function initialize() {

mapcode = new google.maps.Geocoder();

var lnt = new google.maps.LatLng(26.45, 82.85);

var diagChoice = {

zoom: 9,

center: lnt,

diagId: google.maps.MapTypeId.ROADMAP

}

diag = new google.maps.Map(document.getElementById('map_populate'), diagChoice);

}

function getmap() {

var completeaddress = document.getElementById('txt_location').value;

mapcode.geocode({ 'address': completeaddress }, function (results, status) {

if (status == google.maps.GeocoderStatus.OK) {

diag.setCenter(results[0].geometry.location);

var hint = new google.maps.Marker({

diag: diag,

position: results[0].geometry.location

});

} else {

alert('Location Not Tracked. ' + status);

}

});

}

google.maps.event.addDomListener(window, 'load', initialize);

</script>

</html>

</head>

Now add the following div to populate the google map. Here is my complete HTML code.

    &lt;body&gt;  
        &lt;form id="form1" runat="server"&gt;  
         
            &lt;div&gt;  
                &lt;h1&gt;Enter Your Location Details&lt;/h1&gt;  
            &lt;/div&gt;  
            &lt;div&gt;  
                &lt;asp:TextBox ID="txt_location" TextMode="MultiLine" Width="400px" Height="70px" runat="server"&gt;&lt;/asp:TextBox&gt;  
        &lt;/div&gt;  
            &lt;div&gt;  
                &lt;input type="button" value="Search" onclick="getmap()"&gt;  
            &lt;/div&gt;  
        &lt;div id="map_populate" style="width:100%; height:500px; border: 5px solid #5E5454;"&gt;  
        &lt;/div&gt;  
        &lt;/form&gt;

<body>

<div>

<h1>Enter Your Location Details</h1>

</div>

<div>

<asp:TextBox ID="txt_location" TextMode="MultiLine" Width="400px" Height="70px" runat="server"></asp:TextBox>

</div>

<div>

</div>

</div>

</form>

Here I am attaching the screen shot of my UI.

Now save and run the application.

Now type any location and press the search button, it will search the location and will be shown in the div.

In this way we can search any location detail in Google maps.