Technocratica - Plebeian Crucibles

Designing with Umbraco : XSLT vs User Controls

2011-06-13T22:51:00.001-07:00

in Jan, I wrote my first post on Umbraco and how to build a simple Hello World page using Umbraco. Having spent the last few months working on Umbraco, I have to say, my liking for Umbraco has only grown. It is a fairly simple CMS and unlike Sharepoint, does not complicate the whole authoring experience. You could always argue that Sharepoint is comprehensive but that’s a discussion we will save for another post.

Back to what you can do with Umbraco, there are really two major options as an Umbraco developer to build UI; XSLT and User Controls. A lot of times as a developer, the decision you have to make is which way to go. As with a lot of other design discussions, the perfect answer is “It Depends”. But during the course of this post, I will try and unravel that generic answer to some realistic scenarios. I am going to try and layout the factors that I usually consider when deciding one way or the other. Keep in mind that this post is written targeting the web form model of Umbraco and come razor, some of these could change.

XSLT

XSLT is the in-thing when it comes to content managed sites. It gives you the option of giving flexibility to the content author to change the way the page is displayed making it truly content managed.

With umbraco, you get the option of using XSLT to do almost everything you want. I have typically used the following constructs to decide if XSLT is the best fit

Fluctuating UI Changes - You think something is going to change often. A typical scenario is where you have HTML tags emitted within the macro. Though there are ways and means of getting the styling changed with css, there are times when you have no choice but to emit HTML. XSLT is a natural choice in such scenarios

Navigate Content Tree- If you have to work with the Umbraco content tree. Since the Umbraco content tree is XML, XSLT becomes a natural choice if you have to navigate through the content tree.

Compliance to Standards – There are a lot of content managed standards that are prevalent. Standards like DITA are becoming more of a requirement nowadays when authoring sites. A lot of these CMS standards depend on XML and XSLT.

When in Doubt – Yes. We all come across instances when we are not sure whether to use XSLT or user controls. In such cases, my recommendation will be to start off with XSLT unless you hit an implementation roadblock that forces you to change to User Controls.

User Controls

User controls are the most natural choice for most .NET developers because they relate to it better due to their familiarity with .NET. But with XSLT being so powerful, the use of user controls for me, is limited to the following scenarios

Code Abstraction – When you do not want site managers or authors to see the code. A valid argument is that the permissions to viewing XSLT can be restricted as well through the User Permissions but bear in mind that XSLT is file based in Umbraco so users who have permissions to access the XSLT folder can view, copy or do anything with the code. If you do not want users to see what your code is doing, stick to the user control model.

Interaction with external web services – This is one of the scenarios for which I still use User control. Theoretically, it is still possible to write an XSLT extension that talks to the web service and use that within XSLT but I think it is beneficial only in scenarios where you are using the strong points of XSLT. One more interesting approach when using webservices is to use javascript and jquery templates. You could completely eliminate a macro in this scenario by having the webservice return JSON.

Parallelism – If you want to write muti-threaded code or use PLINQ then you do that only with user controls; so they become a forced choice

Use ASP.NET Features - Though this looks like a no-brainer, the caveat here is that you can still access some of the features from XSLT. The umbraco.library does have methods to get the query string or the form variables. But if you want to check if a page is posted back or not, you cannot do that in XSLT without doing some hacks.

Unit Testing Requirements – If your project requires to have high code coverage then move away from XSLT.Though there are XSLT Unit Testing suites, they are still nascent and wont really improve your code coverage results.

Though the above list might not be exhaustive, I have tried to cover scenarios in my experience with Umbraco so far. I will be interested in knowing if there are any scenarios that you have come across that isn’t covered in this post and if you agree\disagree to the observations made in this post.

My first page with Umbraco

2010-11-16T19:15:00.001-08:00

Technorati Tags: Umbraco,CMS,ASP.NET

After a small Diwali break, I am back to my blogging. The focus of this post is going to be a CMS from MS called Umbraco. I came to know about Umbraco from one of my friends. Having been involved in developing and designing a few content managed websites, I decided to take a deeper look into Umbraco. It is just a week since I started playing around with it but I thought I will get started off about creating a first page with Umbraco as I delve into other advanced aspects and figure out how to get it done.

For the unfamiliars, Umbraco is an ASP.NET based CMS. You can install Umbraco by using the web platform installer. The installation is fairly easy and self-explanatory. After you have installed it, launching Umbraco will give you the admin log in page. Use the credentials you used during set up to log in. Your home page will look like below

Settings is where to start off creating the first page. Clicking on Settings will reveal the tree view that shows the building blocks that we will use to build our site. Let us focus on Templates and Document Types for a second. These are the two most important artifacts we will use to come up with a content managed page. For those of you familiar with Sharepoint, Templates are like Master Pages and Document Types are like Page Layouts.

The first step in creating a site is to get the master page and the style sheets done. Since Umbraco is a folder based CMS, you should be able to copy your existing Stylesheets to the stylesheet folder under the Umbraco virtual directory and you are good to go. Though it does work for the master pages to some extent, I had a bit of an issue getting Umbraco to recognise the master pages I had copied. So, I create the master page through the Umbraco interface. You have to right click on Templates and then Click on Create. Once you provide the name and confirm the creation, you will have the ability to add HTML content to the master page. The interface will look as shown below

Umbraco, by itself creates a nested master page. You just have to put in your content. Since it is a nested master page, be sure you put the content inside your content place holder (in my case called “ContentPlaceHolderDefault”). You will also see that you have the option of using one of your own master pages as the parent master page.

Once the master page is done, the next step is to go ahead and create a document type that we will use to put in content. Its quite easy to create a document type. You just right click and say Create.

Give a name for the Document Type and select the Template that this document type will use. You can change this later too so don’t worry too much about selecting the wrong master page.

The document type is where most of the work happens to make a page content managed. There are four tabs for every document type you create. The first tab is the Info tab where all the details of the document type are displayed. You can provide an alias and associate the document type with an image. You can also set what Master Pages this document type can use and what is the default Master Page for this document type. Below is an example of the HomePage document type I created.

Next, let us examine the Tabs tab. In this tab, you can create tabs that will be displayed when this document type is used to create content. To show how it works, I have created a tab called Content that will hold the rich text box for the content author to put in the content.

The next step is to let the document type know that it has to display a rich text box in the Content tab. You do this by creating a property of type Rich text box in the Generic Properties tab under Content.

As you can see in the screenshot, I have created a “HelloWorldContent” property of type rich text box. You can also create properties of various other types. These types are essentially controls. Do note that the alias is like the HTML id of the control. You can also set if the content in this is mandatory and what regular expressions can be used to validate the content but we will save that for later. Now that the document type is created and we have created a rich text control as a part of the document type, we have to let the master page know where to display the content of the rich text box.

This can be done by inserting a page filed in the master page. Go back to the Master Page and click on Insert Page field in the tool bar above the master page. The below window will open up. If you have created the property right, then you should see it in the Choose Field dropdown. Select the field and leave the other fields to default. Save the master page.

We are done with the administration part. The final step in creating a page is the content authoring page. All content authoring in Umbraco is done in the Content screen. Click on Content in the Sections area. Right Click on the top level Content and click on Create. This pulls up a window with a text box for naming your page and a dropdown with the list of created Document Types. Choose the document type you just created and give the page a name. In my case, I choose to call it HomePage. Post creation, you will see two tabs Content and Properties as seen below.

The order in which they are displayed depends on the Sort Order I have set in the Tabs tab of the document type. The content author can put in any content in the rich text box and publish the page by clicking the Save and Publish icon. As soon as you publish, Umbraco generates a URL which you can view in the Properties tab. The page that I have created is shown below

Phew!!! That was quite a long post. I am sure this is the first of many to come from me on Umbraco. If you want to to get adventurous with Umbraco too, take a look at their site. For starters I found this site too very useful. Please feel free to leave your comments on this post and as always, Happy Coding!!!

HTML5.Decode

2010-09-22T01:00:00.001-07:00

Technorati Tags: HTML5,HTML,HTML 4 vs HTML 5

Most of us would have heard that HTML 5 is in the works. It can be expected that almost all new browsers (some of the browsers already do) will now start supporting HTML5. What does it mean for developers and architects? This post will take a look at HTML 5 and some of the new elements in HTML 5. Detailed insights into the working of individual elements is out of scope for this particular post but I have provided links to references wherever necessary

1. Standards: One of the biggest changes in HTML 5 is that it is no longer based upon SGML. Though this does not impact developers or the architect community directly, it is good to know this because the HTML document no longer needs a DTD to render. So the !DOCTYPE element is now redundant. However, this element now performs a different function. It actually tells the browser if the document has to comply to standards or not. You can do this by setting the DOCTYPE to either of the three allowed modes; quirks mode, limited quirks mode and no quirks mode.

2. New Elements: HTML 5 has introduced a lot of new HTML elements. The new elements fall into one (sometimes multiple) of the below categories

