.NET Development

PageRouteHandler and URL patterns

Gal Ratner — Tue, 07 Sep 2010 17:01:00 GMT

PageRouteHandler resides in System.Web.Routing and implements IRouteHandler. It is designed to be a basic handler for Routes defined in an application, eliminating the need to implement custom IRouteHandlers when there are no business rules to validate. It can also check for access to physical files, and is a good quick solution for basic routing. A little known and not documented feature of PageRouteHandler is the ability to use Route style URL patters in its VirtualPath. URL patters are placeholders enclosed by braces and separated by a literal value, for example: {language}-{country}/{action}. Routes will recognize the URL pattern and use the appropriate Page Route.

Let’s look at how to use URL patterns in our PageRouteHandler. In this example I will assume all the user wants to do is to universally route any requests for pages to the directory “pages”.
In Global.asax register the new route:

void Application_Start(object sender, EventArgs e) 
{
	RegisterRoutes(RouteTable.Routes);
}

public static void RegisterRoutes(RouteCollection routes)
{
	routes.Add(new Route("{page}", new PageRouteHandler("~/pages/{page}")));
}

That’s about it. Quick and easy. Pages will be served from the pages directory with no need for any custom handlers.

Creating free shaped windows in WPF

Gal Ratner — Sat, 28 Aug 2010 00:57:00 GMT

WPF Allows for transparent windows which can help shape our desktop program to anything we can drew. In a few simple steps we can make a triangular program window. Here is how:

In the main application window, set two values:

Background="Transparent" AllowsTransparency="True"

Use XAML to draw whatever shape you want your window to be. In our case I chose a triangle surrounded by an ellipse

<Ellipse StrokeThickness="3" Stroke="#FF8F0000" />
        <Polygon
    Points="0,200 800,0 800,400"
    Stroke="Purple" 
    StrokeThickness="2" MouseLeftButtonDown="Polygon_MouseLeftButtonDown">
            <Polygon.Fill>
                <SolidColorBrush Color="Blue" Opacity="0.4"/>
            </Polygon.Fill>
        </Polygon>

All that is left now is to capture and handle MouseLeftButtonDown in order to help drag the window arround the screen.

private void Polygon_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
  DragMove();
}

The finished window looks like this:

This looks and feels great and can really enhance user experience.

Having some fun with the ListView control in ASP.NET

Gal Ratner — Sun, 25 Jul 2010 03:11:00 GMT

The ListView control is a natural progression of the GridView. It displays data by using user-defined templates instead of row fields, allowing for layout flexibility. Paging, sorting, inserting and editing records are all built into a ListView, and, can be greatly manipulated both in the layout and functionality.
Let’s look at some cool features we can implement on our own ListView. For the sake of this article I have created a basic ListView that has an ObjectDataSource along with an in memory list of customers. CRUD methods are implemented using LINQ to objects and all the ObjectDataSource uses methods to select, delete and update the ListView.

<asp:ObjectDataSource 
                ID="ObjectDataSource1"
                runat="server" 
                DataObjectTypeName="Customer"
                DeleteMethod="DeleteCustomer" 
                InsertMethod="AddCustomer"
                SelectMethod="GetCustomers"
                SelectCountMethod="GetCustomerCount"
                EnablePaging="true"
                StartRowIndexParameterName="startRowIndex"
                MaximumRowsParameterName="maxRecords"
                TypeName="CustomerDatabase"
                UpdateMethod="UpdateCustomer">
                <SelectParameters>
                    <asp:Parameter Name="SortExpression" DbType="String" ConvertEmptyStringToNull="true" />
                </SelectParameters>
                </asp:ObjectDataSource>

This is how our ListView looks:

Now let’s start adding some features to it.

Saving multiple rows with changes detection.

By default, we can only edit one row at a time. Editing a row will set the EditIndex property of the view to the row we are currently editing and use the EditItemTemplate to lay out the input controls. Let’s change that and allow multiple row save. First let’s add a button at the bottom of the List next to the DataPager and add an event that saves all the rows.

protected void SaveAllButton_Click(object sender, EventArgs e)
    {
        foreach (ListViewDataItem lv in this.ListView1.Items)
        {
            if (lv.ItemType == ListViewItemType.DataItem)
            {
                this.ListView1.UpdateItem(lv.DataItemIndex, true);
            }
        }
        this.ListView1.EditIndex = -1;
        SetItemsLayout();
    }

Off course we cannot simply save the entire ListView. If we have a screen with 100 records we cannot send 100 update statements to the database if we only changed two rows so let’s try and detect if a row actually changed and only update the rows that changed. We can do that by using the event onitemupdating and checking for this row’s old values against the new values:

protected void ListView1_ItemUpdating(object sender, ListViewUpdateEventArgs e)
    {
        Customer originalValues = (Customer)ViewState[e.ItemIndex.ToString()];
        if (originalValues == null)
            return;
 
        bool isDirty = false;
        object columnValue;
        foreach (DictionaryEntry de in e.NewValues)
        {
            columnValue = typeof(Customer).GetProperty(de.Key.ToString()).GetValue(originalValues, null);
            if (de.Value != null && de.Value.ToString() != columnValue.ToString())
            {
                isDirty = true;
                MessageLiteral.Text = "Data Saved";
            }
        }
        e.Cancel = !isDirty;
    }

Only when a row is dirty we go ahead and continue with the update operation. You notice that the old values are kept in the ViewState. We load them in OnItemDataBound:

 protected void ListView1_ItemDataBound(object sender, ListViewItemEventArgs e)
    {
        ListViewDataItem dataItem = (ListViewDataItem)e.Item;
        if (dataItem != null)
            ViewState[dataItem.DataItemIndex.ToString()] = dataItem.DataItem;
    }

Editing columns

If you notice the little pencil icon near the header columns its function is to allow users to edit all the rows of a column. It does that by replacing the labels that display the row values with text boxes.

This is pretty simple. It requires that we remember what columns are now editable and simply hide the labels in the table cells and show the text boxes and the validators:

/// <summary>
    /// Set layout on all rows
    /// </summary>
    private void SetItemsLayout()
    {
        foreach (ListViewDataItem lv in this.ListView1.Items)
        {
            if (lv.ItemType == ListViewItemType.DataItem)
                SetEditableItem(lv);
        }
    }
 
    /// <summary>
    /// Set layout on one row. This will set a column to be visible and editable
    /// </summary>
    /// <param name="lv"></param>
    private void SetEditableItem(ListViewDataItem lv)
    {
        if (lv.ItemType != ListViewItemType.DataItem)
            return;
        ControlCollection controls = lv.Controls;
        SetVisibleItem(controls);
    }
 
    /// <summary>
    /// Show and hide visible elements in one table row
    /// </summary>
    /// <param name="controls"></param>
    private void SetVisibleItem(ControlCollection controls)
    {
        LoadEditbleColumns();
        Control control;
        IEnumerator en = controls.GetEnumerator();
        while (en.MoveNext())
        {
            control = (Control)en.Current;
            if (control.ID == null)
                continue;
            if (control is HtmlTableCell)
            {
                control.Visible = true;
                // Show and hide the elements inside the cell
                SetEditableItem(control.Controls);
            }
        }
    }
 
    /// <summary>
    /// Show and hide editble elements on one cell
    /// </summary>
    /// <param name="controlCollection"></param>
    private void SetEditableItem(ControlCollection controls)
    {
        Control control;
        bool showVisible = true;
        IEnumerator en = controls.GetEnumerator();
        while (en.MoveNext())
        {
            showVisible = true;
            control = (Control)en.Current;
            if (control.ID == null)
                continue;
 
            // Check if this control is in the editable column list
            if (EditbleColumns.Where(c => control.ID.ToLower().Contains(c.ToLower())).Count() > 0)
                showVisible = true;
            else
                showVisible = false;
 
            if (control is TextBox || control is CheckBox || control is BaseValidator)
                control.Visible = showVisible;
            else
                control.Visible = !showVisible;
        }
    }

This also requires us to add a runat=”server” along with an ID attributes to all of our table cells.

Sorting beyond the current results in a paged ListView

A ListView uses its CommandName="Sort” to set the SortExpression in order to sort all the currently visible rows on the screen. But, what happens when we have a database table with many records and we need to sort the data beyond the current page? Well in this article I won’t teach how to do it with a stored procedure, simply because I don’t use a database for this example, however, the principles I am about to show you now apply beyond LINQ to object into LINQ to SQL, Entities and pure SQL statements. I have added a LinkButton to the header of each column with the CommandName="Sort”

<asp:LinkButton runat="server" ID="SortLinkButton1" Text="CustomerID" CommandName="Sort" CommandArgument="CustomerID"/>

And used the sort event in order to concatenate a string that will hold the sort expression

protected void ListView1_Sorting(object sender, ListViewSortEventArgs e)
    {
        if (String.IsNullOrEmpty(e.SortExpression)) { return; }
        string direction = "";
        if (ViewState["SortDirection"] != null)
            direction = ViewState["SortDirection"].ToString();
 
        if (direction == "ASC")
            direction = "DESC";
        else
            direction = "ASC";
 
        ViewState["SortDirection"] = direction;
 
        string[] sortColumns = e.SortExpression.Split(',');
        string sortExpression = sortColumns[0] + " " + direction;
        for (int i = 1; i < sortColumns.Length; i++)
            sortExpression += ", " + sortColumns[i] + " " + direction;
        ObjectDataSource1.SelectParameters["SortExpression"].DefaultValue = sortExpression;
        ObjectDataSource1.Select();
        e.Cancel = true;
    }

The ListView’s default event is canceled each time. We don’t need it. We use our own and if you noticed the parameter SortExpression in the SelectParameters collection of the ObjectDataSource at the top of the page, you also notice that we use it now in order to load the expression we concatenated. This sort expression will be sent to the select method and be processed in our Data Layer:

 public static List<Customer> GetCustomers(int startRowIndex, int maxRecords, string SortExpression)
    {
        if (string.IsNullOrWhiteSpace(SortExpression))
            return Customers.Skip(startRowIndex).Take(maxRecords).ToList();
        else
            return Customers.AsQueryable().OrderBy(SortExpression).Skip(startRowIndex).Take(maxRecords).ToList();
    }

In order to use a string onside a LINQ statement I utilized the library System.Linq.Dynamic that is avaible as a part of the LINQ Visual Studio code samples. The result is a true data sort that goes behond the current screen.

Input validation with enterprise library’s validation block

Enterprise library 5.0’s validation block has some cool ASP.NET, WCF and WPF integration. I chose to use object attributes on my data objects along with a PropertyProxyValidator. The principle is simple. ValidationAttribute is a part of System.ComponentModel.DataAnnotations and was created for Dynamic Data. If you coded some MVC you are probably familiar with it. ET simply extended it for more functionality. Let’s see how this comes together:

Our data object looks like:

[Serializable()]
public class Customer
{
    [RangeValidator(0, RangeBoundaryType.Exclusive, 999, RangeBoundaryType.Inclusive)] 
    public int CustomerID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    [RegexValidator(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*", MessageTemplate="Email not valid")]
    public string Email { get; set; }
}

And validating the email address on the UI looks like:

<asp:TextBox ID="EmailTextBox" runat="server" Text='<%# Bind("Email") %>' />
                                <EntLibValidators:PropertyProxyValidator
                                    ID="EmailValidator" 
                                    ValidationGroup="Insert"
                                    runat="server"
                                    ControlToValidate="EmailTextBox"
                                    PropertyName="Email"
                                    SourceTypeName="Customer"
                                    OnValueConvert="EmailValidator_ValueConvert">
                                    </EntLibValidators:PropertyProxyValidator>

With the a format validation

 protected void EmailValidator_ValueConvert(object sender, ValueConvertEventArgs e)
    {
        e.ConvertedValue = e.ValueToConvert as string;
    }

This creates the following error messages to appear when we have an invalid input:

Conclusion

As you can see the ListView is a good step forward and is certainly a good base to build on when you are trying to display any tabular data. There are many more features available to explore and I hope to expand on them in a later blog post. I have also attached the complete code example as a Visual Studio website and it is available for download at the bottom of this post.

Eliminating the duplicate String Connection in a Custom Rewrite Provider for URL Rewrite Module

Gal Ratner — Sat, 19 Jun 2010 03:04:00 GMT

I was reading a tutorial from Ruslan Yakushev titled Developing a Custom Rewrite Provider for URL Rewrite Module on iis.net the other day and decided to give it a try.

I downloaded the samples and rewrote the DB Provider with my own logic. The result was good, but, the module uses its one configuration section.

It’s great if you have access to the IIS Manager and can quickly pick up keys and assign them values, however, you can end up with duplicate application keys or connection strings.

The module is relaying on an implementation of IProviderDescriptor to expose its settings to IIS Manager. Since a DB Provider needs a connection to a database, the sample module, which uses its own connection string in the provider settings section, creates a duplicate, and unnecessary connection string.

The application’s connection string was in a file called connectionstrings.config referenced by a configsource in the connectionStrings section like so:

<connectionstrings configsource="connectionStrings.config"></connectionstrings>

I needed a way to access this value from the module in order to use the connection string I got. I tried ConfigurationManager.ConnectionStrings["StringConnection"].ConnectionString, but, this only returned the connection string in the machine.config. then I turned to serverManager.GetWebConfiguration and WebConfigurationManager.OpenWebConfiguration both proved to be ineffective.

Although the module is loaded to the worker process of the application pool, I encountered security errors and the module simply couldn’t use the main settings in web.config.

The solution came from Richard Marr, an escalation engineer on the IIS support team at Microsoft. Richard is a true IIS guru and he suggested a combination of direct fso access to the file containing the connection string along with passing the module the relative path of the web application by use of the tag {DOCUMENT_ROOT} in the module’s settings section. This tag was developed for the file rewrite provider and proved to be useful in this case. Pointing the module to the connection string file looked like:

<add key="StringConnectionPath" value="{DOCUMENT_ROOT}\connectionStrings.config" />

From there on it was just a matter of parsing the XML . Here in the complete example

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using System.Xml.Linq;
using Microsoft.Web.Iis.Rewrite;
 
public sealed class SqlDBRewriteProvider : IRewriteProvider, IDisposable
{
    private Timer timer;
    private IRewriteContext rewriteContext;
    IDictionary<string, string> settings;
    string connectionString = string.Empty;
    private string storedProcedure = string.Empty;
 
    public void Initialize(IDictionary<string, string> settings, IRewriteContext rewriteContext)
    {
        this.rewriteContext = rewriteContext;
        this.settings = settings;
        string stringConnectionPath = string.Empty;
        string stringConnectionName = string.Empty;
        // Get the connection string from the name and path
        if (settings.TryGetValue("StringConnectionPath", out stringConnectionPath) && settings.TryGetValue("StringConnectionName", out stringConnectionName))
        {
            XDocument doc = XDocument.Load(stringConnectionPath);
            if (doc == null)
                throw new Exception("cannot load string connection file");
            var connectionStringElement = doc.Descendants("add").Where(e => e.Attribute("name").Value == stringConnectionName).FirstOrDefault();
            if (connectionStringElement == null)
                throw new Exception("connection string not found");
            connectionString = connectionStringElement.Attribute("connectionString").Value;
        }
        // Get the sproc
        settings.TryGetValue("StoredProcedure", out storedProcedure);
        // CacheMinutesInterval is an optional parameter.
        string minutesString;
        if (settings.TryGetValue("CacheMinutesInterval", out minutesString))
        {
            int minutes = 0;
            if (!string.IsNullOrEmpty(minutesString) && int.TryParse(minutesString, out minutes) && minutes > 0)
            {
                int period = minutes * 60 * 1000;
                this.timer = new Timer(TimerCallback, null, period, period);
            }
        }
    }
    [SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities")]
    public string Rewrite(string value)
    {
        using (SqlConnection connection = new SqlConnection(this.connectionString))
        {
            using (SqlCommand command = connection.CreateCommand())
            {
                command.Parameters.Add("@Input", SqlDbType.NVarChar).Value = value;
                command.CommandType = CommandType.StoredProcedure;
                command.CommandText = this.storedProcedure;
                connection.Open();
                return (string)command.ExecuteScalar();
            }
        }
    }
    private void TimerCallback(object state)
    {
        if (this.rewriteContext != null)
        {
            this.rewriteContext.ClearRewriteCache();
        }
    }
    public void Dispose()
    {
        if (this.timer != null)
        {
            this.timer.Dispose();
            this.timer = null;
        }
        this.rewriteContext = null;
        GC.SuppressFinalize(this);
    }
}

This the Module's config section:

<system.webServer>
    <rewrite>
      <providers>
        <provider name="DB" type="SqlDBRewriteProvider, IISRewrite, Version=1.0.0.0, Culture=neutral, PublicKeyToken=cbbd7bb4d6722457">
          <settings>
            <add key="StringConnectionPath" value="{DOCUMENT_ROOT}\connectionStrings.config" />
            <add key="StringConnectionName" value="StringConnection" />
            <add key="StoredProcedure" value="GetRoute" />
            <add key="CacheMinutesInterval" value="10" />
          </settings>
        </provider>
      </providers>
      <rules>
        <rule name="RewriteUserFriendlyURL1" stopProcessing="true">
          <match url="(.*)" />
          <conditions>
            <add input="{DB:{R:1}}" pattern="(.+)" />
          </conditions>
          <action type="Rewrite" url="{C:1}" />
        </rule>
      </rules>
    </rewrite>
  </system.webServer>

Big thank you to Richard. You can find his excellent blog here: http://blogs.iis.net/richma

Write your own OutputCacheProvider

Gal Ratner — Sun, 06 Jun 2010 03:53:00 GMT

What is output caching?

Output caching is a way of caching the generated HTML created from your ASP.NET pages. Output caching can cache an entire page or fragments of a page. The first request to a page is served dynamically, and then any subsequent requests are served from the output cache until the specified time expires.

how to use output caching?

It’s simple, just place the @ OutputCache directive like so <%@ OutputCache Duration="120" VaryByParam="None" %>, or programmatically set the PartialCachingAttribute on your pages or controls. Remember, once you have done that, any postbacks in the page will not work.

Where that ASP.NET keep the cached output?

By default ASP.NET keeps the cache in memory, you can change this to keep the cache in files, a remote server or anywhere you like by overriding the default OutputCacheProvider and writing your own implementation.

Creating your own OutputCacheProvider

In order to create a custom cache provider you need to inherit from the class OutputCacheProvider and override four methods: Add, Get, Remove and Set

Add: Inserts the specified entry into the output cache. If an entry already exists, this method should return the value already in the cache.
Get: Returns a reference to the specified entry in the output cache.
Remove: Removes the specified entry from the output cache.
Set: Inserts the specified entry into the output cache, overwriting the entry if it is already cached.

For my example implementation I chose a smart cache system. I have four modes users can set:

Memory: will keep the cache in memory. I chose a ConcurrentDictionary since it is thread-safe.
Files: each item will be stored in a file in the cache directory. I am going to use a BinaryFormatter in order to read and write objects from and to disk.
Compressed: same as files, however, to save disk space, objects will be stored as zip files.
Auto: will alternate between memory and files modes. Memory will be used if the amount of available memory on your system is more than 60 percent, beyond that, the cache will identify your system is getting low on memory and switch to files mode.

Let’s take a look at the class:

/// <summary>

/// Inserts the specified entry into the output cache.

/// </summary>

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

/// <param name="entry"></param>

/// <param name="utcExpiry"></param>

/// <returns></returns>

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

{

// If the item exists, return the item

object existingItem = Get(key);

if (existingItem != null)

return existingItem;

// If the item doesnt exist. Add it to the cache

Set(key, entry, utcExpiry);

return entry;

}

/// <summary>

/// Returns a reference to the specified entry in the output cache.

/// </summary>

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

/// <returns></returns>

public override object Get(string key)

{

CacheMode cacheMode = Utils.GetCacheMode();

var cacheItem = Utils.ConcurrentCache.AsParallel().Where(c => c.Key == key && c.Value.UtcExpiry >= DateTime.Now.ToUniversalTime()).FirstOrDefault();

if (cacheItem.Key == null)

return null;

if (cacheMode == CacheMode.Compressed)

return IO.ReadCompressedFile(key);

else if (cacheItem.Value.ItemValue != null) // Check the memory first

return cacheItem.Value.ItemValue;

else

return IO.ReadFile(key);

}

/// <summary>

/// Removes the specified entry from the output cache.

/// </summary>

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

public override void Remove(string key)

{

CachItem cacheObject = new CachItem();

Utils.ConcurrentCache.TryRemove(key, out cacheObject);

string fileKey = Utils.GetCacheFileName(key);

if (File.Exists(Utils.CacheLocation + fileKey))

File.Delete(Utils.CacheLocation + fileKey);

}

/// <summary>

/// Inserts the specified entry into the output cache, overwriting the entry if it is already cached.

/// </summary>

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

/// <param name="entry"></param>

/// <param name="utcExpiry"></param>

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

{

CacheMode cacheMode = Utils.GetCacheMode();

CachItem cacheObject = new CachItem() { UtcExpiry = utcExpiry };

if (cacheMode == CacheMode.Compressed)

IO.WriteCompressedFile(key, entry);

else if (cacheMode == CacheMode.Files)

IO.WriteFile(key, entry);

else

cacheObject.ItemValue = entry;

Utils.ConcurrentCache.AddOrUpdate(key, cacheObject, (oldKey, oldValue) => cacheObject);

}

Configuration changes:

Inside web.config locate system.web and add:

</providers>

</outputCache>

</caching>

I have attached ConcurrentCache.cs to this post and also added the entire example solution to codeplex at http://concurrentcache.codeplex.com/ so feel free to check it out and plug it into your applications.

Convert an int array to a byte array and back

Gal Ratner — Wed, 26 May 2010 05:20:00 GMT

I recently needed to convert an array of integers to an array of bytes in order to work with an existing database design. I looked online and couldn’t find a function to convert between the two types so I wrote my own.

Convert int[] to byte[]:

public static byte[] GetByteArrayFromIntArray(int[] intArray)
        {
            byte[] data = new byte[intArray.Length * 4];
            for (int i = 0; i < intArray.Length; i++)
                Array.Copy(BitConverter.GetBytes(intArray[i]), 0, data, i * 4, 4);
            return data;
        }

Convert back to int[]:

public static int[] GetIntArrayFromByteArray(byte[] byteArray)
        {
            int[] intArray = new int[byteArray.Length / 4];
            for (int i = 0; i < byteArray.Length; i += 4)
                intArray[i / 4] = BitConverter.ToInt32(byteArray, i);
            return intArray;
        }

*Notice BitConverter.GetBytes will always return a 4 byte array.

Hope you find this usefull.

Partial object deep copy with extension methods

Gal Ratner — Thu, 06 May 2010 05:40:00 GMT

Deep copy is the process of cloning a complete object into new object of the same type. All of the member values are being copied into new memory addresses and the clone will not be effected by any changed to the original object.
If you need to perform a partial deep clone, a cloning method that simply copied values of fields from one object into another object of the same type, without creating a new perfect clone, you might find this extension method useful.

public static class ObjectExtensions
    {
        /// <summary>
        /// Copy all of the public properties between the objects
        /// </summary>
        /// <typeparam name="T">The type of the object</typeparam>
        /// <param name="copyFrom">The source</param>
        /// <param name="copyTo">The destination</param>
        /// <param name="copyParentProperties">Copy any properties from parent types</param>
        public static void CopyTo<T>(this T copyFrom, T copyTo, bool copyParentProperties)
        {
            PropertyInfo[] props;
            if(copyParentProperties)
                props = typeof(T).GetProperties();
            else
                props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
 
            for (int i = 0; i < props.Length; i++){
                var propertyValue = copyFrom.GetType().GetProperty(props[i].Name).GetValue(copyFrom, null);
                copyTo.GetType().GetProperty(props[i].Name).SetValue(copyTo, propertyValue, null);
            }
        }

Usage looks like this:

mySource.CopyTo<myType>(myDestination, false);

Enjoy.

A quick lap around .NET 4.0’s parallel features.

Gal Ratner — Sat, 24 Apr 2010 05:59:00 GMT

What is parallelism and why should I care?

As computers today are reaching the practical limits of clock speeds, you are likely to find your program running as fast, or as slow, on newer machines, as they are on your older box. CPU manufacturers have bypassed the clock speed block issue by assembling multi core CPUs. A CPU with two or four cores is pretty standard in the market. In fact, my own development box is a quad core. So how can you capitalize on a multi core machine and speed up your program? One thread can only run on one core at one time. If cores are not clocking faster, threads are not running faster. The solution is to try and redistribute your threads evenly across all cores. The idea behind parallelism is to have the same operation performed concurrently on as many cores as you have available, or as many as you specify. Each core is in charge of a small amount of work and is kept constantly busy. At the end of the task, data is joined from all cores and signals to your program the operation has finished.

Wow sounds good. How can I use it in my code?

Since this is a practical guide, designed to get you started on your way to parallel perfection I am going to break down the classes and show you code you can use, rather than go on and on about the theory of forking work between cores.

First let’s start with what’s new in the framework. There are two new namespaces:

System.Threading.Tasks – This namespace contains the Task Parallel Library (TPL). You can think about Tasks as glorified Threads for now. We will get to Tasks later in this article.
System.Collections.Concurrent – Contains thread-safe collection classes that are used when multiple threads are accessing the collections concurrently
There are also enhancements to System.Linq in order to accommodate PLINQ

New data types

System.Collections.Concurrent Contains new thread safe data types you can leverage when you use tasks. The types I find most useful are:
BlockingCollection<T>
ConcurrentBag<T>
ConcurrentDictionary<TKey, TValue>
ConcurrentQueue<T>
ConcurrentStack<T>

Let’s look how we can leverage BlockingCollection in a snippet of concurrent code. BlockingCollection implements IProducerConsumerCollection<T> and is designed to allow multiple threads to add and remove elements. This collection will block until there are elements to be removed.

BlockingCollection<int> bc = new BlockingCollection<int>();

Task t1 = Task.Factory.StartNew(() =>

{

bc.Add(1);

bc.CompleteAdding();

});

Task t2 = Task.Factory.StartNew(() =>

{

try

{

while (true) bc.Take();

}

catch (InvalidOperationException)

{

Console.WriteLine("This collection is completed");

}

});

Task.WaitAll(t1, t2);

Task Parallel Library (TPL)

Tasks represent asynchronous operations, much like Threads. Under the hood, tasks are composed of multiple threads, locking, scheduling and internal pools, make sure Tasks scale across all cores.
When dealing with Tasks you can use Task.Factory.StartNew and pass in delegates as your methods to execute along with execution options, or you can simply start a new Task. This is equivalent to using the default thread pool vs. instantiating new threads.

Task<int> t1 = new Task<int>(() => 1);

Task<int> t2 = t1.ContinueWith((antecedent) =>

{

return 1 + antecedent.Result;

});

t1.Start();

Console.WriteLine(t2.Result);

Parallel loops

System.Threading.Tasks.Parallel contains the implementation for simple parallel loops. For and ForEach are supported as well as invoke, which executes an array of Actions. Here is an example of a parallel For loop:

ParallelOptions options = new ParallelOptions();

options.CancellationToken = ct;

Parallel.For(0, Settings.Instance.Images.Count, options, i =>

{

//Do Something

});

}, ct);

Parallel LINQ (PLINQ)

System.Linq was enhanced new classes, one of them is ParallelEnumerable. This class contains the added parallel implementation of LINQ and is super easy to use. Every LINQ query you have can run in parallel by simply adding the keyword AsParallel in the query. You can also set WithDegreeOfParallelism that will signal the query how many cores to use.

var data = from myURL in URLs.AsParallel().WithDegreeOfParallelism(numConcurrentRetrievals)

select (new WebClient()).DownloadData(myURL);

Cancelling a parallel operation

To cancel any task or a parallel loop you can use a CancellationTokenSource that signals a CancellationToken a Cancellation has been requested. CancellationToken Is a part of ParallelOptions usage looks like:

CancellationTokenSource cSource = new CancellationTokenSource();

CancellationToken ct = cSource.Token;

var t = Task.Factory.StartNew(() =>

{

ParallelOptions options = new ParallelOptions();

options.CancellationToken = ct;

Parallel.For(0, Settings.Instance.Images.Count, options, i =>

{

try

{

// Do something

}

catch (OperationCanceledException ex)

{

}

});

}, ct);

t.Wait();

You can also use WithCancellation() if you are trying to cancel a PLINQ operation.

When to parallelize?

That’s a good question. Not all threads need to become Tasks and not all LINQ queries need to be AsParallel. Sometimes the overhead of creating the underlying infrastructure can actually slow your code down. Try and parallelize (is that a word? ) when you execute operations that you already multithread and measure the execution time gained or lost. Parallelize when you clearly see one busy core along with idle cores. The most important thing is to test and measure using real life data and decide for yourself if certain segments of code can benefit from running using TPL or PLINQ.

To get you started, here is a little function I wrote in order to copy files between folders. The original function was large and clumsy and used the thread pool in order to multithread file copy.
The new function, simply parallelize the copy operation.
Old:

public void SpeedCopyFolder(DirectoryInfo source, DirectoryInfo target, bool overrideExisting)

{

using (ManualResetEvent mre = new ManualResetEvent(false))

{

int threadCount = 0;

foreach (FileInfo fi in source.GetFiles())

{

Interlocked.Increment(ref threadCount);

// Create a thread for each file

FileInfo file = new FileInfo(fi.FullName); // Created for the delegate scope

ThreadPool.QueueUserWorkItem(delegate

{

try

{

if (File.Exists(Path.Combine(target.ToString(), file.Name)) && !overrideExisting)

return;

fi.CopyTo(Path.Combine(target.ToString(), file.Name), overrideExisting);

}

catch (Exception e)

{

}

if (Interlocked.Decrement(ref threadCount) == 0) mre.Set();

});

}

if (Interlocked.Decrement(ref threadCount) == 0) mre.Set();

mre.WaitOne();

}

New:

public static void CopyFiles(string fromFolder, string toFolder)

{

Parallel.ForEach<string>(Directory.EnumerateFiles(fromFolder, "*"), f =>

{

File.Copy(f, toFolder + @"\" + Path.GetFileName(f), true);

});

}

That was a quick lap around the major components in the new parallel features of .NET 4.0. it is by no means a deep article and I am sure you will discover much more to it as you explore and start programming in Visual Studio 2010.

Enjoy and remember to always try and speed up your code!

How to detect a mobile device in ASP.NET

Gal Ratner — Thu, 04 Mar 2010 06:54:00 GMT

If you have a mobile version of your site, you probably need to detect and redirect users on mobile devices that navigate into the main site. It’s easy in ASP.NET you can just call

Request.Browser.IsMobileDevice

Request.Browser["IsMobileDevice"]

Or even

System.Web.HttpBrowserCapabilities myBrowserCaps = Request.Browser;
((System.Web.Configuration.HttpCapabilitiesBase)myBrowserCaps).IsMobileDevice;

You also need to add <httpRuntime useFullyQualifiedRedirectUrl = "true" /> if you’re doing any redirects with mobile since This sends a fully qualified URL to the client with asession ID.
But what happens under the hood and why doesn’t ASP.NET detect my new phone? Well it’s simple. ASP.NET uses the request’s User-Agent and matches it to one of the Browser Definition Files. The default files are in C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG\Browsers and since they don’t get updated often, there is a good chance your new phone is not recognized. Luckily you can create your own browser files by simply creating a folder named App_Browsers and composing your own files. It’s great, but, not very practical. Unless you keep track of every new phone that comes out to the market and have the time to keep updating your files, you will quickly find yourself wishing there was some sort of ready file you could use.

Codeplex to the rescue

Mobile Device Browser File is a project on codeplex that gets regular updates and contains most of the new devices on the market. You can download it here: http://mdbf.codeplex.com/ installation is super simple. Just Copy the mobile.browser file into the "App_Browsers\Devices" folder. If you don’t have any, create one.

That’s it. Your site can now detect most of the new mobile devices on the market.

Application.StaticObjects is empty in an ASP.NET precompiled website

Gal Ratner — Thu, 25 Feb 2010 03:56:00 GMT

Application.StaticObjects holds all of the objects that have been defined using <object runat="server" scope="Application"> </object> tags in Global.asax. I defined my own object and used it in the Application_OnStart() event. It worked inside visual studio; however, it failed on the server. The event fired just fine, but, the object wasn’t there at all. Application.StaticObjects was empty. After looking into it I discovered that the site simply ignored any object tags. The solution was to copy Global.asax into the recompiled site’s directory. Maybe this bug can be fixed sometime in the future. For now, if you need any StaticObjects, you might have to use a non compiled version of Global.asax.

Get SQL Parameters From an Object Revisited.

Gal Ratner — Wed, 24 Feb 2010 05:35:00 GMT

I have my own custom data layer adapter. Its pretty slick and you probably know it by now if you read my blog post Move a DataReader to an Object with reflection Revisited. If you downloaded and are using the file ObjectHelper.cs you probably noticed a method called GetSQLParametersFromPublicProperties. This method returns an array of SqlParameters from a live object. You can use this array if you are invoking a Stored Procedure and need to send some parameters into it. Something like:

public int AddCustomer(Customer customer)
        {
            try
            {
                SqlParameter[] paramArray = ObjectHelper.GetSQLParametersFromPublicProperties(customer);
                customer.CustomerID = Convert.ToInt32(SqlHelper.ExecuteScalar(SqlHelper.mainConnectionString, CommandType.StoredProcedure, "AddCustomer", paramArray));
            }
            catch (Exception e)
            {
                throw new Exception("Error Adding Customer", e);
            }
            return customer.CustomerID;
        }

A friend of mine was using this function today. He was converting a system from NHibernate to ObjectHelper and needed something I was missing. He needed to skip some fields when creating the SqlParameter array. He was executing an Insert sproc and he didn’t need the object ID as a parameter. It was a field that was auto generated by the Insert statement. He then asked me for a way to hide object fields at will so that the function will only return the parameters he needed and suggested NHibernate like attributes on the fields he needed to hide. This is a great idea and I immediately went to work on implementing it.
First I added a new custom attribute. I created a new class that derived from System. Attribute:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace InvertedSoftware.ShoppingCart.DataLayer.DataAttributes
{
    [Flags]
    public enum CrudFieldType
    {
        Create = 0x01,
        Read = 0x02,
        Update = 0x04,
        Delete = 0x08,
        DontUse = 0x10
    }
 
    public class CrudField : Attribute
    {
        public CrudFieldType UsedFor { get; set; }
    }
}

I used a bit enum to allow multiple operations on the same field and simply left the ones I didn’t need behind. Then I added an attribute to my Data Object

 public class Customer
    {
        [CrudField(UsedFor = CrudFieldType.Delete | CrudFieldType.Read | CrudFieldType.Update)]
        public int CustomerID { get; set; }
    }

Finally I re wrote the function to ignore a field based on the operation type we specify:

public static SqlParameter[] GetSQLParametersFromPublicProperties(object dataObject, CrudFieldType usedFor)
        {
            Type type = dataObject.GetType();
            PropertyInfo[] props = type.GetProperties();
            List<SqlParameter> paramList = new List<SqlParameter>();
            for (int i = 0; i < props.Length; i++)
            {
                if (props[i].PropertyType.IsValueType || props[i].PropertyType.Name == "String")
                {
                    object fieldValue = type.InvokeMember(props[i].Name, BindingFlags.GetProperty, null, dataObject, null);
                    CrudField usedForAttr = Attribute.GetCustomAttribute(props[i], typeof(CrudField)) as CrudField;
                    if (usedForAttr != null && (usedForAttr.UsedFor & usedFor) == usedFor)
                    {
                        SqlParameter sqlParameter = new SqlParameter("@" + props[i].Name, fieldValue);
                        paramList.Add(sqlParameter);
                    }
                    else if (usedForAttr == null)
                    {
                        SqlParameter sqlParameter = new SqlParameter("@" + props[i].Name, fieldValue);
                        paramList.Add(sqlParameter);
                    }
                }
            }
            return paramList.ToArray();
        }

The end result was the ability to have granular control over what parameters we send into the sproc and was still backward compatible with older versions of ObjectHelper. Data objects without the CrudField attribute will be handled in a similar way to the old version and will always be included in the returned array.
Thank you Jason for the idea! You can find Jason Brown here and he is always available for consulting.
I have attached the new ObjectHelper to this post. I hope you all find it as useful as I have.

Create a faster Repeater

Gal Ratner — Tue, 23 Feb 2010 05:26:00 GMT

A Repeater, as we all know is the fastest of the data bound controls. It does not include any UI elements or even paging. This allows it to be light and fast.
What happens if even the Repeater is too heavy for our app? It’s simple, let’s write our own repeater.
The first step in our Repeater is its items class. We are going to hold our own data object; however, we still need to implement IDataItemContainer. This will help in data binding operations.
Let’s say our data object looks something like this:

public class MyDataObject
{
  public string FirstName { get; set; }
  public string LastName { get; set; }
}
 

Our Repeater item will hold this object as its data item like so:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Web.UI;
 
namespace InvertedSoftware.CustomControls
{
    public enum FastRepeaterItemType
    {
        Header = 1,
        Footer = 2,
        Item = 3
    }
 
    [
    ToolboxItem(false)
    ]
    public class FastRepeaterItem : Control, IDataItemContainer
    {
        public FastRepeaterItem(int itemIndex, FastRepeaterItemType itemType)
        {
            this.itemIndex = itemIndex;
            this.itemType = itemType;
        }
 
        private MyDataObject dataItem;
 
        public virtual object DataItem
        {
            get
            {
                return dataItem;
            }
            set
            {
                dataItem = value as MyDataObject;
            }
        }
 
        public string FirstName
        {
            get
            {
                return dataItem.FirstName;
            }
        }
 
        public string LastName
        {
            get
            {
                return dataItem.LastName;
            }
        }
 
        private int itemIndex;
 
        public virtual int ItemIndex
        {
            get
            {
                return itemIndex;
            }
        }
 
        private FastRepeaterItemType itemType;
 
        public virtual FastRepeaterItemType ItemType
        {
            get
            {
                return itemType;
            }
        }
 
        int IDataItemContainer.DataItemIndex
        {
            get
            {
                return ItemIndex;
            }
        }
 
        int IDataItemContainer.DisplayIndex
        {
            get
            {
                return ItemIndex;
            }
        }
    }
}
 
 

The repeater itself is a Control and implements INamingContainer.
Why did I choose to extend the Control class? Well consider the alternatives: CompositeControl and CompositeDataBoundControl both derive from Control and i already have all of the functionality I need in Control. I decided to go with the lightest solution we can find.

[ParseChildren(true)]
public class FastRepeater : Control, INamingContainer

We need to override CreateChildControls in order to build the control.

protected override void CreateChildControls()
{
   Controls.Clear();
   if (ViewState[ItemCountViewStateKey] != null)
      CreateControlHierarchy(false);
   else
      dummyItems = new List<MyDataObject>();
 
      ClearChildViewState();
}

The next function CreateControlHierarchy is where the magic happens. This function is in charge of creating all of the items from the DataSource. It fires twice, once with a full data source, and once with a dummy data source we have created in order to keep the view state on postbacks.

protected virtual void CreateControlHierarchy(bool useDataSource)
{
  List<MyDataObject> dataSource = null;
  int count = -1;
  if (dummyItems != null)
    dummyItems.Clear();
  else
    dummyItems = new List<MyDataObject>();
 
  if (useDataSource == false)
  {
    count = (int)ViewState[ItemCountViewStateKey];
    if (count != -1)
    {
      dataSource = new List<MyDataObject>();
      while (dataSource.Count <= count)
         dataSource.Add(new MyDataObject());
    }
   }
   else
   {
    dataSource = DataSource;
   }
 
   if (dataSource != null)
   {
    FastRepeaterItem item;
    int index = 0;
    count = 0;
 
    AddHeader();
 
    foreach (object dataItem in dataSource)
    {
      item = CreateItem(index, FastRepeaterItemType.Item, useDataSource, dataItem);
      count++;
      index++;
    }
 
    AddFooter();
   }
 
    if (useDataSource)
      ViewState[ItemCountViewStateKey] = ((dataSource != null) ? count : -1);
  }

Notice we are in charge of saving the viewstate ourselves. All we need is the item count and that is what we are using in order to build the dummy data source.

Using the repeater on our page is simple:

<%@ Register assembly="ConceptLoop" namespace="InvertedSoftware.CustomControls" tagprefix="cc1" %>

<cc1:FastRepeater ID="FastRepeater1" runat="server">

<table>

</HeaderTemplate>

<tr>

</tr>

</ItemTemplate>

</table>

</FooterTemplate>

</cc1:FastRepeater>

And in the code behind:

 protected void Page_Load(object sender, EventArgs e)
 {
   if (!Page.IsPostBack)
   {
     FastRepeater1.DataSource = data;
     FastRepeater1.DataBind();
   }
 }
 

You can download the complete source code from the bottom of this post.
Enjoy!

Add a GridView EmptyDataTemplate style to a Repeater

Gal Ratner — Sat, 13 Feb 2010 05:48:00 GMT

A Repeater is one of the lightest data bound controls in ASP.NET. It’s certainly faster than heavier controls like a GridView, however, its performance comes with a price. Its missing most of the functionality you can find in other controls. There is no built in paging or even a UI at all. It does provide some templates to place your HTML in, but that’s it.
If you need to display a message to the user when the Repeater is empty, something in the style of: "No results have been found" or "Your shopping cart is empty" just like EmptyDataTemplate in a GridView, you will need to add a new element, maybe a Label, to the page and check your Repeater. Then you would most likely have to set it to be invisible on the page while you show the user an empty results message. Another option is to inject this message into the repeater itself using an ITemplate.

An ITemplate defines the Control object that child controls and templates belong to. These child controls are in turn defined within the template.

Let’s start by defining our template

 sealed class EmptyTemplate : ITemplate
    {
        public void InstantiateIn(Control container)
        {
            Literal l = new Literal();
            l.Text = "Empty";
            container.Controls.Add(l);
        }
    }

Then showing the Repeater on the page and using its onprerender to check for empty results.

<asp:Repeater ID="Repeater1" runat="server" onprerender="Repeater1_PreRender"></asp:Repeater>

Finally, when we encounter no results, we are going to show the EmptyTemplate

protected void Repeater1_PreRender(object sender, EventArgs e)
        {
            if (Repeater1.Items.Count > 0)
                return;
 
            ITemplate emptyTemplate = null;
            emptyTemplate = new EmptyTemplate();
            emptyTemplate.InstantiateIn(Repeater1);
            Repeater1.ItemTemplate = emptyTemplate;
        }

That’s it. Our Repeater will now show the EmptyTemplate when it contains no items.

Bind a generic dictionary to a RibbonDropDownButton in a WPF Ribbon Control

Gal Ratner — Thu, 28 Jan 2010 05:31:00 GMT

RibbonDropDownButton can show a list of items inside a Ribbon button. You can hard code the items by adding a collection of menu items like so:

<r:RibbonDropDownButton Command="me:AppCommands.OtherReports">

</r:RibbonDropDownButton>

You can also bind the items to a data source. Let's bind the RibbonDropDownButton to a generic dictionary. First lets compose the dictionary:

Dictionary<int, string> myData = new Dictionary<int, string>();
myData.Add(1, "my string");

Next, lets bind the ItemsSource like so:

MyRibbonDropDownButton.ItemsSource = myData; 

Now that our RibbonDropDownButton’s items collection contain our dictionary, lets make sure it displayes the data correctly by adding an ItemTemplate

<r:RibbonDropDownButton Name="MyRibbonDropDownButton" Command="{StaticResource PingGroupCommand}" MenuItem.Click="RibbonDropDownButton_Click">

<r:RibbonDropDownButton.ItemTemplate>

</StackPanel>

</DataTemplate>

</r:RibbonDropDownButton.ItemTemplate>

</r:RibbonDropDownButton>

Notice we have used {Binding Value} in order to bind the TextBlock to the Value of our dictionary. We could also use the {Binding Key} if we need to show the key.
Now that we are showing the items correctly, we can track user selection using the MenuItem.Click event. A MenuItem is actually a HeaderedItemsControl so we are going to have to base type cast it in order to get the item’s key

private void RibbonDropDownButton_Click(object sender, RoutedEventArgs e)
        {
            int myKey = ((System.Collections.Generic.KeyValuePair<int, string>)(((System.Windows.Controls.HeaderedItemsControl)(e.OriginalSource)).Header)).Key;
         }

The end result will be a RibbonDropDownButton that can be populated from a database, XML file or any other data source.

How to create sub menu items in the WPF Ribbon control

Gal Ratner — Sun, 17 Jan 2010 19:18:00 GMT

The WPF Ribbon control can be downloaded from the Office UI Licensing site. One of its most interesting features is its application menu.

You can create menus and sub menus to match the look of an office 2007 application.

Simply add a new RibbonApplicationMenuItem to the ApplicationMenu.
You can then create a combination of sub menu items by placing them inside other Menu Items

<r:Ribbon.ApplicationMenu>

<r:RibbonApplicationMenu>

<r:RibbonApplicationMenu.Command>

<r:RibbonCommand

Executed="OnCloseApplication"

LabelTitle="Application Button"

LabelDescription="Close the application."

SmallImageSource="images/Coins.png"

LargeImageSource="images/Coins.png"

ToolTipTitle="Personal Finance Manager"

ToolTipDescription="Click here to open or save a checkbook register." />

</r:RibbonApplicationMenu.Command>

<r:RibbonApplicationMenuItem Height="200">

<r:RibbonApplicationMenuItem.Command>

<r:RibbonCommand

LabelTitle="Close"

LargeImageSource="images/Coins.png"

LabelDescription="Close The Application"

Executed="OnCloseApplication" />

</r:RibbonApplicationMenuItem.Command>

<r:RibbonApplicationMenuItem BorderBrush="Aqua" BorderThickness="4" Height="50">

<r:RibbonApplicationMenuItem.Command>

<r:RibbonCommand

LargeImageSource="images/Backup.png"

LabelDescription="Close With saving"

Executed="OnCloseApplication" />

</r:RibbonApplicationMenuItem.Command>

</r:RibbonApplicationMenuItem>

<r:RibbonApplicationMenuItem BorderBrush="Aqua" BorderThickness="4" Height="50">

<r:RibbonApplicationMenuItem.Command>

<r:RibbonCommand

LargeImageSource="images/delete.png"

LabelDescription="Close Without saving"

Executed="OnCloseApplication" />

</r:RibbonApplicationMenuItem.Command>

</r:RibbonApplicationMenuItem>

</r:RibbonApplicationMenu>

</r:Ribbon.ApplicationMenu>

Simple and looks like an office application.