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.

Basically, you would integrate and organize all little background images that your website needs into one “big” (won’t be too big anyway) image file, like the one shown below.

It has got some corner images for cornered boxes and a few icons. All images are combined into this one image file while each one of them is laid out nicely. Well, it’s nice to look at and organize them that way, but how you can use them? Suppose you want to use the contact icon in front of some text. Normally, you could do something like:

Contact Name

However, with the combined image, it won’t show the background image as expected.

To make it work, you just need to do something like:

Contact Name

As you can see, it’s fairly easy – you just need to set the position of the background image instead of using the default position, so that only the appropriate background image shows up and rest of the image remains hidden.

Why are you doing this? I don’t claim that I fully understand the purpose behind this idea, but here is one reason that I can think of: performance.

When you view a web page, everything you see on the screen needs to be downloaded, and each download is initiated by an HTTP request. The more files you download, the more HTTP requests are needed, and the more load is put on the web server to handle these requests. Usually, the time spent on processing an HTTP request is much less than the time spent on downloading, but if the file size is small, the processing time for the request will take a big portion of the whole processing time. In the other words, it will be more efficient to send one request and download a big size file than to send a bunch of requests to download smaller files. Although it still takes little time for the web server to process a request, it could use a noticeable amount of resources of the web server to handle them, if there are thousands of people hitting your web server. Also, a web server can only process a certain number of requests at the same time. If there are 50 background images that are used on most of the pages on your website, the web browser will probably need to send that many requests to download each one of them separately, unless they are already cached by the web browser. So, if you can combine those 50 files and let the browser only request and download it once, you allow your web server to run more efficiently. Previously, the web server has to process 50 requests to get those background images to the web browser, but now it only needs to process 1 request, and get the same content to the web browser. Make sense?

There may be other practical reasons for this idea. Please share your input below if you find any.

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.

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.

This now leads to inputting this information into the software that you are using to manage your project.  How important is it to understand the software application that you are using to manage your projects?  Not understanding what the software does or how it works can result in giving false information and dates to Sponsors, Stakeholders, and Team Members.  Most software applications have many advanced settings that people do not even know exist.  It is extremely important to figure out how you want to track information in the schedule and set it up correctly before beginning the project.  If you are going to be tracking duration then make sure that the settings are set on fixed duration, or if you are going to be tracking effort worked of the resource then make sure that the settings are set on fixed work, etc.  Trouble will definitely start to arise if these settings are not being used appropriately since this is how the dates are calculated in the software.  This now leads to a lot of other very important questions: 1) Are the calendars in your project set up correctly with all of the holidays and time off?  2) What type of constraints will be used in the plan?  3) Do you understand how these constraints are affecting your project and critical path?  4) How will you be defining critical activities and using critical paths in the plan?  5) Are you using a baseline to be able to show variance and slippage on tasks in the plan?  6) Do you have multiple views set up to fit the needs of the different audiences that will be viewing the plan?  7)  How often will you be updating status on the plan?  How often will you be changing the Data Date in the plan?

As a Project Manager you are managing time, cost, and scope/quality.  Managing any of these without an accurate schedule is very difficult and probably inaccurate.

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.