Gil Fink's Blog : Performance

Quick Tip – JavaScript Statement Count Do Count

Gil Fink — Sat, 20 Apr 2013 13:09:30 GMT

Quick Tip – JavaScript Statement Count Do Count

One of the things that we as developers don’t seem to mind about is the amount of statements that we write in our code. In JavaScript, the number of statements might affect the speed of the operations we want to perform. It is our responsibility to find statements that should be combined in order to decrease the execution time. This post include some examples of places to decrease the amount of statements.

Variable Declarations

One of the places that developers don’t care about is declaring variables. Lets look at a code with variable declarations:

     var i = 0;

    var j = 0;

    var length = arr.length;

This code block shows the declaration of 3 variables in 3 different statements. This is a little expensive since we can declare all the variables in only one var statement:

    var i = 0,

        j = 0,

        length = arr.length;

This is micro optimization but in large scale JavaScript applications such optimizations can be much more crucial.

Arrays and Object Literals

Another place that you might be tempted to use a lot of statements is initialization of arrays or objects. Here is an example of wasting a lot of statements:

    var arr = new Array();

    arr[0] = 0;

    arr[1] = 1;

    var obj = new Object();

    obj.name = "name";

    obj.value = "value";

Those examples can be shortened in number of statements by using initialization using brackets or literal objects:

    var arr = [0, 1];

    var obj = {

       name: "name",

       value: "value"

    };

Again this is micro optimization but any optimization count and limiting the number of statements means better performance.

Iterative Values

In loops we are using iterative values and increment/decrement them. Lets look at an example:

    var i = 0;

    while (i < 10) {

       doSomething(i);

       i++;

    }

The statements in the loop can be shortened using only one statement which will do the same thing because of the nature of increment operator:

    var i = 0;

    while (i < 10) {

       doSomething(i++);

    }

Returning Evaluated Boolean Value

From time to time I see developers use the following if statement example to make it more comprehensive:

    function checkSomething(value) {

        if (makeCheck(value)) {

           return true;

        }

        else {

           return false;

        }

    }

In the code we check if a value is evaluated to true and then returning true. This is wasteful. The previous code can be shortened to:

    function checkSomething(value) {

        return makeCheck(value);

    }

Pay attention that this is only an example of a pattern that I see people using which can be shortened.

Summary

The number of statements in your JavaScript code do count in your application performance. I know that all of the examples I showed are micro optimizations but in large scale JavaScript applications every micro optimization can help you create a faster application.

The async and defer Script Attributes in HTML5

Gil Fink — Thu, 29 Dec 2011 20:01:28 GMT

The async and defer Script Attributes in HTML5

One of the rules of thumb that you always hear regarding script elements is to put them very close to the </body> closing tag of the Web page. The main reason for that is that script elements are fetched and executed immediately when the browser encounter them. This default behavior includes blocking the browser’s rendering, loading a JavaScript file into memory, and executing its code immediately. In many circumstances, and in particular when large JavaScript files are involved, this might create a performance bottleneck.

One of the solutions for this problem is to use script tag injections or other Ajax techniques to prevent the browser from blocking. That might help to increase performance but it requires more coding and testing and in some occasions might create bugs because it is very hard to synchronize the file loading and executioning.

HTML5 introduces the async script attribute which helps to load scripts asynchronous. In the specifications you can also find another attribute, the defer attribute, that is very similar to the async attribute but it has another purpose. Both of the attributes will be presented in this post.

The async Attribute

The async attribute was introduced in HTML5. Its purpose is to signal the browser that a script should be executed asynchronously, and as soon as it is available. This means that when a browser encounter a script tag with the async attribute, it will download the script asynchronous and not block the rendering process. At the first opportunity after the script finished downloading and before the window’s load event the browser will execute the script. Here is how you will use the async attribute:

     <script src="jsFile.js" async></script> 
  

The async attribute can be used only on script element that point to external JavaScript file. That means that the src attribute must exists when you use the attribute. Also, you can’t know the execution order of scripts that use the async attribute.

In most of the major browsers, such as Chrome, Firefox, and Opera, the attribute is available for use. IE9 and previous versions of IE don’t support the attribute yet.

The defer Attribute

The defer attribute is not new in HTML5. It can be found in most of the browser (even in very early versions of IE). Its purpose is to signal the browser that a script should be executed in parallel and without stopping the page’s rendering. Deferred scripts guaranteed to run in sequence in the order that they are written in the code. They are executed before the DOMContentLoaded event. Here is an example of using the defer attribute:

    <script src="jsFile.js" defer></script>
  

As in the async attribute, defer attribute can be used only on script element that point to external JavaScript file.

Pay attention not to use the defer attribute on external script files that use the document.write or generate document content.

What happens if you add both of the attributes to a script element?
Here is the answer in the specifications:
“The defer attribute may be specified even if the async attribute is specified, to cause legacy Web browsers that only support defer (and not async) to fall back to the defer behavior instead of the synchronous blocking behavior that is the default.”

Summary

