.NET Journey

OWIN - Katana Web Application

2014-07-13T18:01:00.000+10:00

OWIN defines the standard interface between .NET web servers and web applications. KATANA is OWIN implementation for Microsoft servers and frameworks.

If you are not familiar with Katana, read this article An Overview of Project Katana which talks about the history and goals behind OWIN/Katana.

In this post I want highlight Katana's architecture around decoupling host and server from the application.

Katana Architecture

Lets look at some hosting options for OWIN application

Custom Host: You can host owin application in a console application or OwinHost (prebuilt Katana host) using Microsoft.Owin.Host.HttpListner.
IIS: Owin applications can be hosted in IIS using Microsoft.Owin.Host.SystemWeb server package. Unfortunately with this package, you do not get a lean host as it adds the standard ASP.NET piple. Thats where Helios comes to rescue where we can get all the benefits of IIS without the traditional ASP.NET pipeline.
Node.js: Using connect-owin middleware, we can host Owin application in Node.js too.

I have created a demo web api application which highlights how easy it is to switch between different hosts without changing your application. The source code is available here.

Glimpse - ASP.NET Debugging

2013-09-15T21:34:00.000+10:00

As the name suggests Glimpse allows you to glimpse into what is happening on server side of your ASP.NET application. It can save you lot of time whilst debugging by providing plethora of information and also help you learn and understand the internal mechanics of ASP.NET.

You can install Glimpse using Nuget. Ensure you install the right packages for ASP.NET and the features you want use.

You can also use the package manager console to install Glimpse


install-package Glimpse.MVC4

install-package Glimpse.EF5

Glimpse is quite extensible and there are many other packages available from the community.

Once you have installed the packages required for your project, you need to turn on Glimpse by going to http://yourproject:port/Glimpse.axd

Now you can see stats from Glimpse hud in the bottom right corner of your application.

You basically turn Glimpse on and off with cookies, it does not run in background. You can setup security policy to control when you want to use it. For example, locally when debugging or with a specific cookie value, or your authorization role, or parent switch in the web.config.

The Glimpse view is inspired from developer tools like fire bug. The great thing about it is that each tab is a plugin itself and is all built with CSS and javascript.

You can see all the information from your Configuration file like your connection strings. Information on what environment the application is running on. Even SQL queries being run by entity framework and the time taken for them to complete.

Since the server is collecting information on all sessions, you can pull out a popup browser window of Glimpse and connect to sessions from other browsers. For example, you could debug a session for a customer remotely whilst they are performing actions.

I think it is a great tool which should be used in every ASP.NET project. You should watch this great introduction video on Glimpse site by Anthony and Nick.

Command Query Separation

2013-08-25T22:10:00.000+10:00

'Command Query Separation' (CQS) is a design principle by which the methods of an object are categorised separately:

Commands: Changes the state of the system and does not return value.

Public Course Courses.Find(courseName)
{
//implementation
};

Query: Returns a result without having any side effects on the state (i.e. does not alter the observable state of the system).

public void Course.AllocateFaculty(faculty)
{
//implementation
};

Whilst CQS is a sound principle, but there are exceptions in many cases. Some these violations may be acceptable but other could be potentially dangerous.

Lets consider an example where this violation maybe acceptable. The classic violation is Stack.Pop() which is a command and a query. It removes and returns the object at the top of the stack. Another simple example which breaks the pattern but may be useful in multi-threaded programs:

public int IncrementCount()
{
  int copyOfCount;
  lock(_count)
  {
    _count++;
    copyOfCount = _count;
  }
  return copyOfCount;
}

You can manage this better making sure that if a command returns a value, it will go through an out parameter and the command will have a meaningful name IncrementAndReturnCount.

public void IncrementAndReturnCount(out int latestCount)
{
  lock(_count)
  {
    _count++;
    latestCount = _count;
  }
}

There are however instances where CQS violations cause dangerous side effects that can be difficult to debug. Consider the following method in the Course class:

public void GetSchedule()
{
  if(this.Schedule==null)
    this.Schedule = new Schedule();
  return this.Schedule;
}

It may seem very harmless that the method instantiates the schedule if it is null. But imagine someone added a new operation to send an alert all the allocated faculties of courses which do not have a schedule set.

foreach(var course in Courses)
{
  if(course.GetSchedule() == null)
    SendAlertToFaculties(course.AllocatedFaculties);
}

By adding command behavior to GetSchedule(), we have accidentally broken the code. Now we must spend time to re-factor the original code.

We can say CQS is clearly intended as a programming guideline rather than a rule for good coding.

Make your web site mobile friendly

2013-08-19T01:56:00.001+10:00

Last year on an average 15% of traffic to sites was from mobile devices and this will continue to grow.

There are many solutions to optimize your site for mobile devices. For example adaptive design, responsive design, website conversion. Each has pros and cons, and ranges from free to thousands of dollars. The amount you spend depends on the requirements of your business and your visitors. We will walk through things you can do in context of responsive design to make your site mobile friendly.

Mobile meta tags

We can improve users browsing experience on certain devices by using the mobile webkit.

Viewport

This meta tag tells the browser how content should fit on the device's screen.

The above example tells the browser to set the viewport to the width of the device with initial scale of 1.0. We can turn off zooming by setting user-scalable=no or can limit the scaling level.

You can also set the width to a pixel value (e.g. 320px) but note not all devices have same width so it's better to stick with device-width and let browser take care of the rest.

You can look into some device specific settings on Android and iOS to further improve user's experience.

Home Screen Icons

iOS and Android devices also accept a rel="apple-touch-icon" (iOS) and rel="apple-touch-icon-precomposed" (Android) for links. They get used as icon on the user's home screen when they bookmark your site.

CSS3 Media Queries

Media queries enables the content's presentation to be customized to a specific range of output devices without having to change the content itself.

Screen Sizes

The example below shows how we can target mobile devices

A media query with the "only" keyword will cause non CSS3-compliant browsers to ignore it. The following example would target tablet screen sizes.

Some of the styling changes that you should enforce:

Reduce extra whitespace/padding across the site. Space is premium!
Remove :hover states. They'll never been seen on touch devices.
Adjust the layout to be single column.
Remove the box-shadow around big container div. Large box shadows reduce page performance.
Remove opacity changes. Changing alpha values is a performance hit on mobile.

You can read more about media queries here.

CSS Frameworks

In context of responsive design CSS frameworks have many benefits. A well-built CSS framework or boilerplate can streamline the design process, save huge chunks of development time and ensure your website scales properly on all devices. Here are few you can look into:

Silverlight: Manage XAP Files

2011-03-12T13:33:00.000+11:00

The XAP file size for Silverlight projects can become quite large if they are not managed properly. This will cause the initial loading time to increase and slow performance of your application.

Manage common assemblies

To address the duplication of shared assemblies in multiple XAP files, we have couple of options.

The first is to reference all the shared assemblies in the shell application XAP file. Then we can go to the reference of these shared assemblies in each of the modules and set the Copy Local property on the reference to false. This causes the referenced shared assemblies to not be included in the compiled XAP file for that module. However, at runtime, the one provided by the shell application XAP file will also be available to the modules.

Advantages:
- All the common assemblies are downloaded once.
- XAP file size for other modules decreases.
- Subsequent requests are faster.
Disadvantages:
- The initial download size will be large.
The second approach is to use application library caching in Silverlight. To use this feature, we need to go to the properties of all the Silverlight projects and select the check box labeled Reduce XAP size by using application library caching. When we do this, any referenced assemblies that have the right metadata files collocated with them will not be included in the XAP file. Instead, they will be placed in a separate .zip file, and the .zip file will be referenced by the XAP file’s ApplicationManifest.xaml file as an external part. These files are added to the browser cache so that they can be reused on subsequent visits. All downloaded files are subject to the caching configuration settings on the server and in the browser. In a typical configuration, files are downloaded only if they are not in the cache or if they are newer than the cached versions. Libraries from Prism, Silverlight SDK and Toolkit have the required metadata files to use this feature.

If you want to leverage of the functionality for our assemblies, we need to provide the proper metadata files. More about this has been discussed in the following article: How to: Use Application Library Caching

You can test this option with your application using Fiddler, and see that shared assemblies are only downloaded when they are required and are not downloaded on subsequent requests.

Advantages:
- XAP file size of all the module decreases.
- Common assemblies are downloaded separately as they are required.
- Downloaded common assemblies are cached and available to all modules until new versions are provided. (subject to the caching configuration settings on the server and in the client browser)
Disadvantages:
- We cannot use application library caching and out-of-browser support in the same application. Out-of-browser applications require all startup assemblies to reside in the application package.
- We need to ensure the clients are not using old cached assemblies when new versions of the common assemblies are deployed.

Improve XAP file compression

XAP files are basically just standard ZIP files with different extension, so we can use compression tools (like Winrar) to decrease the file size even more by using the best compression algorithm.

We can create batch file that can be added to all the Silverlight projects to automatically re-compress the project’s XAP file more efficiently. And we can do this easily by adding command in the project’s post-build events. Around 5% to 20% reduction can be achieved depending on the contents of the XAP file.

