So that brings me to my solution which is simple and free, and no it is not braindumps which will just hurt you in the long run. Microsoft provides you all you need to prepare by giving you the outline. Utilizing the outline and MSDN it is relatively easy, though very time consuming, to essentially frame out your own book that will be current and error free. So for example lets take a look at the outline for exam 70-573: Microsoft SharePoint 2010, Application Development. The first section deals with interacting with the Sharepoint UI via .NET, more specifically in the first bullet point of utilizing the SPWeb and SPSite objects. What I will do is copy the contents of the outline in to my own html file and proceed to seek out links, preferabbly to the MSDN, detailing the content that the bullet point refers to. So for the example of the 1st bullet point in exam 70-573 the outline has as follows: (Content is subject to change at Microsoft’s discretion)

This objective may include but is not limited to: creating sub webs, referencing SPFiles, manipulating property bag, when to call Update, referencing SPContext, SPSite, SPWeb, SPSite.OpenWeb, SPWeb.Webs, feature activiation and deactivation

This objective does not include: trivial cases such as setting title and other loose properties of the objects

I then proceed to build up my content links similar to what I show here:

This objective may include but is not limited to:

• Site
  Architecture
• SPFiles
• SPContext
• SPSite
• 
  SPSite.Features
• 
  SPFeatureCollection
• SPWeb
• 
  SPWeb.Features
• 
  SPWeb.Properties
• SPSite.OpenWeb
• SPWeb.Webs
• 
  SPWebCollection
• 
  Disposal

Not only are you getting the content from the source that the exams are based off, but as you delve deeper and deeper into the MSDN you will get a more fuller and rewarding experience then most of the preparatory textbooks will provide. This has become a popular technique for preparation over the past few years, and sometimes you may find bloggers that will post their MSDN linked outlines online, but usually I prefer to create my own since they may have excluded content that they didnt neccesarily need for their own preperation. So hopefully this technique will help you some in your own preparation, and good luck.

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.

There are several utility programs that I need to run on a regular basis, but none of them are registered in GAC.  To run those utilities, I have to open a CMD window, and navigate to the directory where they are located.  It starts getting annoying when I have to type cd “C:\Program Files\ProgramName\Version\bin” (which is the path to the directory where those utilities are stored) every time that I need to run these utilities.  It would be nice if there is a way to set the start-up directory of CMD so that when I start the CMD it navigates to the desired directory automatically.

Solution 1 (not recommended):

One option to do this is to change windows registry.  Actually, I was searching on Google, and found many on-line resources about this.  Here is one talking about  How to change the default startup directory for Command Prompt?

However, as the article has mentioned, there may be risks associated with this method, and it may cause problems when I need to run windows or other regular utility programs, so it is not my favorite solution.  I guess the option may be more suitable in other cases, but not in mine.

Solution 2 (my favorite):

After messing around with the CMD.exe and windows shortcut properties, I finally found a much easier way to do what I needed to do.  Windows shortcuts have an option for “Start in” location which sets the start-up directory of CMD when it is executed.  So, all I needed to do was to create a shortcut on my desktop to CMD.exe, and set its “Start in” location to “C:\Program Files\ProgramName\Version\bin”. (See the screen shot below)

Now, when I launch the shortcut, it starts a regular CMD window and sets the current directory to the right directory (which is “C:\Program Files\ProgramName\Version\bin” in my case).  Easy enough?

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.

The manager makes it much easier to see what extensions are available and allows easy access to detailed information about each extension. It also helps you keep you installed extensions up to date by notifying you of any changes.

Two of my favorite extensions are PowerCommands and the Productivity Power Tools. PowerCommands adds the “Open Containing Folder” command to the solution explorer. This allows you to quickly navigate to the folder that contains your source code.  This feature alone makes it worth installing. There are several other handy features that enhance copy and paste as well as document management. You can find more info here.

The Productivity Power Tools extension is one of the most useful extensions available. Some of the best features include auto brace competition, a searchable Add Reference Dialog, Column Guides, Solution Navigator (which is a much improved version of the solution explorer), and tons of improvements to the document tabs. You can find more info here.

Take a few minutes to look through the extension gallery. You might be surprised what features you never knew you were missing from Visual Studio 2010.

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.

What I was doing was to use it to write event entries in windows event log as part of the exception handling in an ASP.NET web application.  Nothing fancy.  It worked fine on my PC, but it didn’t write anything to the event log when Logger.Write is executed. No exception was thrown from that line of code either.  The program just went through as if that line of code was skipped.

It turned out to be a permission issue. When I debug the application in Visual Studio, it was running under my windows account credential which had permission to create Event Source in the system.  However, when the application was deployed to the server, it was running under the default account which was “NT Authority\Network Service” in my case.  By default, that account doesn’t have permission to create new Event Source in the system.  It does have permission to write event entries though.  So, when Logger.Write was executed, it couldn’t proceed because the Event Source wasn’t there, and the program didn’t have permission to create one.  Actually, it makes sense to not throw any exception on this line, because people like me usually use this to log exceptions, and if the logging process itself throws exceptions, there is probably nowhere else we can handle and/or log them.

