.Net'ers

A simple method to calculate age in years in C# and JavaScript.  Additional info on the number of days in a year can be found here.

C#
public static double CalculateAge( DateTime birthDate )
{
    double daysPerYear = 365.242199;
    TimeSpan span = DateTime.Now.Subtract( birthDate );
    double age = span.TotalDays / daysPerYear;   

    return age;
}

JavaScript
function CalculateAge( birthDate )
{
    var msPerDay = 1000 * 60 * 60 * 24;
    var daysPerYear = 365.242199;
    var age = ( new Date() – new Date(birthDate) ) / msPerDay / daysPerYear;
    return age;
}

I love the ability to have recent files listed and various shortcuts for documents of an application pinned to a program’s taskbar icon in Windows 7.  I had shortcuts to Visual Studio 2008 and Visual Studio 2005 pinned to the taskbar, but unfortunately, when you right click the taskbar icons you don’t get access to the most recently used solutions and projects – you only get the most recently used files.  You can’t even manually pin solutions or projects to them.  There is, however, a workaround!

Find your Visual Studio “VSLauncher.exe” application.  For me, it was located in: “C:\Program Files (x86)\Common Files\microsoft shared\MSEnv\VSLauncher.exe”.  Pin that to the taskbar.  You now have access to your most recently used items and you can also pin shortcuts to solutions and projects to that icon.

Here’s a screen shot (with some project & solution names partially blocked out).  Enjoy!

Starting with ASP.NET 2.0, Web Site projects were introduced and allowed for the compilation of the code-behind file for each page and usercontrol into single page assemblies/DLLs (see Figure 1 below). This option works well for the individual pages and usercontrols, however, by default all classes in the App_Code directory are compiled into a single DLL, even if App_Code contains separate sub-directories.

Figure 1. Publish Web Site Options

This normally is not an issue, however, with a recent Web Site that only contain three pages (Medical, Dental and Life), we did not want the classes (the logical tiers) in the App_Code directory combined into one DLL because each page was independent and we could be delivering changes for one page while working on enhancements for the others…we needed separate DLLs for the tiers as well as the pages and usercontrols.  The simplest solution would have been to deploy the source code files, but that was not an option.  Another solution was to create separate Business, Model (custom business objects) and Data projects for each page, but that seemed like overkill.

ASP.NET does support the use of classes in multiple languages within the same project, and those are compiled into separate DLLs by creating codeSubDirectories under App_Code, but you must also specify that you are using code sub-directories in the Web.Config file, <compilation> element (see Web.Config snippet below).

In our case though, we are using the same language (C#), but the concept is the same. We created the sub-directories, updated the Web.config file compilation section to include the appropriate codeSubDirectories, re-compiled the site and a separate DLL was generated for each sub-directory (see Bin Folder contents below).

Note: According to the above link “The build order is inferred from the top-down order of the codeSubDirectories collection. The App_Code directory is built last. However, there are no build order dependencies, therefore that the build order is not significant.”  In practice, if you place the Business folder before the Data folder in the Web.Config file, classes in the Business folder won’t be able to reference classes in the Data folder.  It seems the build order does matter.

Sample Project Solution

Web.Config

<compilation debug=“false“>

<!–Code SubDirectories added in order to have separate DLLs
for each product/page to simplify future maintenance and deployment –>
<codeSubDirectories>

<add directoryName=“Common“/>
<add directoryName=“Model“/>
<add directoryName=“MedicalData“/>
<add directoryName=“MedicalBusiness“/>
<add directoryName=“DentalData“/>
<add directoryName=“DentalBusiness“/>
<add directoryName=“LifeData“/>
<add directoryName=“LifeBusiness“/>
</codeSubDirectories>

</compilation>

Bin Folder

App_SubCode_Common.dll
App_SubCode_DentalBusiness.dll
App_SubCode_DentalData.dll
App_SubCode_LifeBusiness.dll
App_SubCode_LifeData.dll
App_SubCode_MedicalBusiness.dll
App_SubCode_MedicalData.dll
App_SubCode_Model.dll
App_Web_dental.aspx.f9b0821e.dll
App_Web_life.aspx.f9b0821e.dll
App_Web_medical.aspx.f9b0821e.dll

Ken Getz wrote a good article titled Predicates and Actions about the advantage of the new generic features in .NET 2.0 Framework.  One issue I ran into using predicates was passing an argument to use as the filter.  For example, in the callback method Match() below, the predicate searches the states generic list for those that start with “C”, but the string to search for is hardcoded because the predicate signature only allows for one argument that is of the same type as the items in the generic list.

Using a Lambda Expression removes the need for a callback method (anonymous methods as well), so the filter is inline or it could be encapsulated in the method that takes the filter as an argument.

The following code snippet lists 3 different ways to find an item in a generic list.

static void Main( string[] args )
{
    // Create an abbreviated subset of states
    List<string> states = new List<string> {
            "AL", "AZ", "CA", "CO", "MA",
            "MD", "NJ", "NV", "TX", "TN" };

    //----------------------------------------------------------
    // You do not need to create the delegate explicitly
    // http://msdn.microsoft.com/en-us/library/bfcke1bz.aspx
    //----------------------------------------------------------
    //
    // Using an concrete method that matches the predicate 
    // signature to find the matching states
    List<string> methoddel = states.FindAll( Match );

    // Using an Anonymous Method to find the matching states
    List<string> anonymous = states.FindAll(
        delegate( string s )
        {
            return s.StartsWith( "C" );
        } );

    // Using a Lambda Expression to find the matching states
    //(new w/ C# 3.0)
    List<string> lambdaexp =
        states.FindAll( s => s.StartsWith( "C" ) );

    // Display the output from lambdaexp
    lambdaexp.ForEach( Print );

    Console.ReadLine();
}

// Finds the matching states
static bool Match( string s )
{
    return s.StartsWith( "C" );
}

// Display the contents
static void Print( string s )
{
    Console.WriteLine( s );
}

In .NET you can create and initialize an Array of strings or a generic List<string> in C# using a comma-delimited list.  However, the only way I’ve found so far to do the same thing with a generic List(Of String) in VB.NET is to use an Array of strings as a parameter for the List like this.

VB.NET

Dim states As List(Of String) = New List(Of String) _
    (New String() {"AL", "AZ", "CA", "CO", "NV", "OK"})

C#

List<string> states =
     new List<string>() { "AL", "AZ", "CA", "CO", "NV", "OK" };

Get the name of the current ASP.NET page.

string path = System.Web.HttpContext.Current.Request.Url.AbsolutePath;
string name = System.IO.Path.GetFileName( path );