In my last two posts I had discussed about thread synchronization,critical sections and System.Threading.Monitor class.What we have seen is, a critical section in the code where thread synchronization is required is protected by a lock.When a thread encounters a critical section it tries to acquire the lock,if successful it executes the code or else waits to acquire the lock.Now when we say wait, what exactly happens?.There are two possible ways this can be done.

Managed threads, spawned via .NET are actually threads in Windows OS.So they can use the Windows Kernel Synchronization objects(Mutex,Semaphores,..etc.).These synchronization objects can have two states: signaled and non-signaled.When a thread gets reference to a synchronization object which is in non-signaled state there is an immediate context switch i.e. it is taken down from the processor and put into a wait/sleep mode.Later when the synchronization object is signaled the thread is put back to the runnable queue and is ready for execution.In this kind of waiting there is no wastage of CPU cycles in wait state but there is a context switch.So if the waiting period is long enough this can be useful but for shorter duration the overhead of context switch may prove to be costly.We are referring to this as true wait.

There is another way.The thread waits and checks for the lock to be released in some kind of a loop.This is known as spin or busy wait.Here if the waiting period is short this can be useful but for longer duration this will lead to wastage of CPU cycles.

The C# Monitor class implements a mix of the two.First it spins for few cycles and if the lock is still not acquired by that time it then get’s into a true wait using kernel synchronization objects.

From .NET 3.5 the System.Threading.SpinLock structure is introduced to implement busy or spin wait based locks.The methods are quite similar to that of Monitor.The two most important methods are:

• public void Enter(ref bool lockTaken) – To acquire the lock
• public void Exit() – To release the lock

The following code shows the use of this methods to acquire and release locks:

public class Foo
{
     SpinLock spLock = new SpinLock();
     public void M1()
     {
         bool lockTaken = false;
         try
         {
             spLock.Enter(ref lockTaken);
             Thread.Sleep(1000);
             Console.WriteLine("M1::");
         }
         finally
         {
             if(lockTaken)spLock.Exit();
         }
     }
}

However one difference with Monitor is, this lock is non reentrant in nature.In the following code the pne thread is trying to acquire the same SpinLock twice.

public class Foo
{
     SpinLock spLock = new SpinLock();
     public void M1()
     {
         bool lockTaken = false;
         try
         {
             spLock.Enter(ref lockTaken);
             Thread.Sleep(1000);
             M2();
             Console.WriteLine("M1::");
         }
         finally
         {
             if(lockTaken)spLock.Exit();
         }
     }
     public void M2()
     {
         bool lockTaken = false;
         try
         {
             spLock.Enter(ref lockTaken);
             Console.WriteLine("M2::");
         }
         finally
         {
             if (lockTaken) spLock.Exit();
         }
     }
}

The execution of the method M1 will throw a LockRecursionException exception:

{“The calling thread already holds the lock.”}

However we can avoid this by checking whether lock is held by same thread or not using the SpinLock.IsHeldByCurrentThread property

public void M2()
{
    bool lockTaken = false;
    try
    {
        if(!spLock.IsHeldByCurrentThread)spLock.Enter(ref lockTaken);
        Console.WriteLine("M2::");
    }
    finally
    {
        if (lockTaken) spLock.Exit();
    }
}

In the next series we will explore the other thread synchronization mechanisms available in .NET Framework.

In my earlier post I had discussed about the Common Service Locator framework (IServiceLocator interface)and how we can implement an adapter for the StructureMap container.In this post we will take look into how the new ASP.NET MVC provides support to plug in this ServiceLocator.

The new framework supports an interface System.Web.Mvc.IMvcServiceLocator which is defined as:

public interface IMvcServiceLocator : IServiceLocator {
      void Release(object instance);
  }

We also have a default implementation of this interface System.Web.Mvc.MvcServiceLocator. This class exposes a method public static void SetCurrent(IServiceLocator locator) to plug in custom service locator implementation.

If there is no custom service locator set, then it uses a default implementation provided by the class DefaultMvcServiceLocator.This class uses Activator.CreateInstance to instantiate the objects.

Right now there is support for service locator to manage instances of Controller,Views and Filters.Let’s take a look into how we can manage controller instances using the service locator.

The instantiation of controllers are managed through the factory classes implementing the IControllerFactory interface.We can implement our own controller factory or can use the DefaultControllerFactory class provided by the framework itself.

DefaultControllerFactory gets the reference to a IServiceLocator instance in the following way:

protected internal DefaultControllerFactory(IServiceLocator locator) {
    if (locator == null)
        _serviceLocatorThunk = () => MvcServiceLocator.Current;
    else
        _serviceLocatorThunk = () => locator;
}

While creating the instance it first checks with the service locator.If the container is not able to create the instance it then uses Activator.CreateInstance as shown below:

// Try the container first...
try {
    return (IController)_serviceLocatorThunk().GetInstance(controllerType);
}
catch (ActivationException) {
} 

// ...failing that, fall back to MVC 2 behavior
try {
    return (IController)Activator.CreateInstance(controllerType);
}
catch (Exception ex) {
    throw new InvalidOperationException(
        String.Format(
            CultureInfo.CurrentCulture,
            MvcResources.DefaultControllerFactory_ErrorCreatingController,
            controllerType),
        ex);
}

To use our StructureMap based service locator we have to configure the StructureMap container,register the controller type and set the custom service locator in Application_Start event of global.asax.cs as shown below:

Container container = new Container(
    x =>
    {
        x.ForRequestedType<IController>().
                AddInstances
                (
                    y =>
                        {
                            y.
                               OfConcreteType
                               (
                                typeof(DepartmentController)
                               ).
                                    WithName("Department");
                        }
                );
    }
    ); 

StructureMapServiceLocator serviceLocator =
    new StructureMapServiceLocator(container); 

MvcServiceLocator.SetCurrent(serviceLocator);

For past couple of days I was checking out features of the new ASP.NET MVC Preview 3.There are couple of interesting new additions like integration with the new Razor viewengine,improvements in Model Validation,AJAX support and Dependency Injection.In this post we will discuss on, how ASP.NET MVC 3 has streamlined the ability to register/retrieve objects/services in a loosely coupled manner by incorporating support for the Common Service Locator framework.

What is Common Service Locator?Today we have many Inversion of Control/Dependency Injection Containers like NInject,StructureMap,Unity,.. etc in the .NET world.Most of these vary quite widely in terms of configuration and initialization/registration of the instances.But they provide more or less similar interface while resolving the dependencies and returning object instances.Common Service Locator framework extracts these commonalities out and provides an abstraction on top of these IoC/DI containers.This is now part of the Enterprise Library 5.0 and used in the Enterprise Library code to create/retrieve objects.Common Service Locator provides an interface IServiceLocator

public interface IServiceLocator : IServiceProvider
{
    IEnumerable<TService> GetAllInstances<TService>();
    IEnumerable<object> GetAllInstances(Type serviceType);
    TService GetInstance<TService>();
    TService GetInstance<TService>(string key);
    object GetInstance(Type serviceType);
    object GetInstance(Type serviceType, string key);
}

It is quite evident from the method signatures that these are only related to retrieval of right object instances with proper resolution of the dependencies based upon different parameters.

Another important class related to the Common Service Locator is the ActivationException which needs to be thrown whenever there is exception in instantiating the objects /resolving the dependencies.

I was planning to use StructureMap as the DI Container and a StructureMap Adapter for Service Locator was available in Codeplex but that seemed far from complete.

So I went ahead to write few lines of code and develop a service locator which will use StructureMap as the DI container as shown below:

  public class StructureMapServiceLocator : IServiceLocator
  { 

      private IContainer container;
      public StructureMapServiceLocator(IContainer container)
      {
          this.container = container;
      }
    //........
  }

This class accepts an instance of the StructureMap.Container in the constructor and uses it to resolve dependencies and instantiate objects.In the implementation of the IServiceLocator methods we have to just map them suitably to StructureMap.Container.GetAllInstances and StructureMap.Container.GetInstance methods (and their overloads).The code which depends on IServiceLocator will perform exception handling based on ActivationException class whereas StructureMap raises StructureMap.StructureMapException in most of the cases.So we need to catch StructureMapException in this class and throw a ActivationException.The complete code is given below:

namespace MVC.Sample.ServiceLocator
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Web.Mvc;
    using StructureMap;

    /// <summary>
    /// Structure Map Based Service Locator
    /// </summary>
    public class StructureMapServiceLocator : IServiceLocator
    {
        /// <summary>
        /// Strycture Map Container Reference
        /// </summary>
        private IContainer container;
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="container">Instance of the Structure Map Container</param>
        public StructureMapServiceLocator(IContainer container)
        {
            this.container = container;
        }
        #region IServiceLocator Members

        /// <summary>
        ///  Gets all registered instances for a particular type
        /// </summary>
        /// <param name="serviceType">Type of the requested instance</param>
        /// <returns>IEnumerable of Service Instances</returns>

        public IEnumerable<object> GetAllInstances(Type serviceType)
        {
            IList list = null;
            try
            {
                list = container.GetAllInstances(serviceType);
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            foreach (var o in list)
            {
                yield return o;
            }
        }
        /// <summary>
        /// Gets all registered instances for a particular type
        /// </summary>
        /// <typeparam name="TService">Type of the requested instance</typeparam>
        /// <returns>IEnumerable of Service Instances</returns>
        public IEnumerable<TService> GetAllInstances<TService>()
        {
            IList<TService> list = null;
            try
            {
                list = container.GetAllInstances<TService>();
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            foreach (var o in list)
            {
                yield return o;
            }
        }
        /// <summary>
        /// Gets registered instance for a particular type and key
        /// </summary>
        /// <param name="serviceType">Type of the requested instance</param>
        /// <param name="key">Key/Name of the requested instance </param>
        /// <returns>requested object instance</returns>
        public object GetInstance(Type serviceType, string key)
        {
            object o = null;
            try
            {
                o = container.GetInstance(serviceType, key);
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            return o;
        }
        /// <summary>
        /// Gets registered instance for a particular type
        /// </summary>
        /// <param name="serviceType">Type of the requested instance</param>
        /// <returns>requested object instance</returns>
        public object GetInstance(Type serviceType)
        {
            object o = null;
            try
            {
                o = container.GetInstance(serviceType);
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            return o;
        }
        /// <summary>
        /// Gets registered instance for a particular type and key
        /// </summary>
        /// <typeparam name="TService">Type of the requested instance</typeparam>
        /// <param name="key">Key/Name of the requested instance</param>
        /// <returns>requested object instance</returns>
        public TService GetInstance<TService>(string key)
        {
            TService t;
            try
            {
                t = container.GetInstance<TService>(key);
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            return t;
        }

        /// <summary>
        /// Gets registered instance for a particular type
        /// </summary>
        /// <typeparam name="TService">Type of the requested instance</typeparam>
        /// <returns>requested object instance</returns>
        public TService GetInstance<TService>()
        {
            TService t;
            try
            {
                t = container.GetInstance<TService>();
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            return t;

        }

        #endregion

        #region IServiceProvider Members
        /// <summary>
        /// Gets registered instance for a particular type
        /// </summary>
        /// <param name="serviceType">Type of the requested instance</param>
        /// <returns>requested object instance</returns>
        public object GetService(Type serviceType)
        {
            object o = null;
            try
            {
                o = GetInstance(serviceType);
            }
            catch (StructureMapException smex)
            {
                throw new ActivationException(message: smex.Message);
            }
            return o;
        }

        #endregion
    }
}

So we have our Service Locator class ready.In next part of the post we will see how we can plug this into the ASP.NET MVC 3.0 Framework.

Here goes my presentation for July 2010 Microsoft KolkataNET Community Tech Days

In my last post I started the discussion on race conditions and thread synchronization technique using Monitor/lock in C#.In this post also, we will continue with the same and discuss some important points related to the Monitor class.

Value Types

The lock statement or the Monitor.Enter method expects a parameter of type object on which the lock is held.So what happens if we pass value type as parameter?

private int i;

public void M2()
{
    lock (i)
    {
        Console.WriteLine("Method::M2::Entered Critical Section");
    }
} 

This will throw a compilation error CS0185: ‘int’ is not a reference type as required by the lock statement.

So the natural question is why C# compiler is not allowing us to pass a value type as parameter? This is because when we pass a value type it will be boxed to a reference type i.e. object in this case.So every time the lock statement is executed, boxing happens and we get a completely new and separate object instance.So all the executing threads will be able to acquire the lock as the object itself will be a different one.

Re-entrancy

The locking provided by Monitor/lock statement are reentrant in nature i.e. the same thread can acquire the lock on same object multiple times.

public class A
{
    private object objLock = new object();
    private int i;
    public void M1()
    {
        lock (objLock)
        {
            Console.WriteLine("Method::M1::Entered Critical Section");
            M2();
        }
    }
    public void M2()
    {
        lock (objLock)
        {
            Console.WriteLine("Method::M2::Entered Critical Section");
        }
    }
}

This code will produce the output as:

Method::M1::Entered Critical Section
Method::M2::Entered Critical Section

This is because lock statement allows the same thread to acquire lock on objLock multiple times once within method M1 and then within M2.

Lock On Public Types/Objects

As per MSDN

In general, avoid locking on a public type, or instances beyond your code’s control. The common constructs lock (this), lock (typeof (MyType)), and lock (“myLock”) violate this guideline:

• lock (this) is a problem if the instance can be accessed publicly.
• lock (typeof (MyType)) is a problem if MyType is publicly accessible.
• lock(“myLock”) is a problem since any other code in the process using the same string, will share the same lock.

This is very valid guideline I will just try to explain the possible hazards that might arise on using lock on publicly accessible properties/types.Consider the following simple class:

public class Foo
{
    public void Bar()
    {
        lock (this)
        {
            Console.WriteLine("Class:Foo:Method:Bar");
        }
    }
}

Here we are using a lock on the object instance itself.Let’s assume that this code is part of some library/API where the client code is not supposed to be aware of internal implementation.The client code makes a call to Foo/Bar in the following way:

public class MyClient
{
    public void Test()
    {
        Foo f = new Foo();
        lock (f)
        {
            ThreadStart ts = new ThreadStart(f.Bar);
            Thread t = new Thread(ts);
            t.Start();
            t.Join();
        }
    }
}

This program will simply hang because the main thread acquires a lock on instance of Foo and then invokes the method Bar on the same instance f but on a different thread.The method Bar also tries to acquire a lock on this i.e instance of Foo (same as f) and waits forever.

So to be on the safe side and write bug free code we should always avoid locking on publicly exposed types and properties.In the earlier post we have seen that we can use the System.Runtime.CompilerServices.MethodImplAttribute to synchronize a method.But this will lead to a lock on the object instance (this) or the Type instance of the class(in case of static methods).So it’s better to avoid this.

We have heard about the term race condition in relation to threads.This is basically a scenario where two or more threads are competing(racing) to read/write from a shared memory location leading to the possibilities of leaving the program in an inconsistent state.

Consider the program shown below:

public class A
{
     public int x = 0;
     public int y = 0; 

     public void M1()
     {

             if (y == 0)
             {
                 x = y + 1;
             }
             else x = 5;
     }
     public void M2()
     {
             if (x == 0)
             {
                 y = x + 1;
             }
             else y = 5;
     }
}

This a very simple program where the methods M1 and M2 tries to read/write from/to two shared variables x and y.If M1 and M2 are executed using two threads started one after the other we should get an output x=1 and y=5 or x=5 and y=1 depending upon who is scheduled to execute first.

A a = new A(); 

ThreadStart ts1 = new ThreadStart(a.M1);
ThreadStart ts2 = new ThreadStart(a.M2); 

Thread t1 = new Thread(ts1); 

Thread t2 = new Thread(ts2); 

t1.Start(); 

t2.Start(); 

t1.Join();
t2.Join();
Console.WriteLine("x:{0},y:{1}", a.x, a.y);

But when we run it several times we sometimes might see an output where x=1 and y=2 and vice versa.So here what is possibly happening is

• Thread t1 checks if y==0 and gets true
• Thread t2 checks x==0 and gets true
• Thread t2 sets x= y+1 = 0 + 1 = 1
• Thread t1 sets y=x+1 = 1+1 =2

So to ensure a consistent program output we need to ensure that sections of the code where we read/write from x & y will be executed by one thread at a time.These sections of the code are referred to as critical sections and the mechanisms to protect the critical sections are known as synchronization techniques.

.NET has a provision of doing so using the methods of the System.Threading.Monitor class.The two most commonly used methods are:

• public static void Enter(Object obj) – This method is called before entering the critical sections and it grants an exclusive lock on the object passed as parameter.
• public static void Exit(Object obj) – This method is called before leaving the critical sections and it releases the  exclusive lock on the object passed as parameter.

So our modified code  now looks like:

public class A
{
     public int x = 0;
     public int y = 0;
     private object lockObject = new object();
     public void M1()
     {
         Monitor.Enter(lockObject);
         if (y == 0)
         {
             x = y + 1;
         }
         else
         {
             x = 5;
         }
         Monitor.Exit(lockObject); 

     }
     public void M2()
     {
             Monitor.Enter(lockObject);
             if (x == 0)
             {
                 y = x + 1;
             }
             else
             {
                 y = 5;
             }
             Monitor.Exit(lockObject); 

     }

}

When any one of the threads call Monitor.Enter(lockObject) it gets an exclusive lock on the instance of the object.So the second thread has to wait till that lock is released by Monitor.Exit(lockObject).

But from programming perspective this is a bit cumbersome and error prone.What happens if Monitor.Enter is called but not Exit particularly in case of exception situations.So it is a good programming practice to implement Monitor as shown below:

public void M2()
{

    try
    {
        Monitor.Enter(lockObject);
        if (x == 0)
        {
            y = x + 1;
        }
        else
        {
            y = 5;
        }
    }
    finally
    {
        Monitor.Exit(lockObject);
    }
}

C# provides a keyword called lock which helps to implement critical section protection in a much simpler and error free way.

public void M2()
 {
     lock (lockObject)
     {
         if (x == 0)
         {
             y = x + 1;
         }
         else
         {
             y = 5;
         }
     }
 }

The C# compiler will generate the IL code with appropriate calls to Monitor.Enter/Monitor.Exit and try{}finally{} blocks as shown below:

.method public hidebysig instance void  M2() cil managed
{
   …………….

  .try
  {
    IL_0003:  ldarg.0
    IL_0004:  dup
    IL_0005:  stloc.1
    IL_0006:  ldloca.s   ‘<>s__LockTaken0′
    IL_0008:  call       void [mscorlib]System.Threading.Monitor::Enter(object,
                                                                        bool&)
    …………….
    …………….

  }  // end .try
  finally
  {
    IL_003d:  ldloc.0
    IL_003e:  ldc.i4.0
    IL_003f:  ceq
    IL_0041:  stloc.2
    IL_0042:  ldloc.2
    IL_0043:  brtrue.s   IL_004c
    IL_0045:  ldloc.1
    IL_0046:  call       void [mscorlib]System.Threading.Monitor::Exit(object)
    IL_004b:  nop
    IL_004c:  endfinally
  }  // end handler
  IL_004d:  nop
  IL_004e:  ret
} // end of method A::M2

In the above examples the entire code in M1 and M2 are protected as critical sections.We can say these methods itself are synchronized such that one thread can execute them at a time.We can also implement this using the MethodImpl attribute as shown below:

[System.Runtime.CompilerServices.MethodImpl
(System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]
public void M2()
{

        if (x == 0)
        {
            y = x + 1;
        }
        else
        {
            y = 5;
        }
}

In the IL compiler will add the synchronized keyword as shown below:

.method public hidebysig instance void  M2() cil managed synchronized
{

………….

}

This implementation flag called synchronized tells the JIT compiler to insert code to acquire lock on entry of the method and release the lock on exit of the method.For instance methods this lock is placed on object instance i.e. this parameter and for static methods this lock is placed on System.Type.

So in this post we have discussed about the various ways to implement locking of critical sections.In the next post we will some other mechanisms  of locking which is conceptually little bit different from internal implementation standpoint.

We have all heard about immutable objects, the objects whose field values cannot be altered throughout it’s lifetime.Immutable objects are simpler to deal with in case concurrent programs where they can be shared between multiple threads.The single assignment variables variables which is once assigned a value cannot be reassigned again.These are inherently immutable in nature.In languages like Haskell,Erlang,F# etc. variables are by default single assignment variables.

The following code shows how F# throws error when you try to reassign a variable:

As F# is not a pure functional language and some imperative styles are also allowed.So we can have mutable variables as well:

But how does C#, the lingua franca of .NET Framework handle this.C# provides the readonly modifier for similar purposes.A variable marked with this modified can only be initialized while declaration or from within the constructor.Consider the code below:

class Program
{
    static void Main(string[] args)
    {
        C c = new C();
        c.i = 10;
        Console.Read();
    }
}
public class C
{
    public readonly int ; 

}

This will lead to a compile error "error CS0191: A readonly field cannot be assigned to (except in a constructor or a variable initializer)"

However the following code runs fine:

class Program
{
    static void Main(string[] args)
    {
        C c = new C();
        Console.Read();
    }
}
public class C
{
    public readonly int i =0; 

    public C()
    {
        i = 5;
        i = 7;
    }
}

This is not allowing to assign value apart from the initialization process but it is not pure single assignment.As it is very clear that I can assign the variable multiple times in the constructor.

But, what happens if we pass the field i as a ref parameter in some method which alters it’s value.

class Program
{
    static void Main(string[] args)
    {
        C c = new C();
        D d = new D();
        d.M1(ref c.i);
        Console.Read();
    }
}
public class C
{
    public readonly int i =0; 

    public C()
    {
        i = 5;
        i = 7;
    }
}
public class D
{
    public void M1(ref int i)
    { 

        i++;
    }
}

This will not compile and throw compilation error "error CS0192: A readonly field cannot be passed ref or out (except in a constructor)".

As a readonly variable can be assigned multiple times, it might lead to problems where the instance of the object is shared before the entire constructor executes as shown below:

class Program
{
     static void Main(string[] args)
     {
         C c = new C();
         Console.WriteLine("Value of i={0}", c.i);
         Console.Read();
     }
}
public class C
{
     public readonly int i =5; 

     public C()
     {
         Console.WriteLine("Class C::Constructor::Start");

         E e = new E();
         WaitCallback w = (o) =>
         {
             e.M1(this);
         }; 

         ThreadPool.QueueUserWorkItem(w);
         //Do Something.
         Thread.Sleep(100);
         i = 7; 

         Console.WriteLine("Class C::Constructor::End");
     }
}
public class E
{
     public void M1(C c)
     {
         Console.WriteLine("Class D::Method M1::Start");
         if (c.i == 5)
         {
             Console.WriteLine("Somethings.......");
         }
         Console.WriteLine("Class D::Method M1::End");
     }
}

Here the output will be:

Class C::Constructor::Start
Class D::Method M1::Start
Somethings…….
Class D::Method M1::End
Class C::Constructor::End
Value of i=7

In this the final value of the readonly variable i is 7 but the method M1 gets a value of 5 and performs something which is not correct.

Anyway’s sharing an object instance before the constructor executes is not a recommended programming practice.But this also reveals a potential weakness of readonly keyword in terms of concurrency.

A Web Cache stores copies of web resources(html/images etc.) returned by the requests that pass through it and next time onwards returns the stored copy to the client instead of forwarding the same request to the server.This helps to improve the speed of content delivery, reduce bandwidth usage and processing load on the servers.Caching as a concept is nothing new and can be seen in many other areas of software and hardware technologies as well.In this post we will discuss about what all options HTTP as a protocol provides to control and manipulate the caching of web resources.

Before getting into the HTTP specific details let’s take a quick look into some of the common caching related terminologies:

• Cache Hit – When a request arrives at the cache it can serve the local copy.
• Cache Miss – When a request arrives at the cache it does not have the response available in the cache and has to get it from the server.
• Revalidation – From time to time the cache needs to check whether the cached documents are up-to-date with the server or not.This is known as the Freshness Check or Revalidation.

The conditions based on which this freshness check or revalidation is triggered will be discussed later.We will first see what provisions HTTP has to perform such a check.This is done using If-Modified-Since HTTP Header field.This header is passed in the HTTP Request as:

If-Modified-Since: <Date Time>

If the document is modified since the date mentioned in If-Modified-Since header then the server will return the latest document as response with HTTP Status Code 200 other wise it will send the HTTP Status 304: Not Modified with empty response body.

To test the same I have written simple Http Client in C# and tried to fetch a wikipedia page as shown below:

HttpWebRequest wr = null;
HttpWebResponse response = null;
try
{
    wr = HttpWebRequest.Create("http://en.wikipedia.org/wiki/Lady_Gaga") as HttpWebRequest;
    wr.IfModifiedSince = DateTime.Parse("06/30/1910");
    response = wr.GetResponse() as HttpWebResponse;
    Console.WriteLine((response as HttpWebResponse).StatusCode);
}
catch (Exception ex)
{
    Console.WriteLine("Error:" + ex.Message);
}
finally
{
    if(response!=null) response.Close();
} 

Console.Read();

Here I have passed a date in 1910 in the If-Modified-Since header field and got a status code 200 since the page was obviously modified since such a old date.

If I change the date something to future I will get the following output:

Error:The remote server returned an error: (304) Not Modified.

This is because the page was not modified since such a future date.

Now we will examine the response headers a little bit more closely adding following lines of code in the program:

for(int i=0;i<response.Headers.Count;i++)
{
    Console.WriteLine("Response Header:: {0} - {1}",response.Headers.Keys[i] , response.Headers[i].ToString());
}

The output is shown below:

Response Header:: Content-Language – en
Response Header:: Vary – Accept-Encoding,Cookie
Response Header:: Age – 1761
Response Header:: X-Cache – HIT from sq61.wikimedia.org,MISS from sq65.wikimedia
.org
Response Header:: X-Cache-Lookup – HIT from sq61.wikimedia.org:3128,MISS from sq
65.wikimedia.org:80
Response Header:: Connection – keep-alive
Response Header:: Content-Length – 215691
Response Header:: Cache-Control – private, s-maxage=0, max-age=0, must-revalidate
Response Header:: Content-Type – text/html; charset=UTF-8
Response Header:: Date – Sun, 30 May 2010 06:32:28 GMT
Response Header:: Last-Modified – Sun, 30 May 2010 04:22:41 GMT
Response Header:: Server – Apache

The response header Age tells us the amount of time elapsed since the document was sent from (or revalidated ) from the server.The value is in seconds.This is  one of the factors in computing the criteria for freshness checks of the cached documents.

X headers are non standard or extension HTTP headers.The X-Cache and X-Cache-Lookup is used by the Squid Proxy Server which is used by wikipedia for caching.The values indicate multiple levels of cache where there is MISS from sq65.wikimedia.org and HIT from sq61.wikimedia.org.

Another header Cache-Control, the most important HTTP header in terms of caching needs a detailed discussion which we will take up in the next part of the series.

For the past week I am trying to play around with Flex and find out how it works with different back end service endpoints.In this post I will discuss about how Flex works with a simple WCF Service over HTTPS and also the issues I encountered while doing so.

Okay, so let’s get started with the WCF service first.I have a POCO named Contact which is decorated as a DataContract as shown below:

[DataContract]
public class Contact
{
     [DataMember ]
     public string Name { get; set; }
     [DataMember]
     public string Email { get; set; }
     [DataMember]
     public string ContactType { get; set; }
}

The ServiceContract and it’s implementation is shown below:

[ServiceContract]
public interface IContact
{
    [OperationContract]
    Contact[] GetContactList();

}

public class ContactService : IContact
  {

      #region IContact Members

      public Contact[] GetContactList()
      {
          return new Contact[]
                     {
                      new Contact()
                          {
                              ContactType ="Friend",Name="John Doe",
                              Email="John.Doe@xyz.com"
                          },
                      new Contact()
                          {
                              ContactType ="Friend",Name="Robin Crusoe",
                              Email="Robin.Crusoe@xyz.com"
                          },
                      new Contact()
                          {
                              ContactType ="Friend",Name="VanValkenburg",
                              Email="Valkenburg@xyz.com"
                          },
                       new Contact()
                          {
                              ContactType ="Relative",Name="Anthony Price",
                              Email="Anthony.Price@xyz.com"
                          },
                     };
      }

      #endregion
  }

So it’s all very simple.. demo.. demo.. with no demons of complexity.One more thing, I have made the endpoint secure with Transport level security.

<system.serviceModel>
  <bindings>
   <basicHttpBinding>
    <binding name="custombasicHttpBinding">
      <security mode="Transport" >
      </security>
    </binding>
   </basicHttpBinding>
  </bindings>
  <services>
   <service behaviorConfiguration="DemoServiceApp.ContactService"
    name="DemoServiceApp.ContactService">
    <endpoint address="https://localhost/DemoServiceApp/ContactService.svc"
     binding="basicHttpBinding" bindingConfiguration="custombasicHttpBinding"
     contract="DemoServiceApp.IContact">
     <identity>
      <dns value="localhost" />
     </identity>
    </endpoint>
    <endpoint address="mex" binding="mexHttpsBinding" bindingConfiguration=""
     contract="IMetadataExchange" />
   </service>
  </services>
        <behaviors>
   <serviceBehaviors>
    <behavior name="DemoServiceApp.ContactService">
     <serviceMetadata httpGetEnabled="false" httpsGetEnabled="true"
      httpsGetUrl="https://localhost/DemoServiceApp/ContactService.svc/wsdl" />
     <serviceDebug includeExceptionDetailInFaults="false" />
    </behavior>
   </serviceBehaviors>
  </behaviors>
    </system.serviceModel>

In my Flex application I want to call this service and display the data in a datagrid.To do so I followed the steps mentioned below (using Flexbuilder)

• Create the ActionScript Proxy Classes – I used the Flexbuilder option Data -> Import Web Service (WSDL).But I got the following error:

So what’s happening? I have given the URI correct then why is not FlexBuilder able to connect?After checking the log at C:\Documents and Settings\Administrator\My Documents\Flex Builder 3\.metadata I found the following error:

javax.wsdl.WSDLException: WSDLException: faultCode=OTHER_ERROR: Unable to resolve imported document at ‘https://localhost/DemoServiceApp/ContactService.svc?wsdl’.: javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

So it’s clear that the SSL handshake is failing and FlexBuilder is not able to locate the certificate.FlexBuilder is based on Eclipse platform which runs on a JVM.For this we need to add the certificate in the certificate store used by JVM under which Flexbuilder is running.The certificate store is the cacerts file present under D:\Program Files\Adobe\Flex Builder 3\jre\lib\security.This is done with keytool command line tool coming with JRE.

So after adding the certificate everything was set, but alas again there was an error Provider com.bea.xml.stream.MXParserFactory not found. After searching about this error message in google I found that it’s a known bug in FlexBuilder

http://bugs.adobe.com/jira/browse/FB-13542?page=com.atlassian.jira.plugin.system.issuetabpanels%3Aall-tabpanel

I could not locate the fix and used the hack provided in the site http://poradowski.com/fb/. The root cause seems to be

“bug with resolving multiple, recursive <xsd:import> declarations in WSDL that import type schemas“

So now after copying the file https://ovh.poradowski.net/com.adobe.flexbuilder.axis2_3.0.214193.jar to D:\Program Files\Adobe\Flex Builder 3\plugins folder everything went fine and set of ActionScript classes got generated.

In the next part of the post we will see what these classes are and how to make the service call.

In my last post I have discussed about the BerkleyDB product family.In this post we will discuss about using BerkleyDB with it’s C# API set.Before getting into the details we will take a quick look into the different access methods provided by Berkley DB.

• BTree – Here the data is stored in a balanced tree structure.We can put complex as well as simple types as key/values in the database.Duplicate key values also can be stored.
• Hash – Here the data is stored in a hash table structure, both simple & complex types can be stored as key/values in the database, database can be configured to store duplicate key values as well.
• Queue – Here data is stored as fixed length records, logical record number is used as the key.This is specially designed for fast inserts at the tail of the queue and retrieval/deletion from the head of the queue.
• Recno– Like Queue here also the logical record number is used as the key store fixed/variable length records.

BTree database is very suitable when there is some locality reference i.e. query for a given key will be followed by query for one of it’s neighbours.

Hash database is suitable for large dataset.This is because internal information stored by the database in case of BTree is larger than that of Hash.So when the application data grows there will be very little space left in the cache for actual application data in case of BTree databases.

Queue & Recno databases are suitable for cases where we want to use the logical record number as the key.Queue only supports fixed length records whereas Recno support both fixed and variable length records.

The access methods needs to be selected right at the beginning before opening the databases.In the C# API the following classes provides an abstraction of the databases with different access methods:

• BTreeDatabase
• HashDatabase
• QueueDatabase
• RecnoDatabase

Each of these databases classes have a corresponding configuration class which is used to hold the configuration information for those databases e.g. BTreeDatabase as an accompanying class called BTreeDatabaseConfig.

The code sample below shows how to open a BerkleyDB BTreeDatabase.

BTreeDatabase btdb = null;
BTreeDatabaseConfig btcfg = new BTreeDatabaseConfig();
btcfg.Duplicates = DuplicatesPolicy.SORTED;
btcfg.Creation = CreatePolicy.IF_NEEDED;

try
{
btdb = BTreeDatabase.Open(@"C:\\BTreeSample.db", btcfg);
Console.WriteLine("Database Opened..");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
if (btdb != null) btdb.Close();
}
Console.ReadLine();

Here we have first setup the BTreeDatabaseConfig and then opened the database by passing the filename and config.

The BTreeDatabaseConfig exposes two important properties:

• Duplicates – This property is of type DuplicatePolicy enumeration.This enumeration supports three values
  • NONE – This means duplicate keys will not be allowed.
  • SORTED – This means duplicate keys will be stored in a sorted fashion
  • UNSORTED – This means duplicate keys will be stored in an unsorted fashion
• Creation – This property is of type CreatePolicy enumeration.This enumeration supports three values
  • NEVER –It will never create the database.Only existing DB will be opened
  • ALWAYS – It will always try to create the database and throw exception if database already exists. BerkeleyDB.DatabaseException: File exists
  • IF_NEEDED – This will create the database if it does not exists otherwise will open the existing database.

So we have now seen how to configure and open an BerkleyDB database.In the next post we will how insert & retrieve values from it.