Alik Levin's : Implementation

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

ASP.NET Performance: Dynamically Loaded Assemblies Cause Application Recycles (Problem and Solution)

alikl — Wed, 08 Oct 2008 16:21:41 GMT

In my speak - dynamically loaded assemblies are those assemblies that were compiled during run time dynamically via CodeProvider like CSharpCodeProvider directly or by using types that use this class internally. Assemblies that are loaded dynamically using reflection via Load/LoadFrom method are out of the scope of this post.

Customer Case Study

The customer complained on periodic restarts/recycles of the ASP.NET application. We observed relative entries in the Event Log that showed up systematically on timely basis. We also observed memory utilization growth in Task Manager. After reaching 500 MB of memory utilization the application would recycle spawning another w3wp.exe to accept new incoming requests while draining the old w3wp.exe.

Analysis

After short discussion with the dev team about the design of the application we thought that the memory leak might be caused by improper usage of XmlSerializer that generate dynamic assemblies. Tess published fantastic walk through specifically dedicated to this case. Using either perfmon (.NET CLR Loading\Current Assemblies) or Process Explorer (see pic below)we observed unusual number (thousands) of loaded assemblies (notice Assemblies column). Also, notice the csc.exe in red - this is CSharp compiler that is invoked on each request:

We decided to take a memory dump to deeply investigate the case. Following are the steps that we took while analyzing the dump using WinDBG to identify the root cause:

Step 1 - Dumping memory heap to identify object allocated on heap

This is the fragment of the long list of objects. Our attention was caught by unusually large number of reflected assemblies.

!dumpheap –stat
9,019       216,456 System.Reflection.Assembly
112         4,032 System.Xml.Serialization.TempAssembly
104         5,408 System.Xml.Serialization.TypeDesc

After 3 minutes the number of dynamic assemblies is larger by more 350 assemblies (from subsequent dump):

!dumpheap –stat
9,379       225,096 System.Reflection.Assembly
114         4,104 System.Xml.Serialization.TempAssembly
102         5,304 System.Xml.Serialization.TypeDesc

Step 2 - Dumping appdomains to identify loaded assemblies

Another cross check to make sure we are dealing with tons of loaded assemblies.

!dumpdomain -stat
    Domain              Num Assemblies   Size Assemblies    Name
0x793f15d8                       1                       2,142,208        System Domain
0x793f2aa8                       56                    16,012,288      Shared Domain
0x000ab7d8                      2                       2,498,560        DefaultDomain
0x000d3368                  9,018                  55,447,040      /LM/W3SV......

Total 4 Domains, Total Size 76,100,096

Step 3 - Dumping all dynamic assemblies

How many of the assemblies are dynamic? (dda stands for dumpdynamicassemblies)

!dda

Domain: 0x793f15d8
-------------------
Domain: .
-------------------
Domain: DefaultDomain
-------------------
Domain: /LM/W3SVC/1/ROOT/......
-------------------
Assembly: 0x19058818 [RegexAssembly133_0] Dynamic Module: 0x16f4c220 loaded at: 0x0 Size: 0x0((null))
Assembly: 0x19058818 [RegexAssembly133_0] Dynamic Module: 0x190696a0 loaded at: 0x0 Size: 0x0((null))
Assembly: 0x19103ee8 [-0g5u8-v] Dynamic Module: 0x1920d6f8 loaded at: 0x19911000 Size: 0xc000((null))
Assembly: 0x190c9a40 [cvmmynwf] Dynamic Module: 0x190dc0d0 loaded at: 0x19a71000 Size: 0x4000((null))
Assembly: 0x1911bad8 [0ikhy_lx] Dynamic Module: 0x1911aa98 loaded at: 0x19f21000 Size: 0xc00((null))
.......
Assembly: 0x43199720 [nv1lvdiy] Dynamic Module: 0x431b3190 loaded at: 0x4cf61000 Size: 0xc00((null))
Assembly: 0x2d2bf008 [rk6dabem] Dynamic Module: 0x2d2bf258 loaded at: 0x4cf71000 Size: 0xc00((null))
--------------------------------------