Now, how this can be resolve?  The solution is quite simple.  As long as the Event Source is created ahead of time, it will be no problem.  What I did was to create required Event Source(s) on server through CMD.exe.  Here is a sample command:

eventcreate /ID 1 /L Application /T information /SO "My Event Source" /D "My Event Source is created."

This command will create an event entry in the Application log.  If the Event Source doesn’t exist, it will be created during the process.  This is only required when the application is deployed to the server first time.  So, I usually do it manually on server.  However, if that’s not the case, you can build it into the installation package, and when the application is installed, the Event Source is created as well.  Of course, you can use .NET to create Event Source in your installer too.

This pattern works, but sometimes it is tricky to generate a meaningful message.  The problem is that the exception can be thrown anywhere in your application, and the exception message may not always be appropriate or meaningful to end-users.  If you blindly display all exception messages you finally get, users may see something like “Object reference not set to an instance of an object” which doesn’t mean much to them.  So, in the final step of exception handling (where the program displays error messages or redirect users to an error page), you will see all kinds of exceptions which include .NET originated exceptions, exceptions raised by the program on purpose, and custom exceptions.  Some of them are appropriate to show to users, while others aren’t.  So, the question is how you can distinguish among them.

A lot of people suggest that if the original .NET exception message isn’t meaningful to users, and you can’t provide more specific message either, then a generic message such as “An error has occurred…  Please contact the technical support team for help” can be used.  I agree too.  You may do this where you know an exception can be thrown, and re-throw the exception with customized message (whether specific or generic) and with the original exception embedded as the inner exception of the new exception.  However, you don’t want to just put try/catch blocks in every piece of your code, and catch and re-throw every exception the program may possibly encounter.  It’s labor intensive and inefficient.  Also, there will always be something you can’t think of or look over, so there are still chances you can get unexpected exceptions in the end.

So, my solution is to let the program only catch and re-throw .NET originated exceptions when they are predictable and additional meaningful information can be provided, and let all other exceptions bubble up to the top tier.  Then in the final step of exception handling, identify the exceptions that are re-thrown, and retrieve the error message directly from these exceptions; use a generic error message for all other exceptions.  The question is how to identify these exceptions that are re-thrown.  For this purpose, I usually create a custom exception class which is inherited from System.Exception.  Use this class whenever I need to throw new exceptions or re-throw .NET originated exceptions.  So, in the final step, I check the type of the exception, and decide whether to use it as the error message or use a generic one instead.

Here is the custom exception class:

The ExceptionBase class has two constructors which give you the options to create an instance of exception with customized error message and with/without inner exception.

Here is how to use it in code:

Or

The central location I handle all exceptions is in global.asax, and here is what it looks like:

One note for this is that ASP.NET may put a wrapper exception (HttpUnhandledException) around the original exception.  In the code above, it is simply removed because it doesn’t contain any useful information.

You can also create more custom exception classes based on the ExceptionBase class to improve consistency in your application, and the code above will still work.  One example is:

This way the error messages for one type of exception are consistent across the application.

Here are a few things you will need to have on your computer to continue.

1. Windows Virtual PC 2007.  This is required, if you would like to connect the Device Emulator to your local network.  The software can be downloaded from Microsoft website.
2. Microsoft Visual Studio 2008.
3. Microsoft Device Emulator (which comes with VS2008).

With all the above requirements available on your computer, you can follow the steps below to configure your Device Emulator.

1. Start VS 2008 IDE.
2. On the menu, go to Tools >> Device Emulator Manager
   

   Start Device Emulator Manager

3. Right-click on a device you would like to use, and choose Connect option.
   

   Connect to A Mobile Device

4. After the device is connected, right-click on the connected device again, and choose Cradle.
   

   Cradle the Connected Device

5. Go to the device window.  On the menu, choose File >> Configure
   

   Configure Device

6. Go to the Network tab, and select the options as shown in the screen shot below.  And then click OK to close the window.
   

   Choose Network Card

7. In the device window, on the menu, choose File >> Reset >> Soft.  And wait until the device is restarted.
8. Now you need to configure the internet connection in the mobile device.  (The process could be different depending on what device you have picked.)  Normally, you would find the Settings option in the main menu, and then go to the Connections section to choose/define an internet connection.  Here below I use the device I chose as an example.
9. Choose Settings >> Connections >> Advanced >> Select Networks, and then choose My ISP for both Internet and Private Network connections.
   

   Choose Settings

   

   Choose Connections

   

   Choose Advanced Settings

   

   Choose My ISP

10. After confirming all these changes, you can now visit your mobile web application or internet using this Device Emulator.  Task accomplished!
    

    Your Mobile Website