Golf is a Patience game where players try to earn the lowest number of points (as in golf, the sport) over the course of nine deals (or “holes” to further use golfing teminology). It has a tableau of 35 face-up cards and a higher ratio of skill to luck than most other solitaire card games.

My attempts in this tutorial series will be able to keep the code reusable and hopefully build onto this series with other Card/Solitaire games.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part III – Deck Class
For this tutorial we will focus on the class that will handle the logic for a group of cards. Start by right clicking on your classes folder and adding a new class called Deck.cs. The first thing we will need to do is setup are using’s as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;


Next set your class to be public.

Now we can begin by adding a Enum to our class to represent a deck type:

public enum DeckType
{
User = 1,
Source,
Waste,
Target
};


Now we can setup the individual properties that a Card will have, I will show the code first and then proceed to explain what each property is for:

protected List cards = new List();
protected Point pos;
protected int deckID;
protected DeckType deckType;
Texture2D background;

public DeckType Type
{
get
{
return deckType;
}
}

cards will be a list of the cards in the deck, pos is a point that is used for offsetting a card image so you can have one card on top of another and see the values for both. deckID is an ID for keeping track of the decks. DeckType to indicate the enum for which type of deck it is, and a texture to store the decks background.

Next we have our constructors:

public Deck()
{
deckType = DeckType.User;
}

public Deck(int id)
{
deckID = id;
deckType = DeckType.User;
}


Since this deck class is going to be a base type it will default to being a user deck, other deck types (waste, source, etc..) will implement the desk class. Next we will need some basic methods for maintaining the list of cards that are in the deck.

First we will need to be able to retrieve the number of cards in the deck:

public virtual int CardCount()
{
return cards.Count();
}

And finally get a card
public virtual Card GetCard(int index)
{
return cards[index];
}


In the second part of the deck class we will look at Adding cards, handling input, and drawing the cards.

My attempts in this tutorial series will be able to keep the code reusable and hopefully build onto this series with other Card/Solitaire games. Also this tutorial assumes that you have basic XNA knowledge.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part I – Project Setup

Start by creating a new XNA 4.0 Windows game project. In my sample I named the project “Patience” but you are free to name it whatever you like. Then in the main project right click the project and add a new folder called classes. This will be where we define our game logic.

Also in your Content Project right click and add “Cards” and “Fonts” Directories. Where the actual game art will be stored. Right now that gives us the basis for starting our game. In the next tutorial we will focus on creating the Card class.

For this tutorial we will focus on the class that will handle the logic for one individual card. Start by right clicking on your classes folder and adding a new class called Card.cs. The first thing we will need to do is setup are using’s as follows:

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;


Next set your class to be public.

Now we can begin by adding some Enums to our class. The first enum will deal with the suit of the cards:

public enum CardSuit
{
Clubs = 1,
Diamonds,
Hearts,
Spades
}

The next enum will be for the value of the cards:

public enum CardValue
{
Ace = 1,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}

The final enum will be for indicating what color the card is:

public enum CardColor
{
Black = 1,
Red
}


Now we can setup the individual properties that a Card will have, I will show the code first and then proceed to explain what each property is for:

public Rectangle CardRectangle
{
get
{
return rect;
}
set
{
rect = value;
}
}


The first three will be used to set the enums(Suit, value, and color) for the specific card. IsTurned will be used to determine if the front or the back of the card should be drawn. ParentCard and ChildCard will be used for indicating what card is above and below the card on the screen. ZOrder is similar to the css property z-index and will be used for card drag and drop. Though this game does not have drag and drop capability we are adding the ZOrder property for future use. CardName will be a string that will indicate which artwork to use, it will be made up of concatenating the cards suit with a “-” and the cards value. If you choose to use cards other than the ones I provide, please be sure they follow this naming convention. OwnerDeck will refer to which deck the card is currently in (draw pile, plateau, waste, etc…) this refers to a class that we will develop in part 3 of this series. Teh we have the OriginRect this is a placeholder value so that we always know where the card came from, in case we ever need to return it to that spot. Then we have two static variables for storing the size of the card. Next we have two XNA textures that will store the card image and the back of the card image. Finally we have the rectangle where those card images will be drawn.