The post introduced the async and defer script attributes. Both of them can be used to improve the performance of Web pages because they help to load scripts asynchronous without blocking the page rendering. In most of the times you will use the attributes instead of writing your script elements in the bottom of the Web page.

Profiling JavaScript 101 Using IE9 Developer Tools

Gil Fink — Mon, 15 Aug 2011 15:37:00 GMT

Profiling JavaScript 101 Using IE9 Developer Tools

Lately I’m involved in a very interesting project which suffer from JavaScript performance issues in old browsers. The main “pain” in the project is the need to support IE8 which is used by many of the client’s users. I’ve got a call to come and help in the process of tuning the application and decided to share some tips of how I profiled the application and found some of the bottlenecks in the application JavaScript execution. Those bottlenecks were handled by the development team very fast and the application’s execution is becoming much better. Since the main problems were mainly in IE8 then I used IE Developer Tools in the process and not FireBug.

Starting a Profiling Session

The first thing that you’ll want to do when you profile JavaScript is to setup your environment. First open the relevant web page in IE and press F12 in order to open the IE Developer Tools. In the developer tools, change the Browser Mode and Document Mode to IE8 and IE8 standards respectfully like in this figure:

Now open the Profiler tab and press the Start profiling button to enable profiling:

Then, press F5 to refresh the page and after the page finish to run press the Stop profiling and get the profiling report.

Reading the Profiling Report

When you have the report here are things that you need to pay attention while figuring out the information you got:

Count – when the count of function calls is very big (for example the amount of RegExp.exec in the figure) that might indicate that you have a problem. Combining the count with the Exclusive time might help to find bugs in the JavaScript use.

At the client there were a lot of calls to jQuery’s CLASS method. After figuring this out and seeing that the Exclusive execution time was very high I debugged the CLASS method and got the stack call to figure that there was a bug in an application function. Fixing the function helped to improve performance.

There are times that you will find that there are functions that got call in very similar numbers. This might indicate that they were called inside the same function. This is very inaccurate measurement but it might help sometimes.
Inclusive time – this is the execution time of a method and all of its children. Here you’ll find the methods that executed for very long time. This measurement can help to figure out bottlenecks.

At the client we found out that Telerik’s RadGrid control and its inner LoadSod function are one of the bottlenecks in the application. I’m not saying here that the control has bad performance (on the contrary the control is fast) but only that in the application the control is one of the bottlenecks. I found a way to improve a little the control’s performance but the improvement was very negligible (50 milliseconds) so we dropped it.
Exclusive time – this is the amount of time that is spent in the function itself. Here you can track very long running functions and then debug them to understand why the run for so long.

At the client we found a bug in one of the functions that was called with setTimeout very often and damaged the performance of the application.

Another way to use the report is the Call tree report that pack all the execution of functions in a tree view:

Here you can drill down the execution stack and figure out using the previous measurements how the application operate.

Tip: pressing double click on a function line in the report can take you to the JavaScript source file (if exists). Then you can set a break point and debug the function call.

Summary

Profiling JavaScript isn’t as simple as it sound. Using profiling tools like in IE Devloper Tools (which I used because IE8 was giving hard times to the client) or FireBug can help to simplify this matter a lot. Knowing how to read the reports will probably help to fine tuned the code you wrote.

Using Javascript to Measure Web Page Performance with IE9

Gil Fink — Tue, 05 Oct 2010 19:55:00 GMT

Using Javascript to Measure Web Page Performance with IE9

One ability that currently available in IE9 is the new msPerformance javascript object that enables developers to measure real-world performance of websites. In this post I’ll explain what is msPerformance and how you can use it to measure web page performance.

The msPerformance Object

Wanting a web application that performs great is a very regular and crucial demand in these days. With IE9 beta developers have a new set of javascript profiling API integrated at the DOM’s core – msPerformance object. The msPerformance captures key timing information about the load of the root document and also network activity that occurs on the page. This data is available from the DOM after the page was loaded. Using these metrics the developer is able to measure where the browser is spending it’s time during the run of the web application. This of course enables performance tuning when the developer finds bottlenecks or other problems.

How to Use msPerformance?

The msPerformance which is located under the window DOM object exposes three properties:

navigation – a reference to MSPerformanceNavigation object, which holds navigation data.
timing – a reference to MSPerformanceTiming object, which holds timing data.
timingMeasures – a reference to MSPerformanceTimingMeasures object, which holds timing measures.