Sectioning – Sectioning can internally be divided into root and content. Root is a type of element that can have children under it. One of the new sectioning root element in HTML 5 is <figure>. <detail> is another sectioning root element that is new on the block. The <detail> element lets you hide details unless the user wants to view them explicitly. For example, you are showing only the name of the user and you want to show the details only if the user clicks on a button or a link. The sectioning content category contains new elements like <nav>, <article> and <section>. While <nav> identifies sections intended for navigation (similar to a sitemap), <section> and <article> isolate elements in a HTML Page. <article>, for example, is intended for something like a blog entry which can be distributed independently.
Heading – The heading category introduces <header> and <hgroup> tags. While there were already 6 header tags <h1> to <h6>, you can now wrap them inside the newly introduced <header> and <hgroup> tags. While the <header> tag identifies something as a header section, the <hgroup> tag can be used to categorise the 6 header tags as subsections.
Embedded Content – In HTML 4, we used the object tag to display video or play audio. In HTML 5, we have separate tags to embed audio or video in the page. <video> and <audio> tags do exactly this. Apart from these tags, there is also the <embed> tag that helps you embed any other plug in. One of the more important embedded elements is also the <canvas> that helps you display graphics or dynamic images.
Phrasing Content – These are the HTML elements that can include normal text mark up. <span> is an example of phrasing content. <mark> is a new phrasing element in HTML 5. This is like the highlight text is MS Word. Using mark you can highlight text in a document for example, search results. <progress> element helps you show progress bar. There are other Phrasing elements like <time> which help you show timestamps on your page. There is also the <datalist> element which now helps you create re-usable list options in your page.
Menus and Commands – Though both the <menu> element and <command> element are phrasing content, I have called them out separately because of the significant differences from the previous version. <menu> element, which was deprecated in HTML 4 has been reintroduced in HTML 5. The menu element can now be enhanced using the <command> element. The <command> element allows the user to execute commands specified as a part of the element.

3. New Attributes: HTML 5 has also introduced a whole set of new attributes to existing elements. One of the most significant additions is to our favorite <input> tag. The type attribute of the <input> tag now has some new additions. Some of these are search, month, date etc. See here for the complete list of new values.

The <area> element now has a host of new attributes. I am listing some of them below

ping – this attribute contains a list of space separated URLs that are pinged when the URL is clicked. This is useful for content targeting and can be turned on or off by the user.
media – This attribute is similar to the media attribute in the link element. This is again used to specify the type of media a link targets
hreflang and rel – Again, these do the same function as in a link element.
target – this attribute which was deprecated has been re-introduced.

There is now an autofocus attribute to elements like <input> and <select>. This will declaratively set the focus on the control when the page loads. This is something the user can turn off if he does not want to use.
There is a required attribute to the <input> element which validates mandatory fields.
A new form attribute for text element inputs help the developer specify which form the specific element belongs to. This way, it is not necessary that all the elements lie within a form. They can be placed outside the form but still be a part of it in the HTML DOM.
You can now disable validation of a form by using the novalidate attribute in the form element.
The individual input elements now have attributes like formaction, formtarget which overrides the value set in the form tag. This way, a single page can submit to multiple targets declaratively
You can now write scoped style sheets by using the scoped attribute of the style element. for example, if you want the style to be applied only to a specific scope like one flow section, you can mention that by setting the scoped attribute to true.
Developers also have more control over when a particular script is being executed by using the async and the defer attributes in the script element.
The iframe element has a set of new attributes that controls how the content within the iframe behave. Using the sandbox attribute, for example, you can now restrict users from clicking links or executing active content within an iframe. There is now also a srcdoc attribute using which you can specify the source of an iframe to be a document with a valid DOCTYPE
Some HTML attributes have now been upgraded to global attributes which means they will now be available across all the elements. Examples of such attributes are class, id, lang, dir etc. There are also new global attributes and event handlers in the list.
The draggable attribute is more powerful and can be used in conjunction with the new drag & drop APIs in HTML 5

4. Absent Elements: Some of the defunct elements are frame, frameset, acronym, applet, font

I will conclude this particular post here. Please be advised that HTML 5 is still being developed and some of the above may change. You can always find the latest reference to HTML 5 specifications here. One of the things that has not been covered as part of this post are the HTML APIs and the changes in these APIs. Hopefully I will come out with another post that concentrates on the HTML 5 APIs. Till then ciao and happy coding!!!

Enterprise Library 5.0 – Configuration Services Part - III

2010-08-30T10:20:00.001-07:00

Technorati Tags: enterprise Library 5.0,parentSource

The previous two posts on Configuration Services showed how we can use an external configuration file and how we can use a specific section from an external config source.

In the final post of the Configuration Sources series, we will look at what I personally think is one of the most useful features of Configuration Services. We will see how we can have the application configuration file inherit from another configuration file and override or add only sections that are application specific. I will give you a scenario where this can be very useful.

In one of my recent projects we were developing a number of websites. Except for some application specific key value pairs a lot of the other environmental configurations were the same across most of these websites. With this feature, it will be very easy to isolate the environmental specific values in a separate configuration file, inherit the same and add key value pairs to store application specific values.

To show how this works, I have a shared config file that looks like the below.

        1: <configuration>   2:     <configSections>   3:         <section name="loggingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.LoggingSettings, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />   4:     </configSections>   5:   <connectionStrings configSource="">   6:        7:   </connectionStrings>   8:     <loggingConfiguration name="" tracingEnabled="true" defaultCategory="General">   9:         <listeners>  10:             <add name="EntLIbTestListener" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.FormattedEventLogTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  11:                 listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.FormattedEventLogTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  12:                 source="Enterprise Library Logging" formatter="Text Formatter"  13:                 log="" machineName="." traceOutputOptions="None" />      14:         </listeners>  15:         <formatters>  16:             <add type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  17:                 template="Timestamp: {timestamp}{newline}&#xA;Message: {message}{newline}&#xA;Category: {category}{newline}&#xA;Priority: {priority}{newline}&#xA;EventId: {eventid}{newline}&#xA;Severity: {severity}{newline}&#xA;Title:{title}{newline}&#xA;Machine: {localMachine}{newline}&#xA;App Domain: {localAppDomain}{newline}&#xA;ProcessId: {localProcessId}{newline}&#xA;Process Name: {localProcessName}{newline}&#xA;Thread Name: {threadName}{newline}&#xA;Win32 ThreadId:{win32ThreadId}{newline}&#xA;Extended Properties: {dictionary({key} - {value}{newline})}"  18:                 name="Text Formatter" />  19:         </formatters>  20:         <categorySources>  21:             <add switchValue="All" name="General">  22:                 <listeners>  23:                     <add name="EntLIbTestListener" />  24:                 </listeners>  25:             </add>  26:         </categorySources>  27:         <specialSources>  28:             <allEvents switchValue="All" name="All Events" />  29:             <notProcessed switchValue="All" name="Unprocessed Category" />  30:             <errors switchValue="All" name="Logging Errors &amp; Warnings">  31:                 <listeners>  32:                     <add name="EntLIbTestListener" />  33:                 </listeners>  34:             </errors>  35:         </specialSources>  36:     </loggingConfiguration>  37: </configuration>

This is the same configuration as I have used in Part I and II with the logging settings. To use this as my parent configuration, I have to set a couple of properties. I have to set the Parent Source of my config file to the common config file I have created above. The settings are shown in the screenshot below. I have also changed the configuration source to be System Configuration which means my local app.config is being used.

Notice how this configuration file does not have any logging settings. After these changes, my config file now looks like

      1: <?xml version="1.0" encoding="utf-8" ?>   2: <configuration>   3:     <configSections>   4:         <section name="enterpriseLibrary.ConfigurationSource" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceSection, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />   5:     </configSections>   6:     <enterpriseLibrary.ConfigurationSource selectedSource="System Configuration Source"   7:         parentSource="Shared Config">   8:         <sources>   9:             <add name="System Configuration Source" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />  10:             <add name="Shared Config" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.FileConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  11:                 filePath="C:\Users\r.vaideeswaran\Documents\Visual Studio 2010\Projects\EntLibTest\EntLibTest\CommonConfig.config" />  12:         </sources>  13:     </enterpriseLibrary.ConfigurationSource>  14: </configuration>

Notice how there are now two sources added; one is the system configuration source and the other points to the shared configuration file.

As a first step, let me now test the logging code I wrote in the previous two parts. For re-cap, here is the code

      1: namespace EntLibTest1   2: {   3:     class Program   4:     {   5:         static void Main(string[] args)   6:         {   7:             LogWriter textWriter = EnterpriseLibraryContainer.Current.GetInstance<LogWriter>();   8:             LogEntry testEntry = new LogEntry();   9:             testEntry.Message = "Logging the loading of EntLibTest1";  10:             testEntry.Priority = 2;  11:             testEntry.Categories.Add("General");  12:             textWriter.Write(testEntry);  13:    14:             Console.WriteLine("Message Logged");  15:             Console.ReadLine();  16:         }  17:     }  18: }

This does indeed produce a “Message Logged” output on the console though there are no logging sections directly in my config. This tells me that my parent source is working. The next step is now to add a specific section and see if that works.

I add a new key value pair in the appSettings section through enterprise library. The screenshot for the same is as below.

This is our good old appSettings key value pair. Unsurprisingly, the config is now changed to reflect the above settings.

   1: <?xml version="1.0" encoding="utf-8" ?>   2: <configuration>   3:     <configSections>   4:         <section name="enterpriseLibrary.ConfigurationSource" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceSection, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />   5:     </configSections>   6:     <appSettings>   7:         <add key="ConnectionString" value="TestConnectionString" />   8:     </appSettings>   9:     <enterpriseLibrary.ConfigurationSource selectedSource="System Configuration Source"  10:         parentSource="Shared Config">  11:         <sources>  12:             <add name="System Configuration Source" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />  13:             <add name="Shared Config" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.FileConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  14:                 filePath="C:\Users\r.vaideeswaran\Documents\Visual Studio 2010\Projects\EntLibTest\EntLibTest\CommonConfig.config" />  15:         </sources>  16:     </enterpriseLibrary.ConfigurationSource>  17: </configuration>

