Alik Levin's : Development Phase

DebugView - Free Simple Tool To Quickly Identify Performance Problems

alikl — Tue, 11 Nov 2008 18:12:53 GMT

DebugView is well known free tool from Systinternals (Microsoft). Vast majority of developers is aware of its existence. Nevertheless, I've decided to write this post following my practice of journaling my technical accomplishments during engagements with the customers. Yesterday the tool helped us identify serious performance problem without installing profiler or even taking memory dumps.

Customer Case Study

The customer complained about "bad performance" of web pages. The application was pretty simple one - ASP.NET pages accessing SQL Server for simple queries. The SQL Server was installed on the same machine where ASP.NET app resided. The pages took up to ten seconds to render.

Analysis

After quick code review we found out that the code called function that traversed all server controls using recursion. This function was called several times during the page lifecycle. I presented the team with my assumption that this code is a potential culprit of the "bad performance". The opposite assumption I faced was "but there is only so few controls on the page, it cannot consume too much time."

We decided to add single line of code to the function in question:

System.Diagnostics.Trace.WriteLine ("Calling Recursive Function");

Then we fired up DebugView and ran the page.

The team was amazed by what DebugView presented interactively. "Calling Recursive Function" line kept piling up on and on. Each call took from 50 to 100 milliseconds but when multiplied to overall number of calls (~700) it gave us clear understanding what caused the performance hit.

Conclusion

Instrument your application properly - simple yet powerful technique that helps you avoid calling expensive consultants onsite.

Instrument your application and surprise your end users by high performing application.

Related Materials

This post is made with PracticeThis.com plugin for Windows Live Writer

ASP.NET Performance: Fast AJAX, Faster AJAX

alikl — Wed, 29 Oct 2008 00:43:52 GMT

AJAX improves significantly both user experience and performance. It can be further improved by using down level capabilities that .Net framework offers. Specifically, consuming Web Services and WCF directly from client script. The best part is that ASP.NET AJAX comes with built in libraries - server and client - that make coding fun while significantly improving the web application's performance.

Customer Case Study

The customer was using hand crafted XmlHttp requests from client scripts requesting the data from ASPX pages. While the goal was achieved - the amount of information sent to the server was minimal and the user interface was responsive - the coding was not really fun. Also, since the requests were sent to regular ASPX pages the whole ASPX pipeline was executing unnecessarily utilizing CPU for nothing. The customer did not want to use Update Panel control. Although it boosts coding productivity, it also adds some burden on the network. Network utilization should have been kept to the minimum.

Analysis

After quick research I found two great resources that directed me to the solution that would satisfy both requirements:

Coding productivity.
Minimum of data in transit on the wire.

The first one is from Chris Hay - remix08 UK ASP.NET Front End Performance Slides and the other one is from Jeff Prosise - Power ASP.NET AJAX Programming. They both outline the usage of Script-Callable Web Services. There are three simple steps to follow:

Declare your Web Service as Script-Callable by adding class level attribute:

[System.Web.Script.Services.ScriptService]
public class AJAXCallableWebService : System.Web.Services.WebService
{
    [WebMethod]
    public string HelloWorld(string name)
    {
        return "Hello, " + name;
    }
}

Declare service reference inside the ScriptManager:

<asp:ScriptManager ID="ScriptManager1" runat="server">
    <Services>
        <asp:ServiceReference InlineScript="true" Path="~/AJAXCallableWebService.asmx" />
    </Services>
</asp:ScriptManager>

Call a Web Service from the client script:

<script type="text/javascript" language="javascript">
function callAjax()
{
    var text = document.getElementById("Text1").value
    
    AJAXCallsWebService.AJAXCallableWebService.HelloWorld(text,onSuccess);
}
function onSuccess(result)
{
    document.getElementById("result").innerText = result;
}
</script>

    <span id="result"></span>
    <input id="Button1" type="button" value="button" onclick="callAjax()" />
    <input id="Text1" type="text" />

Sample Visual Studio Solution

Grab the sample solution implemented using Visual Studio 2008 form my SkyDrive here:

Related Materials

This template is made with PracticeThis.com plugin for Windows Live Writer

Improve ASP.NET 2.0 Performance With PageAsyncTask - Multithreading For The Masses

alikl — Thu, 02 Oct 2008 11:31:38 GMT

Multithreading is tough. This is what John Robbins says about it in his excellent book Debugging Microsoft .NET 2.0 Applications:

"Don't do it... Make sure there's no other way you can structure your program before you decide to incorporate multithreading into your application... you are easily adding a minimum of an extra month of development and testing to your schedule". I agree with it completely. But there are times multithreading is unavoidable. Especially when more and more Services popping up in the wild...

From Asynchronous Pages in ASP.NET 2.0

Customer Case Study

I am working with the customer to improve their ASP.NET 2.0 application performance. The application issues multiple requests to the backend middleware that is exposed as a web service. The application cannot get a hold on the actual proxies rather it is provided with the components that wrap the web services proxies. The application needs to issue concurrent requests. Serial request would result in serious latency which is unacceptable by end users.

Analysis

Since we cannot get hold on web services proxies we cannot utilize available asynchronous methods available with it: BeginMyMethod/EndMyMethod and MyMethodAsync/MyMethodCompleted. But we definitely can utilize another option available with ASP.NET 2.0 - registering asynchronous tasks using PageAsyncTask class.

The following information is based on the following materials:

PageAsyncTask Implementation Steps

This is the summary of the steps to implement and register PageAsyncTask:

Create a class that contains lengthy operation
Declare AsyncTaskDelegate
Add OnBegin, OnEnd, OnTimeout methods to the class
Mark the calling page as Async="true"
Register the PageAsyncTasks in the ASPX page and execute it

You can grab the Visual Studio 2008 project with the implementation from my SkyDrive here:

Related Materials

This template is made with PracticeThis.com plugin for Windows Live Writer

Best ASP.NET Performance Winner For Data Binding - Hands Up To Response.Write()

alikl — Thu, 31 Jul 2008 15:29:58 GMT

To achieve best performance you need to make decisions based on trade-off between coolness, coding productivity, and personal engineering values. I never thought I would be recommending my customer considering using old fashion Response.Write() in his Internet facing ASP.NET web application in order to significantly improve the application’s performance.

Customer Case Study

During load/stress testing customer’s ASP.NET web application we identified high CPU utilization (up to 90%). After quick investigation we noticed that %Time in GC performance counter is less than optimal. Our assumption was that the application uses memory allocation techniques that are less than optimal. From GC Performance Counters:

"First thing you may want to look at is “% Time in GC”... What is a health value for this counter? It’s hard to say. It depends on what your app does. But if you are seeing a really high value (like 50% or more) then it’s a reasonable time to look at what’s going on inside of the managed heap."

Another resource we used is timeless patterns & practices’ Chapter 15 — Measuring .NET Application Performance:

.NET CLR Memory\% Time in GC

"…The most common cause of a high value is making too many allocations, which may be the case if you are allocating on a per-request basis for ASP.NET applications. You need to study the allocation profile for your application if this counter shows a higher value."

So we headed to looking into the code and this is what we found out.

Analysis

During performance code inspection we identified massive usage of collections. The collections were used to transfer the data between the logical layers and then the collections were transferred into datatables to be bindable for DataGrid (yes, it is .Net 1.1 app).

Eureka! We just spotted 3 performance anti-patterns. Massive memory allocation, massive loops, massive type conversions. I’ve shown it to 4 very respected professionals and everyone was saying the same – current situation is pure performance anti-pattern. Here are few suggestions that came up:

Bind collections directly to DataGrid eliminating additional memory allocations and loops.
Create Datatable directly from XML skipping collection creation step eliminating additional memory allocations and loops.
Use Xslt transformation transforming original Xml into Html table using Xslt elminating memory allocations and loops for both collections and datatables.
Use Response.Write() as it’s suggested by patterns & practices:

"Use the Response.Write method. It is one of the fastest ways to return output back to the browser."