Next up is the constructor followed by a description:

public Card(CardSuit suit, CardValue value, int z, ContentManager contentManager)
{
ZOrder = z;
ParentCard = null;
ChildCard = null;
OwnerDeck = null;

LoadCard(suit, value, contentManager);
}


Since we are just declaring the card and not yet putting it in a deck we will be setting several of the properties to null, and then lastly we call another method to load the cards content based on the suit and value that we passed in.

The cards Load method is detailed next:

public void LoadCard(CardSuit suit, CardValue value, ContentManager contentManager)
{
if (suit == CardSuit.Clubs || suit == CardSuit.Spades)
TheColor = CardColor.Black;
else
TheColor = CardColor.Red;

card = contentManager.Load("Cards/" + CardName);
}


Based on the suit we first determine the cards color, Clubs/Spades are black and Hearts/Diamonds are red. We set the cards suit and value from the passed in parameters and then we create the rectangle that will hold the card texture. Next we load the cards background picture into its texture, and then after determine the cards name we load the card image into its texture.

Finally we have the method that will draw the card to the screen:

public void Draw(SpriteBatch theSpriteBatch)
{
if (IsTurned)
{
if (card != null)
theSpriteBatch.Draw(card, CardRectangle, Color.White);
}
else
{
if (cardBack != null)
theSpriteBatch.Draw(cardBack, CardRectangle, Color.White);
}
}

Here we are determining if the card is face up or face down and drawing that particular image to the screen.

That is it right now for our card class. In the future it will be expanded more to handle different input types like drag and drop but for now clicking on the card is all that is necessary. Also not the reason the card has no coordinates is because it’s draw location will be based on the location of it’s stack/deck. Stay tuned for the next part in the series where we will make a deck class.

1. Watch out for those non-ASP.NET components.  Actually, all ASP.NET components were designed very well and the scanner was not able to inject any script on any page.  The only problem we found was on the error page which accepts some parameters in the query string and displays part of the information on the error page which is a fairly common implementation.  Because it is simply an HTML page and does not contain server-side code, it was overlooked for XSS attack.  The scanner was able to embed scripts in the query string, and had them executed when the error page tried to render them on the page.  Although the error page cannot post any data back to the ASP.NET application itself or insert any data to the database, it is still a security risk.  You never know what hackers can do with this small hole in your site.
2. DO NOT perform the scan on production database.  We performed the scan on our QA environment assuming it would not do any harm to our database because it was only for XSS scan.  However, we have found that it entered thousands of records in a table in our database through a page which only requires one field for data entering.  As a result, the scanner tried all possible injection scripts on that page, and entered them all into the table in the database.  Now, we have a list of scripts we can try on other sites to have some fun. : )  So, I guess we shouldn’t have done this in the QA environment which points to our production database.  Even if we had to do so for whatever reason, we probably should have pointed the application to a test database for the duration of the scan.

Introduction

This tutorial will show how to create a custom pipeline component for Biztalk server 2010. The pipeline component will be called “PeopleReader”. The pipeline task is simple; it is going to consume an xml file on the receive port from a specified location, and then write a modified file to another location.

The xml content before passing through BizTalk:

<?xml version=”1.0″ encoding=”ISO-8859-1″?>

<People>

<FirstName>Peter</FirstName>

<LastName>Decosta</LastName>

</People>

The final xml file after passing through Biztalk :

<?xml version=”1.0″ encoding=”ISO-8859-1″?>

<People>

<FirstName>your_First_Name</FirstName>

<LastName>your_Last_Name</LastName>

</People>

The tutorial is going to cover all aspects of the custom pipeline coding, adding to orchestration, setting up ports, and debugging.

1. Creating C# project:
   