To make sure my app can retrieve the appSettings value, I add the following three lines of codev(Do not forget the usings at the top)

  1: AppSettingsReader connReader = new AppSettingsReader();  2: var connString = connReader.GetValue("ConnectionString", typeof(string));  3: Console.WriteLine(connString.ToString());

Nothing fancy. Now when I run the application, you will see that the application picks up both the logging configuration and the appSettings key. This happens because at run time the Enterprise library merges the two configuration files so that they act as one. The above example did not specifically override a section but if I were to override, the value in the local configuration will take precedence over the shared configuration.

That concludes my three part starter posts on Configuration Services. The Configuration Services is no where near perfect yet but as with anything else, I am sure this will evolve over multiple releases. Happy Coding!!!

Enterprise Library 5.0 – Configuration Services Part -II

2010-08-19T11:09:00.001-07:00

Technorati Tags: Enterprise Library 5.0,Configuration Services,configSource

Last week, we saw how to use the same configuration file for two different applications. If you have not read the post yet, you can read it here. This week, we will look at how configuration services can help you use a section from a shared configuration file. For the sake of continuity, I will use the same example we used in the previous post.

In the previous post, we added a separate logging section, the change here is that we will just add a redirected section in the Configuration Sources element itself. To enable section redirection, the following has to be done

Change the configuration source to System Configuration Source. This will enable the application to use its default app.config
Add a redirected section. You can do this by expanding the Configuration Sources section and then add a redirected section. The source of the configuration section should now point to the section in the external file. The screenshot below shows how to add a redirected section

The configuration file now looks like the below

        1: <?xml version="1.0" encoding="utf-8" ?>   2: <configuration>   3:     <configSections>   4:         <section name="enterpriseLibrary.ConfigurationSource" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceSection, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />   5:     </configSections>   6:     <enterpriseLibrary.ConfigurationSource selectedSource="System Configuration Source">   7:         <sources>   8:             <add name="System Configuration Source" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />   9:             <add name="Shared Config" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.FileConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  10:                 filePath="C:\Users\r.vaideeswaran\Documents\Visual Studio 2010\Projects\EntLibTest\logging.config" />  11:         </sources>  12:         <redirectSections>  13:             <add sourceName="Shared Config" name="loggingConfiguration" />  14:         </redirectSections>  15:     </enterpriseLibrary.ConfigurationSource>  16: </configuration>

Note how the logging is now configured as a redirectSection. This will ensure that the logging section is picked up from the shared config file. The code in the previous post will now work with this configuration as well without any changes. For the sake of reference, below is the code

      1: class Program   2: {   3:     static void Main(string[] args)   4:     {   5:         LogWriter textWriter = EnterpriseLibraryContainer.Current.GetInstance<LogWriter>();   6:         LogEntry testEntry = new LogEntry();   7:         testEntry.Message = "Logging the loading of EntLibTest1";   8:         testEntry.Priority = 2;   9:         testEntry.Categories.Add("General");  10:         textWriter.Write(testEntry);  11:    12:         Console.WriteLine("Message Logged");  13:         Console.ReadLine();  14:     }  15: }

While in theory, this is the same as using the configSource for a particular setting, one of the advantages is that configSource doesnt permit you to use absolute paths (except for appSettings where you can use the file attribute instead of configSource). Sometimes, this can be a real pain. The Ent Lib Configuration Sources solves that problem.

Hope I was able to give you an idea of how to use a redirected section with Ent Lib 5.0. Happy Coding!!!!

Enterprise Library 5.0 – Configuration Services Part - I

2010-08-08T07:45:00.001-07:00

Technorati Tags: Enterprise Library 5.0,Configuration Services,.NET

Microsoft recently released Ent Lib 5.0. While most of the application blocks are the same as 4.1, one of the new kids on the block is Configuration Services. Hence, I will start off this series on Ent Lib 5.0 by taking a closer look at the Configuration Services.

The configuration services provides three capabilities when it comes to managing config files

Ability for multiple applications to use the same config file
Ability to use of a specific section from a shared config file
Ability for a configuration file to inherit from another config file

In this post, we will see how to enable multiple applications to share the same config file.

Multiple Applications using the Same Config File

I will start off by creating a simple console application. For first timers, right click on the config and you should see a context menu to edit enterprise library configuration.

Clicking on the menu brings up the Ent Lib configuration console. The console has been re-designed in the latest version of enterprise library. To add a configuration source section, there is a menu called “Add Configuration Settings” under Blocks menu. Click on it and you should see a Configuration Section now added. Click on the icon to expand the section and add a File Based Configuration Source.

Provide the values of the config name and the path of the config file. In the selected source dropdown, select the shared source that we have just configured. Save the settings and right click on the Configuration Sources section and click on Validate. You will get the list of warnings and errors, if any. Let us take a moment to look at the changes in the config. The following section has been added under the <configuration> section

<configSections>
<section name="enterpriseLibrary.ConfigurationSource" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceSection, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />
</configSections>

<enterpriseLibrary.ConfigurationSource selectedSource="Common Config">
<sources>
<add name="System Configuration Source" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
<add name="Common Config" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.FileConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
filePath="CommonConfig" />
</sources>
</enterpriseLibrary.ConfigurationSource>

When you close the enterprise library console, you should now see a commonconfig.config file in your project path. Right click and include the same in your project. Make sure you change the property of the file to copy over to the output path. This will now be the configuration that your application now uses.

To test this, I have added a logging application block and used the following code to log an entry into the event log.

        1: LogWriter textWriter = EnterpriseLibraryContainer.Current.GetInstance<LogWriter>();   2: LogEntry testEntry = new LogEntry();   3: testEntry.Message = "Logging the loading of EntLibTest";   4: testEntry.Priority = 2;   5: testEntry.Categories.Add("General");   6: textWriter.Write(testEntry);   7:     8: Console.WriteLine("Message Logged");   9: Console.ReadLine();

Do remember to make the appropriate configuration changes to ensure logging is enabled. Running the application creates an entry in the event log. I now add another project to the same solution and update the configuration source to point to the commonconfig.config of the first project. Below is a snapshot of how my config for the second project looks like.

You should be able to run the application without making any other changes and ensure that messages are logged from the second console application as well.

Before all you web developers get excited, please remember that this feature does not work with web applications just yet. You can see the details of why in this blog.

That concludes our first look at Configuration Services in Enterprise Library 5.0. I will dig into the other two aspects in subsequent posts. Happy Coding!!!

Code Generation with VS 2010

2010-07-19T11:56:00.001-07:00

Technorati Tags: VS 2010,Code Generation,UML,Architecture

Have been off for quite some time, so its good to be back blogging. I will start off with a relatively light post.

All of us know that you can create Architectural Diagrams in VS 2010 using the architecture menu. But once, you have done creating the diagrams how do you actually make the diagrams generate code? The last thing you want to do is to create the diagrams and write the code for it manually.

Though VS 2010 does not have built in support for code generation, you can have it generate code by downloading and installing Visualisation and Modelling Feature Pack.

Once you download and install the feature pack from the link above, there are a couple of small things you have to do to get your diagrams ready for code generation. The first thing is to set a profile to your model. i.e tell the model which language to generate code.

You can do this by viewing the properties of the model explorer. You should see an attribute called Stereotypes as shown in the diagram below.

Select C# namespace. As you can see, the whole code generation works on T4. So if you want to have code generated in SQL for example you could just write your text transformation templates and you should be ready to go.

Actually, there is a very good blog here on how exactly to write your own T4 templates for code generation.

Once you have done that, you can then configure how your classes and namespaces should be named and organised. You do this by clicking on Architecture-> Configure Default code generation settings.

Beware, by default, the namespace is always the name of the model so be wary when you name the model because once you set it, you will not be able to change it. You should now be ready to start generating code. Right click on your modelling diagram and you should see a generate code menu as shown. You can set the path under which you want the class to be generated here.

Working with Hierarchical data in SQL Server 2008

2010-01-01T10:05:00.001-08:00

Technorati Tags: HierarchyId,SQL Server 2008,CTEs

In my series on SQL Server 2008, one of the features I had missed was the HierarchyId datatype and its usage. I came across this recently and decided to take a peek into what it does. This post covers my thoughts on the HierarchyId datatype.

At the time of this writing, I am still not convinced on the value add the HierarchyId datatype provides over traditional parent/child storage mechanisms. More on that later. For now, we will deal with how the datatype works and how it can be used to store hierarchial data.

The big advantage with HierarchyId is that it is optimised to store data in a tree structure thereby making it simpler for developers to query and update hierarchical information. The important thing to keep in mind is that using the hierarchyid by itself does not mean that data is stored in a tree structure. It is the responsibility of the application to make sure that the data is stored in the desired structure. HierarchyId just acts as an enabler.

To demonstrate this, I will work through an example where we have to store the list of folders and files in the database. I have created a table with the following structure.

Create Table FileExplorer
(
    ItemId HierarchyId Primary Key,
    ItemLevel as ItemId.GetLevel(),
    ItemName varchar(100)
)

I will touch upon the ItemLevel column later. Do note that the HierarchyId datatype by itself is not unique. It is application’s responsibility again to maintain the uniqueness of the ItemId column and hence I have declared a PrimaryKey on that column.

Coming to ItemLevel column, the primary purpose of that is to enable breadth first ordering. Typically, hierarchy ids can be breadth first or depth first indexed. You can find the details and working of both these types of ordering here.

Now, let us create the breadth first index. Depending on how many levels (called fan-outs) you plan to store, your indexing strategy will vary. It is not necessary to create both the indexes for all the scenarios.