Case close? Not really...

Secretly I’ve built Visual Studio 2003 project with these implementations and ran simple stress test using TinyGet utility. The results left us all a bit surprised.

Converting Collection To Datatable (Current Situation)

The code:

   1: //create custom collection

   2: MyCollection myCollection = (MyCollection)SampleServices.GenerateCollection(200);

3:

   4: //convert collection to datatable

   5: DataTable datatable = SampleServices.ConvertCollectionTableIntoDataTalbe(myCollection);

6:

   7: //bind datatalbe to dynamically created datagrid

   8: datagrid.DataSource = datatable;

   9: datagrid.DataBind();

The stress test:

tinyget.exe -srv:192.168.50.68 -uri:/dynamiccontrolsloadingrelease/UseDataTable.aspx -loop:100 -threads:15

The result:

Bind Collection Directly To Grid

The code:

   1: MyCollection myCollection = (MyCollection)SampleServices.GenerateCollection(200);

2:

   3: //bind datatalbe to dynamically created datagrid

   4: datagrid.DataSource = myCollection;

   5: datagrid.DataBind();

The stress test:

tinyget.exe -srv:192.168.50.68 -uri:/dynamiccontrolsloadingrelease/UseCustomCollection.aspx -loop:100 -threads:15

The result:

Create Datatable From Xml

The code:

   1: string xml = SampleServices.GenerateXml(200);

2:

   3: StringReader theReader = new StringReader(xml);

   4: DataSet theDataSet = new DataSet();

   5: theDataSet.ReadXml(theReader);

6:

   7: datagrid.DataSource = theDataSet.Tables[0].DefaultView;;

   8: datagrid.DataBind();

The stress test:

tinyget.exe -srv:192.168.50.68 -uri:/dynamiccontrolsloadingrelease/LoadXmlIntoDataTable.aspx -loop:100 -threads:15

The result:

Use Xslt Transformation To Create Html Table

The code:

   1: Xml1.DocumentContent = SampleServices.GenerateXml(200);

   2: Xml1.TransformSource=@"xsl.xml";

The stress test:

tinyget.exe -srv:192.168.50.68 -uri:/dynamiccontrolsloadingrelease/XmlXslTransformation.aspx -loop:100 -threads:15

The result:

Use Response.Write()

The code:

   1: MyCollection myCollection = (MyCollection)SampleServices.GenerateCollection(200);

2:

   3: // Put user code to initialize the page here

   4: Response.Write("<table>");

5:

   6: foreach(MyModelItem item in  myCollection)

   7: {

8:

   9:     Response.Write("<tr>");

  10:     Response.Write("<td>" +  item.Address  + "<td>");

  11:     Response.Write("<td>" +  item.City  + "<td>");

  12:     Response.Write("<td>" +  item.Education+ "<td>");

  13:     Response.Write("<td>" +  item.Family  + "<td>");

  14:     Response.Write("<td>" +  item.Name  + "<td>");

  15:     Response.Write("</tr>");

  16: }

  17: Response.Write("</table>");

The stress test:

tinyget.exe -srv:192.168.50.68 -uri:/dynamiccontrolsloadingrelease/ResponseWrite.aspx -loop:100 -threads:15

The result:

Sample Visual Studio 2003 Project

Interested in testing it yourself? Grab the source code from my SkyDrive here:

Conclusion

After conducting this simple test these are the conclusions I’ve made:

“Don't be afraid to challenge the pros, even in their own backyard." - How to Get Things Done - Colin Powell Version
Testing IS DA thing. Assumptions are good but nothing speaks louder than facts.
Test early - avoid massive rework afterwards. Create POC's (Proof of concept) early in architecture/design stages.
Best performance comes on expense of productivity and coolness.

Related Materials

Improve ASP.NET Performance With Multithreading Using Thread Or ThreadPool Objects

alikl — Mon, 23 Jun 2008 13:27:12 GMT

Your ASP.NET application performs slower than expected? How many times do you access your database for each request? Did you use SQL Profiler to find out? Did you know that chatty database access is one of the most common performance sins (this is my own observation)?

Want to improve? - Reduce the number of database queries.

Not an option? - You may want using multithreading. Proceed with caution.

Real world scenario

You need to run 3 independent heavy database queries – Q1, Q2, Q3. You need to use the result from the three – Result = Q1+Q2+Q3. You never know the order in which each query completes. It can be: Q1Q2Q3, Q1Q3Q2, Q2Q3Q1, Q2Q1Q3, Q3Q2Q1, Q3Q1Q2. Missed any combination? Run one after another would create significant latency. Running each on its own thread would create latency of Max(Q1,Q2,Q3) which is less that sum of the three.

How to run each query on its own thread and wait for the completion for each one?

Using Thread object

The following code spawns three threads and waits for all to join, and then use the results from each.

   1: Thread t1 = new Thread(DoWork1);

   2: t1.Start();

3:

   4: Thread t2 = new Thread(DoWork2);

   5: t2.Start();

6:

   7: Thread t3 = new Thread(DoWork3);

   8: t3.Start();

9:

  10: t1.Join(1000);

  11: t2.Join(1000);

  12: t3.Join(1000);

13:

14:

  15: Label1.Text = (i1 + i2 + i3).ToString();

See any issues using it in ASP.NET? One caveat though, creating threads manually like this may cause performance hit as it involves context switching – CPU consuming operation. Consider using ThreadPool object.

Using ThreadPool object (preferred, but are you using COM?)

ThreadPool is preferred as it already has live threads allocated for you. No need to ask for a favor from CPU in the moment of truth. Here is the code:

   1: public partial class _Default : System.Web.UI.Page

   2: {

   3:     int i1 = 0;

   4:     int i2 = 0;

   5:     int i3 = 0;

6:

   7:     WaitHandle[] waitHandles = new WaitHandle[]

   8:         {

   9:             new ManualResetEvent(false),

  10:             new ManualResetEvent(false),

  11:             new ManualResetEvent(false)

  12:         };

13:

14:

  15:     protected void Page_Load(object sender, EventArgs e)

  16:     {

17:

  18:     }

19:

  20:     protected void Button1_Click(object sender, EventArgs e)

  21:     {

  22:         Stopwatch sw = new Stopwatch();

23:

  24:         sw.Start();

25:

  26:         WaitCallback method1 = new WaitCallback(DoWork1);

  27:         bool isQueued1 = ThreadPool.QueueUserWorkItem(method1, waitHandles[0]);

28:

  29:         WaitCallback method2 = new WaitCallback(DoWork2);

  30:         bool isQueued2 = ThreadPool.QueueUserWorkItem(method2, waitHandles[1]);

31:

  32:         WaitCallback method3 = new WaitCallback(DoWork3);

  33:         bool isQueued3 = ThreadPool.QueueUserWorkItem(method3, waitHandles[2]);

34:

  35:         if (WaitHandle.WaitAll(waitHandles, 5000, false))

  36:             Label1.Text = (i1 + i2 + i3).ToString();

  37:         else

  38:             Label1.Text = "Problem";

39:

  40:     }

41:

  42:      void DoWork1(object state)

  43:     {

  44:         int.TryParse(TextBox1.Text, out i1);

45:

  46:         //HEAVY QUERY GOES HERE. Sleep is for the demo only! Remove it!

  47:         Thread.Sleep(i1);

  48:         ManualResetEvent mre = (ManualResetEvent)state;

  49:         mre.Set();

50:

  51:     }

52:

  53:      void DoWork2(object state)

  54:     {

  55:         int.TryParse(TextBox2.Text, out  i2);

56:

  57:         //HEAVY QUERY GOES HERE. Sleep is for the demo only! Remove it!

  58:         Thread.Sleep(i2);

  59:         ManualResetEvent mre = (ManualResetEvent)state;

  60:         mre.Set();

  61:     }

62:

  63:      void DoWork3(object state)

  64:     {

  65:         int.TryParse(TextBox3.Text, out  i3);

66:

  67:         //HEAVY QUERY GOES HERE. Sleep is for the demo only! Remove it!

  68:         Thread.Sleep(i3);

  69:         ManualResetEvent mre = (ManualResetEvent)state;

  70:         mre.Set();

  71:     }

72:

  73: }

Caveat

If your function calls on COM object – avoid using ThreadPool, its Apartment model is not compatible with COM and it cannot be changed. More info - Pitfalls With .Net Multithreading And COM Objects – Threads Must Have Compatible Apartment Models (MTA vs. STA).

Another point to call out is that performance improvements based on multithreading is subject to amount of available CPU’s. Test your solution first!

This post was written with help from Lior, MCS Israel Architect.

Download sample project with the code from my SkyDrive:

Enjoy.

Pitfalls With .Net Multithreading And COM Objects – Threads Must Have Compatible Apartment Models (MTA vs. STA)

alikl — Fri, 20 Jun 2008 10:09:11 GMT

Be alert when implementing multithreading .Net in conjunction with COM objects. Thread apartment models matter.

.Net threads have Multi Threaded Apartment (MTA) model by default. COM objects have Single Thread Apartment (STA). Calling on COM objects on .Net threads that you spawn may cause unpredicted result.

Multithreading in .Net is easily implemented based on either Thread or ThreadPool objects. Thread.Start() method spawns new thread which has Multi Threaded Apartment (MTA) model . ThreadPool.QueueUserWorkItem(myMethod) queues myMethod to be executed on available thread managed by it.

Thread object and COM

When spawning your own threads with Thread.Start() set Thread’s apartment model to STA if you plan calling COM object on it:

        1: Thread t = new Thread(DoWork);

       2: t.SetApartmentState(ApartmentState.STA);

       3: t.Start();

Note, spawning your own threads with Thread.Start() utilizes resources – mainly CPU, spawning too much threads may cause performance hit. Consider using ThreadPool object.

ThreadPool object and COM

All threads managed by ThreadPool objects are MTA threads. Apartment model of ThreadPool’s threads cannot be changed. Do not call COM objects on ThreadPool’s threads.

Possible designs and solutions

ASP.NET. Calling COM objects in ASP.NET pages configure AspCompat=true:

“Most COM components will work with ASP.NET…”

“…The AspCompat attribute forces the page to execute in STA mode. The runtime throws an exception if the compatibility tag is omitted and an STA component is referenced on the page.”

Client side (like WinForms)multithreading. Use ThreadPool with its MTA threads. Spawn another thread with Thread.Start() setting its apartment model to STA.
Custom server side multithreading. I’d consider using Remoting infrastructure. In case your server application should serve messages that are not covered by Remoting’s built in mechanisms I’d consider building my own Channel sink.
And the last but not the least. Do not forget to call Marshal.ReleaseComObject(obj) to dispose the COM objects created on your the threads.

Related materials

WCF Security - Input/Data Validation Using Schemas

alikl — Sun, 25 May 2008 17:52:48 GMT

WCF offers very flexible approach of Input and Data Validation based on XML Schemas. The approach is flexible since the validation rules are expressed in form of XML schema and can be changed at any time without recompiling the solution.

I followed the steps detailed in How To: Perform Message Validation with Schema Validation in WCF and ended up with another working sample (imagine that!).

It took me a bit to struggle with the schema thing and then enabling debugging info on the service side (remember, WCF is secure by default) to understand what's going on and why it fails time after time.

In the end me and WCF made friends and I'd thought it'd be good to share with you the Visual Studio project. Download it here from my SkyDrive and save yourself some time.

My related posts

WCF Security - Input/Data Validation Sample Visual Studio Project

Enjoy.

WCF Security - Input/Data Validation Sample Visual Studio Project

alikl — Sun, 25 May 2008 14:17:44 GMT

Input and Data Validation is one of the core security principles. WCF is no exception. To get most out of WCF in secure way one must implement proper Input and Data Validation.

