My first discovery is that XPath in .NET only supports XPath 1.0 – meaning you don’t have many native functions to build from. However, Microsoft allows you to extend XPath using XSLT Context Extensions. The process of setting up the extensions is quite tedious, but it would seem worth the effort if it can centralize reusable parsing functions. However, about this time I discovered that LINQ to XML would provide a great wrapper on top of the basic XmlDocument operations using XDocument. Here we go through the process used to create a reusable search routine for XML content.

To demonstrate our search process, we created a sample XML document (business.xml). Here is a brief section for reference.

We want to now search for all services that match the given product name “Sharepoint”. Our first approach is to do the traditional XPath workflow using the XmlDocument class. Here is the snippet.

             string searchKey = "Sharepoint"; // search string to find in product name

            // retrieve and load source XML document from output directory
            XmlDocument businessXML = new XmlDocument();
            businessXML.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "business.xml"));

            // parse using strictly XPath (could also use confusing translate function - but needs repeated for each call)
            string xPath = string.Format("/company/services/service[products/product[contains(@name,'{0}')]]", searchKey);
            var services = businessXML.SelectNodes(xPath);
            if (services != null && services.Count > 0)
            {
                foreach (XmlNode node in services)
                    Console.WriteLine("{0}\n{1}", node.OuterXml, new string('-', 70));
            }
            else
                Console.WriteLine("Could not find search key: {0} using XPath", searchKey);

The results that come back demonstrate that we are not matching all possibilities. Pearl provides SharePoint services for both Application Development and Microsoft Services. The problem with our basic XPath search is that it is not case agnostic. We have variations of “Sharepoint” in our data – Sharepoint and SharePoint. In order to capture all variations, we now tackle the same problem with LINQ to SQL and extension methods.

Below we see the use of XDocument in place of XmlDocument, now replaced by parsing the original XmlDocument source. We also include a reference to System.Xml.XPath namespace to enable XPath-support within the LINQ to XML statements (using XPathSelectElements). Our LINQ statement is using a similar XPath as before with the exception of the filtering which is now handled by the lambda function HasValue(searchkey).

            // simple parse using LINQ to XML and XPath for navigation (easier to understand)
            XElement bizXML = XDocument.Parse(businessXML.OuterXml).Root;
            var items = (from service in bizXML.XPathSelectElements("/company/services/service/products/product")
                         where service.Attributes("name").HasValue(searchKey)
                         select service.Parent.Parent);

            if (items != null && items.Count() > 0)
            {
                foreach (XElement node in items)
                    Console.WriteLine(string.Format("{0}\n{1}", node.ToString(), new string('-', 70)));
            }
            else
                Console.WriteLine("Could not find search key: {0} using LINQ to XML", searchKey);

The lambda function (HasValue) exists in a utility class XMLSearchExtensions – satisfying our primary goal to create a reusable case agnostic search routine. The extension methods are filtering on XAttributes, but could easily be extended to cover enumerable XElements as well.

    /// 

    /// XML Extension Methods for parsing XML using case insensitivity
    /// 
    public static class XMLSearchExtensions
    {
        /// 

        /// Handles case when attribute is missing
        /// 
        public static bool HasValue(this IEnumerable nodes, string searchKey)
        {
            return nodes.Any(GetValue(searchKey));
        }
        /// 

        /// Search Expression using Case Insensitve Compare (resusable search filter)
        /// 
        public static Func GetValue(string searchKey)
        {
            return name => name.Value.ToLowerInvariant().Contains(searchKey.ToLowerInvariant());
        }
    }

The HasValue extension uses the Any LINQ command to safely ignore cases when the attribute may not be present in the current enumerable item. This adds greater flexibility if you cannot control the XML source. The GetValue delegate is called for each item and by comparing each element using the Contains we can easily support case insensitive filtering with ease. We could also extend this library to support Equals, StartsWith, or other behaviors you want to centrally control.

The entire solution can be downloaded here. This exercise demonstrates the importance and sophistication that LINQ-powered applications can provide when working with XML.

Prometric would provide this error message when trying to schedule the certification exams – “No Dates Found – We’re sorry. We couldn’t find any Exam Dates based on the selections you’ve made. Please try another Test Center”.

After contacting PDI, we discovered that some testing centers may limit their hours of operation and cannot accommodate the longer testing time slots. In this case, PDI was limiting their tests to 3 hours, yet some of the newer Microsoft exams are 3.5+ hours. Thankfully the testing center was willing to change their testing hours to allow us to keep local – thus saving us travel costs, time, and convenience. Kudos to PDI for their help! Hopefully this will someone else who may have experienced this issue with the Prometric exam scheduling system.

