My Thoughts

Coding Fun:: Different Switch Case

2010-02-25T22:23:00.000-08:00

You might have written switch-case numerous times. Have you ever thought of writing the same in different way? The code snippet below shows you how to achieve the same differently.

The code combines functionality provided by .Net Multi-cast delegate and inspired from State design pattern. Inspired because it is not exactly the state design pattern, but as state design pattern leave it to states to change the behavior of object, here the statement part evaluates condition and check whether the statements can be executed or not. Look at the code below:

The example above might not be appealing, but I think this is more modular, easy to extend and inclusive way of programming. Isn’t it?

VB6 to .Net Migration Approach

2010-02-25T21:33:00.000-08:00

Introduction

Application migration from VB6 to .Net is more than just a one-to-one code conversion which may/is common understanding. It should be looked as an opportunity to realign with market, with technology, with business goals etc. etc. The major business drivers that that lead to migration are:

Flexible solution than can be extended easily
Integration with external systems
Scaling up to cope with ever increasing number of users
Adding new features and functionalities

Considering above there are multiple approaches:

Quick and automated conversion (probably using readily available tools)
Re-architecting – Green field approach
Re-architecting – hybrid approach

Approaches
Quick and automated conversion, in my view is a dirty way of conversion and there are lots of tools – open source and commercial - available in market to do this. But still they do not do 100% job, you have to tweak the code after conversion. The biggest draw back in the approach is you do not get the opportunity to take advantages from new technology and realign. All coding sins from earlier code base gets percolated to new code base. You do not get the chance to understand the code which can have impact on bug-fixing turnaround time. Moreover the coding conventions/standards and imposed by the tools which may differ significantly from your organizations coding standard.

Both the re-architecting approaches provide opportunity to take a fresh look towards system. It use different architectural styles like layered/N-tier, Domain Driven Design, SOA rather than typical VB6 traditional Client-Server architecture style. The better suited style can be decided only after thorough assessment. There is a slight difference between Re-architecting – Green field approach and Re-architecting-hybrid approach. The hybrid approach is open to use few existing components which are well designed, fairly stable, cohesive in nature and can be re-aligned with new architecture. Green filed approach is to throw away everything, which in my view is little harsh . The figure below shows very high level execution plan for re-architecting approach.

Conclusion
Above section described approaches that can be taken for migration, with my inclination towards Re-architecting-hybrid approach. The details about technology stack, architectural style, tools and platform can be decided only after better understanding of the product.

Windows Phone 7 Series

2010-02-25T21:16:00.000-08:00

Yesterday I watched an offline video of Microsoft CEO Steve Ballmar’s presentation on Windows Phone 7 Series. Yes! You read it correctly; it’s not Windows Mobile 7.0. Windows Phone 7 Series was officially unveiled at Mobile World Congress in Barcelona on 15th this month.

As told, it is a ground up approach from Microsoft with brand new operating system and efficient device drivers. Home screen is completely altered with "tiles" which scroll vertically and can be customized as quick launches, links to contacts, or self contained widgets. User interface experience is kind of WOW! (Should I say iPhone style ? Probably more than that) It will support multiple form factors and 4-point multi touch screen. Lot of extensibility is promised, even OS can be extended.

The architecture seems to be in information integration space. Integration approach is deeply rooted in operating system level. Like the people hub – targeted towards social networking – provides integrated contact pages which show status updates from multiple social networking services. Likewise there are five inbuilt hubs.

For developers Microsoft has promised new development platform, new tools and new services in could. The details will be announced at MIX10 conference in Mar 2010.

Apart from focusing on software, Microsoft is also focusing on carrier and hardware partnership. Carrier partnership including AT&T, Deutsche Telekom AG, Orange, SFR, Sprint, Telecom Italia, Telefónica, Telstra, T-Mobile, Verizon Wireless and Vodafone, while hardware partners include Dell, Garmin-Asus, HTC, HP, LG, Samsung, Sony Ericsson, Toshiba and Qualcomm.

I believe, the focus will be to grab major pie of 66-million smart phone market in US for 2010. I believe this is going to be a make or break situation for Microsoft as it is losing fast on smartphones to iPhone and Android (source: Gartner).