Total 8,911 Dynamic Assemblies, Total size: 0x1d5b600(30,782,976) bytes.

Step 4 - Saving dynamic assembly to physical DLL

Save assemblies to the filesystem

!savemodule 0x2d2bc4c8 C: \0x1c344438.dll

To save all the assemblies to the file system use the following command:

!dda -save C:\MODULES

Step 5 - Using Reflector to reverse engineer the DLL:

Use Reflector to inspect the implementation/source code of the dynamic assemblies.

Step 6 - Using Reflector to find ExpressionEvaluator class

Try to locate the class in the static assemblies hopefully hitting the code that generates it:

Step 7 - Bingo! Each constructor for ExpressionEvaluator invokes compiler

ICodeCompiler compiler = new CSharpCodeProvider().CreateCompiler();
...
CompilerResults results = compiler.CompileAssemblyFromSource(options, builder.ToString());
...
this._Compiled = results.CompiledAssembly.CreateInstance("NavServices._ExpressionEvaluator");

This is actually the code that causes Process Explorer to show csc.exe under w3wp.exe (see red line in the first pic). And this is the code that caused number of loaded assemblies to grow. And this is the code that caused the application restarts.

Acknowledgements

During this investigation the following resources were used. Big THANK-YOU goes to:

Tess - .NET Memory Leak: XmlSerializing your way to a Memory Leak
Tom - Dynamic Assemblies and what to do about them
Johan - Getting started with windbg - part I
Cuko - OutOfMemory & CompiledAssembly

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

ASP.NET Data Binding Performance – Collection Is More Expensive Than Datatable

alikl — Fri, 01 Aug 2008 14:40:00 GMT

In my previous post - Best ASP.NET Performance Winner For Data Binding - Hands Up To Response.Write() – I’ve conducted several simple performance tests for data binding to GridView in ASP.NET page. What surprised me most is that eliminating massive loops and collection enumerations did not help in reducing CPU utilization. When we measured the execution times for both scenarios, DataBind() method revealed the secret.

Reporting Execution Times

We used System.Diagnostics.Trace to report execution times.

UseCustomCollection.aspx.cs

   1: System.Diagnostics.Trace.WriteLine("1. STARTING");

2:

   3: DataGrid datagrid = SampleServices.GenerateDynamicDataGridControl();

   4: this.Controls.Add(datagrid);

5:

   6: System.Diagnostics.Trace.WriteLine("2. GRID CREATED AND ADDED TO PAGE");

7:

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

9:

  10: System.Diagnostics.Trace.WriteLine("3. CUSTOM COLLECTION CREATED");

11:

  12: datagrid.DataSource = myCollection;

  13: datagrid.DataBind();

14:

  15: System.Diagnostics.Trace.WriteLine("5. DONE");

UseDataTable.aspx.cs

   1: System.Diagnostics.Trace.WriteLine("1. STARTING");

2:

   3: DataGrid datagrid = SampleServices.GenerateDynamicDataGridControl();

   4: this.Controls.Add(datagrid);

5:

   6: System.Diagnostics.Trace.WriteLine("2. GRID CREATED AND ADDED TO PAGE");

7:

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

9:

  10: System.Diagnostics.Trace.WriteLine("3. CUSTOM COLLECTION CREATED");

11:

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

13:

  14: System.Diagnostics.Trace.WriteLine("4. CUSTOM COLLECTION CONVERTED INTO DATATABLE");

15:

  16: datagrid.DataSource = datatable;

  17: datagrid.DataBind();

18:

  19: System.Diagnostics.Trace.WriteLine("5. DONE");

Note, that UseCustomCollection.aspx.cs misses step “4. CUSTOM COLLECTION CONVERTED INTO DATATABLE”.

Collecting Execution Times

We used DebugView to collect reported execution times.

Analysis

Applying simple mathematics we can see that converting Collection to Datatable takes 0.00081015 seconds. This is the gain we get when skipping this step in UseCustomCollection.aspx.cs.

Now lets examine DataBind() in both cases:

UseCustomCollection.aspx.cs 0.00268023 seconds
UseDataTable.aspx.cs 0.00215912 seconds