So how long can Microsoft keep us captive in the testing center? According to Microsoft, the maximum test duration is 4 hours. Thank goodness for time limits! Now back to the studying…

The first step to enabling PDF indexing is to ensure that the Full-Text Index Daemon service is running. This service is responsible for working with 3rd party iFilters to extract textual content from non-Microsoft formats (PDF iFilter in this case).

Once we’ve verified that the Filter Index is enabled, we need to install the PDF iFilter from Adobe. Depending on which SQL Edition you have, you need to download the x86 or x64 version of the PDF iFilter.

After the iFilter has been installed, you need to setup a system Environment Path variable which helps SQL locate the newly installed indexing filter. Below we show that the PATH variable has been modified to include our installation path of the Adobe iFilter (C:\Program Files\Adobe\Adobe PDF iFilter 9 for 64-bit platforms\bin\ in our case)

After we have the Adobe iFilter configured, we can configure our SQL Database to make use of this new component. Our next step is to tell SQL Server we have a new iFilter that needs to be registered. After running the commands below, you should see a list of the active iFilters appear in SSMS – you should verify that you see PDF listed.

-- reloading filters/3rd party components
EXEC sp_fulltext_service @action='load_os_resources', @value=1; -- update os resources
EXEC sp_fulltext_service 'verify_signature', 0 -- don't verify signatures
EXEC sp_fulltext_service 'update_languages'; -- update language list
EXEC sp_fulltext_service 'restart_all_fdhosts'; -- restart daemon
EXEC sp_help_fulltext_system_components 'filter'; -- view active filters

SQL Server is now prepared to handle PDF content, however we need to create the Full-Text Catalog and Index to enable query support. We are assuming you already have a VARBINARY(MAX) field setup – hopefully backed using a FILESTREAM. If your SQL Table stores multiple file formats, you should also create a column in your table that tells the indexer what iFilter it should use to index the content (the TYPE COLUMN indicator). The following SQL statements will create the SQL Catalog (ftCatalog), Full-Text Index with system stop list, and a file extension column for the CardImages table that has a BLOB field ThumbImage.

-- creatae full-text catalog
CREATE FULLTEXT CATALOG ftCatalog AS DEFAULT

-- create file extension column
ALTER TABLE dbo.CardImages add FileExtension varchar(4) not null default('pdf') 

-- create fulltext index
CREATE FULLTEXT INDEX  ON dbo.CardImages (ThumbImage TYPE COLUMN FileExtension LANGUAGE 'English')
KEY INDEX PK_CardImages on ftCatalog -- unique index
WITH STOPLIST = SYSTEM -- default system index

Once we have the index defined for our SQL table, we can check the index status or re-index using the following commands. If our indexing status value is ‘0′, SQL Server is ready to respond to PDF searches.

ALTER FULLTEXT INDEX ON dbo.CardImages START FULL POPULATION; -- re-index
select FULLTEXTCATALOGPROPERTY('ftCatalog', 'PopulateStatus') -- 1 indicates running

To issue a standard SQL search queries we can use CONTAINS or FREETEXT depending on what our intentions are. Below are some examples on how to query the newly generated index.

-- contains search
select * from CardImages where contains(ThumbImage, 'pearl technology rocks')

-- freetext search - searches for meaning of words
select * from CardImages where freetext(ThumbImage, 'cardinals')

One of the issues that this SQL Server search approach does not solve is providing context around your search terms (‘pearl technology rocks’ and ‘cardinals’ above.). We will be reviewing this gap in the future and hopefully providing some insights into how we can find the paragraph or sentence where the search term was located in the text – instead of merely returning the matching rows.

There were many sites that helped in troubleshooting issues during this process, but StackOverflow has some good steps to follow if you run into any trouble.

There are many approaches here, but we have discovered one that works regardless of which AJAX mechanism you are building upon (MS AJAX, jQuery, XMLHttpRequest, etc.).

The approach we took is to add a tag block to the Login.aspx page. This marker will be used to tell us when we’ve been redirected to the Login.aspx page from an AJAX request sent to IIS. Here is a sample snippet that you could use.

After you’ve added this token to your login page, you can begin checking for the existence of this tag when you receive AJAX responses back from the application server. Here is how we implemented it.

// tell MS AJAX request manager that we have to check for valid login session (Ajax.ActionLink)
Sys.Net.WebRequestManager.add_completedRequest(function (result) {
    IsValidSession(result.get_responseData()); // capture returned ajax response data
});

// attach all ajax completion requests for session review
$('*').ajaxComplete(function (e, xhr, settings) {
    IsValidSession(xhr.responseText);
});