I was following instructions on How To – Perform Input Validation in WCF compiled by patterns&practice team lead by JD Meier.

In a nutshell the process consists of creating 3 classes and tweaking a config file a "bit".

From the guide:

Step 4 – Create a Class That Implements the Validation Logic
Step 5 – Create a Class That Implements a Custom Endpoint Behavior
Step 6 – Create a Class That Implements a Custom Configuration Element
Step 7 – Add the Custom Behavior to the Configuration File
Step 8 – Create an Endpoint Behavior and Map It to Use the Custom Behavior
Step 9 – Configure the Service Endpoint to Use the Endpoint Behavior

I ended up with working sample built with Visual Studio 2008. I though it'd be good idea to share it to help you boost your productivity.

Grab the Visual Studio project on my SkyDrive here.

Enjoy

ASP.NET Performance Sin - Serving Images Dynamically (Or Another Reason To Love Fiddler)

alikl — Fri, 02 May 2008 16:12:19 GMT

Serving images dynamically may cause performance hit. Dynamically served images require more HTTP requests which violates Steve Souders' performance rule #1 - Make Fewer HTTP Requests. The latency is also caused by parallelism (or parallel downloading) limitations as described in detail here Performance Research, Part 4: Maximizing Parallel Downloads in the Carpool Lane

Static Images

Below are the series of images that served dynamically and static.

Static images displayed using GridView's ImageFiled column type. ImageField generates the following HTML mark-up:

<img src="IMAGES/Birds/icon-penguin.gif" style="border-width:0px;" />

Browser interprets it as a static image and is ready to cache it for further reuse.

Serving Images Dynamically