I know it is not a huge improvement for binding datatable vs. collection, but the tests we conducted always showed this gap. That is why eliminating the type transformation from collection to datatable that included enumeration and looping did not really help and we ended up with similar results of ~65% CPU utilization:

UseDataTable.aspx	UseCustomCollection.aspx

Conclusion

Binding custom collection is expensive performance wise since internally it uses reflection and reflection is expensive thing to do. Looping is expensive performance wise too but it is cheaper than reflection.

Related Materials

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

Use FREE Tools From IIS Resource Kit To Warm Up Your ASP.NET 1.1 Application By Batch Compilation

alikl — Sun, 20 Jul 2008 18:24:42 GMT

Have you noticed that when ASP.NET web application is accessed for the first time the response is slow? The reason for such behavior is batch compilation that occurs on the first hit.

ASP.NET batch compilation is the process of compiling ASP.NET markup (content of aspx files) into temporary dll’s. Compilation requires invoking compiler (csc.exe for C#) – that is pretty heavy activity. Process Explorer shows it clearly:

ASP.NET batch compilation occurs on per folder basis. Said that, if your application divided into multiple sub-folders that contain ASP.NET pages each time any of the folders accessed for the first time the batch compilation is invoked.

Note that starting with ASP.NET 2.0 compilation model has changed. Also, there is a tool Aspnet_compiler.exe that allows pre-compile your ASP.NET web application to improve performance.

Customer’s case study

Customer’s web application is built with ASP.NET 1.1. It is divided into multiple subfolders reflecting logical modules that are hosted across about 20 application pools. The application connects to Oracle database.

QA team complains that the application responds slowly each time any of the modules (subfolders) accessed for the first time.

Using Process Explorer and profiler we identified three main latency points:

Creating the application pool – w3wp.exe.
Batch compiling the application for each subfolder.
Creating Oracle connection pool when Oracle is accessed for the first time.

The solution

We decided to create a Warmer – solution that will hit each subfolder’s page in unattended manner thus warming up the application before the first user hits it.

For the solution we used free tools from IIS resource kit:

LogPrser.exe to identify the URL’s of the pages to hit.
TinyGet.exe to actually hit the pages identified by LogParser.

To identify what pages to hit we took IIS log files from QA environment and than we ran the following query using LogParser:

LogParser.exe "SELECT DISTINCT STRCAT('XXX', cs-uri-stem) AS cs-uri-stem-strcat INTO 'C:\result.txt' FROM 'C:\yourIISlogFile.log' WHERE INDEX_OF(cs-uri-stem, 'aspx') > 0" -o:w3c

Notice XXX – it has nothing to do with XXX rated content rather it is a placeholder to replace it with tinyget command.

Open resulting yourIISlogFile.log file in Notepad, hit Ctrl+H for “Replace” and replace all occurrences of XXX with the following command:

tinyget -srv:www.YourServer.com -uri:

yourIISlogFile.log before the Replace:

yourIISlogFile.log after the Replace:

Remove the header and save the file with BAT extension - your Warmer is ready for action. Run it each time you deploy new version.

Do not forget to remove old temporary files in ASP.NET temporary folder:

C:\Windows\Microsoft.NET\Framework\<<NET FX VERSION>>\Temporary ASP.NET Files\

CAUTION. This action may potentially corrupt your application if you do not provide proper exception handling. On one hand it is good check to make. on other hand – be aware of it and do not do it on production sites unless you are completely sure it will not corrupt the application.

Related materials

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

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

Chain Of Responsibility Design Pattern – Focus On Security, Performance, And Operations

alikl — Mon, 14 Jan 2008 18:50:19 GMT

The pattern is also called Intercepting Filter, Pipeline, AOP, and may be few more… I am confused by the name for this design pattern.

“Life is really simple, but we insist on making it complicated.” - Confucius

No matter how they call it I like the idea of decoupling actions while processing one after another. Here is the definition from data & object factory:

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

Intercepting Filter visual from MSDN’s Discover the Design Patterns You're Already Using in the .NET Framework

.Net framework implements Chain Of Responsibility design pattern for many its internal mechanisms. My favorite is HttpModule. I like it so much I decided to build my own pipeline.

This post summarizes my steps I took to create my own simple implementation for this design pattern. I did not do any research purposely online and wanted to get my hands dirty without bias.

The goal

My goal was creating simple code that can be adopted and extended:

The code should be very simple
The code should provide pipeline infrastructure to invoke aspects/filters
The code should allow dynamic invocation of any arbitrary number of aspects
The code should include no optimization to stay simple
The code should demonstrate practical idea and not be state of the art, production ready to go one.

What I needed

Provide generic mechanism that will execute arbitrary logic – the Pipeline.
The logic is encapsulated in decoupled components – Aspects.
Aspects can be independently configured without rebuilding the application.

The design

Summary of steps

Step #1 – Create base classes and interfaces.
Step #2 – Create concrete implementation of specific Pipeline.
Step #3 – Modify config file.
Step #4 – Test the solution.

Following section describes each step in details

Step #1 – Create base classes and interfaces. I needed two bases classes - BasePipeline and IAspect. BasePipeline is responsible to perform generic actions of:

Consulting configuration file.
Loading the configured aspects.
And invoking them one by one.

private void LoadPipelineAspects()
{
    aspects = new List<IAspect>();

    Configuration config =

                  ConfigurationManager.OpenExeConfiguration(

                  ConfigurationUserLevel.None);

    string  piplineConfig =

            config.AppSettings.Settings[pipelineName].Value;

    string[] aspectNames = piplineConfig.Split(',');

    for (int i = 0; i < aspectNames.Length; i++)
    {

        Type t = Type.GetType(aspectNames[i]);

        IAspect aspect=(IAspect)Activator.CreateInstance(t);

        aspects.Add(aspect);

    }
}

IAspect interface serves as a contract between BasePipline and aspect's concrete implementation. Take a look at the design diagram. When the client invokes HandleRequest method on concrete Pipeline implementation it invokes underneath generic implementation of the method of its base - BasePipeline:

public virtual bool HandleRequest(object request) 
{

    foreach (IAspect item in aspects)
    {
        item.ProcessRequest(request);
    }
    return true;
}

Step #2 – Create concrete implementations. Concrete implementations of both types SimplePipeline and SimpleAspect are nothing fancy. SimplePipeline calls into its base but reserves the right to add any additions without interfering with any other concrete implementations:
```
public override bool HandleRequest(object request)
{
    base.HandleRequest(request);

    return true;
} 
```
To indicate what aspect is running I simply spit out aspect's name for aspect's ProcessRequest. That is the place where the whole logic should be performed - DB access, Web Services calls, request modifications etc :
```
public bool ProcessRequest(object request)
{
    Console.WriteLine("processing from SimpleAspect1");
    return true;
}
```

Step #3 – Modify config file. Config file - app.config or web.config in my case - holds the information about what aspects should be called for specific pipeline:
```
<appSettings>
 <add key =
"MyPipeline.SimplePipeline" 
 value ="MyPipeline.SimpleAspect1,MyPipeline.SimpleAspect2"/>
</appSettings>
```
The key is the type of the pipeline and the value is comma separated types of the aspects. When the concrete pipeline is instantiated by the client it already knows it type which serves to consult the config file and identify what aspects to load using reflection. This is how BasePipeline constructor looks like:
```
public BasePipeline()
{
    pipelineName = this.ToString();
    
    LoadPipelineAspects();

}
```
See Step #1 for LoadPipelineAspects() function implementation where reflection magic happens to dynamically load the aspects.

Step #4 – Test the solution. To test the solution follow these steps:
- Create Class library project and reference to the library where Pipeline base classes reside. Implement your own Pipeline while inheriting from BasePipeline.
- Implement few aspects that implement IAspect interface.
- Create simple Windows Console application, add reference to the libraries and add simple code similar to this to Main function:
```
MyPipeline.SimplePipeline sp = 
                        new MyPipeline.SimplePipeline();

sp.HandleRequest(null);
```
- In the config file add modifications as described in Step #3.
- Run the application.

Done.

Any time one needs to change the logic, add/remove aspects - it is just a matter of tweaking config file - that is it.

I've just copied and pasted existing aspects inside the configuration file and run the application again, here is what I get:

I think it is cool.

Focus on Security

From security perspective there are few things to keep in mind. When invoking assemblies with reflection there is immediate risk of luring attacks that result in spoofed assemblies. For more information how to get protected see my related post below - .Net Assembly Spoof Attack.

Focus on Performance

Reflection is considered as slow operation. Everything is relative. In case where reflection is used in performance critical application you should consider performance optimization for reflection. One such optimization is constructor caching as described in More Provider Goodieness

Focus on Operations

From operations perspective it seems ideal case. I witnessed few times the situation where the change was not an option since it required whole rebuild of the application - something that operations team was not happy with and put veto on it.

The trick is constantly asking yourself "What I am optimizing? Security, Performance, or Operations?"

My related posts

Download the sample from my SkyDrive:

Have fun.

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.

Basic Sample - How To Keep ASP.NET ViewState On The Server

alikl — Wed, 02 Jan 2008 13:38:40 GMT

During recent few engagements with my customers I've noticed VIewState is extensively [unintentionally] used. ViewState is on by default. The result is heavy weight Html that round trips on the network. This causes slow response time and high network utilization that affects another applications using the same network.

How to remove ViewState from the network completely while taking an advantage if its functionality at same time?

This post walks through basic steps of creating ASP.NET Base Page that implements functionality allowing saving ViewState on the server. The approach reduces dramatically network utilization.

Summary of steps

Step 1 - Create Visual Studio Solution.
Step 2 - Implement Base Page
Step 3 - Inherit Each ASPX page from Custom Base Page
Step 4 - Test The Solution

The following section describes each step in details.

Step 1 - Create Visual Studio Solution. Open Visual Studio 2008 and create empty solution, found under "Visual Studio Solutions". Name it BasePageSample. In Solution explorer right click the solution and add new project. Choose "ASP.NET Web Application" under Web node in "Add new Project" dialog. Name it SampleWebToUseExternalBasePage. Right click the solution in Solution Explorer and add new project. Choose "Class Library" under Windows node. Name it MyBasePage. In MyBasePage project add reference to System.Web assembly. Right click MyBasePage project and add new class, name it LeaveViewStateOnTheServer.cs.

Step 2 - Implement Base Page. While in LeaveViewStateOnTheServer class add using declarations and inherit from Page type:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Web.UI;
using System.Web;

namespace MyBasePage
{
    class LeaveViewStateOnTheServer : Page
    {
    }
}

Override two relevant methods that handle Loading and Saving of ViewState:

protected override object LoadPageStateFromPersistenceMedium()
{
    object viewStateBag;
    string m_viewState = (string)Session["ViewState"];
    LosFormatter m_formatter = new LosFormatter();
    try
    {
        viewStateBag = m_formatter.Deserialize(m_viewState);
    }
    catch
    {
        throw new HttpException("The View State is invalid.");
    }
    return viewStateBag;
}
protected override void SavePageStateToPersistenceMedium(object viewState)
{
    MemoryStream ms = new MemoryStream();
    LosFormatter m_formatter = new LosFormatter();
    m_formatter.Serialize(ms, viewState);
    ms.Position = 0;
    StreamReader sr = new StreamReader(ms);
    string viewStateString = sr.ReadToEnd();
    Session["ViewState"] = viewStateString;
    ms.Close();
    return;
}

This is a basic code that can be adopted and adapted to specific needs. The code mostly based on Dino Esposito's code.

Step 3 - Inherit Each ASPX page from Custom Base Page. Right click SampleWebToUseExternalBasePage project and reference to MyBasePage project. Right click SampleWebToUseExternalBasePage project and add new ASPX page, name it default.aspx. Open default.aspx.cs code behind and inherit the page from custom Base Page:

using MyBasePage;

namespace SampleWebToUseExternalBasePage
{
    public partial class _Default : LeaveViewStateOnTheServer

Step 4 - Test The Solution. Add any control to the page from the toolbox. GridView uses ViewState the most. Here is how rendered Html For GridView looks with default ViewState behavior:

And here is how it looks without:

My Related Posts

Related Resources

Download Sample Visual Studio 2008 solution from my SkyDrive: