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.

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.

Since Visio 2003, a new feature, Reverse Engineer, has been made available in its Professional edition (and Premium edition in Visio 2010).  This feature allows you to connect to an existing database, extract database schema, and create an ER Diagram automatically.  You can also lay things out in the way that you want, and catch changes made to the database.

The key here is to create a connection to your database.  It does not have to be a Microsoft database.  Most likely, if there is an ODBC Data Source defined on your computer, you can connect to your database in Visio and generate the diagram.  In the rest of this article, I will show you how to generate an ER Diagram for an existing Access Database using Visio 2010 Professional Edition.  The process would be similar for connecting to other types of databases.

1. Make sure you have an ODBC Data Source defined for MS Access Database.  Usually, you do not have to do this for Access Database.  It should have been created when Office or Visio is installed.  For other types of databases, you may need to first install an ODBC Driver which is often available from your database provider.
2. Start Visio, and choose Database Model Diagram Template under Software and Database Template Category.  It is important to choose the right template, or you will not see the feature we want to use.
3. Once the file is created, you will see two new things that you normally do not see.  The Tables and Views window in the Task Pane, and the Database Tab in the Ribbon area.  Please note that you will not see them, if you did not choose the right template in step #2.
4. Click on the Reverse Engineer button under the Database Tab to start the Reverse Engineer Wizard.
5. Select Microsoft Access in the Installed Visio drivers drop down list, and choose MS Access Database as the data source. (If you are connecting to another type of database, you may have to choose ODBC Generic Driver in this step.)
6. Then you will be asked for user credential.  Leave them blank if the database is not password protected. (This step may look different, if you are connecting to another type of database, but the wizard should lead you through the data source setup in a similar way.)  Select your Access Database file and click OK to continue.
7. You will be given the chance to select types of objects you want to pull from your database.  Do all that and then click Next to continue.
8. After everything is set, click Finish to close the wizard window.
9. Visio will then connect to your database, and pull desired information back.  Tables and Views will be placed in the Task Pane, and shapes and connections will be drawn on the current page (if you chose to do so in step #7).
10. You can drag the entities around on the page without breaking the relationships, and click the Refresh button under the Database tab to get changes from the database.  During the update, new Tables or Views will be added to the Task Pane, changes may be applied to the diagram, and everything else should be kept unchanged.

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.

Think about the case where customers are continuously sending orders to you, and you are batch-processing these orders.  (Batch-processing would generally increase the processing efficiency in cases like this.)  The orders are stored in a SQL Server Database, and there is a service written to repeatedly pull order records back from the database for processing.

In synchronous operation, there is no problem.  The service could select all unprocessed orders from the database, process them, mark them as processed in the database, and repeat the same process over and over again.  The same order will only be processed once, and no order will be missed.

However, in asynchronous operation (or multi-threading), there may be a problem.  When one thread picks up some unprocessed orders from the database, it is not guaranteed that they are not being processed on another thread.

Well, you could let the service pick up the orders and then mark them as being processed, so other threads won’t pick them up again.  However, unless you can select and mark them at the same time, other threads can still squeeze in the small time interval between after you select them and before you mark them in the database.

Can we select and mark the orders at the same time?  Yes, we can use the OUTPUT statement in an SQL UPDATE and SQL transactions to achieve this.  Basically, we mark (update) orders and then select the ones we just marked (updated) within a single SQL transaction.  Here is a demonstration.

CREATE TABLE [dbo].[Orders](
	[OrderId] [int] NOT NULL,
	[State] [varchar](50) NOT NULL
) ON [PRIMARY]

GO

INSERT INTO [TestDb].[dbo].[Orders] ([OrderId], [State])
     VALUES (1, 'Waiting for processing')
INSERT INTO [TestDb].[dbo].[Orders] ([OrderId], [State])
     VALUES (2, 'Waiting for processing')
INSERT INTO [TestDb].[dbo].[Orders] ([OrderId], [State])
     VALUES (3, 'Waiting for processing')
GO

UPDATE Orders
SET [State] = 'In processing'
OUTPUT inserted.*
WHERE [State] = 'Waiting for processing'

In the SQL statements above, we defined a simple table to store orders, and insert some order records. In the UPDATE statement, we marked all orders in “waiting for processing” state as “In processing”, and output (return) the orders we just updated. The keyword “inserted” is somewhat confusing, because we are not inserting new records. To me, “updated” would make more sense. Anyway, the result of the UPDATE SQL statement should look like:


OrderId State
-------- --------
1 In processing
2 In processing
3 In processing

In real practice, we should put the UPDATE statement in a SQL transaction, no matter whether it is handled in a Stored Procedure or in the application layer. By doing this, each order will only be picked up once, no matter how many threads are querying the database using the same SQL statement at the same time.

 Businesses who fall into the above category generally don’t realize how powerful
    MS Access really is. They may use Excel to format data, import that data into Access
    and then use that data to update, query and report on. The following are almost standard
    practice in small and large businesses:

  • Use Excel to format data
  • Use multiple (manual) steps to maintain an excel spreadsheet
  • Use multiple (manual) steps to update an Access table
  • Combine data stored in multiple spreadsheets or tabs
  • Create reports manually
  • Create files (exported) manually
  • Get data from a database (sql)
  • Use multiple Access databases. (can typically use 1)

 Pearl Technology has extensive experience with automation, streamlining and enhancing
    these points. Examples:

  • Create data entry screens
  • Create forms to automate most manual processes
  • Create backup files/tables
  • Create log files to track changes
  • Link to external data, tables, files…
  • Validate input data
  • Set up auditing queries
  • Create reports
  • Create export queries (to excel, flat files..)

 These are all good selling points for MS office product users.