Below is the sample code that implements dynamic image serving. I witness in the field different variation but the pattern (I'd call it anti-pattern) remains the same. ASP.NET and HTML mark-up that is usually part of repeater control looks similar to the following:

<img src="ServeImage.ashx?FN = 
<%#DataBinder.GetPropertyValue(Container.DataItem, "Image")%>" />

ASHX file's code that actually serves the image looks similar to this:

public void ProcessRequest(HttpContext context)
{
    string imageFileName = 
           context.Request.MapPath(@"IMAGES\" + context.Request.QueryString["FN"]);

    context.Response.ContentType = "image/jpeg";
    context.Response.WriteFile(imageFileName);
    context.Response.Flush();
    context.Response.Close();

}

Network Analysis

Using one of my most favorite tools - Fiddler - it is easy to reveal browser's view on the traffic:

There is expiration attribute attached to static images while dynamically served images do not have such attribute.

Subsequent call the the same page that gets the same images reveals the following:

All dynamically served images are not cached and utilize the network on each request.

Further investigation shows, using Fiddler's P and C fantastic feature, that overall network utilization caused by these dynamically served images is about 350 KB, which could be saved by caching the images.

Recommendations

Avoid serving images dynamically. Follow best practices outlined at Exceptional Performance:

My relative posts

Free Performance Tool - Analyze IIS Logs Like A Pro With Funnel Web Analyzer

alikl — Mon, 21 Apr 2008 13:16:00 GMT

These free performance tools will save you time and money identifying performance bottlenecks. Your customers will thank you for building fast and responsive applications.

Funnel Web Analyzer 5.0 for Windows

Download the tool here.

Analyzer gives insight into everything from server load and customer usage to intranet analysis. It allows you to gain vital feedback on visitor behaviour and preferences, so you can more accurately customize your site to meet the needs of your clients

How- to use

After you download and install the tool - run it. Just drag and drop log files onto it and then click on View icon:

You will be presented with nice array of summary and detailed reports:

Usage Scenarios

There are few scenarios I can see this tool would be very useful:

Developer analyzes the module she developed during development phase just before submitting for holistic performance testing.
IT support personnel probes production applications to get a quick view on potential performance hotspots.
Performance team analyzes the data after running load/stress tests.

My related posts

patterns & practices WCF Security Guidance Project - live on Codeplex

alikl — Wed, 02 Apr 2008 10:53:10 GMT

patterns & practices has recently released WCF Security Guidance Project. JD, the program manager behind the effort, has been blogging about it too.It is evolving project but the initial content is fantastic already. It has Application Scenarios, Video Index, but my favorites are How-To's:

Pure love.

How To Consume WCF Using AJAX Without ASP.NET

alikl — Mon, 18 Feb 2008 23:35:21 GMT

How to consume WCF services directly from Html client? How to add AJAX-like functionally to application that does not natively support ASP.NET AJAX like classic ASP, ASP.NET 1.1, or PHP?

WCF that ships with .Net 3.5 provides capability to consume it from any JavaScript enabled client via XML or JSON encoding. There is new built in webHttpBinding that supports either JSON or XML encoded messages to be sent to WCF services.The functionality can dramatically improve performance and user experience.

This post summarizes the steps to create and consume basic WCF service using webHttpBinding binding.

Summary of Steps

Step 1 – Create WCF service.
Step 2 – Configure WCF end point.
Step 3 – Create JavaScript to invoke WCF service.
Step 4 – Test the solution.

Next section describes each and every step in details

Step 1 – Create WCF service

Open Visual Studio and create new WCF service project by choosing "WCF Service Application" template under "Web" project type. Name it Wcf2Ajax. Open IService1.cs file and create OperationContract as follows:

        1: [ServiceContract]

       2:  public interface IService1

       3:  {

       4:  

       5:      [OperationContract]

       6:      string Sum2Integers(int n1, int n2);

Open Service1.svc.cs file and add public method that accepts to integers and returns the sum of it. This is the functionality that will be exposed by the WCF service and consumed by JavaScript enabled client:

       1: public class Service1 : IService1

       2: {

       3:     public string Sum2Integers(int n1, int n2)

       4:     {

       5:         int result = num1 + num2;

       6:  

       7:         return result.ToString();

       8:     }

Step 2 – Configure WCF end point

Open web.config file and add <binding> section to <system.serviceModel section. Add <webHttpBinding> to binding section:

<system.serviceModel>
  <bindings>
    <webHttpBinding>
      <binding name="AjaxBinding"/>
    </webHttpBinding>
  </bindings

Add AjaxBehavior to <behaviors> section to support WCF invocation via AJAX:

<behaviors>
  <endpointBehaviors>
    <behavior name="AjaxBehavior">
      <enableWebScript/>
    </behavior>

Configure WCF service's endpoint to use newly created binding:

<endpoint address="ajaxEndpoint" 
          behaviorConfiguration="AjaxBehavior" 
          binding="webHttpBinding" 
          bindingConfiguration="AjaxBinding" 
          contract="Wcf2Ajax.IService1">

Step 3 – Create JavaScript to invoke WCF service

Add Html file to the solution by right clicking on the solution node in solution explorer and choosing "New Item..." and then "HTML Page" template. Name it WCFConsumer.htm. Add few HTML controls - two text boxes to accept two integers, one pure HTML button to trigger WCF call, and <span> element to present the result:

<input type="text" id="num1" />
<input type="text" id="num2" />
<br>
<input type="button" onclick="CallWcfAjax()" value="Call WCF via AJAX" />
Result <span id="result"></span>

Add <script> block to <header> section and add JavaSctip that builds HTTP request and wires invocation function to some event, say button click:

    <script type="text/javascript">
    function CallWcfAjax()
    {
        var xmlHttp = new ActiveXObject("Microsoft.XmlHttp");

        var url = "Service1.svc/ajaxEndpoint/";
        url = url + "Sum2Integers";

        var body = '{"n1":';
        body = body + document.getElementById("num1").value + ',"n2":';
        body = body + document.getElementById("num2").value + '}';
          
        // Send the HTTP request
        xmlHttp.open("POST", url, true);
        xmlHttp.setRequestHeader("Content-type", "application/json");
        xmlHttp.send(body);

        // Create result handler 
        xmlHttp.onreadystatechange= function X()
        {
        
             if(xmlHttp.readyState == 4)
             {
                  result.innerText = xmlHttp.responseText;
             }
        }
    }
    </script>

Step 4 – Test the solution

Build the solution and navigate to WCFConsumer.htm. Provide two integers to both text boxes and hit "Call WCF via Ajax" button. You should expect for result similar as depicted below:

Parse the result to your needs.

My related post

Related resources

Creating WCF AJAX Services without ASP.NET

Download Visual Studio 2008 project with the sample from my SkyDrive

Performance Sin - Using Exceptions To Control Flow

alikl — Sat, 02 Feb 2008 16:19:50 GMT

Want to spot coding anti-patterns from performance perspective without actually looking in the code?

One of the common performance coding anti-patterns I’ve noticed lately is using Exception Handling to control program flow.

The anti-patterns

Most common anti-pattern is just using exception handling to control flow, in some cases it was even nested exception handling – that means the exception is thrown anyway.

In other cases there were empty “catch” exception statements. That means that precious cycles .Net consumes to handle the exception spent for nothing.

The last case was where exception handling was done to catch simple types parsing. That was done on each request.

How to identify Exception Handling anti-pattern

To identify exception handling anti-pattern set “.NET CLR Exceptions/# of Excepts Thrown” perf counter. If you see the graph constantly climbs on each request chance are Exception Handling is used to control the flow which is performance anti-pattern:

Look at the relevant source code to spot try/catch blocks. If the source code is not available use Reflector to reverse engineer the compiled assemblies into C# sources – I used it very successfully during my latest performance review.

Best practices

Do not use exception handling to control the flow. Try to reduce catching exceptions to only most upper component/class. Catching exceptions is expensive from both CPU and memory perspective.

Use TryParse method instead Parse method to avoid throwing exceptions .

Use simple "if" statement to check for nulls.

Tools

Use perfmon to spot the anti-pattern with Exception handling. Run perfmon in command line and add “.NET CLR Exceptions/# of Excepts Thrown” counter. Then run few scenarios to see the graph.

Use Practice Checker for static code analysis. The tool scans the code and reveals excessive usage of exception handling.

My related posts

Performance Code Review Tool – Practices Checker

Performance Code Review Tool – Practices Checker

alikl — Tue, 22 Jan 2008 00:37:50 GMT

Care about performance? Do you write your code with performance in mind? Want little help to spot performance bottlenecks automatically?

Practices Checker to the rescue.

The goal of the tool is

“Help you perform a manual code inspection by analyzing your application for potential coding and configuration settings that do not adhere to the patterns & practices ASP.NET Performance Checklist.”

The tool is available as free download here. Download, install, point to your web application solution folder and hit “Analyze” button. You will get the report for potential performance issues and recommendations on how to fix. I am sure you will be surprised by few findings.

Performance rules:

Case Study

I used Practices Checker with one of my recent engagements . The tool spotted in no time web pages where there were 30 loops, enormous amount of serialization issues, and few more.

My related posts

How To Keep ASP.NET ViewState On The Server – Revised

alikl — Tue, 08 Jan 2008 23:13:52 GMT

This is a follow up post to Basic Sample - How To Keep ASP.NET ViewState On The Server

ASP.NET 2.0 offers much easier built-in mechanism to save ViewState on the server in Session using SessionPageStatePersister. Thanks to Russ who pointed me to this feature available in ASP.NET 2.0 via comments in the previous post.

The details can be found here ASP.NET 2.0 Page State Persister [thanks go to Eddie from our own ACE team for the pointer].

Short analysis. Using SessionPageStatePersister to store VIewState is very convenient as there is no code needed, almost. The down side is that this approach allows storing ViewState only in Session while the approach described in previous post allows routing ViewState to any storage of your choice – Session, Cache, DB, Web Services – up to your imagination. This can be important when considering scalability aspects of the solution that kazlak pointed out in the comments for the previous post.

To commentators. Big-thank-you for leaving your insightful comments. Sharing your insights helps me to improve and I am sure it also enriches this blog readers experience – THANKS! Please comment more and leave your web sites/blogs so I can link back to you and give you full credit to your insights.