CREATE INDEX FileExplorer_Breadth_First
ON FileExplorer(ItemLevel,ItemId)
GO

Since the FileExplorer table already has a Primary key, the above index will be created as a non-clustered index.

Now that we have created the table, let us start loading data into the table. If you haven’t already noted, let me point out that the ItemId is not declared as an Identity (it cannot be, actually) and hence it is the application’s responsibility again to make sure that the generated ids are unique. In addition, to ensure the tree structure, we have to make sure the id generated is based on the parent id.

The stored procedure to insert a new file or folder is

CREATE PROCEDURE InsertFile(@folderId hierarchyid, @ItemName nvarchar(100) )
AS
BEGIN
DECLARE @last_child hierarchyid

SELECT @last_child = MAX(ItemId) FROM FileExplorer
WHERE ItemId.GetAncestor(1) = @folderId
INSERT FileExplorer (ItemId, ItemName)
SELECT @folderId.GetDescendant(@last_child, NULL), @ItemName
END ;

Let us examine this procedure for a second. The ItemId.GetAncestor(1) gets the immediate parent of the ItemId. So essentially, the select statement gets the last valid file under the given folder id. Now that we have the last inserted item under the parent, our new file has to be created as a peer to that item.

This is done by the second select statement in the procedure. We use the GetDescendant method to create a child similar to another child, in this case, the item retrieved from the previous select. It wouldn’t be out of place to mention here that this is where our breadth first ordering helps.

The tree can also be maintained by creating a parentId column that references the itemId but there is also a performance drag associated with that approach. A snapshot of the data after inserting some rows is as below

Note how the item level computes itself. The folders testFolderChild and TestfolderChildPeer are at the same level and have the same parent –TestFolder.

Let us now see how we can retrieve the list of parents for a given node. To do this, I had to write a stored procedure using CTEs. Below is the stored procedure I wrote

create proc dbo.GetAncestors(@ItemId hierarchyId)
as
begin

With AncestorsList(Itemid, ItemName, ItemLevel, Parent)
As
(
    Select ItemId, ItemName, ItemLevel, ItemId.GetAncestor(1) as Parent from Fileexplorer where ItemId=@ItemId
    UNION ALL
    Select fe.ItemId, fe.ItemName, fe.ItemLevel, fe.Itemid.GetAncestor(1) from FileExplorer fe Inner Join AncestorsList al
    ON fe.ItemId = al.Parent
)
    Select fe.ItemId, fe.ItemName, fe.ItemLevel from FileExplorer fe INNER JOIN
    AncestorsList al on fe.ItemId = al.Itemid
end

If you are familiar with CTEs then most of the code above is self explanatory. My anchor members gets the first ancestor of the given node. This is then executed recursively by my recursive query. The last select executes the CTE to return the resultset.

Having seen most of the uses of HierarchyId, its biggest drawback lies in the fact that it still needs the developers to do a lot. For fan-outs of less that 2 levels, I still feel the self referencing table is faster than using the hierarchyId. I strongly believe that Microsoft still has some work left to do with the HierarchyId datatype to make sure it is a bit more easier to implement.

That though concludes this post. If you are looking to work with HierarchyIds, I hope this post has given you an idea of where to start. Hope to be back soon with something else. Happy Coding!!!!!!

.NET 4.0 and VS 2010 Series – Dynamic Features

2009-12-12T07:37:00.001-08:00

Technorati Tags: Dynamic,Expando,.NET 4.0,C# 4.0,DLR

I have deliberately delayed writing this post to try and get my heads around all the dynamic features in .NET 4.0. At first read, I thought it was just the Expando object and whenever you use the ExpandoObject in your code, the code runs in DLR. Though this is partly true, I realised there is a bit more to the dynamic features than just a two-liner.

The Dynamic Features are implemented in the following forms in .NET 4.0

The Expando Object
The Dynamic Object
The Dynamic Language Runtime (DLR)

ExpandoObject

As the name roughly suggests, expandos are expandable objects which means you can add properties, methods and even events at runtime. You can also set and get the values of such members.

The syntax to create expandable objects is as follows

dynamic person = new ExpandoObject();
person.FirstName = "test First Name";
person.LastName = "test Last Name";

You will see that I have created the person object as dynamic. We will come to that a bit more later. If you compile a solution, with just this piece of code, it will compile perfectly fine.

You can also pass Expando objects as parameters to other methods or functions. Beware that when you do so, you will not get intellisense on the dynamic object because they aren’t yet resolved; they are resolved only during runtime. Below is a code snippet where I have created an ExpandoObject and passed that as a parameter to another method that displays the values of the object’s. members.

        1: using System;       2: using System.Collections.Generic;       3: using System.Linq;       4: using System.Text;       5: using System.Dynamic;       6:         7:         8: namespace DLRExample       9: {      10:     class Program      11:     {      12:         static void Main(string[] args)      13:         {      14:        15:             dynamic Vehicle = new ExpandoObject();      16:             Vehicle.Make = "Ford";      17:             Vehicle.Model = "Endeavour";      18:             Vehicle.Engine = "4 cylinder";      19:             Vehicle.Color = "Black";      20:        21:             WriteVehicleDetails(Vehicle);      22:             Console.ReadLine();      23:         }      24:        25:        26:         static void WriteVehicleDetails(dynamic vehicleobject)      27:         {      28:             Console.WriteLine("The make of the vehicle is {0}", vehicleobject.Make);      29:             Console.WriteLine("The color of the vehicle is {0}", vehicleobject.Color);      30:         }      31:     }      32: }

Similarly, .NET allows you to add methods at runtime to an expando object. In C#, you can add methods by using lambda expressions. The syntax for the same is as below

expandObject.Increment = (Action)(() => { expandoObject.attribute++; });

I have modified the above code to add a method to the ExpandoObject called ChangeVehicleColor. The method changes the color of the vehicle to white from its existing value. The new code is as below

       1: using System; 2: using System.Collections.Generic;
    3: using System.Linq;       4: using System.Text;       5: using System.Dynamic;       6:         7:         8: namespace DLRExample       9: {      10:     class Program      11:     {      12:         static void Main(string[] args)      13:         {      14:        15:             dynamic Vehicle = new ExpandoObject();      16:             Vehicle.Make = "Ford";      17:             Vehicle.Model = "Endeavour";      18:             Vehicle.Engine = "4 cylinder";      19:             Vehicle.Color = "Black";      20:             Vehicle.ChangeVehicleColor = (Action)(() => {Vehicle.Color="White";});      21:             WriteVehicleDetails(Vehicle);      22:             Vehicle.ChangeVehicleColor();      23:             WriteVehicleDetails(Vehicle);      24:             Console.ReadLine();      25:         }      26:        27:        28:         static void WriteVehicleDetails(dynamic vehicleobject)      29:         {      30:             Console.WriteLine("The make of the vehicle is {0}", vehicleobject.Make);      31:             Console.WriteLine("The color of the vehicle is {0}", vehicleobject.Color);      32:         }      33:     }      34: }

Please note that the syntax to invoke the method in C# is slightly different from VB.NET. In VB.NET, you will have to use the Invoke function explicitly to call the dynamic method.

Lastly, the expando object also implements the generic IDictionary interface. This enables developers to enumerate the members of the object, if need be. The syntax to enumerate the members is fairly simple. For the vehicle object above, the code will be as below

foreach (var property in (IDictionary<String, Object>)Vehicle)

{

Console.WriteLine(property.Key + ": " + property.Value);

}

Dynamic Object

The dynamic object has been introduced in C# for a variety of reasons. One of the most important aspects of the dynamic object is that it skips type checking during compile time. You can invoke any method on the dynamic object type without having to worry about compiling errors.

Thought at the outset, the dynamic and expando objects seem similar, there are a number of differences between the two. While you can instantiate an expandoobject class, you cannot do the same with a dynamic class. Dynamic object is just a holding class. They are declared with the dynamic keyword as shown in my first example in this post.

Some of the practical usages of the dynamic object are with COM Interops. Instead of trying to tightly bind an interop class you can always declare that class as dynamic. You will do away with a lot of type casting that needs to be done otherwise.

Dynamic Language Runtime (DLR)

The DLR is an open source runtime that sits above the CLR and ensures the working of the dynamic languages in .NET. Apart from the two objects described above, .NET also supports a couple of dynamic languages like IronRuby and IronPython. These run on the DLR. You can download the latest version of DLR from codeplex.

What the DLR does is to keep track of usages of the dynamic objects and ensures that they are evaluated at runtime. For this, the DLR has three services

Expression Trees - These represent language syntaxes and semantics

Call Site Caching – These help track dynamic object usages and information about operations on the Dynamic Objects

Dynamic Object Interoperability – These are essentially a set of interfaces that help creation of dynamic objects.

You can get more information about the DLR here.

Usage Scenarios

Now that we have seen the different elements of dynamic features in C# 4.0, let me try and explain where I think these can be used.

The Expando object is interoperable between different framework languages. So it is an obvious choice in situations where you have to pass objects between different framework languages.

String to object conversion scenarios. A scenario commonly found in projects where mainframe is involved. I think it would be compelling to use the Expando object along with text generation templates to come up with a code generator for mapping mainframe strings to application objects

As mentioned earlier in the post, the dynamic object is a good choice for interacting with COM interops. Not only that, I think it is very useful to also be used with scripting objects.

If these two objects don’t do the trick for you, remember you can always create your own dynamic objects by implementing the IDynamicMetaObjectProvider interface.

That concludes this post regarding the dynamic features in C# 4.0. I hope this has given you a good overview for you to start exploring these objects in a bit more detail

.NET 4.0 and VS 2010 Series – Named and Optional Parameters

2009-11-21T08:58:00.000-08:00

Technorati Tags: .NET 4.0,Named Parameters,Optional Parameters,C# 4.0

After my posts on the framework features over the past couple of weeks, I will now start focussing on the language aspects of C# 4.0. In C# 4.0, named and optional parameters have been introduced. This is one feature that I have been waiting for so I am only glad that the .NET team has decided to introduce this feature in C# 4.0.

VB 6.0 programmers are aware of the usage of the optional parameters. It used to be declared as

 Sub DoSomething(Optional ByVal Switch As Boolean = False)

What the above declaration meant was that you could call the DoSomething method without explicitly passing the Switch parameter. The default value of false will be assigned to the variable if it was not passed.

This was not possible in .NET. The workaround was to declare overloaded methods. You do not need to do that anymore. In C# 4.0, you can declare a method with an optional parameter simply by assigning a default value for the parameter in question like the example below.

private string Extract(String inputString, int endIndex=0, int startIndex =0)

Named parameters as the name suggests, enable the developers to skip a parameter while calling the method if they wish to. This is done by passing the parameter by quoting its name and value separated by a colon as shown in the syntax below

Extract(inputString, startIndex: 4);

The syntax above calls the method extract with three parameters the signature of which is described previously. You will notice that the second parameter endIndex has been skipped and the value is being passed for startIndex. Below is the complete code snippet

   1: using System;   2: using System.Collections.Generic;   3: using System.Linq;   4: using System.Text;   5: using System.Diagnostics.Contracts;   6:     7:     8: namespace NamedOptionalParams   9: {  10:     class Program  11:     {  12:         static void Main(string[] args)  13:         {  14:             String inputString = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";  15:             String result = Extract(inputString,6);  16:             String result1 = Extract(inputString, startIndex: 4);  17:             String result2 = Extract(inputString, startIndex: 6, endIndex: 10);  18:             Console.WriteLine(result);  19:             Console.WriteLine(result1);  20:             Console.WriteLine(result2);  21:             Console.ReadLine();  22:    23:         }  24:    25:         //this method creates a substring based on the input parameters  26:         //1. The input string is always passed  27:         //2. Start Index is an optional parameter. If this is not passed then the   28:         //   start is assumed to be 0 which is the default value  29:         //3. The End Index can be omitted. If it is omitted, then start Index has to  30:         //   be passed and the string is from the start index to the end of the input  31:         //   string  32:         static string Extract(String inputString, int endIndex=0, int startIndex =0)  33:         {  34:    35:             if (endIndex==0)  36:             {  37:                 endIndex = inputString.Length;  38:             }  39:    40:             String outString = inputString;  41:             outString = inputString.Substring(startIndex, (endIndex - startIndex));  42:               43:             return outString;  44:         }  45:     }  46: }

In the above example, the extract method just creates a substring for a specified start and end index. I have made three calls to the method. Note that with Named Parameters, the order in which you pass the parameters is not important as long as you don’t forget to name them correctly. You can see this in Line 17 of the above code.

That is it for this post on named and optional parameters. They are quite a useful feature that will reduce the number of overloaded methods that we will have to write. I am sure you will find more ways of putting them to use.

.NET 4.0 and VS 2010 Series - PIA – Rest in Peace

2009-11-17T18:43:00.001-08:00

Technorati Tags: .NET 4.0,PIA,Interop,Embedded Interop Types,Type Equivalence

In previous versions of .NET, Primary Interop Assemblies (PIA) acted as the bridge between unmanaged COM components and managed code. Though PIA solved the problem of marshalling for almost all types, they came with their own problems. One of the biggest problem was that even if a small feature was used, the developer had to ship the complete PIA which is not a small payload by any means.

Also, a developer had to develop an assembly for each version of word or excel that the application targeted. This drastically increased the size and the complexity of the deployment package.

With .NET 4.0 this has changed. Developers no longer need to ship the whole PIA. .NET 4.0 gives the developer the flexibility of embedding only those features that are used by the application rather than shipping the whole assembly. This also means that the developer does not need to worry about the availability of the target applications like Word or Excel. Enabling embedded interop assemblies is very easy. You right click the interop reference and change the EmbedInteropTypes from false to True.

When you do that, the interop assemblies are no longer referred. You can confirm this by using the reflector. The snapshot will look like below. Note that the Excel and Word are now namespaces within the project instead of references.

How to: Increase the size of your virtual hard disk

2009-11-06T23:09:00.001-08:00

Technorati Tags: VHD,Harddisk,VHD Resizer,How to,Microsoft Virtual PC,Virtual Image,DISKPART

If you have run out of space in your virtual image hard disk and didn’t know the way out of it; read on. I ran into this problem last week and found the following solution after a bit of googling. Though there were a lot of posts targeted at VMWare, I was looking for ones specific to Microsoft VPC. The magic tool that you have to look at is called VHD Resizer. It is a free download available from the VM tool kit site. You just have to register on the site to download.

When you run the tool, it will ask you to point to the vhd whose hard disk size you want to increase. You can also set the size you want to increase it to. The only thing that needs to be remembered, is that it makes a copy of the VHD so you will need the disk space to cope with it.

When this process is complete, the next thing you have to do is to make sure your volume uses the new space allocated. You can do this by using the DISKPART command. You will find the necessary instructions here. That’s it!!! You will have your new drive with loads of space!!!

VS 2010 and .NET 4.0 Series – Code Contracts - II

2009-11-03T16:59:00.001-08:00

Technorati Tags: .NET 4.0,VS 2010,Code Contracts,Invariant,PostConditions

In the first part of this series, I wrote about how you can check preconditions with Code Contracts. We also looked at some of the features of postconditions. In this post, we will implement postconditions with an example and go on to look at object invariants.

You can implement Postconditions using Contract.Ensures method. Similar to the Contract.Requires, this takes in a boolean parameter and can display a string as the error message. Unlike the Requires method, Contract.Ensures cannot throw a specific exception.

We will use the same Concatenate method that we kicked off in the first part and enhance that with some postconditions checks. Here is what it looks like

        1: static string Concatenate(string leadingstring, string trailingstring)       2:        {       3:         4:            //raise an exception if the contract fails       5:            Contract.Requires<ArgumentNullException>(leadingstring.Length > 0);       6:            //make sure the string is greater than 10 characters before the code exits the method       7:            Contract.Ensures(Contract.Result<string>().Length > 10, "The string is too short");       8:            //ensure that the concatenated string is at least longer than the leading string by 2       9:            Contract.Ensures(Contract.Result<string>().Length > Contract.OldValue<string>(leadingstring).Length + 2, "The value of the concatenated string is not long enough");      10:            leadingstring = String.Concat(leadingstring, trailingstring)      11:            return leadingstring;      12:        }

The method now returns the concatenated string. It also includes a couple of ensures statements. Note that though we are implementing postconditions, the Contract.Ensures statement should be included at the beginning of the method and not at the end. There are two checks I have done

The first to make sure that the length of the concatenated string is greater than 10. The Contract.Result returns the value that is being returned from the method.

The second check makes sure that the concatenated string is at least 2 characters longer than the leading string. Here, I have used the Contract.OldValue to get the original value of leadingstring when it entered the method.

Unlike Contract.Requires, you will not be able to catch a specific exception if the Contract.Ensures fails. In the main method, I have caught a generic exception to handle any contract exceptions. Below is my main method with the changes.

      1: static void Main(string[] args)   2:         {   3:             try   4:             {   5:                 string resultString = Concatenate("1234567891011", "a");   6:                 Console.WriteLine("The result is {0}", resultString);   7:                 Console.WriteLine(resultString);   8:     9:             }  10:             //catch the argument null exception raised by the contract  11:             catch (ArgumentNullException nullString)  12:             {  13:                 Console.WriteLine(nullString.Message);  14:             }  15:             catch (Exception ex)  16:             {  17:                 Console.WriteLine(ex.Message);  18:             }  19:    20:             Console.ReadLine();  21:         }

Object Invariants

Invariants are code contract features that enable you to check object state and ensure conditions are met when you call methods on these objects. To validate a class using invariants, you will have to write an Invariant method that returns void. This method needs to be decorated with the [ContractInvariantMethod] attribute.

To demonstrate the use of invariants, I have refactored the above concatenation code using an external class called StringManipulation. This class that has two public variables and one Concatenate method.

   1: using System;   2: using System.Collections.Generic;   3: using System.Linq;   4: using System.Text;   5: using System.Diagnostics.Contracts;   6:     7: namespace CodeContractsSample   8: {   9:       10:     class StringManipulation  11:     {  12:         public string leadingString = "12345678";  13:         public string trailingString = "87654321";  14:    15:         [ContractInvariantMethod]  16:         protected void ObjectInvariant()  17:         {  18:             Contract.Invariant(this.leadingString.Length>5);  19:             Contract.Invariant(this.trailingString.Length>5);  20:    21:         }  22:           23:         public string Concatenate()  24:         {  25:             return String.Concat(leadingString, trailingString);  26:         }  27:    28:     }  29: }

As you can see, I have also added the CodeInvariant method to check if both the strings are at least 5 characters in length. This means that I will have to initialize the string to pass that condition. Otherwise the object does not get created.

The other consideration you will have to keep in mind when using object invariants are that the invariant checks are only done when a method call is made. In essence, invariants will not work for DTO or DataContracts. The workaround is to use Contract.Requires on the property.

Legacy If..Else Blocks

While Code Contracts are a new .NET 4.0 feature, there exists a lot of legacy code using If…Else… that does similar validations. If you want the .NET framework to treat them as contracts, you can use the EndContractBlock provided the If…Else… are the first set of statements in a method. when you use EndContractBlock, all the If..Else.. conditions are assumed as preconditions.

Code Contract Usage Considerations

Code Contracts give dev leads and architects a plethora of options to do validations. But, as with anything else, there are certain decision points that need to be taken care of.

Decide very early in the project how you are going to use Code Contracts. Though static checking is very powerful, it also puts a lot of drab in your build process. Make sure you are turning static checking on only when you need it.
You could also do runtime checking only on debug builds. This works very well for TDD projects
Be wary of turning on runtime checking on production builds. Remember, .NET 4.0 is still in its beta.
Code Contracts are very extensive. Make sure you understand all the features offered before picking on the best way to do your validations or checks.
When you are using both preconditions and postconditions in the same method, there is a specific order which is recommended. The order according to the Code Contract documentation is as follows
- Legacy if…Then…Else blocks
- Contract.Requires to check public preconditions
- Contract.Ensures to check public postconditions
- Contract.EnsuresOnThrow to check public exceptional conditions
- Contract.Ensures to check all private postconditions
- Contract.EnsuresOnThrow to check all private postconditions before finishing off with the EndContractBlock
You can use Contracts with pre .NET 4.0 versions by referencing the Microsoft.Contracts library. In .NET 4.0 Code Contracts have been integrated into the mscorlib.dll
One of the recommended ways of using Code Contracts is to have a separate config file for contracts.
The contracts build output can be shipped along with your build so that other developers\administrators can make use of it. Make sure you understand the different build options.

That concludes my two part post on Code Contracts and their usage. The posts try to give you a peek are by no means exhaustive on the features that Code Contracts offer. For complete understanding, I would recommend you download the manual from DevLabs and give it at least a quick skim through. Happy Coding!!!!

Visual Studio 2010 and .NET 4.0 Series – Code Contracts

2009-10-28T06:42:00.001-07:00

Technorati Tags: .NET 4.0,Visual Studio 2010,VS 2010,Code Contracts

I had written a couple of days ago on my blog about the release of VS2010 and .NET 4 Beta 2. Now that I have had a chance to install and play around a bit, I am hoping to explore some of the new features of .NET 4 and VS 2010 in the next few weeks. I will kick off this week with Code Contracts.

According to MSDN, “Code contracts provide a way to specify preconditions, postconditions, and object invariants in your code”. To work with code contracts .NET 4 now comes with a new namespace System.Diagnostics.Contracts.

As mentioned in the above definition, code contracts can be used to check, pre-conditions, post-conditions and invariants. Pre-conditions are conditions that should be satisfied before a method is invoked; post-conditions are conditions that should be met just before the method finishes execution and invariants validate class state. We will look at Pre-Conditions with an example and a peek into Post Conditions in this post. I will finish this off with another post on Post Conditions example and invariants.

Preconditions

The Contract.Requires method can be used to validate preconditions. An example of this will be to validate parameters that are being passed into a method. To demonstrate this, I will create a new console project and write the code below.

        1: using System;       2: using System.Collections.Generic;       3: using System.Linq;       4: using System.Text;       5:         6: using System.Diagnostics.Contracts;       7:         8: namespace CodeContractsSample       9: {      10:     class Program      11:     {      12:         static void Main(string[] args)      13:         {      14:             Concatenate(String.Empty, "test");      15:             Console.ReadLine();      16:         }      17:        18:         static void Concatenate(string leadingstring, string trailingstring)      19:         {      20:             Contract.Requires(leadingstring.Length > 0, "Ensure leading string is valid.");      21:             Console.WriteLine(String.Concat(leadingstring,trailingstring));      22:        23:         }      24:     }      25: }

Let us harp a bit on the Contract.Requires method. The method takes two parameters; the first is a boolean condition that needs to be enforced. The second optional parameter is the message that needs to be displayed if the condition evaluates to false. In the above example, the method makes sure the leading string is not empty.

When I wrote this code and ran it, I found it to my surprise that the contracts were not working. After a bit of research, I found that for contracts to work, you need an additional download. You can find the download at Dev Labs. Once you download and run the installer, you will find an additional tab called Contracts in your solution properties as shown below.

You can then control how your contracts work in this window. Please note that to without Team System you can do only runtime checking. Running the application now throws the designated message if we pass an empty string to the Concatenate method.

A variant of this is the Requires<> method which takes a generic TException parameter. Below is the code to raise an exception and catch it in code. One thing you have to make sure is you turn off the assert on contract failure setting in the Code Contracts settings tab. This will ensure exceptions are raised from the contracts.

      1: using System;       2: using System.Collections.Generic;       3: using System.Linq;       4: using System.Text;       5:         6: using System.Diagnostics.Contracts;       7:         8: namespace CodeContractsSample       9: {      10:     class Program      11:     {      12:         static void Main(string[] args)      13:         {      14:             try      15:             {      16:                 Concatenate(String.Empty, "test");      17:                       18:             }      19:             //catch the argument null exception raised by the contract      20:             catch(ArgumentNullException nullString)      21:             {      22:                 Console.WriteLine(nullString.Message);      23:             }      24:             Console.ReadLine();      25:         }      26:        27:         static void Concatenate(string leadingstring, string trailingstring)      28:         {      29:        30:             //raise an exception if the contract fails      31:             Contract.Requires<ArgumentNullException>(leadingstring.Length > 0);      32:             Console.WriteLine(String.Concat(leadingstring, trailingstring));      33:        34:         }      35:     }      36: }

PostConditions

Though most of the basic concepts are the same for post and preconditions, postconditions offer a bit more flexibility and features that preconditions do not. Postconditions are validated by using the Contract.Ensures method. Postconditions also offer the following capabilities

Ability to refer the return value of a method using Contract.Result<T> where T should be of the same type as the return type of the method. Obviously you cannot use Result for methods that do not return anything.

Ability to check the value of a variable at the beginning of the method. This can be done by using Contract.OldValue<T>(e) where e is the variable for which you want the old value and T is the type of that variable.

Ability to ensure a condition is met when an error is thrown in the method. You can use the Contract.EnsuresonThrow<>.

That is it for this post. I will show you in my next post how to write PostConditions and we will also look at invariants.

Visual Studio 2010 and .NET 4.0 Beta 2 now available

2009-10-19T11:14:00.001-07:00

Technorati Tags: VS2010,.NET 4,Beta,MSDN

Microsoft made available today the beta 2 of VS2010 and .NET 4.0. It is available for MSDN Subscribers on the 19th and its general availability is from the 21st of October. You can download the beta 2 from https://msdn.microsoft.com/en-us/subscriptions/securedownloads/default.aspx?pv=18%3a370.

Apart from bug fixes the Beta 2 also is supposed to have templates for Sharepoint solutions and Azure. More details on Somasegar’s blog http://blogs.msdn.com/somasegar/

I will write more on VS 2010 when I have had a chance to play with it.

Using Table Value Parameters in SQL Server 2008

2009-10-04T10:39:00.001-07:00

Technorati Tags: SQL Server 2008,Table Value Parameters,.NET

Table-valued parameter is another exciting new feature in SQL Server 2008. Essentially, TVP solves the problem of inserting multiple rows into the database. Various solutions have been implemented to achieve this, ranging from round trips for every row to comma separated values. With TVP, you can insert multiple rows with a single round trip to the server without having the additional overheads of composition and de-composition of values.

TVP is not entirely new to SQL Server. SQL Server 2000 introduced the table variables which can be used to store a set of records. Where TVP builds on it, is the ability to pass them as input parameters to stored procedures or functions. This could not be done with table variables.

Let us look at some of the features of TVP before we see how they can be used to insert data.

TVPs can participate in Set based operations.
They are strongly typed
You cannot perform DML operations on TVPs. They can be passed as only READ-ONLY parameters to stored procedures\functions
Remember that TVPs are materialized in the TempDB. Essentially, it means that if you insert more rows into your TVP, the size of TempDB is what gets affected.

Having seen what TVP is, let us now move onto build an example which will actually use TVP. Here, I will show you a very common scenario that we use for multiple entries. We have an order and each order is comprised of multiple products. I have created the necessary tables using the scripts below

        1: Create table dbo.Products

       2: (

       3: ProductId int IDENTITY(1,1) PRIMARY KEY,

       4: ProductName varchar(250),

       5: ItemRate decimal

       6: )

       7:  

       8: Create table dbo.Orders

       9: (

      10:     OrderId int IDENTITY(1,1) Primary key,

      11:     OrderDate datetime,

      12:     OrderStatus int

      13: )

      14:  

      15: Create Table dbo.OrderDetails

      16: (

      17:     OrderId int Foreign Key references Orders(OrderId),

      18:     ProductId int Foreign Key references Products(ProductId),

      19:     Quantity int,

      20:     Amount decimal

      21: )

I have also inserted data for the tables above. The next thing to do is to create a user defined type that will insert data into the OrderDetails table.

       1: Create type dbo.OrderParam as Table

       2: (ProductId int, Quantity int, Amount decimal)

Now that the type has been created, let me go ahead and create a stored procedure that takes the just created type as an input parameter.

       1: Create proc dbo.InsertOrders

       2: @OrderItems OrderParam ReadOnly

       3: as

       4: begin

       5:     Declare @iOrderId int

       6:     Insert into Orders values (GETDATE(),0)

       7:     Select @iOrderId=SCOPE_IDENTITY()

       8:     Insert into OrderDetails(OrderId, ProductId, Quantity, Amount)

       9:         Select @iOrderId, ProductId, Quantity, Amount from @OrderItems

      10: end

Notice the fact that the TVPs have been declared read only. Also pay attention to the second insert statement. The values are inserted from the input parameter using a single select statement. The only remaining thing to do is to call this stored procedure from the front end.

For this purpose, I have created a data grid where users select the orders and save it into the database. Below is the code that goes into the Save Click routine.

       1: private void SaveButton_Click(object sender, EventArgs e)

       2:         {

       3:             //create a new datatable to hold the grid data

       4:             DataTable OrderParam = new DataTable();

       5:             //the columns are the same as the TVP type

       6:             OrderParam.Columns.Add("ProductId", typeof(int));

       7:             OrderParam.Columns.Add("Quantity", typeof(int));

       8:             OrderParam.Columns.Add("Amount", typeof(decimal));

       9:  

  

            //loop through the grid to load data into the datatable

            foreach (DataGridViewRow item in grdOrders.Rows)

            {

                DataGridViewComboBoxCell prodCell = (DataGridViewComboBoxCell) item.Cells[0];

                if (prodCell.Value != null)

                {

                    DataRow prdRow = OrderParam.NewRow();

                    prdRow[0] = prodCell.Value;

                    prdRow[1] = item.Cells[1].Value;

                    prdRow[2] = item.Cells[2].Value;

                    OrderParam.Rows.Add(prdRow);

                }

            }

            //connect to the database to insert the values.

            var connString = ConfigurationManager.ConnectionStrings["DatabaseConn"].ConnectionString;

            SqlConnection dbConn = new SqlConnection(connString);

            dbConn.Open();

            using(SqlCommand cmd = new SqlCommand("InsertOrders", dbConn))

            {

              cmd.CommandType = CommandType.StoredProcedure;

              cmd.Parameters.AddWithValue("OrderItems", OrderParam);

              cmd.ExecuteNonQuery();

            }

            dbConn.Close();

        }

The only thing worth noticing is that I have used a datatable which is quite logical because TVPs are tables anyways. As you can see, the savings in the number of round trips to the database is enormous. The USP of the TVPs lie in the fact that they are not hard to implement at all. Have fun!!!

Time well SpEnt

2009-10-02T22:04:00.001-07:00

Technorati Tags: Quizzing,ASAP,Chennai

When a relatively unheard of theatre group comes forward to do a quiz, you are not sure what to expect. But ASAP did themselves only favours, be it the quiz or the short sketch they showcased just before the finals. The only disappointing thing for the evening was the number of teams participating. The quiz master put the number at 100 which seemed a bit low given that Chennai usually attracts a lot of participation.

The quiz kicked off with 40 question prelims which seems to be the standard nowadays. It fittingly started with a question on the Bapu.

There were questions on Anjali Tendulkar, the Olympics and Quick Gun Murugan. The toughest one seemed to be on the longest winning streak in sports history. I don’t think any of the 100 odd teams got this right. 8 teams qualified for the finals at the end of a low scoring prelims with “When I was in London” comprising of Srinivasan and Rajagopal coming out tops.

The questions in the finals were engrossing bringing out some brilliant answers from the teams. The quality of quizzing was again top-class. JK and Sriram were quick off the blocks but the team of V.V. Ramanan and Ramkumar eventually caught up leading the quiz into the last round. It came down to the last question to decide the winners and “When I was in London” bagged it with a brilliant answer on the word “FAIL”.

Overall a very enjoyable evening. If anything, the finals just seemed to be one round too long but I dont think the ardent quizzers of Chennai would complain given the good quizzing that was in offing. Mention should also go to the quiz master Vinod and his colleague Ganesh for the research and the quality of questions.

I hope that this now goes on to become an annual event and one more annual quiz gets added to the Chennai quizzing calendar. Way to go ASAP!!!

CLR Integration Changes in SQL Server 2008

2009-09-12T13:01:00.001-07:00

Technorati Tags: SQL Server 2008,CLR Integration,Nullable Types,Database

CLR Integration was first introduced in SQL Server 2005. Though there was a lot of excitement when the feature was introduced, it has since fizzled off. Personally, I think CLR Integration is one of the most underused features of SQL Server. For some reason, we have not been able to move away from extended procedures or UDFs to writing CLR Integrated code.

In SQL Server 2008, there are two noticeable introductions to CLR Introduction. One is the support for LINQ and the other is the support for Nullable types.

To enable CLR support in SQL Server, you first have to switch it on. This is done by running the sp_configure with clr enabled = 1. One thing to keep in mind is when you are using nullable types, you cannot use the automatic deployment option within Visual Studio 2008. You will have to register your assemblies manually. I will briefly show you how it is done.

Once you have turned the support for CLR on, the next step is to create your assembly. For this, I have a stored procedure written in Visual Studio. The code for the same is as below

        1: using System;

       2: using System.Data;

       3: using System.Data.SqlClient;

       4: using System.Data.SqlTypes;

       5: using Microsoft.SqlServer.Server;

       6:  

       7:  

       8: public partial class StoredProcedures

       9: {

    [Microsoft.SqlServer.Server.SqlProcedure]

    public static void SearchEmployee(Int64? iEmployeeId, out Int32? iVacationhours)

    {

        iVacationhours = null;

        if (iEmployeeId !=null)

        {

            //open the sql connection with the current context

            using (SqlConnection connection = new SqlConnection("context connection=true"))

            {

                //open the connection

                connection.Open();

                //build the query and execute it               

                string query = "Select VacationHours from HumanResources.Employee where EmployeeId = " + iEmployeeId.ToString();

                SqlCommand sCommand = new SqlCommand(query, connection);

                SqlDataReader vacationReader = sCommand.ExecuteReader();

                using (vacationReader)

                {

                    vacationReader.Read();

                    iVacationhours = vacationReader.GetInt32(0);

                }

            }            

        }

        

  

    }

};

The code just returns the vacation hours for a given employee. The point worth noting is that both input and output parameters are nullable types. The next step is to add the assembly to the SQL Server database.

The syntax to do that is

1: create assembly NullableTypes from

   2:  'C:\Users\Administrator\Documents\Visual Studio 2008\Projects\NullableTypesExample\NullableTypesExample\bin\Debug\NullableTypesExample.dll'

   3:  Go

Once the assembly is registered, you can now proceed to create your stored procedure pointing it to the managed code by executing the statement below

   1:  Create Proc dbo.SearchEmployee(@a bigint, @b smallint output)

   2:  as

   3:  EXTERNAL NAME NullableTypes.[StoredProcedures].SearchEmployee

   4:  GO

That is it!!! You are now all set to execute the stored procedure and check the results. For your reference, I am also giving below the statements to execute the procedure

   1:  declare @outvalue smallint

   2:  set @outvalue = 0

   3:  exec dbo.SearchEmployee 1,@outvalue output

   4:  select @outvalue

If I change the input value to null, null will be returned as output exhibiting support for Nullable Types.

A Date with SQL Server 2008

2009-08-29T08:26:00.001-07:00

Technorati Tags: SQL Server 2008,Database,Datetime,datetime2,datetimeoffset,SwitchOffset,datatypes

Almost everybody who has worked a fair bit in SQL Server knows that the datetime data type in SQL Server is one of the most primitive. Infact, in a lot of applications I have seen, they don’t even see it worthy of being used, opting to use varchar instead. Their argument: If I am going to convert it into varchar anyways, then I might as well store it in the same format.

Hopefully, that will change with SQL Server 2008. DateTime datatype has been given special attention in the latest edition of SQL Server; so much so that I will stick my neck out and say that it is the only data type that has been enhanced!!! (FILESTREAM is not a data type, remember?). This post is an attempt to give you a preview of what the enhancements are in the DateTime datatypes.

In the previous versions of SQL Server, there were no separate datatypes for date and time. That has changed now. In SQL Server 2008, you have date and time datatypes that let you store only date or time. Apart from this, there is also the datetime2 and datetimeoffset. The datetime2 lets you store a wider range of dates. If you use datetime your minimum value for the year is 1/1/1753. The datetime2 datatype lets you store a wider range and is based on the ANSI standard. The datetimeoffset as you would have already guessed, helps you store dates for different regions. Some of the key points that you have to remember when using the above datatypes are

You cannot use mathematical functions or expressions with the new datetime2 datatype. Use DateAdd instead.
Try avoiding the format ‘dmy’. This is the only string format that produces different results with the old datetime and the new datetime2 format.
Most of the old t-sql functions work consistently with both the datetime and the datetime2 datatypes.
If you are using datetime2, use the SYSDATETIME function for more precision.
Though you can use the Datetimeoffset datatype, SQL Server 2008 does not support automatic support for daylight savings.
It does not also provide support for timezones, so the most effective way to use the offset is to store the timezone at which the date was entered.
Use the SWITCHOFFSET function of SQL Server to convert the offsets to the timezones.

Madras Quiz 2009

2009-08-23T07:07:00.001-07:00

Technorati Tags: Chennai,Quizzing,Madras Week,Indian Quizzing League

I am just back from the annual Madras quiz that is conducted as a part of the Madras Week celebrations. The quiz this time was conducted by the Indian Quizzing League. The quiz master for the day was Sylvian Patrick.

The event started off with a 30 question prelims. There were some thought-provoking questions from various aspects of Chennai, ranging from the Chennai Metro to the Ergo. On the whole, the prelims were not too tough. A lot of the questions were guessable. Couple of questions from the top of my head

What did Gandhiji establish in Chennai in 1918 recognising the importance of the whole nation speaking one language?

Who is the most famous grandson of Rajagopala Bhagavadar who excelled in Hari Katha kathakalakshebam?

Six teams made it to the finals, which comprised of 5 rounds of Madras Intensive questions. Jayakanthan and his teammate managed to surge ahead wresting the rolling trophy from V.V. Ramanan and Ramshankar who were lacklustre today. There were some quality answers from all the teams. I don’t remember the name of the team who finished second.

Overall the quality of the questions in the finals was passable. I personally believe the Indian Quizzing League need to find themselves some quizmasters. I attended their India quiz and there again, the quizmasters were found wanting.

SQL Server 2008 FILESTREAM – Part – II

2009-08-22T03:08:00.001-07:00

Technorati Tags: SQL Server 2008,FILESTREAM,Database,.NET

Having done the necessary set up for configuring FILESTREAM on a SQL Server instance in Part - I, we will now look at how to query a FILESTREAM column from .NET code and insert new files.

For this purpose, I have created one more table called UserMaster. This has the usual details of a user like the first name, last name and a column PhotoId which is a foreignkey to the ProductPhotoId that we created in the previous part.

Querying files or data from the FILESTREAM is not too different from how you would query and display data from an ordinary table. I first create a stored procedure to get the user details and the photo associated with each user. The stored procedure is as below

create proc dbo.GetUserDetails
as
begin
Select UM.UserId, UM.UserName, UM.FirstName, UM.LastName, UM.EmailAddress, PP.ProductPhotoId, PP.LargePhoto
from
UserMaster UM INNER JOIN ProductPhotoWithFileStream PP
On
PP.ProductPhotoId=UM.PhotoId
end

As you can see, there is nothing special with the above stored procedure. The next step is to display these photos in a Windows form. I have a DataGridView which is going to display the pics. The code for Form.cs is

          1: var connString = ConfigurationManager.ConnectionStrings["FileStreamConn"].ConnectionString;         2: var query = "GetUserDetails";         3: var daProducts = new SqlDataAdapter(query,connString);         4:           5: productsGridView.DataSource = null;         6: productsGridView.Refresh();         7: var binding = new BindingSource()         8: productsGridView.DataSource = binding;         9:          10: // Populate a new data table and bind it to the BindingSource.        11: var table = new DataTable();        12: daProducts.Fill(table);        13: binding.DataSource = table;        14:          15: // Resize the DataGridView columns to fit the newly loaded content.        16: productsGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCellsExceptHeader);        17: productsGridView.AutoResizeRows(DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders);

Again, nothing fancy. Plain old-fashioned code. But good enough to query the files in the database and display it as shown below.

To insert a user, I create a form where the user will enter the details and select the picture associated with the user.

We will ignore the rest of the code in the form and concentrate on the Insert Button click. Below is the code for the complete button click event

   1: //1. Call the procedure to insert an empty value as photo and get transaction context

   2: var connString = ConfigurationManager.ConnectionStrings["FileStreamConn"].ConnectionString;

   3: var query = "GetUserDetails";

   4: string filePath = String.Empty;

   5: string selPhotoPath = txtFilePath.Text;

   6: SqlCommand daInsertCommand=null;

7:

   8: try

   9: {

10:

  11:     //1.1open a new connection

  12:     SqlConnection conn = new SqlConnection(connString);

  13:     conn.Open();

14:

15:

  16:     SqlTransaction tranPhoto = conn.BeginTransaction("photoInsert");

17:

  18:     //1.2 Execute the command to insert the photo and get the photo id

  19:     daInsertCommand = new SqlCommand(query,conn);

  20:     daInsertCommand.Transaction = tranPhoto;

  21:     var PhotoId = daInsertCommand.ExecuteScalar();

22:

  23:     //1.3 Get the Path Name for the newly created file.

  24:     query = "Select LargePhoto.PathName() from ProductPhotoWithFilestream where ProductPhotoId = " + PhotoId;

25:

  26:     daInsertCommand.CommandText = query;

  27:     var PhotoPath = daInsertCommand.ExecuteScalar();

  28:     if (!PhotoPath.Equals(DBNull.Value))

  29:     {

  30:         filePath = (string)PhotoPath;

  31:     }

32:

  33:     //1.4 Get the transaction context for writing to the file.

  34:     daInsertCommand.CommandText = "SELECT GET_FILESTREAM_TRANSACTION_CONTEXT()";

  35:     var txContext = daInsertCommand.ExecuteScalar();

  36:     if (!txContext.Equals(DBNull.Value))

  37:     {

  38:         //convert the transaction into a bytearray

  39:         byte[] transContext = (byte[])txContext;

  40:         //create a photostream object to write

  41:         SqlFileStream photoStream = new SqlFileStream(filePath, transContext, System.IO.FileAccess.Write);

42:

  43:         //read the selected image as a byte array

  44:         byte[] imgByte = File.ReadAllBytes(selPhotoPath);

45:

  46:         //write to the sql filestream

  47:         photoStream.Write(imgByte, 0, imgByte.Length);

48:

  49:         //close the filestream and commit transaction

  50:         photoStream.Close();

51:

52:

  53:         //2. Insert the User record with the PhotoId

  54:         daInsertCommand.CommandText = "InsertUser";

  55:         daInsertCommand.CommandType = CommandType.StoredProcedure;

  56:         daInsertCommand.Parameters.Add("@FirstName", SqlDbType.VarChar, 10);

  57:         daInsertCommand.Parameters.Add("@LastName", SqlDbType.VarChar, 10);

  58:         daInsertCommand.Parameters.Add("@UserName", SqlDbType.VarChar, 20);

  59:         daInsertCommand.Parameters.Add("@emailAdd", SqlDbType.VarChar, 100);

  60:         daInsertCommand.Parameters.Add("@PhotoId", SqlDbType.Int, 32);

61:

  62:         daInsertCommand.Parameters[0].Value = txtFirstName.Text;

  63:         daInsertCommand.Parameters[1].Value = txtLastName.Text;

  64:         daInsertCommand.Parameters[2].Value = txtUserName.Text;

  65:         daInsertCommand.Parameters[3].Value = "test@add.com";

  66:         daInsertCommand.Parameters[4].Value = PhotoId;

67:

  68:         daInsertCommand.ExecuteNonQuery();

69:

  70:         daInsertCommand.Transaction.Commit();

71:

  72:     }

  73: }

  74: catch(Exception ex)

  75: {

  76:     daInsertCommand.Transaction.Rollback();

  77:     MessageBox.Show(ex.Message);

  78: }

I have tried and added comments so that the snippet makes sense but I will re-cap the steps to insert a new file. The first thing to do is to insert an empty string value into the FILESTREAM column. This is done so that the SQL Server creates a new file on the file system. Note that a null value does not create a file.

The next thing is to get the path of the new file created and wrap it around the same transaction. This is done between lines 24 and 35. Once we get the transaction context, then writing the file is like writing to any other file on the file system.

Also note the use of the SQLFileStream data type which is tightly integrated with the FILESTREAM attribute. The downside of the approach I have shown above is the number of round trips to the database. There are atleast three, one to insert the empty value into the FILESTREAM column, another one to get the path and the final trip to get the transaction context. Though I did read somewhere that this can now be reduced with the output clause I have not tried this yet. I will get around to that in a while and post an update to this post.

That concludes our two part post on the FILESTREAM attribute. Though it is easy to get excited by the ability of thee FILESTREAM attribute, there are as with a lot of other things, considerations that need to be taken into account when using this. I found the below links useful for further reading

Using FILESTREAM with Other SQL Server Features

FILESTREAM Storage in SQL Server 2008

To FILESTREAM or not to FILESTREAM... That is the question

Landmark Quiz ‘09

2009-08-16T04:38:00.001-07:00

Technorati Tags: Landmark,Quizzing

It was August 15th and India’s 63rd Independence Day. As with every year, the evening was consumed by the 18th edition of India’s largest open quiz: The Landmark Quiz Competition. The prelims were set to start at 2.30 P.M. The turnout was huge once more. Almost every seat in Music Academy was taken. It is not for nothing that Chennai is the quizzing capital of India and quiz enthusiasts turned out in large numbers to confirm that. If that was not enough proof, the quality of quizzing settled the matter beyond doubt.

The prelims had an interesting set of 40 questions, starting with the National Anthem rendering by the grandma granddaughter pair of Nithyashree and Late. D.k. Pattamal and closing with a question on Vikram crooning for Kanthasaamy. Try these questions

What is a bunch of bananas called? or What does the M stand for in M.R. Radha and M.L. Vasanthakumari.

You should be able to get the full list of questions on www.quizzing.in site in a short while.

The top 8 teams qualified for the Chennai finals. The team calling themselves No Enthu da won the Regional round and were crowned Chennai champions. They qualified for the National finals along with the team finishing runners up The Dhukkan Chargers.

The National Finals was another mouth-watering fare with the quiz master Dr. Navin Jayakumar raising the bar on the diffficulty of the questions and teams doing brilliantly to keep up with it. Though the teams for the national finals had qualified from three other cities, Pune, Mumbai and Bangalore, the teams comprised mostly of quizzers from Chennai. The team comprising of V.V. Ramana, Swamy and Samanth called Q.E.D walked home with the top laurels of the evening but not before they were given a run for their money by the team from Bangalore “We are like that only.” It was so close that the winner had to be decided by a tie-breaker.

Overall it was a well spent evening of quizzing and we all returned home having acquired a bit more power because “Knowledge is Power”.