Open VS 2010 as administrator then go to “New Project“, then under Visual C# select Windows then class library, and name it People Reader (fig.1).

Fig. 1 creating the PeopleReader Class for the Custom Pipeline component

1.2 Adding references

The first step after the project is created is to add a reference to the BizTalk pipeline. In order to accomplish that, go to solution explorer; right click “references “then select “Add”. On the Add Reference Dialog box select the “Browse” tab then go to your Biztalk server 2010 installation directory, in the case of this tutorial it’s “C:\Program Files (x86)\Microsoft BizTalk Server 2010″ then select the reference “Microsoft.BizTalk.Pipeline.dll” then hit the “OK” button (fig2). Then right Click on “Class1.cs” then “rename”. Call the file “PeopleReader.cs”. Next Step is to add the namespaces necessary for this project and these are the following:

using System;

using System.Xml;

using System.IO;

using System.Collections;

using System.Text;

//Biztalk stuff

using Microsoft.BizTalk.Message.Interop;

using Microsoft.BizTalk.Component.Interop;

Fig.2 Adding a reference to “Microsoft.BizTalk.Pipeline.dll”.

In order to build a custom Pipeline class, our Peoplereader class need to inherit from four interfaces which are in no specific order: IComponent, IcomponentUI,IpersistPropertyBag and IbaseComponent.

Public
class
PeopleReader: IbaseComponent

,IcomponentUI

,IpersistPropertyBag

,IcomponentUI

{

}

Since this is a small project all the code can be in one file, however, in case the pipeline required heavy coding, I would recommend declaring the people reader class as partial, then separating the code to different files each inheriting from a different Interface, that will greatly facilitate readability, and scalability since multiple developer could be working on different parts of the Custom Pipeline.

Our next step is to declare that this class is going to a Pipeline component we do that by adding the following:[ComponentCategory(CategoryTypes.CATID_PipelineComponent)] above the class declaration. Then we define where in the pipeline this component will go, by adding [ComponentCategory(CategoryTypes.CATID_Decoder)] which means that the component can only be added in the decoder stage of a receive pipeline. Last we need to create a “GUID” since it’s required for use in COM interop. To generate a new “GUID” go to the Tools Menu, then select the “Create GUID” Option, select GUID format 6 then hit copy (fig. 3). Paste the new GUID in [System.Runtime.InteropServices.Guid("0D212B7D-F3E9-418B-92BA-9FBC36CF2948")] right above the class declaration.

Fig.3 Creating a new GUID

1. Defining public properties

After adding the GUID, we declare two private member strings (m_FirstName, m_LastName) along with their (get, set) properties. Those properties will allow the user to modify the content of <FirstName> and <LastName> Tags by exposing the properties to the pipeline designer at design time.

Your code should look like this at this point

[ComponentCategory(CategoryTypes.CATID_PipelineComponent)]

[ComponentCategory(CategoryTypes.CATID_Decoder)]

[System.Runtime.InteropServices.Guid("0D212B7D-F3E9-418B-92BA-9FBC36CF2948")]

public
partial
class
PeopleReader: IBaseComponent

,IcomponentUI

,IpersistPropertyBag

,IcomponentUI

{

private
string m_FirstName;

private
string m_LastName;

public
string FirstName

{

get

{

return m_FirstName;

}

set

{

m_FirstName = value;

}

}

public
string LastName

{

get

{

return m_LastName;

}

set

{

m_LastName = value;

}

}

}

1.4 Defining the IBaseComponent Members

Next we will define the IBaseComponent members. For ease of readability we create a new region then define the properties Description, Name, and version which represent the description for the Pipeline component we are creating, the Name as it will be seen in the BizTalk project and the version number.

#region IBaseComponent members

public
string Description

{

get

{

return
“Pipeline component to Read XML with Peoples Name”;

}

}

public
string Name

{

get

{

return
“PeopleReader Test Pipeline”;

}

}

public
string Version