Those objects hold a lot of properties and information about the performance of the web page that is currently running. The following code example shows how to fill a table with some web page performance measurements:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="msPerformance.aspx.cs"    Inherits="WebApplication5.msPerformance" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head runat="server">    <title>msPerformance Example</title>    <script type="text/javascript">   1:     2:         function InsertPerformanceData() {   3:             if (window.msPerformance != null) {   4:                 var w = window;   5:                 var navStart = w.msPerformance.timing.navigationStart + "ms";   6:                 var navStartTime = Date(w.msPerformance.timing.navigationStart);   7:     8:                 var loadEnd = w.msPerformance.timing.loadEventEnd + "ms";   9:                 var loadEndTime = Date(w.msPerformance.timing.loadEventEnd);  10:    11:                 var navigation = w.msPerformance.timingMeasures.navigation + "ms";  12:    13:                 var runtime = (w.msPerformance.timing.loadEventEnd - w.msPerformance.timing.navigationStart) + "ms";  14:    15:                 document.getElementById("ticksNavigationStart").innerText = navStart;  16:                 document.getElementById("timeNavigationStart").innerText = navStartTime;  17:    18:                 document.getElementById("ticksLoadEnd").innerText = loadEnd;  19:                 document.getElementById("timeLoadEnd").innerText = loadEndTime;  20:    21:                 document.getElementById("timeNavigation").innerText = navigation;  22:    23:                 document.getElementById("timeRuntime").innerText = runtime;  24:             }  25:         }          26:     </script></head><body>    <form id="form1" runat="server">    <div>        <table>            <tr>                <th>                    Event                </th>                <th>                    API                </th>                <th>                    TICKS                </th>                <th>                    TIME                </th>            </tr>            <tr>                <td>                    Navigation Start                </td>                <td>                    window.msPerformance.timing.navigationStart                </td>                <td id="ticksNavigationStart">                </td>                <td id="timeNavigationStart">                </td>            </tr>            <tr>                <td>                    Load End                </td>                <td>                    window.msPerformance.timing.loadEnd                </td>                <td id="ticksLoadEnd">                </td>                <td id="timeLoadEnd">                </td>            </tr>            <tr>                <td>                    Run Time                </td>                <td>                    window.msPerformance.timingMeasures.navigation                </td>                <td>                </td>                <td id="timeNavigation">                </td>            </tr>            <tr>                <td>                    Run Time                </td>                <td>                    timing.loadEnd - timing.navigationStart                </td>                <td>                </td>                <td id="timeRuntime">                </td>            </tr>        </table>        <input type="button" onclick="InsertPerformanceData();" value="Show Performance Data" />    </div>    </form></body></html>

In this simple page when the button is clicked I first check that the windows.msPerformance exists. Then I pull out some performance data and show it to the user. After pushing the button an example of the table that can be generated could be:

Pay attention that the performance data is available only after the page was loaded!

Summary

IE9 includes a lot of features that can help developers in their daily activities. One of the these features is the new msPerformance javascript object which can help developers with their web pages performance tuning. Currently, this feature isn’t interoperable with other browsers so don’t try to use it outside IE9.

EFProf – Profiler Tool for Entity Framework

Gil Fink — Thu, 12 Aug 2010 13:53:20 GMT

EFProf – Profiler Tool for Entity Framework

One of the important tools in your tool arsenal when you develop with an ORM tool
is a profiler. Like SQL profiler to a SQL Server DBA an Entity Framework profiler is a must have tool to Entity Framework developer.
The main reasons to acquire such a tool are to understand what is going on underneath the hood in the query engine and for performance tuning. If you think that you can use Entity Framework without knowing what it is committing to database then you should think again. Things like select N+1 or avoiding too many joins will get back at you during runtime and kick you in the face.

EFProf is an Entity Framework profiler from Hibernating Rhinos.
It includes a very intuitive views/reports and supply a lot of valuable information about what is going on when you use Entity Framework. It also provides a lot of performance alerts which can lead you to find bottle necks or problems in writing the data access queries. Behind the tool you can find Oren Eini (Ayende) which is very known for his support for NHibernate and he brings tones of knowledge in the ORMs world to the tool.

How to Get Started with EFProf

When you want to use EFProf you first need to do the following things:

Add reference to the HibernatingRhinos.Profiler.Appender dll in your application.
The dll can be found in the tool folder.

In the application start you will call the following line of code:

         HibernatingRhinos.Profiler.Appender.EntityFramework.EntityFrameworkProfiler.Initialize();
      

Now start the profiler application and then run your application and get the profiler input.

Easy as that.

Using the Tool

When you start the profiler you will get the following screen:

After I configured my test application and ran it I got the following screen with all the information I needed:

You can see the queries that I run at the bottom, application statistic at the left menu and more important stuff which gives you very crucial details about your running application. You can also get analysis of your code in the left menu such as:

One feature that I really liked and made me feel like a DBA was the ability to see the query plan of the query in a visual way:

And of course the ability to run your queries from the profiler:

The tool also supports alerts about common mistakes that you can do when you program against an ORM.

Summary

Profiling your application is a very important aspect for gaining better performance and learning what you are doing in code when you use a tool that you didn’t write. Blind development without understanding what is going inside a development tool is something that will get back at you after deployment. EFProf supply the insight on what is going on and is a very helpful tool to have.
As a last word, since EFProf is a commercial tool this is my opinion that is expressed in this post and I wasn’t contact by Hibernating Rhinos.

ASP.NET Output Cache Provider

Gil Fink — Sun, 18 Jul 2010 18:17:23 GMT

ASP.NET Output Cache Provider

One of the new
features that were
shipped with
ASP.NET 4
was new providers
for caching purpose.
In this post I’ll explain
one of them – the OutputCacheProvider.