The Repository Pattern - Entity Framework

2011-01-16T11:02:00.000+11:00

Introduction
In many applications, business logic accesses data from data stores. There are lot of potential issues when accessing them directly, for example:

Code duplication
Higher chances of programming errors
Problems in testing business logic in isolation from external dependencies
Difficulty in implementing centrally managed consistent rules and logic

So it is a good idea to build a layer of abstraction which mediates between the business layer and data source layer of the application. This is where repository pattern comes in to achieve our objectives.

What is Repository
As described on Martin Flower's website:

"A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Client objects construct query specifications declaratively and submit them to Repository for satisfaction. Objects can be added to and removed from the Repository, as they can from a simple collection of objects, and the mapping code encapsulated by the Repository will carry out the appropriate operations behind the scenes. Conceptually, a Repository encapsulates the set of objects persisted in a data store and the operations performed over them, providing a more object-oriented view of the persistence layer. Repository also supports the objective of achieving a clean separation and one-way dependency between the domain and data mapping layers."

Implementation
We will discuss the implementation of repositories in context of DDD(domain driven design) for entity framework. Using generics we will create a base repository which will have all the common functionality. And then we will inherit from the base repository to create model/domain specific repositories.

Repository Interface
This is how the repository interface will look like. IRepository<T> is the contract where T is a POCO class. For testing we can later write an fake implementation to remove the dependency.

public interface IRepository<T> where T : class

{

IQueryable<T> GetQuery();

IEnumerable<T> GetAll();

IEnumerable<T> Find(Expression<Func<T, bool>> where);

T Single(Expression<Func<T, bool>> where);

T First(Expression<Func<T, bool>> where);

void Delete(T entity);

void Add(T entity);

void Attach(T entity);

void SaveChanges();

}

Generic Repository Implementation
The base repository takes an IObjectContext as a constructor argument for dependency injection.

public abstract class EFRepositoryBase<T> : IRepository<T> where T : class

