Silverlight Cookie Manager

Cookies are popular in web programming for state management, mostly used for persisting small data on client computer. Each cookie is a name-value pairs, this information is stored as small files on client hard-disk. You can also set expiration  date and time of a cookie. If no expiration is provided cookie will be discarded when user closes the browser, this type of non-persistent cookies is useful to store secure or short time data.

In Silverlight, one can access cookies through the 'HtmlPage' class. This class provides browser functionalities and other details like Cookie data, Browser name and version, Popup Window, Platform, UserAgent, Product name and version.  Below is a diagram illustrating how the Silverlight plug-in access cookies through the browser. In traditional web programming, the Response Object or java script is used to set a cookie. A user can disable cookies on his browser, so while using the response object  we should check if cookies are enabled or not. To verify if cookies are enabled, set a cookie and try to read it back, if you can't read it means cookies are disabled. Silverlight code executes on client PC, so we can directly check if cookies are enabled or not just by using 'HtmlPage.BrowserInformation.CookiesEnabled'.

Securing cookie data is very important and should be take in account during application design. To prevent unauthorized access of cookies, combination of tricks can be used like encryption, expiration time, HttpOnly,etc. Silverlight code executes on client PC and cannot access HttpOnly cookies. Cookie class is a part of 'System.Net' and is used to retrieve information about cookies that are received with Http responses. Cookies are stored in a CookieContainer on a Web request, and a CookieCollection on a Web response. You must always create a CookieContainer to send with a request if you want cookies to be returned on the response, also for HTTPOnly cookies.

Limitation if a cookie is that it can store only string data types.
1) Some user may disable cookies on their browser in some case user may manually delete cookies
2) Size limitations Most browsers place a 4096-byte limit on the size of a cookie, although support for 8192-byte cookies is becoming more common in newer browser and client-device versions.
3) User-configured refusal Some users disable their browser or client device's ability to receive cookies, thereby limiting this functionality.
4) Potential security risks Cookies are subject to tampering. Users can manipulate cookies on their computer, which can potentially cause a security risk.

I have created a simple class that aggregates common functionality related to cookies. All members in the class are static so there is no need to create new instances every time you read or write a cookie. The overloaded method SetCookie() will create a new cookie or reset the value of an existing cookie, you can also set the expiration time, path, domain, security using the same method. GetAllCookieList() method will return a list of all available cookies. DeleteCookie() method will delete the cookie by setting the expiration time to yesterday. GetCookieAsString() will return the full cookie data as a string.

1. using System;
2. using System.Net;
3. using System.Text;
4. using System.Linq;
5. using System.Collections.Generic;
6. using System.Windows.Browser;
7.  
8. namespace Utilities
9. {
10.     public static class CookieManager
11.     {
12.         // 1) If same name cooke exist, SetCookie() will over-ride value.
13.         // 2) Exception handling should be done in user code
14.         // 3) - expireDays = 0, indicates a session cookie that will not be written to disk
15.         //    - expireDays = -1, indicates that the cookie will not expire and will be permanent
16.         //    - expireDays = n, indicates that the cookie will expire in n days
17.  
18.  
19.         public static bool IsCookieEnabled()
20.         {
21.             return HtmlPage.BrowserInformation.CookiesEnabled;
22.         }
23.  
24.         public static bool SetCookie(string key, string value)
25.         {
26.             return SetCookie(key, value, null, null, null, false);
27.         }
28.  
29.         public static bool SetCookie(string key, string value, TimeSpan? expiry)
30.         {
31.             return SetCookie(key, value, expiry, null, null, false);
32.         }
33.  
34.         public static bool SetCookie(string key, string value, TimeSpan? expiry, string path, string domain, bool secure)
35.         {
36.             if (!IsCookieEnabled()) return false; //If cookies not enabled return false.
37.  
38.             StringBuilder sbCookie = new StringBuilder();
39.             sbCookie.Append(string.Concat(key, "=", value));
40.  
41.             if (expiry.HasValue)
42.             {
43.                 DateTime expire = DateTime.UtcNow + expiry.Value; sbCookie.Append(string.Concat(";expires=", expire.ToString("R")));
44.             }
45.  
46.             if (path != null)
47.             {
48.                 sbCookie.Append(string.Concat(";path=", path));
49.             }
50.  
51.             if (domain != null)
52.             {
53.                 sbCookie.Append(string.Concat(";domain=", domain));
54.             }
55.  
56.             if (secure)
57.             {
58.                 sbCookie.Append(";secure");
59.             }
60.  
61.             HtmlPage.Document.SetProperty("cookie", sbCookie.ToString());  // User should handle exceptions if any while writing cookie.
62.  
63.             return true;
64.         }
65.  
66.         public static List<Cookie> GetAllCookieList()
67.         {
68.             string[] cookies = HtmlPage.Document.Cookies.Split(';');
69.             List<Cookie> cookieList = new List<Cookie>();
70.             foreach (string cookie in cookies)
71.             {
72.                 string[] cookieParts = cookie.Split('=');
73.                 if (cookieParts.Count() >= 1)
74.                 {
75.                     cookieList.Add(new Cookie(cookieParts[0].Trim(), cookieParts[1].Trim()));
76.                 }
77.             }
78.  
79.             return cookieList; //User should check for count to know how many cookies are retrieved.
80.  
81.             ////LINQ code
82.             //return (from cookie in cookies
83.             //        select cookie.Split('=')
84.             //            into cookieParts
85.             //            where cookieParts.Count() >= 1
86.             //            select new Cookie(cookieParts[0].Trim(), cookieParts[1].Trim())).ToList(); //User should check for count to know how many cookeies are retrieved.
87.         }
88.  
89.         public static CookieCollection GetAllCookieCollection()
90.         {
91.             string[] cookies = HtmlPage.Document.Cookies.Split(';');
92.             CookieCollection cookieCollection = new CookieCollection();
93.             foreach (string cookie in cookies)
94.             {
95.                 string[] cookieParts = cookie.Split('=');
96.                 if (cookieParts.Count() >= 1)
97.                 {
98.                     cookieCollection.Add(new Cookie(cookieParts[0].Trim(), cookieParts[1].Trim()));
99.                 }
100.             }
101.             return cookieCollection; //User should check for count to know how many cookies are retrieved.
102.  
103.             //LINQ code
104.             //foreach (string[] cookieParts in
105.             //   cookies.Select(cookie => cookie.Split('=')).Where(cookieParts => cookieParts.Count() >= 1))
106.             //{
107.             //    cookieCollection.Add(new Cookie(cookieParts[0].Trim(), cookieParts[1].Trim()));
108.             //}
109.             //return cookieCollection; //User should check for count to know how many cookies are retrieved.
110.         }
111.  
112.         public static string GetCookieAsString(string key)
113.         {
114.             string[] cookies = HtmlPage.Document.Cookies.Split(';');
115.  
116.             foreach (string cookie in cookies)
117.             {
118.                 string[] keyValue = cookie.Split('=');
119.  
120.                 if (keyValue.Length == 2)
121.                 {
122.                     if (keyValue[0].ToString().Trim() == key) //sometime we get one space infront of the cookie so need to Trim()
123.                     {
124.                         return cookie;
125.                     }
126.                 }
127.             }
128.             return null;
129.             //LINQ code
130.             //return (from cookie in cookies
131.             //        let keyValue = cookie.Split('=')
132.             //        where keyValue.Length == 2
133.             //        where keyValue[0].ToString().Trim() == key
134.             //        select cookie).FirstOrDefault();
135.         }
136.  
137.         public static string GetValue(string key)
138.         {
139.             string[] cookies = HtmlPage.Document.Cookies.Split(';');
140.  
141.             foreach (string cookie in cookies)
142.             {
143.                 string[] keyValue = cookie.Split('=');
144.  
145.                 if (keyValue.Length == 2)
146.                 {
147.                     if (keyValue[0].ToString().Trim() == key) //sometime we get one space infront of the cookie so need to Trim()
148.                     {
149.                         return keyValue[1]; //this will return only Value                        
150.                     }
151.                 }
152.             }
153.  
154.             return null;
155.             //LINQ code
156.             //return (from cookie in cookies
157.             //        select cookie.Split('=')
158.             //            into keyValue
159.             //            where keyValue.Length == 2
160.             //            where keyValue[0].ToString().Trim() == key
161.             //            select keyValue[1]).FirstOrDefault();
162.         }
163.  
164.         public static bool DeletCookie(string key)
165.         {
166.  
167.             if (Exists(key, ""))// check if cookie is present or not
168.             {
169.                 DateTime expireDate = DateTime.Now - TimeSpan.FromDays(1); // yesterday
170.                 string expires = ";expires=" + expireDate.ToString("R");
171.                 string cookie = key + "=" + expires;
172.                 HtmlPage.Document.SetProperty("cookie", cookie);
173.                 return true;
174.             }
175.             else
176.             {
177.                 return false;
178.             }
179.         }
180.  
181.         public static bool Exists(string key, string value)
182.         {
183.             if (string.IsNullOrEmpty(key))
184.                 return false; //If key not provided, return false
185.  
186.             return string.IsNullOrEmpty(value)
187.                        ? HtmlPage.Document.Cookies.Contains(key + "=")
188.                        : HtmlPage.Document.Cookies.Contains(key + "=" + value);
189.         }
190.  
191.     }
192. }

Cookie FAQ
http://www.cookiecentral.com/faq/

Silverlight cookies
http://msdn.microsoft.com/en-us/library/dd920298%28v=VS.95%29.aspx

HttpOnly cookies
http://msdn.microsoft.com/en-us/library/system.web.httpcookie.httponly.aspx

Silverlight double click event

We had to perform some business logic when a user double click’s on a Image, unfortunately till the current version of silverilght( version 4.x) there is no double click event. In future versions of silverlight we might get the double click functionality but for right now we will have to get this done by our self. So how do we implement double click event? The trick is to start a timer and check if the MouseLeftButtonDown event is fired again in certain duration(milliseconds).

Code is very simple and short, In the xaml we have a Image with a MouseLeftButtonDown event in the code behind we add a dispatch timer which is a part of  System.Windows.Threading. On the first click start the timer, when next click event is fired check if the timer is active, if the timer is active then it is a double click so go ahead and perform the intended action.

1.    private DispatcherTimer timer;
2.    public MainPage()
3.    {
4.        InitializeComponent();
5.        timer = new DispatcherTimer();
6.        timer.Interval = new TimeSpan(0, 0, 0, 200);
7.        timer.Tick += new EventHandler(( sender,  e) => { timer.Stop(); });
8.    }
9.  
10.    private void Image_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
11.    {
12.        if (!timer.IsEnabled)
13.        {
14.            timer.Start();return;
15.        }
16.        timer.Stop();
17.        HandleDoubleClick();
18.    }

 

DoubleClick Class
The above functionality can be encapsulated in a class for a cleaner looking code. The class ‘DoubleClick’ has a dispatch timer and a public event. In the constructor you pass the UIElement as parameter and hook the MouseLeftButtonDown event. The timer tick event has an inline event handler defined that will stop the timer on the first tick.

1. namespace DoubleClickInSL4
2. {
3.     using System.Windows.Threading;
4.     public class DoubleClick
5.     {
6.         private const int dblclickDelay = 200;
7.         private DispatcherTimer timer;
8.         public event MouseButtonEventHandler MouseDoubleClick;
9.  
10.         public DoubleClick(UIElement uiElement)
11.         {
12.             timer = new DispatcherTimer();
13.             timer.Interval = new TimeSpan(0, 0, 0, dblclickDelay);
14.             timer.Tick += new EventHandler((sender, e) => { timer.Stop(); });
15.  
16.             uiElement.MouseLeftButtonDown += new MouseButtonEventHandler(UIElement_MouseLeftButtonDown);
17.         }
18.  
19.         private void UIElement_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
20.         {
21.             if (!timer.IsEnabled)
22.             {
23.                 timer.Start();
24.                 return;
25.             }
26.             timer.Stop();
27.  
28.             //HandleDoubleClick();
29.             if (MouseDoubleClick != null)
30.             {
31.                 MouseDoubleClick(sender, e);
32.             }
33.         }
34.     }
35. }

 

Rx Framework
A very interesting use of the Rx framework can simplify the above code to just couple of lines. In the MouseLeftButtonDown event we add a Observable.FromEvent  and set TimeInterval, so when the event is fired for the first time the timer starts. On the second event the code in the body of lambda will be executed which checks if  duration is greater then 300.

1. private void Image_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
2. {           
3.    Observable.FromEvent<MouseButtonEventArgs>(this.LayoutRoot, "MouseLeftButtonDown").TimeInterval().Subscribe(evt =>
4.     {
5.         if (evt.Interval.Milliseconds >= 300)
6.         {
7.             // Do something on double click
8.         }
9.     });
10. }

 

Doubleclick Behaviour
The above code is helpful for application that handles the logic directly in the codebehind, so how about MVVM application where the application logic is handled in the model view. A decent solution for such a scenario would be to write a behavior that implements the double click functionality. There are many posts which explain how to create a behaviors so I will not go in details, basically this double click behavior have a dependency property named as DoubleClickCommand that will bind to a property in the view model of type ICommand. I created a class called as DelegateCommand which implements the interface ICommand, this class will be instantiated in the view model and assigned to view models property. 

1. namespace DoubleClickInSL4
2. {
3.     using System.Windows.Threading;
4.     public class DoubleClickBehavior : Behavior<UIElement>
5.     {
6.         private const int dblclickDelay = 200;
7.         private DispatcherTimer timer;
8.  
9.         public object CommandParameter
10.         {
11.             get { return (object)GetValue(CommandParameterProperty); }
12.             set { SetValue(CommandParameterProperty, value); }
13.         }
14.         public ICommand DoubleClickCommand
15.         {
16.             get { return (ICommand)GetValue(DoubleClickCommandProperty); }
17.             set { SetValue(DoubleClickCommandProperty, value); }
18.         }
19.  
20.         public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.Register
21.             ("CommandParameter", typeof(object), typeof(DoubleClickBehavior), new PropertyMetadata(CommandParameterChanged));
22.         private static void CommandParameterChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { }
23.  
24.         public static readonly DependencyProperty DoubleClickCommandProperty = DependencyProperty.Register
25.             ("DoubleClickCommand", typeof(ICommand), typeof(DoubleClickBehavior), new PropertyMetadata(DoubleClickCommandChanged));
26.         private static void DoubleClickCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { }
27.  
28.         public DoubleClickBehavior()
29.         {
30.             timer = new DispatcherTimer();
31.             timer.Interval = new TimeSpan(0,0, 0, 0, dblclickDelay);
32.             timer.Tick += new EventHandler((sender, e) =>
33.             { timer.Stop(); });
34.         }
35.         protected override void OnAttached()
36.         {
37.             base.OnAttached();
38.             AssociatedObject.MouseLeftButtonDown += UIElement_MouseLeftButtonDown;
39.         }
40.         protected override void OnDetaching()
41.         {
42.             base.OnDetaching();
43.             AssociatedObject.MouseLeftButtonDown -= UIElement_MouseLeftButtonDown;
44.         }
45.  
46.         private void UIElement_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
47.         {
48.             if (!timer.IsEnabled)
49.             {
50.                 timer.Start();
51.                 return;
52.             }
53.             timer.Stop();
54.  
55.             //HandleDoubleClick();
56.             if (CommandParameter != null)
57.                 DoubleClickCommand.Execute(CommandParameter);
58.         }
59.     }
60. }
61.  
62. namespace DoubleClickInSL4
63. {
64.      public class DelegateCommand : ICommand   
65.      {   
66.          Func<object, bool> canExecute;   
67.          Action<object> executeAction;   
68.          bool canExecuteCache;   
69.          public DelegateCommand(Action<object> executeAction, Func<object, bool> canExecute)  
70.          {  
71.              this.executeAction = executeAction;
72.              this.canExecute = canExecute;
73.          }  
74.          #region ICommand Members  
75.          public bool CanExecute(object parameter)  
76.          {  
77.              bool temp = canExecute(parameter);
78.              if (canExecuteCache != temp)
79.              {  
80.                  canExecuteCache = temp;
81.                  if (CanExecuteChanged != null)
82.                  {  
83.                      CanExecuteChanged(this, new EventArgs());
84.                  }  
85.              }  
86.              return canExecuteCache;
87.          }  
88.          public event EventHandler CanExecuteChanged;  
89.          public void Execute(object parameter)  
90.          {  
91.              executeAction(parameter);
92.          }  
93.            #endregion
94.      }
95. }

Here is the code for the MainPage.xaml.cs

1. using System;
2. using System.Collections.Generic;
3. using System.Windows;
4. using System.Windows.Controls;
5. using System.Windows.Documents;
6. using System.Windows.Input;
7. using System.Windows.Threading;
8. using System.Windows.Interactivity;
9.  
10. namespace DoubleClickInSL4
11. {    
12.     public class myViewModel
13.     {
14.         public ICommand DoubleCommand { get; set; }
15.         public myViewModel()
16.         {
17.             DoubleCommand = new DelegateCommand(myAction, canExe);
18.         }     
19.         private void myAction(object param)
20.         { //Write your action here }
21.         private bool canExe(object param)
22.         { return true; }
23.     }
24.  
25.     public partial class MainPage : UserControl
26.     {      
27.         public MainPage()
28.         {
29.             InitializeComponent();
30.             Image.DataContext = new myViewModel();
31.         }
32.     }
33. }

 

Here is the xaml for the MainPage.xaml.

1. <UserControl x:Class="DoubleClickInSL4.MainPage"
2.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4.     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
5.     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
6.     xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
7.     xmlns:Local="clr-namespace:DoubleClickInSL4"
8.     mc:Ignorable="d" d:DesignHeight="300" d:DesignWidth="400">
9.     <UserControl.Resources>
10.         <Local:myViewModel x:Name="vm"/>
11.     </UserControl.Resources>
12.     <Grid x:Name="LayoutRoot" Background="White" Height="300" Width="400">
13.         <Image x:Name="Image" Source="Images/80_20.jpg" >
14.             <i:Interaction.Behaviors>
15.                                 <Local:DoubleClickBehavior DoubleClickCommand="{Binding DoubleCommand}" CommandParameter="{Binding ElementName=Image,Path=Source}"/>
16.             </i:Interaction.Behaviors>
17.                                </Image>
18.     </Grid>
19. </UserControl>

Extending Silverlight mouse events

SharpGIS has a very interesting blog post about extending the silverlight mouse events. Including double-clicks they have provided many more extensions with source code and a online demo.
http://www.sharpgis.net/post/2009/05/02/Extending-Silverlighte28099s-mouse-events.aspx

Exam 70-506 ( TS: Silverlight 4, Development )

 
In November I gave the beta exam for silverlight 4, it took me more then four hours to complete the exam questions, review and comment. For beta exams you do not get the score right away, exactly after three months I got an email from Microsoft stating that I passed the beta exam for silverlight  and now I am certified Silverlight 4,Developer.

Silverlight exam is now released and is available through prometric testing centers and the exam number is 70-506. I like  beta exams because they are challenging, one reason is you don't get ready made material to study all you have is MSDN documents, blogs,some samples and forums. There is a huge community support for silverlight and luckily there where some good books in the market. I find many of my fellow programmers worried about not able to find definite material to prepare for the exam. I am going to put together a list of  useful links that will help to prepare for the exam.

Exam details on Microsoft learning.
http://www.microsoft.com/learning/en/us/Exam.aspx?ID=70-506&Locale=en-us#tab2

Some good books
Professional Silverlight 4
Silverlight 4 in Action
Pro Silverlight for the Enterprise
Microsoft Silverlight 4 Data and Services Cookbook

Forums
http://forums.silverlight.net
http://social.msdn.microsoft.com/Forums/eu/silverlightdeveloper/threads

Links

Silverlight Show Getting ready for silverlight exam 70-506
http://www.silverlightshow.net/items/Getting-ready-for-the-exams-Part-1.aspx
http://www.silverlightshow.net/items/Getting-ready-for-Microsoft-Silverlight-Exam-70-506-Part-2.aspx
http://www.silverlightshow.net/items/Getting-ready-for-Microsoft-Silverlight-Exam-70-506-Part-3.aspx
http://www.silverlightshow.net/items/Getting-ready-for-Microsoft-Silverlight-Exam-70-506-Part-4.aspx
http://www.silverlightshow.net/items/Getting-ready-for-Microsoft-Silverlight-Exam-70-506-Part-5.aspx
http://www.silverlightshow.net/items/Getting-ready-for-Microsoft-Silverlight-Exam-70-506-Part-6.aspx
http://www.silverlightshow.net/items/Getting-ready-for-Microsoft-Silverlight-Exam-70-506-Part-7.aspx

Mark’s Blog
http://mark.mymonster.nl/2010/10/25/exam-preparationsilverlight-4-development70-506part-1/
http://mark.mymonster.nl/2010/10/26/exam-preparationsilverlight-4-development70-506part-2/
http://mark.mymonster.nl/2010/10/31/exam-preparationsilverlight-4-development70-506part-3/
http://mark.mymonster.nl/2010/11/01/exam-preparationsilverlight-4-development70-506part-4/
http://mark.mymonster.nl/2010/11/02/exam-preparationsilverlight-4-development70-506part-5/
http://mark.mymonster.nl/2010/11/03/exam-preparationsilverlight-4-development70-506part-6/
http://mark.mymonster.nl/2010/11/04/exam-preparationsilverlight-4-development70-506part-7/

Microsoft training catalog
http://learning.microsoft.com/Manager/Catalog.aspx?qry=silverlight&nav=0&btn=1

Silverlight Documents on MSDN
http://msdn.microsoft.com/en-us/library/cc838158(VS.95).aspx

Silverlight 4 Hands On Labs
http://www.silverlight.net/learn/handsonlabs/

List of all popular books
http://www.silverlight.net/learn/books/

Chanel 9 - What's New in Silverlight 4
http://channel9.msdn.com/Learn/Courses/Silverlight4/Overview

Videos and screen cast
http://www.silverlight.net/learn/videos/all/
http://blogs.msdn.com/b/joestagner/archive/2008/08/01/44-silverlight-videos.aspx
http://sandrinodimattia.net/blog/post/Complete-Expression-Blend-and-Silverlight-5-day-OnRamp-training-course-All-videos-all-assets-download-packages-in-one-place.aspx

 

For developers having right experience the exams are not really tough but I would say the questions are tricky so make sure you have good hands-on experience with silverlight before you appear for the exam. Although the exam focuses on sivlerlight 4, I would say Visual Studio 2010 and Expression Blend are inevitable tools for a silverlight developer. I have tried to put together some of the good links, if you find some more good links please put them in the comments