{

get

{

return
“1.0.0.0″;

}

}

#endregion

1. Defining the IComponentUI Members

Next up is the IcomponentUI interface members, which contains the icon that will show up in Biztalk toolbox for pipeline and a validate method. We are going to define the icon to be the default system icon, and as far as validation we are not going to add any validation at this stage.

#region IcomponentUI members

public
IntPtr Icon

{

get

{

return
new System.IntPtr();

}

}

public
Ienumerator Validate(object projectSystem)

{

return
null;

}

#endregion

}

1.6 Defining the IPersistPropertyBag Members

IPersistPropertyBag Has 4 methods: GetClassID, InitNew, Load and Save

GetClassID: return a unique ID (the GUID we defined earlier) that represents the component

InitNew: used to establish structures (data, caching..) used by other IPersistPropertyBag methods, we are going to leave it blank for this tutorial

Load: used to load the properties values (in this case the value the user enters at design time)

Save: same as load but used to save the values.

In the code below I used two helper functions ReadPropertyBag and WritePropertyBag that are called from within the Load and Save methods.

#region IPersistPropertyBag members

public
void GetClassID(out
Guid classID)

{

classID = new
Guid(“0D212B7D-F3E9-418B-92BA-9FBC36CF2948″);

}

public
void InitNew()

{

}

public
void Load(IPropertyBag propertyBag, Int32 errorLog)

{

string val = (string)ReadPropertyBag(propertyBag, “FirstName”);

if (val != null)

m_FirstName = val;

else

m_FirstName = “N/A”;

val = (string)ReadPropertyBag(propertyBag, “LastName”);

if (val != null)

m_LastName = val;

else

m_LastName = “N/A”;

}

public
void Save(IPropertyBag propertyBag, bool clearDirty, bool saveAllProperties)

{

object val = (object)m_FirstName;

WritePropertyBag(propertyBag,“FirstName”,val);

val=(object)m_LastName;

WritePropertyBag(propertyBag,“LastName”,val);

}

private
static
object ReadPropertyBag(IPropertyBag propertyBag, string propertyName)

{

object val = null;

try

{

propertyBag.Read(propertyName, out val, 0);

}

catch (ArgumentException)

{

return val;

}

catch (Exception ex)

{

throw
new
ApplicationException(“Error reading propertybag: “ + ex.Message);

}

return val;

}

private
static
void WritePropertyBag(IPropertyBag propertyBag, string propertyName, object val)

{

try

{

propertyBag.Write(propertyName, ref val);

}

catch (Exception ex)

{

throw
new
ApplicationException(“Error Writing propertybag: “ + ex.Message);

}

}

#endregion

1.7 Defining IComponent Members

Finally the most important Interface of the custom pipeline Icomponent which has one method Execute. BizTalk calls the execute method to process the message, and then passes the context of the message and the message.

#region Icomponent members

public
IbaseMessage Execute(IpipelineContext pContext, IbaseMessage pInMsg)

{

IbaseMessagePart bodyPart = pInMsg.BodyPart;

StringBuilder outputMessageText = null;

if (bodyPart != null)

{

Stream originalStream = bodyPart.GetOriginalDataStream();

if (originalStream != null)

{

XmlDocument xdoc = new
XmlDocument();

xdoc.Load(originalStream);

XmlElement root = xdoc.DocumentElement;

XmlNodeList firstName = xdoc.GetElementsByTagName(“FirstName”);

XmlNodeList lastName = xdoc.GetElementsByTagName(“LastName”);

outputMessageText = new
StringBuilder();

outputMessageText.Append(“<?xml version=\”1.0\”

encoding=\”ISO-8859-1\”?>”);

outputMessageText.Append(“<” + root.Name + “>”);

outputMessageText.Append(“<” + firstName[0].Name + “>”

+ this.m_FirstName + “</” + firstName[0].Name + “>”);

outputMessageText.Append(“<” + lastName[0].Name + “>”

+ this.m_LastName + “</” + lastName[0].Name + “>”);

outputMessageText.Append(“</” + root.Name + “>”);

byte[] outBytes =

System.Text.Encoding.ASCII.GetBytes(outputMessageText.ToString());

MemoryStream memStream = new
MemoryStream();

memStream.Write(outBytes, 0, outBytes.Length);

memStream.Position = 0;

bodyPart.Data = memStream;

pContext.ResourceTracker.AddResource(memStream);

}

}

return pInMsg;

}