{

readonly IObjectContext _objectContext;

readonly IObjectSet<T> _objectSet;

public EFRepositoryBase(IObjectContext objectContext)

{

_objectContext = objectContext;

_objectSet = _objectContext.CreateObjectSet<T>();

}

public IQueryable<T> GetQuery()

{

return _objectSet;

}

public IEnumerable<T> GetAll()

{

return GetQuery().ToList();

}

public IEnumerable<T> Find(Expression<Func<T, bool>> where)

{

return _objectSet.Where(where);

}

public T Single(Expression<Func<T, bool>> where)

{

return _objectSet.Single(where);

}

public T First(Expression<Func<T, bool>> where)

{

return _objectSet.First(where);

}

public void Delete(T entity)

{

_objectSet.DeleteObject(entity);

}

public void Add(T entity)

{

_objectSet.AddObject(entity);

}

public void Attach(T entity)

{

_objectSet.Attach(entity);

}

public void SaveChanges()

{

_objectContext.SaveChanges();

}

Domain specific repository
In these derived repositories you can add the domain/model specific query operations. Here is how the interface and implementation of a User model repository will look like.

public interface IUserRepository : IRepository<User>

{

//add user specific operations

}

public class EFUserRepository : EFRepositoryBase<User>, IUserRepository

{

public EFUserRepository(IObjectContext objectContext)

: base(objectContext)

{

//add user specific operations

}

Microsoft Light Switch

2010-11-29T13:07:00.001+11:00

Microsoft has come out with a rapid-application development tool to build applications for the desktop, the web, and the cloud. Microsoft is promoting LightSwitch as the simplest way for developers of all skill levels to develop business applications, but it seems to be targeted more at inexperienced developers.

You can download the beta version and look at some demonstration videos here.

WCF Data Services

2010-11-28T17:55:00.002+11:00

It often becomes difficult (if not painful) to share data beyond its original intent. As systems continue to become more interconnected, the need to reuse information also grows and the value of any given data becomes greater the more it can be shared and accessed by other systems.

The Open Data Protocol, referred to as OData, is a new data-sharing standard that breaks down silos and fosters an interoperative ecosystem for data consumers (clients) and producers (services) that is far more powerful than currently possible. WCF Data Services, is the Microsoft technology to support the Open Data Protocol. Microsoft now also supports OData in SQL Server 2008 R2, Windows Azure Storage, Excel 2010 (through PowerPivot), and SharePoint 2010.

In addition to client libraries that simplify working with OData, the Data Services framework builds on the general WCF capabilities to provide a solution for creating OData services for the web. Data Services enable you to expose data models to the Web in a RESTful way, with rich built-in data access capabilities such as flexible querying, paging, and association traversal.

The Data Services framework facilitates the creation of flexible data services that are naturally integrated with the web. WCF Data Services use URIs to point to pieces of data and use simple, well-known formats to represent that data, such as JSON and ATOM (XML-based feed format). This results in the data service being surfaced as a REST-style resource collection that is addressable with URIs and with which agents can interact using standard HTTP verbs such as GET, POST, PUT or DELETE.

For examples and quick start guides on WCF Data Services, go to this link. Also, read more about OData protocol here.

Difference between XmlSerializer and DataContractSerializer (WCF)

2010-11-25T17:06:00.004+11:00

Lets start with, what is serialization?
It is the process of converting an object instance into a format that can be persisted and formated. The objects can be serialized into all sorts of formats(Xml, binary, json, etc). Serializing to Xml is most often used for its interoperability. Serializing to binary is useful when you want to send the object from one .Net application to another. .Net even supports the interfaces and base classes to build your own serialization format.

Deserialization is basically the reverse of serialization. Its the process of taking some data (Xml, binary, json, etc) and converting it back into an object.

I want to point out, that the differences between XmlSerializer and DataContractSerializer are in context of WCF.

XmlSerializer

Advantages:

Opt-out rather than opt-in properties to serialize. This mean you don’t have to specify each and every property to serialize, only those you don’t want to serialize
Full control over how a property is serialized including it being a node or an attribute
Supports more of the XSD standard

Disadvantages:

Can only serialize properties
Properties must be public
Properties must have a get and a set which can result in some awkward design
Supports a narrower set of types
Cannot understand the DataContractAttribute and will not serialize it unless there is a SerializableAttribute too

DataContractSerializer

Advantages:

Opt-in rather than opt-out properties to serialize. This means, you specify what you want to serialize
Because it is opt in model, you can serialize not only properties, but also fields. You can even serialize non-public members. And you don't need a set on a property either (however without a setter you can serialize, but not deserialize)
Is faster than XmlSerializer because you don’t have full control over how it is serialized, there is a lot that can be done to optimize the serialization/deserialization process.
Can understand the SerializableAttribute and know that it needs to be serialized
More options and control over KnownTypes

Disadvantages:

No control over how the object is serialized outside of setting the name and the order

For WCF, prefer to use the DataContractSerializer. But if you need full control over how the xml looks, use XmlSerializer.

ASP.NET Page Life Cycle Overview

2010-11-19T21:55:00.000+11:00

It is important to understand how ASP.NET page life cycle works, as it provides insight about the series of processing steps it goes through and then you can write code at the appropriate life-cycle stage. Specially when you are developing custom controls, you need to be familiar with the page life cycle in order to correctly initialize controls, populate control properties with view-state data and run behavior code.

I am not going to explain all the stages and events of the page life cycle, as it is well documented on MSDN and other blogs. But I found a really good image which provides you an overview of the page life cycle. The following image shows some of the most important methods of the Page class that you can override in order to add code that executes at specific points in the page life cycle. The image also shows how these methods relate to page events and to control events. The sequence of methods and events in the illustration is from top to bottom, and within each row from left to right.

This above image is relevant to .NET framework 4.0. I am going to print this out and stick it somewhere near my desk. BTW, an easy way of remember the important page life-cycle stages is SILVER.

S – Start
I – Initialize
L – Load
V – Validate
E – Event Handling
R – Render

Update T4 POCO Template for inheritance

2010-11-18T14:02:00.000+11:00

Lately I have been working on an application which uses Entity Framework 4. After playing around with the default code generation, I found the option of using ADO.NET POCO template generator. They are very light compared to the entities generated by the default code generator.

But I wanted to customize the template further to suit my requirements. One of the requirements was that all the entity classes should inherit from a base class. So to edit the template, first you need to install T4 editor extension (download it from here). This editor provides intelli-sense and syntax-hilighting.

Currently the entities generated from the model inherit from other entities only if that inheritance is defined in the model. For example, Employee inherits from Person. This is how the entity decleration looks in the original template:

partial class <#=code.Escape(entity)#><#=code.StringBefore(" : " ,code.Escape(entity.BaseType))#>

This ensures that the Employee class inherits from Person, or that any derived entity inherits from its base, in the generated code. But we now want to have every entity inherit from the new base class (BaseModel) unless the entities are already deriving from another base entity. In other words, Person should inherit directly from BaseModel, while Employee continues to inherit from Person (and therefore indirectly inherits BaseModel).

First, you’ll need to add the method, BaseTypeName, as shown below. Look for IsReadWriteAccessibleProperty method and add the following method above it.

string BaseTypeName(EntityType entity, CodeGenerationTools code)

{

return entity.BaseType == null ? "Namespace.BusinessEntities.BaseModel" :

code.Escape(entity.BaseType);

}

Now you can modify the code shown before, where the entity declaration is made to call the BaseTypeName method. As result, the entity will inherit from either BaseModel or its base type as defined in the model.

partial class <#=code.Escape(entity)#><#=code.StringBefore(" : ", BaseTypeName(entity, code))#>

Ensure the entities can locate the BaseModel class. Once you save the template, the entities should get re-generated again based on our customised template.

SQL OVER Clause with aggregate functions

2010-11-17T13:23:00.001+11:00

In one of my previous post, we saw the usage of OVER() clause for ranking functions. We can also use the OVER() Clause to simplify aggregate calculations. We can now add aggregate functions to any SELECT (even without a GROUP BY clause) by specifying an OVER() partition for each function. Consider the following table:

StudentID	Quesiton Reference No	Section	Required Score
1	Q-M100	Maths	10
1	Q-M200	Maths	15
1	Q-M300	Maths	20
1	Q-M400	Maths	10
1	Q-P100	Physics	10
1	Q-P200	Physics	30
1	Q-P300	Physics	10
1	Q-C100	Chemistry	50
1	Q-C200	Chemistry	10
1	Q-C300	Chemistry	15

Say, there is a requirement where you want to find the weightage of each question within a section
and also the wieghtage of each section for a student. Normally, you would create sub-queries to retrieve the summary values for calculations, as shown below:

SELECT [StudentID], [Quesiton Reference No], [Section], [Required Score],

((([Required Score]*1.0)/

(SELECT SUM(A.[Required Score]) FROM Answers A WHERE A.[Section] = Answers.[Section]))*100)

AS QuestionWeightageInSection,

((((SELECT SUM(A.[Required Score]) FROM Answers A WHERE A.[Section] = Answers.[Section])*1.0)/ (SELECT SUM(A.[Required Score]) FROM Answers A WHERE A.[StudentID] = 1))*100)

AS SectionWeightage

FROM Answers WHERE Answers.[StudentID] = 1

But now with OVER() Clause this becomes more simple and efficient. This is how the query will look:

SELECT [StudentID], [Quesiton Reference No], [Section], [Required Score],

((([Required Score]*1.0)/(SUM([Required Score]) OVER(PARTITION BY [Section])))*100)

AS QuestionWeightageInSection,

((((SUM([Required Score]) OVER(PARTITION BY [Section]))*1.0)/(SUM([Required Score]) OVER(PARTITION BY [StudentID])))*100)

AS SectionWeightage

FROM Answers WHERE Answers.[StudentID] = 1

StudentID	Quesiton Reference No	Section	Required Score	Question Weightage In Section	Section Weightage
1	Q-C100	Chemistry	50	66.66666667	41.66666667
1	Q-C200	Chemistry	10	13.33333333	41.66666667
1	Q-C300	Chemistry	15	20	41.66666667
1	Q-M400	Maths	10	18.18181818	30.55555556
1	Q-M100	Maths	10	18.18181818	30.55555556
1	Q-M300	Maths	20	36.36363636	30.55555556
1	Q-M200	Maths	15	27.27272727	30.55555556
1	Q-P100	Physics	10	20	27.77777778
1	Q-P200	Physics	30	60	27.77777778
1	Q-P300	Physics	10	20	27.77777778

The way it works is similar to joining an aggregated copy of a SELECT to itself. In my experience it is 20% or more faster than co-related sub queries. You can always look up the execution plan to see the differences between performance. You can use the OVER() Clause with all the other aggregate functions similarly. Read more about it here.

Entity Framework 4 and WCF Services

2010-11-14T22:49:00.003+11:00

Recently I have been reading about using entity framework 4 with WCF services. There are array of options for building services, each option servers a different purpose. As I have played around with various options, I want to talk about which solution(s) applies to different requirements.

POCO entities or EntityObects?
EntityObjects are the “out of the box” option, while they provide a lot of useful automated change tracking and relationship management, it is challenging to work with services that depend on EntityObjects and transfer them across tiers. POCO(Plain Old CLR Objects) entities remove lot of extra layers concerning state management, when you are creating services and making them easy for end users to consume.

Custom service, data service, or RIA service?
There are three paths to choose for WCF services. The first is to write your own service. This is where you have full control over the service operations and the other logic, including handling features such as security.

WCF Data Services is a more lightweight solution and allows you to provide your data to a wide range of consumers. Unlike WCF services, which use SOAP to move data across the wire, WCF Data Services exposes your data for access through URIs over REST (i.e., directly through HTTP). There are also convenient client APIs for .NET, Silverlight, PHP, AJAX, and other consumers. This approach might appear as putting your database on the Internet, which is not the case. What is exposed is first defined by your model and further refined by settings in your service. You do have some control over securing the data, but it is not the same control you can exercise with your custom services.

WCF RIA Services attempts to bridge the gap between custom services and WCF Data Services. WCF RIA Services was originally designed to help getting data into and out of Silverlight applications, you can also consume RIA services from other applications as well, because in the end, unlike WCF Data Services, WCF RIA Services is still a WCF service. RIA services encapsulate some of the most common desired CRUD functionality.Though this does not still give you complete control, but if you want leverage a boxed solution which is customizable, WCF RIA Services could be a good candidate.

Self-tracking entities?
Self-tracking entities are not lightweight, and to get their true benefits, the consuming application must be a .NET 3.5 or 4 app that contains self-tracking entities. Self-tracking entities is the simplest path for using entities in WCF services. Do not mistake self-tracking entities as a great solution for all of your applications. They are written specifically to be used with custom WCF services. They will not work with WCF Data Services or WCF RIA Services, nor can you use them to solve n-tier issues in other applications.

Self-tracking entities are very different from other POCO classes, whether your POCO classes are generated from the provided template, a customized version of that template, or your own template.

It is very important to understand what different options are available, so we can make the right choice when exposing business model through WCF.

Reference: Programming Entity Framework, Second Edition, by Julia Lerman.

SQL Ranking functions

2010-11-11T23:50:00.001+11:00

Ranking functions return a ranking value for each rows in your result set. Many tasks, like generating sequential numbers, finding ranks, and so on, which in pre-2005 SQL Server versions requires many lines of code, now can be implemented much easier and faster.

Look at the following example:

SELECT FirstName, LastName, PostalCode, 
       ,ROW_NUMBER() OVER (ORDER BY PostalCode) AS 'Row Number'
       ,RANK() OVER (ORDER BY PostalCode) AS 'Rank'
       ,DENSE_RANK() OVER (ORDER BY PostalCode) AS 'Dense Rank'
       ,NTILE(2) OVER (ORDER BY PostalCode) AS 'Bi-tile'
FROM   Persons

Result Set:

FirstName	LastName	PostalCode	Row Number	Rank	Dense Rank	Bi-tile
Joe	Harley	3007	1	1	1	1
David	Bigel	3007	2	1	1	1
Joel	Friedlaender	3007	3	1	1	1
Kenny	Lam	3128	4	4	2	2
Nirmal	Parrera	3128	5	4	2	2
Gurnam	Madan	3128	6	4	2	3
Troy	Parker	3150	7	7	3	3
Melanie	????	3150	8	7	3	4
Jeremy	Pickhaver	3150	9	7	3	4

Lets look at each of these ranking functions:

1. ROW_NUMBER()

ROW_NUMBER ()     OVER ( [ <partition_by_clause> ] <order_by_clause> )

This function returns the sequential number of a row within a partition of a result set, starting at 1 for the first row in each partition. The ORDER BY clause determines the sequence in which the rows are assigned their unique ROW_NUMBER within a specified partition. In the above example we have not specified any partition columns, so the ROW_NUMBER is assigned based on the ordering of postal code column for each row.

2. RANK()

RANK ()    OVER ( [ < partition_by_clause > ] < order_by_clause > )

This function returns the rank of each row within the partition of a result set. The rank of a row is one plus the number of ranks that come before the row in question. You can also group the the rankings by using the PARTITION BY clause. In the above example the rankings are the same for rows having the same value in postal code column. But the ranking value keeps on incrementing for each row, so that when a new postal code value is encountered, ranking value on that new row will be one more than the number of proceeding rows.

3. DENSE_RANK()

DENSE_RANK ()    OVER ( [ < partition_by_clause > ] < order_by_clause > )

This function returns the rank of rows within the partition of a result set, without any gaps in the ranking. The rank of a row is one plus the number of distinct ranks that come before the row in question. In the above example rankings are incremented as the value in postal code column changes.

4. NTILE()

NTILE (integer_expression)    OVER ( [ <partition_by_clause> ] < order_by_clause > )

This function distributes the rows in an ordered partition into a specified number of groups. The groups are numbered, starting at one. For each row, NTILE returns the number of the group to which the row belongs. The integer constant expression specifies the number of groups into which each partition must be divided. In the above examples the rows are divided in 2 groups. Because the total number of rows(9) is not divisible by the number of groups, the first group has three rows and the remaining groups have two rows each.

These functions can be really handy for complex sorting and generating sequential record set. These windowed functions can only be used in SELECT and ORDER BY statements. You can read more about them here.

LINQ Pad

2010-11-11T10:41:00.000+11:00

I have been playing around with Entity Framework 4 and WCF Data Service lately. Whilst reading through some articles on these topics, I found this cool tool to play around with LINQ.

LINQPad interactively lets you query data sources in a modern query language. It supports everything in framework 4.0:

LINQ to Objects
LINQ to SQL
LINQ to Entity Framework
LINQ to XML
OData/WCF Data Services

It also comes loaded with lot of examples which can help you to learn LINQ. You can also execute C#/VB expression, statement block or program with rich output formatting.

LINQPad standard edition is free to download and use, but you can also get the premium edition with support for auto completion and some other features. So check it out http://www.linqpad.net/

Convert string to enum

2010-10-14T17:05:00.000+11:00

Number of times I have come across the situation where I wanted to convert a string into enum. Using switch case statements to return the enum becomes quite tedious when there are many items. Recently I found a static method in Enum class which replaces these switch statements and is a big time saver.

public static object Enum.Parse(System.Type enumType, string value)

Look at the following code

enum Days
{
  Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
}
//........

string val = "Tuesday";
Days day = Enum.Parse(typeof(Days), val);
Console.WriteLine("Day Value: {0}", day.ToString());

//You can also ignore the case of the string being parsed 
//by using the following method
public static object Parse(Type enumType, string value, bool ignoreCase);

Parsing an invalid day will throw an Argument Exception. So it is always a good idea to check if the enum exists, look at the following code:

string val = "Tuesday";
Day day;

if(Enum.IsDefined(typeof(Days), val))
  day = Enum.Parse(typeof(Days), val);

Unfortunately, Enum.IsDefined() does not provide ignore case option.

C# Bitwise Flag Enum

2010-09-18T20:24:00.001+10:00

Imagine there was a requirement for a notification system, where users could select multiple days for delivery in a week (eg: MON, TUE, WED, THU, FRI, SAT, SUN). Now you could do this by having Boolean flags for each option or a better way is to use bitwise enum flags. They store very efficiently in memory and manipulation is very fast.

Before reading ahead, I would strongly suggest to read about bitwise operations here, otherwise it will be very hard to understand the logic of the example.

So lets declare our bitwise flag enum:

[Flags]
private enum DeliveryDays
{
  NONE = 0, // 0000000
  MON = 1,  // 0000001
  TUE = 2,  // 0000010
  WED = 4,  // 0000100
  THU = 8,  // 0001000
  FRI = 16, // 0010000
  SAT = 32, // 0100000
  SUN = 64, // 1000000
  WORKDAYS = MON | TUE | WED | THU | FRI,  //0011111
  WEEKENDS = SAT | SUN  //1100000
}

The [Flags] attribute indicates that an enumeration can be treated as a bit field. Do use powers of two for a enumeration's values so they can be freely combined using the bitwise OR operation. As you can see for workdays and weekends we have combined the relevant days.

Now lets write down the methods which set these flags on or off.

private DeliveryDays _selectedDays = DeliveryDays.None;

public void AddDeliveryDays(DeliveryDays days)
{
  _selectedDays |= days;
}

public void RemoveDeliveryDays(DeliveryDays days)
{
  _selectedDays &= ~days;
}


public void testDaysBitEnum()
{
  //lets select monday and tuesday
  AddDeliveryDays(DeliveryDays.MON | DeliveryDays.TUE);
  //lets change it all the work days
  AddDeliveryDays(DeliveryDays.WorkDays);
  //now lets remove monday and tuesday and add weekends
  RemoveDeliveryDays(DeliveryDays.MON | DeliveryDays.TUE);
  AddDeliveryDays(DeliveryDays.WEEKENDS);
}

As shown above we can quickly toggle multiple flags. But we also need some functionality to find which flags have been selected. In .NET framework 4.0 the enum has a method called HasFlag which does this for you. For older frameworks you can use the following method.

public bool HasFlag(DeliveryDays day)
{
  return ((_selectedDays & day) == day);
}

If you are using .NET 3.5 Framework it will be handy to add the above method as an Extension Method.

Progress Bar using css (cascading style sheet)

2010-09-10T11:50:00.149+10:00

Recently I worked on some functionality where we wanted to show progress to users whilst they were answering a survey. Basically as they answered the questions a progress bar would show the completion percentage. As I started playing around with some css, it turned out be quite easy.

Have a look at the example below:

Progress

The above progress bar is made of three div tags,
1. The outer container div with a border which works as a place holder for the progress and the text being displayed

The relative positioning of this container ensures that all it's child div tags are contained within.

2. Next is the div container which will sit inside the above div and show the progress. This is just an absolute positioned div with a background color or an repeater image. Basically, we just change the width of this div to show the increase in progress.

3. The third div is another absolute positioned container which will sit inside the place holder div tag to show the text. The important thing to notice about it's style is that, it completely fills the place holder div with a transparent background so you can see the progress. The higher z-index ensures that it will sit on top of the div showing the progress in background.

Now what you need is some jquery to manipulate the width of the div showing the progress. As an example:

Vertical Content Scrolling

2010-09-08T15:22:00.013+10:00

There are lot of jquery plugins available which provides horizontal or vertical content scroll functionality, like for scrolling through image gallery. Recently I had a requirement where a web page needed vertical scrolling functionality for a navigation system.

Below is a very simple example, where content of a list is being scrolled by two buttons.

Item 0
Item 1
Item 2
Item 3
Item 4
Item 5
Item 6
Item 7
Item 8
Item 9

So lets get into this,
1. First we need to create a div tag with it's style overflow attribute set to hidden.

2. Add the content.

Item 0
Item 1
Item 2
Item 3
Item 4
Item 5
Item 6
Item 7
Item 8
Item 9

3. Now for scrolling, we will use jquery's animate function which will provide us a smooth scrolling effect.


function scroll(val) {
            jQuery('#list').animate({
                scrollTop: jQuery('#list').scrollTop() + (val)
            }, 450);
        }

The above function takes a integer parameter which gets added to the scrollTop attribute of the div containing the content, which causes the content to scroll. The animate function makes the transition smoother, to read more about animate function go here.

4. Now what we need is just two buttons, which will call this function and pass +ve values to scroll down and -ve values to scroll up.

This a very simple example, but gives a good idea for building cool vertical content scrolling.

Check if string is null or empty.

2010-09-06T12:07:00.001+10:00

I have seen so many lines of code where people write checks for a string being null or blank. Also, sometimes there is no check for string being empty.
For example:

There is a better way of doing this, there is very neat static function in the String class which does this check for you String.IsNullOrEmpty(string value).

Tuple in C# 4.0

2010-09-05T15:18:00.000+10:00

C# 4.0 includes a new feature called Tuple. Tuple provides us with a way to group elements of disparate data types together.This is present in functional languages like Haskell and also dynamic languages like Python.

Consider the following code:
It creates a tuple storing name and age of person.

We can create nested tuples as shown below:

The most important thing to know about the Tuple type is that it is a class, not a struct, and thus will be allocated upon the managed heap. Each class instance that is allocated adds to the burden of garbage collection. The properties Item1, Item2, and further do not have setters, so you cannot assign them. The Tuple is immutable once created in memory.

It is difficult for developers to choose between Tuples and Anonymous Types as they serve similar purpose. It can be a difficult to make the best choice between those two solutions.

Read more about it here.

Extension Methods

2010-09-04T17:45:00.001+10:00

Extension methods behavior is similar to that of static methods. You can declare them only in static classes. To declare an extension method, you specify the keyword this as the first parameter of the method, for example

static class StackOps
{
   public static void Push<T>(this List<T> TheList, T Value)
   {
      TheList.Add(Value);
   }

   public static T Pop<T>(this List<T> TheList)
   {
      if (TheList.Count == 0)
         throw new Exception("Nothing to pop.");
      
      int LastPos = TheList.Count - 1;
      T Result = TheList[LastPos];

      TheList.RemoveAt(LastPos);
      return Result;
   }
}


static void Main(string[] args)
{
   var Stack = new List<int>();

   // Put stuff onto the stack.
   for (int i = 0; i <= 10; i++)
      Stack.Push(i);

   // And now pop stuff off it.
   while (Stack.Count > 0)
      Console.WriteLine(Stack.Pop());
}

C# Lambda Expressions

2010-09-04T17:36:00.001+10:00

A lambda expression simply defines an anonymous function. All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters (if any) and the right side holds the expression or statement block.

Read more about lambda expressions here.

SQL Server - Comma delimited string from a table column

2010-09-04T16:31:00.000+10:00

This is a very simple and efficient way of getting values of a column in a delimited string.

USE AdventureWorks
GO

DECLARE @nameslist VARCHAR(MAX)
SELECT @nameslist = COALESCE(@nameslist+',' ,'') + Name
FROM Production.Product

SELECT @nameslist

Using the COALESCE function ensures that result set does not get affected by null values. For more information about this function check out this link.