/// Checks for invalid session [JQUERY/MSAJAX]
function IsValidSession(response_data) {
    if (response_data.match(/id="ajaxexpiry"/gi) != null)  // pattern to locate
        window.location.href = "/"; ; // redirect matching to login page
}

The code above is made up of three separate blocks. The first block handles MS AJAX integration. We leverage the WebRequestManager’s completed request handler in the MicrosoftAjax.js library. In the next section we integrate the jQuery AJAX framework by using the ajaxComplete() method handler.

Once we’ve collected the response data from the AJAX requests (MS AJAX or jQuery), we can process the text by matching on the tag pattern (id=”ajaxexpiry”) we created earlier. This is done in the IsValidSession routine called by each AJAX interface above. If we discover a match on our token, we will redirect the user to the login page. In our example, the login page is at the root of the domain, but in your instance, you may need to customize accordingly.

Another possible solution to this issue is to use a periodic polling routine to request content from the server. However, this approach puts additional load on your application server unnecessarily. We chose to do the session checking locally, and check for session expire only when necessary on the client (thus no impact to server resources).

When trying to check in code artifacts into TFS (Team Foundation Server), you receive this cryptic error message (Microsoft Visual Studio cannot shut down because a modal dialog is active. Close the active dialog and try again).

It turns out that the order in which you install Team Explorer matters. If you apply Visual Studio 2008 SP1 before installing the TFS Client (Team Explorer), you will receive this error during code check-in. The IDE will freeze and you will have to force-close the application (losing all unsaved work).

The fix is simple – just reinstall VS2008 SP1 and you’re back in business.

To deploy MVC 2 applications, you just right click on your visual studio project and click “Publish”.

A wizard pops open and allows you to assign where you want to publish your site to. In our case, we just used the filesystem so we could cleanup the folders prior to copying them to the server.

The first gotcha we ran into when deploying our MVC application was not having .NET 4.0 installed on the Windows Server 2008 standard. A quick 50MB download of the .NET 4.0 Redistributable from Microsoft and a brief install and reboot corrected this issue.

After reboot, we created our website in IIS and assigned the physical directory path. When we tried browsing to the website we discovered this error message – “Unrecognized attribute targetFramework” from the web.config.

With help from this article, we correctly assigned the Application Pool to run as a .NET 4.0 application.

With the recent release of .NET 4.0, a new CLR was created to handle the dynamic languages integration. Previously, the only CLR’s available for ASP.NET applications were .NET 1.1 and .NET 2.0. With .NET 4.0, we now have a new target framework to be aware of.

After you’ve downloaded the developer tools installer, you will go through a download process…

After downloading the remaining components, you will install all component resources.

Once the developer tools have been installed, you can startup Visual Studio 2010 Express for Windows Phone which is the IDE used for the mobile development.

We will use the Silverlight for Windows Phone – Windows Phone Application project template and add some custom XAML and image resource to the base project.

In this simple application we’ve titled Mobile Portal just going to add some textblocks, buttons, and use a standard Silverlight grid layout. We first modify MainPage.xaml to create our custom view for the mobile application. Here is a view of our coding changes.

Next, we go to our Solution Explorer add our image resource using the context menu on the project and selecting Add -> Existing Item.

Finally, we add our custom styles to App.xaml. After building the solution and running the emulator, we see the following results.

If we rotate the device orientation, we can see how the view shifts to fit the space available.

We are glad to see that Microsoft is embracing the WPF and Silverlight-based development engine for the mobile platform. This decision allows developers and designers skilled in XAML to leverage their existing knowledge and prowess to create useful mobile applications for both business and pleasure. The small footprint of Silverlight makes it ideal for usage with embedded or mobile systems with limited power and memory.

You can download our complete solution here.

Following the Microsoft KB you can see that you need to edit the docicon.xml file located at the path C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\TEMPLATE\XML

The Docicon.xml configuration file is a listing of all document types that are supported by SharePoint. To support the PDF icon, you need to add the following Mapping XML element to the XPath //DocIcons/ByExtension. The Mappings are listed in alphabetical order, so you should insert the PDF mapping accordingly.

<Mapping Key="pdf" Value="pdficon.gif"/>

Here is the Docicon.xml file after the edit.

The next step is retrieving the small PDF icon from Adobe. When you have download the icon image, you need to save the image as “pdficon.gif” to match the mappings entry we created earlier. The last step is to copy the PDF icon image to the SharePoint template images path: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\TEMPLATE\IMAGES\pdficon.gif. This is the location where SharePoint will search for document type icons for rendering in document library views – according to the configured file extension mappings in docicon.xml.