#endregion

1.8 Compilation and strong key creation for Assembly

Finally we can compile the code and check that the solution build succeeded. Next step though is to assign a key to the assembly.

Start the “Visual Studio” command prompt (fig 1.4). Make sure it’s not the windows command prompt!!!

Fig.1.4 starting the VS command Prompt

Go to the directory where your solution is, to do that type CD\ + whatever_your_directory_is in our case it’s CD\ Users\yourusername\Documents\Visual Studio 2010\Projects then hit enter. For the simplicity I am going to create a key under C:\temp (fig. 5)

Fig. 5 creating a strong key

After the key is created go to solution explorer, then right click on your project and select properties. Select the signing tab then check the “sign assembly” check box, and from the drop down menu select browse, then navigate to where you create your strong key (fig. 6).

Fig. 6 attaching the strong key to the assembly

Then compile again!

Setting a property based on a data value:

In this example, we have a label on a form that will display a dollar amount from our data source.  If the dollar amount is negative we want the label’s background to be red, and green if the value is positive.  To do this, we simply create a converter class in our code behind page.  This will use the numeric value and return a Brush object which we will use in our label’s Background property.  Here’s the code for the converter:

We then have to create a simple reference to our converter class in our ResourceDictionary in the Window.Resources section of our XAML:

So far so good.  Now all we have to do is bind the label’s background property to the converter and data value.  Notice that we have to bind both the label’s content (text) and background to the Amount value from our data context.  We also can set the ContentStringFormat property to automatically format the value as currency:

Setting a property based on another control’s property:

This method is useful when there isn’t a data field to bind to, but there is a need to conditionally set a control’s property.  Let’s assume we need to set a button control’s IsEnabled property based on a check box’s IsChecked property:

As you can see, we’ve bound the IsEnabled property of the buttons to the IsChecked property of  the check box by specifying the ElementName (control’s name) and Path (control’s property).  We also bound the Content property of the button to the same IsChecked property using the same method, to show the current state of the button (which the framework automatically converts from a boolean to a string).  The best part about this method?  No code behind!  Here’s the result:

This is a very simple overview of the power of converters and bindings, and how they can be used to help you do more than just display the data on your page.

A few other handy extensions besides “Reload All Tabs” are: JavaScript Beautifer, jQuery API browser, and Lorem Ipsum Generator.

The JavaScript Beautifier extension will “beautify” a long, hard to read JavaScript file that looks like this:

if(typeof deconcept==”undefined”){var deconcept=new Object();}if(typeof deconcept.util==”undefined”){deconcept.util=new Object();}if(typeof deconcept.SWFObjectUtil==”undefined”){deconcept.SWFObjectUtil=new Object();}deconcept.SWFObject=function(_1,id,w,h,_5,c,_7,_8,_9,_a){if(!document.getElementById){return;}this.DETECT_KEY=_a?_a:”detectflash”;this.skipDetect=deconcept.util.getRequestParameter(this.DETECT_KEY);  …

and make it look like this:

For anyone that likes jQuery, the jQuery API browser will also come in handy. It provides a quick search through the API documentation. Simply type in what you want to search for and you’ll receive your results.

A lot of times while testing an application you’ll need some generic text to populate text fields. The Lorem Ipsum Generator will provide you with random “Lorem Ipsum” text. You can specify how many paragraphs and words per paragraph you would like.

The first question was “We can do anything you can think of”, and the second one was “We can do anything that makes sense”.  In my opinion, the first is a false statement, but the second is definitely true.  I was not trying to “insult” my colleagues by implying “what they can think of does not make sense”.  What I really meant by that was that not every idea or customer’s requirement that sounds good is feasible in the real world.  Hardware and software limitations do exist, and sometimes there are things we should not do due to considerations in certain aspects like security and performance.  Hopefully, they won’t tag me as some slaggy developers who always say things like “Oh, no… you can’t do this”, or “It’s impossible”, or just laugh at you and your “stupid” ideas, simply because they lack the knowledge and skills, or they are not creative enough.

Here is one of my favorite jokes.

Boss: Hey, why the Ctrl+C and Ctrl+V (the hotkeys in Windows to copy and paste content) doesn’t work for me as you just showed me the other day?

Me: What happened, boss?

After me doing some investigation, analysis, troubleshooting, testing, validation, and whatever that could be.

Basically, a few seconds later, I told my boss: “Boss, it’s not going to work, if you press Ctrl+C on your computer at home and press Ctrl+V on the computer in your office”.

By the way, my real boss is twice as smart as the boss in this joke.  What!?  Doesn’t sound like he is a smart guy either, does it?  How about 4 times smarter… maybe 8 or 16 times?  Wait, I was trying to praise him.  How do I do this?  All right, my real boss is 2^n times smarter than the boss in the joke above (where n represents a positive integer which equals to a magic number m which can be used to calculate how many times that my boss is smarter than the boss in the joke by using the formula 2^m).  Sounds much better now?  Anyway, my boss is a smart guy.

So, I thought about this joke and asked myself: is there a way to make it work?  I think there is.  With the convenience of the Internet and the power of technology, we as application/software developers can probably make it happen, regardless of whether it is cost-effective or not.  We can develop an application and install it on the boss’s home computer, so when he presses Ctrl+C on his home computer, the content he tries to copy is pushed into the Cloud for storage.  On his office computer, we can load a similar application which allows him to pull the content back from the Cloud.  In addition, if he has a smartphone, he may be able to get the content on his phone as well.  Actually, there are companies doing just this.  Online storage/backup solutions can back up your files and store them in the Cloud (at a secret and secure location or multiple locations).  Sometimes, it’s done automatically in the background which means you don’t need to press Ctrl+C or even notice its existence.  The files stored in the Cloud can be retrieved on-demand or automatically on the other endpoints which could be your laptops, computers or smartphones.

In the end, the joke wasn’t a joke any more.  The boss’s idea wasn’t stupid either.  Online storage service is now a billion-dollar business.  People always say there is no stupid idea.  I couldn’t agree more on that.  So, be creative.  Find a billion-dollar idea for yourself.

What this report says to me is that there are still a lot of development teams that don’t take security seriously enough when releasing applications to the web.  I thought it was very telling when the mySQL.com website was brought down by a SQL injection attack this past weekend.  Without the inclusion of a security mindset during all phases of a development project you are leaving yourself open to vulnerabilities. 

A Forrester Consulting report commissioned by Microsoft in November of 2010 showed that “most companies choose to transfer risk from development to operations, where remediation cost for vulnerabilities are the highest.”  The report went on to show that almost half of companies do not perform any type of security testing on third party code.

We, as developers, must help change those numbers and show the importance of security in the SDLC.  We have to educate ourselves first, then bring our arguments to the business owners to show the positive impact taking a little bit of time up front will bring to the organization.  Compliance shouldn’t, and can’t, be the only reason to pay attention to software security.

There are resources out there that I would recommend every developer to familiarize yourself with:

http://www.owasp.org – Open Web Application Security Project, an open source community focused on the security of application software. 

http://www.isc2.org - A leader in educating and certifying security professionals (I have my CSSLP through this organization)

http://www.microsoft.com/security/sdl/ - Yes, even Microsoft has a Security SDL for us .NET developers that need to make sure our software is secure.

Know of any more?  Leave a comment and discuss…

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.