OutputCacheProvider

Up until ASP.NET 4 the output cache mechanism was implemented as
in-memory caching and we couldn’t do nothing to change its behavior.
If we desired to use a distributed cache like AppFabric caching or our own
implementation we couldn’t achieve it. From ASP.NET 4 the caching is now
following the ASP.NET provider model which means that we can create
our own provider in order to use caching. If we wish to use our own output
cache all we need to do is to inherit the OutputCacheProvider class which
exists in the System.Web.Caching namespace. After we implement the relevant
interface that include the Add, Get, Remove and Set methods we can
plug our provider inside the web.config file in order to use it.

OutputCacheProvider Example

As I wrote all we need to do is to inherit the OutputCacheProvider class.
The following code sample is a naive in-memory implementation for
OutputCacheProvider:

     public class InMemoryOutputCacheProvider : OutputCacheProvider

    {

      #region Members

      private Dictionary<string, InMemoryOutputCacheItem> _cache = new Dictionary<string, InMemoryOutputCacheItem>();

      private readonly static object _syncLock = new object();

      #endregion

      #region Methods

      public override object Add(string key, object entry, DateTime utcExpiry)

      {

        Set(key, entry, utcExpiry);

        return entry;

      }

      public override object Get(string key)

      {

        InMemoryOutputCacheItem item = null;

        if (_cache.TryGetValue(key, out item))

        {

          if (item.UtcExpiry < DateTime.UtcNow)

          {

            Remove(key);

            return null;

          }

          return item.Value;

        }

        return null;

      }

      public override void Remove(string key)

      {

        InMemoryOutputCacheItem item = null;

        if (_cache.TryGetValue(key, out item))

        {

          _cache.Remove(key);

        }

      }

      public override void Set(string key, object entry, DateTime utcExpiry)

      {

        var item = new InMemoryOutputCacheItem(entry, utcExpiry);

        lock (_syncLock)

        {

          if (_cache.ContainsKey(key))

          {

            _cache[key] = item;

          }

          else

          {

            _cache.Add(key, item);

          }

        }

      }

      #endregion

    }

In the code I implement the cache as a in-memory dictionary.
The implementation is very simple and it is based on a item
class which looks like:

    public class InMemoryOutputCacheItem

    {

      #region Members

      public DateTime UtcExpiry { get; set; }

      public object Value { get; set; }

      #endregion

      #region Ctor

      public InMemoryOutputCacheItem(object value, DateTime utcExpiry)

      {

        Value = value;

        UtcExpiry = utcExpiry;

      }

      #endregion

    }

Configuring the OutputCacheProvider

In order to use the previous output cache implementation we need
to plug it into the web.config file of the application. Under
system.web element we need to add the caching element. Inside the
caching element we add an outputCache element and add the provider
that we have created. The following example show you how to do that:

    <?xml version="1.0"?>

    <configuration>

        <appSettings/>

        <connectionStrings/>

        <system.web>

            <compilation debug="true" targetFramework="4.0">

            </compilation>

        <caching>

          <outputCache defaultProvider="InMemory">

            <providers>

              <add name="InMemory" type="InMemoryOutputCacheProvider"/>

            </providers>

          </outputCache>

        </caching>

            <authentication mode="Windows"/>

            <pages controlRenderingCompatibilityVersion="3.5" clientIDMode="AutoID"/></system.web>

    </configuration>

Checking the Implementation

Now we are ready to go and test the implementation.
The following web page contains a label control which shows the
current date and time (which is inserted in the code behind).
As you can see I added the OutputCache page directive to the page
in order to test the provider:

    <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="HttpModuleTestWeb.WebForm1" %>

    <%@ OutputCache Duration="15" VaryByParam="*" %>

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <html xmlns="http://www.w3.org/1999/xhtml">

    <head runat="server">

        <title></title>

    </head>

    <body>

        <form id="form1" runat="server">

        <div>

            <asp:Label ID="lblTime" runat="server" />

        </div>

        </form>

    </body>

    </html>

The page code behind:

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

    {

      protected void Page_Load(object sender, EventArgs e)

      {

        lblTime.Text = DateTime.Now.ToString();

      }

    }

Summery

In ASP.NET 4 the caching is now provider based. That means that
we can plug our implementation to the cache including the
output cache. In the post I showed a simple example of how to
replace the output cache with a naive in-memory implementation.

Cache Retrieval Pattern

Gil Fink — Sun, 13 Jun 2010 12:32:00 GMT

Cache Retrieval Pattern

In my previous post I wrote about cache layer and its position
in every application. In this post I’m going to explain what is
the cache retrieval pattern and show an example of how to
implement it.

Cache Retrieval Pattern

When we implement a cache layer we need a strategy in order to
retrieve cached items. The cache retrieval pattern is very
simple and can be imposed into any application very fast.
So how does it work?
The business logic component will use the cache API in order to
check whether some data exists in the cache. If the data doesn’t exists
in the cache, the business logic component responsibility will be to
insert the data into the cache. Since cache is volatile you can’t depend
on it to hold the data you need. This is why you always need to check
whether the data exists in the first place. The business logic component
will use a data access component to retrieve the relevant data from a
data storage. After it has the data in hand it will place the data in
the cache and return it to its consumer. The following diagram
shows how this pattern work:

Cache Retrieval Pattern Example

After we understood the what lets take a look at the how.
The following BL class implement the data retrieval pattern:

public class BLComponent{  #region Properties   private ICacheManager CacheManager { get; private set; }       #endregion   #region Ctor   public BLComponent(ICacheManager cacheManager)  {    CacheManager = cacheManager;  }   #endregion   #region Methods   public Department GetDepartmentById(int departmentId)  {    if (!CacheManager.Contains(departmentId.ToString()))    {      DALComponent dataAccessor = new DALComponent();      Department department = dataAccessor.GetDepartmentById(departmentId);      CacheManager.Insert(departmentId.ToString(), department);      return department;    }    return CacheManager.Get<Department>(departmentId.ToString());  }   #endregion}

As you can see I use the ICacheManager interface in order to
create an abstraction against the cache layer. This will enable
me to create a class which uses the cache API of my chosen
cache implementation (in memory, distributed and etc).
The ICacheManager can look like:

public interface ICacheManager{  /// <summary>       /// Add a new object into the cache       /// </summary>       /// <param name="key">The key of the object to add</param>       /// <param name="value">The value of the object to add</param>       void Add(string key, object value);   /// <summary>       /// Check whether the key is contained by the cache       /// </summary>       /// <param name="key">The key to check</param>       /// <returns>Returns true if the key is contained by the cache</returns>       bool Contains(string key);   /// <summary>       /// Returns the number of items in the cache       /// </summary>       /// <returns></returns>       int Count();   /// <summary>       /// Insert a new object into the cache        /// </summary>       /// <param name="key">The key of the object to insert</param>       /// <param name="value">The value of the object to insert</param>       void Insert(string key, object value);   /// <summary>       /// Get the object that its key is given      /// </summary>       /// <typeparam name="T">The object</typeparam>       /// <param name="key">The given key to check</param>       /// <returns>returns the object or null if it doesn't exists</returns>       T Get<T>(string key);   /// <summary>       /// Removes the object that is referenced by the given key       /// </summary>       /// <param name="key">The given key</param>       void Remove(string key);   /// <summary>       /// Get/Set the the given key and object       /// </summary>       /// <param name="key">The given key to the indexer</param>       /// <returns>Returns the object that the given key reference</returns>       object this[string key]  {    get;    set;  }}

The data access component isn’t relevant to our discussion because
underneath it can be implemented by IRepository, some service or
whatever method you pick to retrieve your relevant data. Also,
pay attention that this example isn’t thread safe.

Summary

The cache retrieval pattern is simple to understand and implement
in any application. As I wrote in my previous post using caching in
applications is a must and the pattern for retrieving data will help
you to insure you have the relevant data close to your application.

Cache Layer

Gil Fink — Fri, 11 Jun 2010 15:51:00 GMT

Cache Layer

Lately I found myself in some architecture consulting sessions at
some customers. In every one of those customers I found myself
explaining how to implement a cache layer in order to decrease
the amount of round trips to the database and for better scalability.
In this post I’ll try to explain in high level how to build a cache layer.

Deciding to Build a Cache Layer

Every application that performance is important to its developers
and managers must contain some sort of caching. The cache is a very
fast in memory resources container which holds relevant data close to the
application itself. I explained in the past the candidate resource types
for caching in this post. So you have decide to implement caching
in your application, what next?
The answer is simple – create a cache layer.

Cache Layer Position in Application Architecture

The next thing to understand is the location of the cache layer in your
application. The next diagram shows were you should place the cache layer:

As you can see the cache layer's best place is between the business
logic layer and the data access layer. The business logic responsibility
will be to check whether an entity or some data exists in the cache
and then if not to make a round trip to the database (using the data
access layer of course) and bring the data to application. When the data
exists we first put it in the cache and then we have the data in hand
and also it exists our the cache. This is called the cache retrieval pattern.
There are many ways to create a cache layer for example by using
distributed cache like AppFabric caching services, Enterprise Library
Caching Application Block, ASP.NET caching and many more cache services.
It’s your responsibility to evaluate which cache technology to use in your
application by answering to your application requirements.

Summary

Caching in applications is a very vital way to improve the application
performance and make the application more scalable. It’s our
responsibility to create a cache layer which will exists between
your business logic and data access layer. By using the cache retrieval
pattern you will be able to use your cache in a very efficient way.

Using Stub Entities in Entity Framework Screencasts

Gil Fink — Fri, 14 May 2010 21:04:00 GMT

Using Stub Entities in Entity Framework Screencasts

Today I recorded my first
two screencasts (one in
English and one in Hebrew)
about how to use
stub entities in Entity
Framework in order to
produce better performance
by reducing database round trips.
The link to the English version can be found here.
The link to the Hebrew version can be found here.
You can also download the screencasts in the details tab if you
like.
Enjoy!

CompiledQuery in Entity Framework

Gil Fink — Mon, 01 Mar 2010 13:50:00 GMT

CompiledQuery in Entity Framework

There are times
when we want
to make optimizations
on some piece of
code. If we want to
reduce the cost of
executing a query in Entity Framework we can use a CompiledQuery
to the rescue. Yesterday I used added a compiled query to a code
base which was executing multiple times. This reduced the execution
time of the repeating queries. In the post I’ll explain what are
CompiledQueries and how to use them.

CompiledQuery

CompiledQueries are a delegate which store a compiled LINQ query that we
have built in advance. When we use them we can reduce the cost of
executing a LINQ query. This can be very helpful when we have a query that
we execute multiple times. Pay attention that the compilation of a query
also cost so don’t use CompliedQueries for every query you build only for
the queries that you want to run a lot.

Creating a CompliedQuery

When we want to use a CompiledQuery we will first create a static member
which will hold the delegate that will be created from the CompiledQuery.
The reason for the static member is because CompliedQuery is always
used with a context and we don’t want to lose it when we dispose the
context. The following code is showing how to declare a CompiledQuery:

private static Func<SchoolEntities, decimal, IQueryable<Department>> _compiledQuery =    CompiledQuery.Compile((SchoolEntities ctx, decimal budget) =>        (from d in ctx.Departments         where d.Budget > budget         select d));

We declare a Func delegate which will hold the compiled query as a static
member and we use the CompiledQuery object to with the Compile
method to compile the LINQ query.
When we want to use the compiled query we do it by invoking it:

using (var context = new SchoolEntities()){    var query = _compiledQuery.Invoke(context, 150000);    foreach (var item in query)    {        Console.WriteLine(item.Name);    }}

CompiledQuery Restrictions

Currently there are few restrictions that you must know when you
are using a CompiledQueries:

No compilation is being done up until the first execution of the
query. This means that in the first execution of a CompiledQuery
we will get a downgrade of performance (because of the
compilation). The other executions will much faster.
There is a side affect of this restriction. When combined with Merge
options the first Merge option that you pass with the first context
will be saved and will be used in the other executions.
For example running the following code for the first compiled query
execution will cause the next running to use the
MergeOption.NoTracking:

context.Departments.MergeOption = MergeOption.NoTracking;var query = _compiledQuery.Invoke(context, 150000);

Changes to the query such as compositions or calling for methods like
First(), FirstOrDefault() and more will produce a not complied query.
You must use the query as is.
If you want to avoid this problem call the AsEnumerable() method
and transform the query to LINQ to Objects query.

Summary

Lets sum up, CompiledQuery is a very powerful tool for performance
when you use Entity Framework. You should follow the restrictions
I wrote when you use them in your code.

Replacing ASP.NET Session with Velocity Session Provider

Gil Fink — Tue, 06 Oct 2009 14:13:00 GMT

Replacing ASP.NET Session with Velocity Session Provider

One nice feature of
Microsoft Distributed
Cache aka Velocity is
a custom session
provider that can
replace the ASP.NET
default session provider.
In this post I’ll explain how to replace ASP.NET session with the
Velocity session provider that is being provided with Velocity.

Why Replacing the ASP.NET Session with Velocity Session?

Sometimes we want to share a session across servers in a server farm.
The ways to do so are to use a State Server or a database. When Velocity
came out it was released (currently in CTP) with a custom session provider.
The use of Velocity cluster as a session provider can have impact of
performance as opposed to the other methods since we are talking about
a distributed cache. Another reason to use Velocity as session provider is
the availability feature it gives us compared to State Server or database
which can fail and we will need a recovery plan for them.

Doing the Trick

First of all we need to reference the Velocity dlls from the ASP.NET
web site or web application. You should reference the CacheBaseLibrary
and ClientLibrary dlls. After we have the reference you should add the
following data in the web.config file -

In the configSections element add the following element:

<section name="dataCacheClient" type="Microsoft.Data.Caching.DataCacheClientSection, CacheBaseLibrary" allowLocation="true" allowDefinition="Everywhere"/>

Add the dataCacheClient element with your relevant configurations.
This can be for example:

<dataCacheClient deployment="simple">  <localCache isEnabled="true" sync="TTLBased" ttlValue="300" />  <hosts>          <host name="localhost" cachePort="22233" cacheHostName="DistributedCacheService"/>  </hosts></dataCacheClient>

The last thing to do is in the system.web element to add the sessionState
element that will be custom and point to the Velocity session provider:

<sessionState mode="Custom" customProvider="Velocity">  <providers>    <add name="Velocity" type="Microsoft.Data.Caching.DataCacheSessionStoreProvider, ClientLibrary" />  </providers></sessionState>

That is it. After doing so you can run the Velocity cluster and use the
ASP.NET session as you used it before. The only difference will be that
the data will be saved inside Velocity.

A full example could look like:

<?xml version="1.0"?><configuration>  <configSections>    <sectionGroup name="system.web.extensions" type="System.Web.Configuration.SystemWebExtensionsSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">      <sectionGroup name="scripting" type="System.Web.Configuration.ScriptingSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">        <section name="scriptResourceHandler" type="System.Web.Configuration.ScriptingScriptResourceHandlerSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>        <sectionGroup name="webServices" type="System.Web.Configuration.ScriptingWebServicesSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">          <section name="jsonSerialization" type="System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="Everywhere" />                 </sectionGroup>      </sectionGroup>    </sectionGroup>    <section name="dataCacheClient" type="Microsoft.Data.Caching.DataCacheClientSection, CacheBaseLibrary" allowLocation="true" allowDefinition="Everywhere"/>  </configSections>   <dataCacheClient deployment="simple">    <localCache isEnabled="true" sync="TTLBased" ttlValue="300" />    <hosts>      <host name="localhost" cachePort="22233" cacheHostName="DistributedCacheService"/>    </hosts>  </dataCacheClient>   <appSettings/>  <connectionStrings/>   <system.web>    <sessionState mode="Custom" customProvider="Velocity">      <providers>        <add name="Velocity" type="Microsoft.Data.Caching.DataCacheSessionStoreProvider, ClientLibrary" />      </providers>    </sessionState>  </system.web></configuration>

Summary

Lets sum up, I explained why you should consider using Velocity as a
session provider. The main reasons for that are performance and availability.
Also, I showed how to configure your ASP.NET application to use the
Velocity session provider.

Data Types For Caching

Gil Fink — Tue, 06 Oct 2009 12:51:22 GMT

Data Types For Caching

One of the big problems I see
when I talk with people about
caching is not recognizing the
different cached data types.
Understanding the different types
of data can help us to define
what sort of caching do we need and also how to use caching systems
to achieve the appropriate cache scenario we are going to use.
This post will describe how to define data types for caching.

Reference Data

Reference data is data that doesn’t change frequently. This kind of
data is usually a result of data storage/storages query or aggregate query.
Since it doesn’t change frequently it is very ideal for caching. Instead of
hitting the data source when we need this kind of data, in the first hit
we will store it in cache and then retrieve it from cache when it is needed.
Reference data can also change so we need to refresh it periodically.
A very good example of reference data can be catalogs or lookup tables
(for example countries lookup table) that don’t change frequently.

Activity-Oriented Data

Activity-oriented data as it’s name indicate is data that belong to some
business activity or transaction. The data is created inside a business
activity and then at the end of the activity is persisted into the data
storage for historical or log information. Such data type is a data per
open session. A good example for an activity data is shopping cart in
a web store like Amazon. Other examples can be a user session state
or purchase order. As you can understand this kind of data has exclusive
access and therefore it is very recommended to cache it.

Resource-Oriented Data

Resource-oriented data is shared, concurrently read and write into, and is
accessed by many users/transactions. This kind of data is very hard to keep
inside a cache since there can be race conditions between transactions and
many transactions can manipulate the data at the same time.If this kind of
data is used inside cache it should be handled with caution and you should
use concurrency mechanisms in order to minimize problems. Examples for
such data can be auction items and flight inventory.

Summary

Let sum up, it is very important to understand the kinds of data that you
are going to use with cache. Every data kind has it’s appropriate caching
scenarios and have different considerations. These data type include
reference data, activity-oriented data and resource-oriented data.

Building a Simple Cache Manager

Gil Fink — Fri, 21 Aug 2009 21:25:07 GMT

Building a Simple Cache Manager

As I wrote in a previous post,
I’ve started to work in a
new project. My role
there is a technical team
leader of a very big team
(10 developers).
Part of my role is helping the
team to create infrastructure for their applications. As part of the application’s
infrastructure, I recommended to start using caching for better performance.
In the post I’ll demonstrate the simple cache manager I’ve built for the team.

ICacheManager Interface

Before building the cache manager I created an interface for caching.
I’ve done that in order to create abstraction between the application
and the used cache manager since in the future we may want to change
the implementation for Velocity distributed cache for example. Another
reason was for the testability of the caching subsystem. The last reason is
because we are going to use a dependency injection container for our
infrastructure. The following code is the interface I’ve created:

     public interface ICacheManager

     {

         /// <summary>

         /// Add a new object into the cache

         /// </summary>

         /// <param name="key">The key of the object to add</param>

         /// <param name="value">The value of the object to add</param>

         void Add(string key, object value);

         /// <summary>

         /// Check whether the key is contained by the cache

         /// </summary>

         /// <param name="key">The key to check</param>

         /// <returns>Returns true if the key is contained by the cache</returns>

         bool Contains(string key);

         /// <summary>

         /// Returns the number of items in the cache

         /// </summary>

         /// <returns></returns>

         int Count();

         /// <summary>

         /// Insert a new object into the cache 

         /// </summary>

         /// <param name="key">The key of the object to insert</param>

         /// <param name="value">The value of the object to insert</param>

         void Insert(string key, object value);

         /// <summary>

         /// Get the object that its key is given

         /// </summary>

         /// <typeparam name="T">The object</typeparam>

         /// <param name="key">The given key to check</param>

         /// <returns>returns the object or null if it doesn't exists</returns>

         T Get<T>(string key);

         /// <summary>

         /// Removes the object that is referenced by the given key

         /// </summary>

         /// <param name="key">The given key</param>

         void Remove(string key);

         /// <summary>

         /// Get/Set the the given key and object

         /// </summary>