After these steps have been completed, you can now visually distinguish the document type for PDF extensions with a quick icon type indicator.

To use App Engine, you need a Google Account. Once you have your Google Account, you can enable App Engine services by entering in your cell phone number and carrier on the App Engine setup page. Google will send you an SMS with an access code you need to enter into the website. This activation scheme is Google’s way of restricting you from creating multiple App Engine accounts.

When you have received your code via SMS and entered your activation code, you can begin creating applications. The following appears after you have activated your App Engine account.

When you click “Create an Application” you can enter an application alias where your new application will be hosted on the appspot.com domain.

If your alias is available, you can then create an application and deploy to your new cloud application. In this example, we created the alias “pearlcompanies”.

Since we’re running in a windows environment, our next step is to setup Eclipse and the Google Plugin for Eclipse to deploy to our cloud application. We used Eclipse 3.5 (Galileo) in our example. After unpacking the Eclipse folder contents, we tell Eclipse where to get the Google Plugin. We add the available software site “http://dl.google.com/eclipse/plugin/3.5″ to our Eclipse Preferences.

Download and Install both the Google Eclipse plugin and GWT and App Engine SDKs.

After installing the Google SDKs, we can create Google App Engine projects (Web Application Projects). The nice thing here is that we can run the cloud application locally and verify it before deploying remotely to the cloud. The Google SDK comes with the components necessary to simulate the cloud environment.

Once we have our web project, we can begin creating our WAR package for deployment into the App Engine cloud service. The current App Engine supports Java and Python environments, but in this example we are going to use the Java runtime. Since we’re demonstrating deployment here, we are not going to use any servlets, but simply an HTML front-end. After changing the index.html page in our web project, we click the App Engine icon in the Eclipse toolbar.

After clicking the icon, we are prompted with the deployment wizard which has our Google account credentials and a link to the App Engine project settings. Click the project settings and enter the Application ID and version for the application (use the alias we setup previously).

Click ‘Ok’ on the properties dialog, and then enter your login credentials. Once you click ‘Deploy’, your application will be pushed into the Google App Engine cloud. You can view and manage your applications that are live in the Google App Engine site.

You can view the clone of our Pearl Companies website which we deployed to pearlcompanies.appspot.com. Please let us know about your App Engine experiences. We look forward to using this new powerful platform.

When you receive your access token, you can begin creating projects on the Azure platform with the Azure Developer Portal. You can only create one project with the CTP, but you can have multiple services inside each project (web/worker roles).

After you’ve created your project in the developer portal, you can add services which will be the endpoints you deploy to for Windows Azure. We will add a Windows Azure Service in this example.

To create our Windows Azure application, we need to create a package (cspkg) that contains our application contents and a configuration definition (cscfg) that defines our roles. Microsoft has created Azure tools to assist in generating the package and configuration file. You can download the Azure SDK to create Azure applications using Visual Studio. The Azure SDK allows you to run your own local development fabric before pushing your application into the cloud. Eclipse also has its own Azure Tools if you prefer to develop in the Eclipse environment.

After installation of the Azure Tools, you now have a new project template “Cloud Service” which we’ll use to create our web role.

After clicking “Ok”, you will now have a Cloud Service project and a Web Role project in your solution. We will now remove the Web Role for this exercise, and replace it with an existing ASP.NET application called ASP.NET Chart Controls which Scott Guthrie announced last year. This application did not work on the PDC release of Azure, but Azure now allows web applications to run in Full Trust with some minor tweaking.

We now have our solution complete and have one web role we would like to deploy to the cloud. We must now publish the solution to Azure. We right-click on the Cloud Service project and click “Publish” which opens up the Azure Developer Portal.

After logging in with Windows Live, you want to deploy your application to the Staging Environment before pushing it live. To deploy, you simply select the application package (cspkg) and configuration definition (cscfg) from your “/publish” folder in the cloud service “/bin/Debug” directory.

Clicking on “Deploy” will load the Azure package and service definition to the cloud and create a VM necessary to run the application. The environment takes some time to setup and will show its state as “Initialization” until the VM is entirely ready. You are given a URI based upon a randomly generated GUID to view your application and test it before moving it into production. Having two environments is nice if you also have database changes that need to coincide with your deployment.

Once the application has been verified, you can click the center arrows icon to swap the Staging site into Production. You can see the two environments have now been switched.

Azure does make the deployment process a bit more involved, but there is an managed Azure Deployment API in the works to automate the build and deploy steps you may need in your organization. You can view our sample ASP.NET Chart Controls application running on Azure Services (cloudapp.net). Kudos to Microsoft for allowing full trust applications! We will be watching for more exciting features from the Azure Team.