First handsets are supposed to hit the market by the holidays of this year. I am super excited and as a developer and architect looking forward to MIX10.

Loose Coupling

2010-02-25T21:02:00.000-08:00

Introduction

The world is changing fast. Immense market pressure and cut-throat competition has changed the idiom from “build to last” to “build to change”. This and development methodologies like Agile stress software system to be more flexible more resilient. Apart from other design and development principles “Loose Coupling” plays a lead role in flexibility. In simple term loose coupling can be defined as –

In the system of dependent unit, if we change any unit the other units are (ideally) unaffected, in other words change in one unit do not have any impact on another unit.

Software systems are built as collaborating components, which intern are set of collaborating cohesive classes, collaborating and communicating layers, communication with data sources and external sources. This requires loose coupling to be applied at different levels:

architectural style
design and classes
Interaction with databases

Loosely coupled systems are easier to maintain and extensible.

This paper explains the technology and techniques that can be applied at these different levels for loosely coupled software system. The paper should be looked as source of pointers to achieve loose coupling. Details description of any technique is out of scope of the paper.

Architectural Style

Selecting appropriate architectural style, among client/server architecture, layered/N-Tier architecture, component-based architecture, message/service bus architecture and service oriented architecture (SOA), or combining different architectural styles plays significant role in loosely coupled software system. These styles can be grouped as follows:

Low degree of coupling

Layered/N-Tier architecture
Message Bus architecture
Service Oriented architecture
Domain Driven Design

High degree of coupling

Client/Server architecture
Component-based architecture

The above grouping should be looked as just pointers and even lower degree of coupling can be achieved when different architectural styles are mixed. In SOA style services implemented with N-Tier style adds up low coupling benefits of both the styles. Client/server architectural style’s coupling – where traditionally server logic is written in database stored procedures - can further be loosen by dividing the logic in self contained well interfaced components.

Many factors will influence the architectural style or combination of architectural style one choose. You will have to strike a balance between loose coupling and other design principles. For example loosely coupled N-Tier architecture with each tier deployed on separate box will have more demand for security measures than less loosely coupled client/server architecture which generally offers a great control on security.

Design and Class

Separating interface from implementation provides better control on coupling. Consider the example below which shows loose coupling between depending class and set of concrete classes. The DependentClass does not have any knowledge of concrete implementation of interface IInterface. One can add new implementation of IInterface, say InterfaceImpl4, without informing anything about this new interface to DependentClass, which provides a great degree of flexibility. Even if you have one to one mapping between dependent class and dependency, I recommend programming dependent class against interface of dependency, as shown in figure B.

One has to ensure that interfaces are well articulated, well defined and fairly stable.

In above arrangement, still there exists a small amount of coupling if DependentClass creates an instance of InterfaceImpl1 like IInterface inf = new InterfaceImpl1().This can further be eliminated by linking classes at runtime – through configuration – rather than compile time. Following design patterns helps to achieve loose coupling:

Factory/Named-factory/Abstract Factory pattern
Plug-in pattern
Dependency injection pattern
Bridge pattern
Service locator pattern etc.

Reflection APIs can take the coupling to lowest level. Many languages like C#, Java provides built-in reflection APIs. Third party libraries like XCppRefl can be used for reflection in C++. Microsoft Enterprise Library Unity block, NInject and Sprint.Net are few dependency injection frameworks available. The new initiative from Microsoft, Managed Extensibility Framework (MEF) – still in development – also provides Dependency Injection.

In Figure B even if DepedentClass is programmed against IInterface, but chatty communication, it increases the coupling between dependent class and dependency. Sometime chatty communication results in exposing greater details about dependency. It mud-slides dependent class code with dependency behavior. Try to reduce number of calls between classes.

Improper identification of classes also has adverse impact on coupling. They lead to increased number of dependencies and cress-cross communication between units. Consider reorganizing class responsibilities and communication between them.

Wherever possible, prefer composition over inheritance. Inheritance imposes very tight coupling between parent and child classes, thereby limiting the reuse of child classes.

Avoid deep dotting. Deep dotting exposes dependencies to other classes. Consider figure below. ClassA is dependent on ClassB which in turn is dependent on ClassC. It is better to delegate method call from ClassA to ClassC through ClassB to avoid calls like objClassB.GetClassC().DoSomething().This minimizes the impact of any change in ClassC which requires dependent classes to be changed.

In case of layered/N-Tier architecture, use abstraction between layers for loose coupling. This can be achieved with the help of façade pattern with well known input and output.

A simple magic wand to test loose coupling

Take a class from your business layer, and just copy its code into a new console project. Try to compile it. You'll likely be told about missing some dependencies. Copy those classes to the console project and try again. You'll likely discover other missing classes. When you are finally able to compile, you may find that you have quite a significant fraction of your codebase in the new project. If this is so, your design needs to be re-investigated.

Persistence Ignorance

Persistence Ignorance is development technique to design and build business logic independent of the database. It is mostly used in domain-centric design like DDD or TDD. Frameworks/utilities like Entity Framework with LINQ, from Microsoft and NHibernate with HQL provides fair amount of independency from database.

Wrapping it up

There are various design techniques, principles, design patterns, frameworks, utilities etc. to develop loosely coupled software systems. All of these provide loose coupling by adding a layer of indirection or abstraction.

Achieving loose coupling definitely needs extra development time in initial phases of application – which is scarcity in current “wanted it yesterday” scenario. One has to negotiate with stakeholders and present the case on how it pays off in long term.

One has to judge the degree of coupling wisely. When loose coupling is abused or misapplied or not though thru, you have unneeded indirection and abstractions, requiring extra setup, inefficiency, extra complexity, translations between concepts and performance hit. Many factors will influence the options you choose like capabilities and experience of developers, infrastructural and organizational constraints, capacity to handle indirections and abstraction etc.

Nightmare:: Installing TFS 2008 Service Pack 1

2008-09-23T04:17:00.001-07:00

It was a nightmare installing TFS 2008 SP1 on the production server. My production environment is a TFS single machine (application and data tier on same server) installation with Visual Studio 2008.

As per installation guide, Microsoft suggested to install Visual Studio 2008 SP1 first and then install TFS 2008 SP1. I did it in the same way but after installing VS SP1, thought to see whether VS SP1 was installed correctly or not. When I opened Visual Studio it simply failed to connect to TFS. TFS Server event viewer revealed that Sharepoint service is unable to connect to STS_Config_TFS database. Started googleing for the issue without any luck. In FRUSTRATION I decided to proceed for TFS SP1 installation and surprisingly everything started working.

It seems that installing VS SP1 broke the TFS server, which in my view should not happen.

Moral of the story is, if you have TFS client and TFS server (app tier) on same machine install both and then test it.

I spent close to five (5) hours in identifying this. Hope you will not.

Databound WIT Dropdown Custom Control

2008-09-07T05:29:00.001-07:00

The out of box drop down controls provided by TFS requires the drop down elements to be either hardcoded inside the WIT or defined as a global list. This makes the dropdown content definition quite inflexible from list management point of view.

The databound dropdown custom WIT control achieves the easy management of dropdown contents by fetching the data from database data-table. The code snippet below explains the important part of the control.

The custom control is defined as UserControl and implement IWorkItemControl interface. It holds the combobox and listens to SelectedIndexChanged event.

using Microsoft.TeamFoundation.WorkItemTracking.Client;

using Microsoft.TeamFoundation.WorkItemTracking.Controls;

#endregion

namespace TelarixWitCustomControls

{

///

/// This class represents data bound dropdown custom control to be used in side

/// Team foundation server work item definition.

///

public partial class DataboundDropdownList : UserControl, IWorkItemControl

{

private ComboBox m_databoundCombo = new ComboBox();

private bool m_isIndexChange = false;

private bool m_IsUpdatingFromDatasource = false;

///

/// Default constructor

///

public DataboundDropdownList()

{

InitializeComponent();

//Create the combo box with sorted option and add it to control

m_databoundCombo.Dock = DockStyle.Top;

m_databoundCombo.Sorted = true;

m_databoundCombo.SelectedIndexChanged +=

new EventHandler(m_databoundCombo_SelectedIndexChanged);

this.Controls.Add(m_databoundCombo);

}

SelectedIndexChanged event sink is used to set the value of workitem field.

void m_databoundCombo_SelectedIndexChanged(object sender, EventArgs e)

{

if (m_IsUpdatingFromDatasource)

{

//Control is updating its contents from datasource.

//Do nothing to avoid inconsistant state.

return;

}

//Set selected value to work item field

if(m_databoundCombo.SelectedItem != null)

m_workItem.Fields[m_fieldName].Value = m_databoundCombo.SelectedItem.ToString();

m_isIndexChange = true;

}

The function below populates the dropdown values from data source.

///

/// Populate drop down with values from data source

///

void IWorkItemControl.InvalidateDatasource()

{

if (m_isIndexChange)

{

// Do not do anything if datasource is invalidated because of selected index change.

m_isIndexChange = false;

return;

}

if (m_databoundCombo.Items.Count > 0)

return;

m_databoundCombo.Items.Clear();

m_databoundCombo.Text = m_workItem.Fields[m_fieldName].Value.ToString();

AllowedValuesCollection allowedValues = m_workItem.Fields[m_fieldName].AllowedValues;

if (allowedValues.Count != 2)

{

MessageBox.Show("Invalid Parameters defined in WIT xml." +

"Please refer design document for DataboundDropdownList design and configuration.");

return;

}

//Read connection string and sql from WIT definition

string connectionString = allowedValues[1].Replace("/","\\");

string sqlQuery = allowedValues[0];

m_IsUpdatingFromDatasource = true;

//Open SQL Connection

SqlConnection _sqlCon = new SqlConnection(connectionString);

_sqlCon.Open();

SqlDataReader dsSource = null;

try

{

if (_sqlCon.State == ConnectionState.Open)

{

dsSource = SqlHelper.ExecuteReader(_sqlCon, CommandType.Text, sqlQuery);

while (dsSource.Read())

{

m_databoundCombo.Items.Add( dsSource.GetString(0));

}

catch (Exception exp)

{

MessageBox.Show("Unable to connect to datasource.");

}

finally

{

if(null != dsSource) dsSource.Close();

if(null != _sqlCon) _sqlCon.Close();

m_IsUpdatingFromDatasource = false;

}

The parameters to the control are database connection string and SQL query to fetch the dropdown contents as shown in the snippet below:

- <FIELD name="How Found" refname="Telarix.HowFound" type="String">

<HELPTEXT>Maps to 'Source' from eFly.HELPTEXT>

- <SUGGESTEDVALUES>

SUGGESTEDVALUES>

FIELD>

Complete code

#region Using directives

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Data;

using System.Data.SqlClient;

using System.Text;

using System.Collections;

using System.Collections.Specialized;

using System.Windows.Forms;

using Microsoft.TeamFoundation.WorkItemTracking.Client;

using Microsoft.TeamFoundation.WorkItemTracking.Controls;

#endregion

namespace TelarixWitCustomControls

{

///

/// This class represents data bound dropdown custom control to be used in side

/// Team foundation server work item definition.

///

public partial class DataboundDropdownList : UserControl, IWorkItemControl

{

private ComboBox m_databoundCombo = new ComboBox();

private bool m_isIndexChange = false;

private bool m_IsUpdatingFromDatasource = false;

///

/// Default constructor

///

public DataboundDropdownList()

{

InitializeComponent();

//Create the combo box with sorted option and add it to control

m_databoundCombo.Dock = DockStyle.Top;

m_databoundCombo.Sorted = true;

m_databoundCombo.SelectedIndexChanged +=

new EventHandler(m_databoundCombo_SelectedIndexChanged);

this.Controls.Add(m_databoundCombo);

}

void m_databoundCombo_SelectedIndexChanged(object sender, EventArgs e)

{

if (m_IsUpdatingFromDatasource)

{

//Control is updating its contents from datasource.

//Do nothing to avoid inconsistant state.

return;

}

//Set selected value to work item field

if(m_databoundCombo.SelectedItem != null)

m_workItem.Fields[m_fieldName].Value = m_databoundCombo.SelectedItem.ToString();

m_isIndexChange = true;

}

private void DropdownResized(object sender, EventArgs e)

{

}

#region IWorkItemControl Members

private EventHandlerList m_events;

private EventHandlerList DataSourceEvents

{

get

{

if (m_events == null)

{

m_events = new EventHandlerList();

}

return m_events;

}

private static object EventBeforeUpdateDatasource = new object();

event EventHandler IWorkItemControl.BeforeUpdateDatasource

{

add { DataSourceEvents.AddHandler(EventBeforeUpdateDatasource, value); }

remove { DataSourceEvents.RemoveHandler(EventBeforeUpdateDatasource, value); }

}

event EventHandler IWorkItemControl.AfterUpdateDatasource

{

add { DataSourceEvents.AddHandler(EventBeforeUpdateDatasource, value); }

remove { DataSourceEvents.RemoveHandler(EventBeforeUpdateDatasource, value); }

}

void IWorkItemControl.Clear()

{

}

void IWorkItemControl.FlushToDatasource()

{

}

///

/// Populate drop down with values from data source

///

void IWorkItemControl.InvalidateDatasource()

{

if (m_isIndexChange)

{

// Do not do anything if datasource is invalidated because of selected index change.

m_isIndexChange = false;

return;

}

if (m_databoundCombo.Items.Count > 0)

return;

m_databoundCombo.Items.Clear();

m_databoundCombo.Text = m_workItem.Fields[m_fieldName].Value.ToString();

AllowedValuesCollection allowedValues = m_workItem.Fields[m_fieldName].AllowedValues;

if (allowedValues.Count != 2)

{

MessageBox.Show("Invalid Parameters defined in WIT xml." +

"Please refer design document for DataboundDropdownList design and configuration.");

return;

}

//Read connection string and sql from WIT definition

string connectionString = allowedValues[1].Replace("/","\\");

string sqlQuery = allowedValues[0];

m_IsUpdatingFromDatasource = true;

//Open SQL Connection

SqlConnection _sqlCon = new SqlConnection(connectionString);

_sqlCon.Open();

SqlDataReader dsSource = null;

try

{

if (_sqlCon.State == ConnectionState.Open)

{

dsSource = SqlHelper.ExecuteReader(_sqlCon, CommandType.Text, sqlQuery);

while (dsSource.Read())

{

m_databoundCombo.Items.Add( dsSource.GetString(0));

}

catch (Exception exp)

{

MessageBox.Show("Unable to connect to datasource.");

}

finally

{

if(null != dsSource) dsSource.Close();

if(null != _sqlCon) _sqlCon.Close();

m_IsUpdatingFromDatasource = false;

}

private StringDictionary m_properties;

///

/// Get or Set workitem properties

///

StringDictionary IWorkItemControl.Properties

{

get

{

return m_properties;

}

set

{

m_properties = value;

}

private bool m_readOnly;

///

/// Get or Set workitem permission.

///

bool IWorkItemControl.ReadOnly

{

get

{

return m_readOnly;

}

set

{

m_readOnly = value;

}

void IWorkItemControl.SetSite(IServiceProvider serviceProvider)

{

}

private WorkItem m_workItem;

private WorkItem m_workItemCopy;

///

/// Get or Set workitem in which this control shall be hosted.

///

object IWorkItemControl.WorkItemDatasource

{

get

{

return m_workItem;

}

set

{

m_workItem = (WorkItem) value;

}

private string m_fieldName;

///

/// Get or Set workitem field name.

///

string IWorkItemControl.WorkItemFieldName

{

get

{

return m_fieldName;

}

set

{

m_fieldName = value;

}

#endregion

}

MSBuild Script to Publish Web Service

2008-08-22T03:41:00.001-07:00

Following MSBuild Script Publishes web service to the Deployment directory.

<?xml
version="1.0"
encoding="utf-8"?>

</CreateProperty>

</CreateProperty>

</CreateProperty>

</CreateProperty>

</CreateItem>

</CreateItem>

</CreateItem>

</CreateItem>

<MSBuild
Projects="$(ProjectRoot)\$(ProjectName)\$(ProjectName).vbproj"

Targets="Clean;Build">

</MSBuild>

<Copy
SourceFiles="@(AsmxFilesToCopy)"
DestinationFiles="@(AsmxFilesToCopy -> '$(DeploymentDir)\%(RecursiveDir)%(FileName)%(Extension)' )"/>

<Copy
SourceFiles="@(AsaxFilesToCopy)"
DestinationFiles="@(AsaxFilesToCopy -> '$(DeploymentDir)\%(RecursiveDir)%(FileName)%(Extension)' )"/>

<Copy
SourceFiles="@(ConfigFilesToCopy)"
DestinationFiles="@(ConfigFilesToCopy -> '$(DeploymentDir)\%(RecursiveDir)%(FileName)%(Extension)' )"/>

<Copy
SourceFiles="@(BinaryFilesToCopy)"
DestinationFiles="@(BinaryFilesToCopy -> '$(DeploymentDir)\bin\%(FileName)%(Extension)' )"/>

</Target>

</Project>

C# Sharing / UN-sharing Local Disk Folder

2008-07-17T21:29:00.000-07:00

Following code snippet share and removes the share on local disk folder.

using System.Management;
using System.IO;

namespace FolderNetworkSharing
{
public class FolderSharer
{
public void ShareFolder(string folderPath, string shareName)
{
// Create a ManagementClass object
ManagementClass managementClass = new ManagementClass("Win32_Share");

// Create ManagementBaseObjects for in and out parameters
ManagementBaseObject inParams = managementClass.GetMethodParameters("Create");
ManagementBaseObject outParams;

// Set the input parameters
inParams["Description"] = "My Files Share";
inParams["Name"] = shareName;
inParams["Path"] = folderPath;
inParams["Type"] = 0x0; // Disk Drive

// Invoke the method on the ManagementClass object
outParams = managementClass.InvokeMethod("Create", inParams, null);

// Check to see if the method invocation was successful
if ((uint)(outParams.Properties["ReturnValue"].Value) != 0)
{ throw new Exception("Unable to share directory.") }
}

public void RemoveShare(string shareName)
{

// Create ManagementBaseObjects for in and out parameters
ManagementObject mObject = new ManagementObject("root\\cimv2", "Win32_Share.Name='" + shareName + "'", null);
ManagementBaseObject outParams;

// Invoke the method on the ManagementClass object
outParams = mObject.InvokeMethod("delete", null, null);

// Check to see if the method invocation was successful
if ((uint)(outParams.Properties["ReturnValue"].Value) != 0)
{
throw new Exception("Unable to remove share.");
}

}
}
}

.Net WinForms Control.Focus

2008-05-18T12:11:00.001-07:00

Today I spent a good amount of time to set the focus for my newly created text box. Somehow the txtName.Focus() was returning false. After googelling for a while, I realized that the control was not added to parents collection which prevented it to gain the focus.

So, if you are creating the control by yourself remember to add it first to parents control collection and then call Control.Focus().

Also, visit http://msdn.microsoft.com/en-us/library/system.windows.forms.control.focus.aspx for more details on further requirements for setting control's focus.

PowerCommands in Visual Studio

2008-04-22T02:25:00.000-07:00

I always found it cumbersome to expand and collapse project items in solution explorer tree, especially when one has more than 5 projects in a solution. Though there should be a command like "Collapse All" or "Expand All". My wish has been fulfilled by PowerCommands for Visual Studio 2008.

PowerCommands is a Visual Studio extensibility package developed by VSX team at Microsoft. The installation package and source code is available at http://code.msdn.microsoft.com/PowerCommands/Release/ProjectReleases.aspx?ReleaseId=559. In order to compile the source code you will need Visual Studio 2008 SDK available at http://www.microsoft.com/downloads/details.aspx?familyid=30402623-93ca-479a-867c-04dc45164f5b&displaylang=en.

The package makes few things really easy and enhances productivity. It has features like:

Copy and Paste references from one project to another
Open Visual Studio Command prompt with project location as directory
Copy project as reference so that it can be pasted in another project as reference
Convert constant strings inside source code to string constants
Close all open editors (documents) etc. etc.

For more details please refer to http://blogs.msdn.com/vsxteam/archive/2008/02/29/PowerCommands-for-Visual-Studio-2008-released.aspx.
I am going to extend the source to add specific commands for my current project. Will write about that next.

Enjoy!