         /// <param name="key">The given key to the indexer</param>

         /// <returns>Returns the object that the given key reference</returns>

         object this[string key]

         {

             get;

             set;

         }

     }

The CacheManager Implementation

The implementation of the cache manager is very straight forward.
I’ve used the ASP.NET caching in order to cache the data. The following code
is the simple implementation I’ve created:

    public class CacheManager : ICacheManager

    {

        #region ICacheManager Members

        public void Add(string key, object value)

        {

            HttpRuntime.Cache.Add(key, value, null, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);

        }

        public bool Contains(string key)

        {

            return HttpRuntime.Cache.Get(key) != null;

        }

        public int Count()

        {

            return HttpRuntime.Cache.Count;

        }

        public void Insert(string key, object value)

        {

            HttpRuntime.Cache.Insert(key, value);

        }

        public T Get<T>(string key)

        {

            return (T)HttpRuntime.Cache.Get(key);

        }

        public void Remove(string key)

        {

            HttpRuntime.Cache.Remove(key);

        }

        public object this[string key]

        {

            get

            {

                return HttpRuntime.Cache[key];

            }

            set

            {

                HttpRuntime.Cache[key] = value;

            }

        }

        #endregion

    }

This isn’t going to be our caching manager in the future but for now
it is enough in order to start using cache in the application.

Summary

I’ve shown a very simple cache manager. I could have created other
solutions like having an in memory dictionary with cached data or other
implementation that I can think about but the ASP.NET caching is there
for using so why not use it. In the future this implementation will be
replaced with a more appropriate caching mechanism such as Velocity.

Quick Tip – How to Enable Local Cache in Velocity (Microsoft Distributed Cache) Client

Gil Fink — Thu, 16 Jul 2009 18:04:34 GMT

Quick Tip – How to Enable Local Cache in Velocity (Microsoft Distributed Cache) Client

Since I got this question twice
this week, I’m writing this post.
One of Velocity (Microsoft
Distributed Cache) features is
called local cache. In this post I’ll
show how to enable that feature.

Velocity Client Local Cache

Local cache is a Velocity feature that can help speed up access on Velocity clients.
When enabled, a de-serialized copy of the object is saved in the client memory.
Before retrieving cached objects, the client cache will first checks whether the
object exists locally and if so will get it from the local cache.

Enabling Local Cache

There are two ways to enable local cache on a Velocity client:

The runtime way – the DataCacheFactory object has a constructor that gets
as parameter whether the local cache is enabled.
for example:

         DataCacheServerEndpoint[] servers = new DataCacheServerEndpoint[1];

        servers[0] = new DataCacheServerEndpoint("localhost",

                                22233, "DistributedCacheService");

        bool routingClient = false;

        // True = Enable local cache

        // False = Disable local cache

        bool localCache = false;

        var factory = new DataCacheFactory(servers,

            routingClient, localCache);

        var cache = factory.GetCache("default");

The configuration way – in the client config file, we we use the localCache
attribute like in the following example:

        <dcacheClient deployment="simple" localCache="false">

          <hosts>    

            <host name="localhost"

                  cachePort="22233"

                  cacheHostName="DistributedCacheService" />

          </hosts>

        </dcacheClient>

Summary

Local cache is a very useful feature of Velocity. It can help to boost the
performance of an application that uses Velocity to new heights.

Setting an EntityReference Using an EntityKey in Entity Framework

Gil Fink — Fri, 15 May 2009 17:01:00 GMT

Setting an EntityReference Using an EntityKey in Entity Framework

Yesterday I got a question
in my blog concerning the
ability to set a reference to
an entity in Entity Framework
by using a foreign key that exists
in my hand. The answer is described
in this post.

Setting an EntityReference Using an EntityKey

Sometimes you want to set an EntityReference but you don’t have
that entity in the ObjectContext but you have its key. One solution
for this problem is to load the entity and then to set the EntityReference.
This will make an unwanted roundtrip to the database which we would
like to avoid. The second solution is to create the EntityReference
using only its EntityKey. This solution will allow to create a foreign key
for an entity without having the related data in the ObjectContext.
One drawback for this solution is that you must know the entity key or else
you’ll get an exception.

The Solution

The following example shows how to set an EntityReference using
an EntityKey:

Course course = new Course();course.DepartmentReference.EntityKey =    new EntityKey("SchoolEntities.Departments", "DepartmentID", 1);

In the example I create a new course and I know that the engineering
department has a DepartmentID of 1. I make a entity reference to that
department through the created DepartmentReference property using
its EntityKey.

Summary

Let sum up, in the post I showed a simple solution that enables to set a
navigation property by using an entity key. You must pay attention that
setting an un-existing EntityKey will raise an exception. This solution
can decrease roundtrips to the database and increase the performance
for your application.