I thought I will post my views on certification as this discussion comes up often within forums, casual chats and comments I see scattered over the web. I have been in the industry for 21 years and have been in-and-out of the training game since the start. I would hope to think that I understand the IT training game and how learners learn.  As a certified trainer I will promote certification as it continues the learning after the course.

As an employee looking for a job, my certifications have definitely opened doors for me and got interviews.  I have not landed every job offer as there are brighter people and better suited people than myself.  When I wrote each exam, I studied hard giving me more confidence in the technology. What I found quite interesting in some “technical interviews” the person interviewing me was actually quite weak … and allowed me to have a bit of “fun” by asking them on how they use or plan to use the technology. The interviewer suddenly became the interviewee.

I have also sat on the side of the employer and have had to hire several technical resources for the company or project. I have had to advertise and do the whole process myself and also have worked through many recruitment agencies.  On a few occasions I have been completely inundated with tons of applicants where I could not actually cope with the response,  one that springs to mind is I had 327 applicants for a C# .NET developer.

As a employer and tech lead here are some random points on the topic of certification

• When I come across individuals that have taken certification, it shows the person is a bit more serious about his/her career and willing to go the extra mile. I will also look at how long the person has being doing certifications for and how recent their certification is.
• A person that has actually studied for an exam has a good broad understanding of a topic and as a tech lead I can work with this base understanding. 
• I do acknowledge that on any certification there are areas were a person will have more experience and exposure to than other areas.
• The certification indicates the person has a bit of passion to the technology. 
• Certified people that have studied and used the technology are normally very confident in their own skill and knowledge base.
• Having no certification does not mean a person is good, their experience and work history are vital.  I have hired many uncertified geeks over certified people. These individuals however had experience that really stuck out when going through the resumes.
• Certification does not mean the person is good either, I have come across many individuals that have used brain dumps to pass and have no clue to technology. Looking at when they certified and what they have been doing since the certification gives some indication.
• I use technical interviews to filter out the brain dumpers who are trying their luck. 
• As a technical interviewer, it is really easy to pick out good and bad people within the first set of questions.  I start out with some really easy general questions and progress into more technical and specific questions.  Finally I push the boundaries of the person with serious geeky questions to find the persons range of knowledge. 
• My questions cannot be found from brain dumps as they are adaptive and if I am not sure about the persons skill the more questions I ask.
• A certification means the person has been exposed to a set level of technologies and features of a product.
• I will not hire just based on certification, experience and technology exposure also play a huge part.  I always conduct technical interviews with the short listed candidates.
• Should I be faced with two candidates that are equal in skill, have similar levels of experience and both will fit into the team.  I will pick the certified person over the non certified person.
• The certification is definitely a foot in the door.  When faced with heaps of resumes the certified applicants do stick out a bit more and make me look twice. 

For me the certification opens the door and gives you a slightly better edge over other people.  It does not guarantee the position, but it gives you the opportunity to showcase yourself.

My recommendation … get certified as it does help you.

Over the past two decades I have learnt a hell of a lot when it comes to different architectures and designs; also what things work and where things do not.  I have had a heap of failures in varying degrees from “oops, here is the fix”  to “Please don’t axe me”.  One of failures was the development of a Monolithic application and the mother of all ….

As one progresses in the developer career, ones experience increases and exposure to multiple systems within a organisation grows.  Very quickly commonality, duplication between these systems are uncovered.  The business processes start to look long and lengthy as a lot of duplicate work is done, often with tons of manual effort and bureaucracy.

As the problem domain is investigated, common grounds between systems look even more simple. There are shared processes, shared data, common workflows. Eventually the appeal to develop a single system for the organisation is made;  the one system to rule all systems.  Teams are formed and the product idea sold through the organisation.

Benefits

There are a lot of appeals for a single and central system

• A single and centralised data store
• Only one truth of the data
• No data duplication
• Single technology stack so it is easy for developers to maintain
• Inefficient business processes can be reengineered
• The new system better models the organisation and more accurately
• Lowered support base as there are fewer systems to support
• System integration is easier as it is one system with a few external data links
• Management reporting is easier across systems as there is a single data store to pull data form
• A single architecture
• A single developer framework and toolset
• Central collaboration and user interfaces
• Easier for users to learn the system
• A single security system that is easily to maintain
• Portal facilitated with central user access
• A consistent look and feel that promotes the company brand.
• Unified information, data, security, application, system architectures.

My experience

Well this happened to me,  I worked for a large international that had 45 small(ish) systems that were all independent.  Each one with a 25-60% functional overlap.  There was a lot of maintenance on each system and each had bug lists that went on for miles.  Users were frustrated with the system to no end.   These systems were just impacting the business too much causing the production support and development teams to run around like headless chickens.  As a lead architect, I spotted the common grounds of all applications; I saw they were all divisions needs and each integrated.  I saw a “big picture” of how they could all fit into a single system.  I was given the go-ahead to explore and prototype the idea with a team of really great guys.  We hashed out some prototypes, designed the architecture across the different architecture domains.  We use the latest technologies and best practices we could find.  Finally external “experts” were brought in to verify the designs and help minimise the risk to the business. This was going to be multi-million dollar project and we needed to get it right.  Everyone gave the green light and “Mother” was born.

Development and testing went fairly smoothly and we did have our fair share of challenges along the way.  There were several scope changes as business thought through their processes.  The project took 2 years to develop with a team of 30 techs.  We had a successful system and business was happy.

The first year of the project was bliss and we enhanced the system with new features and stabilised others.   

The bad

Building a monolithic application is not easy, and through the eagerness and passion of everyone to make it work we did not see some tell tale signs.

• When we embarked on the process, the organisations business processes were distorted due to the way the had to do their work.  The complexity was high and no one really understood the real complexity of getting a mature business process model in place.  This lead to a significant amount of scope changes.
• During the process there was a fair amount of red-tape to cut through as previous processes forced people to protect themselves so they could not be blamed for errors.  Figuring out real process versus “cover your butt” processes was a challenge.
• There was a fair amount of politics as no one really understood the process, but everyone wanted to control it.
• The business analysts, architects and designers had a tremendous challenge of fitting in new scope changes or stripping out ineffective ones.  There was a lot of balancing that needed to be done as one change rippled through the system.

The team did not really notice many of these tell-tale signs and wet ahead regardless; we took many of the issues in our stride and attributed them to “scope change” and refactoring.

The ugly

There is a really horrible side of monolithic applications, these things are real enterprise killers.  These “uglies'” only surfaced well after the project was deployed and into our second year live.

Staff skill

After the project completed, the contractors had all left and we were left with a handful of staff.  Some of these developers worked on “Mother” and others were pulled into other projects and lost their knowledge of the system.  Then we had some resignations and core staff left for greener pastures, new people came in.  The original vision and designs became vague to some and wrong interpretations were made.  Early after the project I was moved to another area and not actively involved in the maintenance

Change management

In the first couple of months after implementing the monolithic the world is ideal, the bugs are ironed out and the world is beautiful. The business starts implementing more and more features into the system and the designs handle these changes.

Eventually features are added that start changing the data structures and dependencies of information, these changes start affecting other changes which need to be revisited. Changes no longer become quick and simple; and result in a lot of side affects brining down the system. Many change issues were also due to new team members misinterpreting the system and requirement.

Complexity

As the system was large and feature rich, newer staff were not aware of all the functionality and thought many new features needed to be developed from scratch, where many where there in the first place but only hidden.  The system grew arms and legs with other weird bits too.  The perfect little system soon became a monster.

Due to the number of features a change impacts, the sheer manpower needed to implement the change becomes enormous.  A somewhat simple change touched many areas needing refactoring and extensive testing through the change control process.   The team simply was not able to respond fast enough to business demands.

Users became frustrated as an unrelated new feature, meant they should re-do their User Acceptance Testing for something another team in another area of the system needed, but they were affected.  To this add typical corporate politics and you have a nightmare on your hands.

In many cases the business areas were affected, it also affected collaboration and reporting making the change huge.

Business agility

The biggest downside to a monolithic systems is that all new features need to be integrated with the monolithic system, new smaller systems cannot be procured to fulfil a specific role .. they were not integrated. 

Changes to the system took long and the team was not able to respond fast enough to business demand.

Have to code

Having a home grown system yields a lot of control in the development team and IT management and may have its attractions. Introducing new features will require the team to hand write the feature as not to break the monolithic pattern. A quick fix and procurement of a vendor system breaks the architecture, thus the features have to be internally written.  Resulting in time and money.

Resistance is futile

As time progresses, smaller solutions are purchased to fulfil a specific need. Management look at the cost benefit of implementing a new purchased system versus an integrated home grown solution, the pain of change management, In dealing with issues, management need the quickest route to resolve the crisis and a system is introduced.

The developer team slowly changed and new developers started making their own “interpretations” and “improvements” to the architecture and in some cases areas were re-written.  The monolithic architecture slowly started breaking down and the team was starting to head back to square one.

This pattern occurs a few times and within a few years the team is back to having many smaller systems, thus defeating the original idea in the first place. It is pretty much what the Borg say in Star Trek ... “Resistance is futile”

Alternatives

Investigate your application architecture and adopt multiple smaller systems, of which many can be vendor supplied and others home grown.

Attempt to create a “plug-and-play’ system architecture, allowing functional systems to be changed with relative ease.

Independent systems should expose services allowing multiple systems to communicate with each other through some enterprise workflow or orchestration.  Making smaller service exposed systems using a Service Oriented Architecture is far more beneficial.  However the path of SOA is also a tricky minefield to navigate .. I feel a blog topic coming on.

Focus the development teams energy in building (or procuring) an integration framework that acknowledges the system independence, but supports integration. This will require building interfaces to systems that do not have interfaces.

As the team and integration framework matures, adding new systems becomes easy. All new systems pose challenges but nothing that can be overcome. A key “buy” decision on any new system is does it have an API, or a service infrastructure to integrate with.

The guys at Readify have finally convinced me to get onto twitter and I have been for the last two weeks.  Fair, I can get the hang of this and I have found benefit in it already.  Catch me @brettmaytom

Two months ago I decided to upgrade to Windows 7 x64 (Beta build 7000) on my XPS M1730.  Although I have had driver related issues I can report that I am completely satisfied with the change.  There are a few little annoyances that I have come across and this one keeps catching me.

When developing any web based application in Visual Studio 2008, be it ASP.NET, MVC, WCF, Web Services or Web Applications. I get the following symptoms and errors when debugging the application

After starting to debug an instance of the browser (IE 8) shows up and freezes then I get an error in the IDE.  “Unable to start program ‘http://localhost:{port}’.” and “Element not found.” as shown below:

When this happens, you will need to do the following in order (don’t ask me why this baffles me)

• You have to click ok to remove the error
• Stop the ASP.NET Development Server
• Kill the iexplorer.exe in Windows Task manager

If you do this and debug your application it works fine and you can debug.   However should make changes to your code and debug it again the symptoms reappear.

Temporary Solution

Run Visual Studio as Administrator and the problem goes away.

Provisioning a solution to a SharePoint server can be done using several methods, however the only correct methods are to use templates and solution packages.  In my series of posts on provisioning, discussed the relevance of provisioning, if this is your first article you are reading, I would suggest looking at Overview of features, templates, site definitions, solutions in SharePoint and SharePoint - Overview to creating a Solution Package.

Now, remember WSS is a powerful provisioning engine and is geared up to deploy web sites and components.  These can be deployed to a single or multiple servers in a web farm with ease.  Provisioning is easy once you get to grips with the WSS provisioning engine, the most important thing is follow the rules and you will not have issues deploying to SharePoint.  I strongly urge you to master this deployment mechanism especially solutions and solution packages, it is not conventional deployment as it is geared to SharePoint. 

After you have created the content of your new SharePoint functionality, that is features, web parts, assemblies, pages, resources etc; you will have to register them into a solution manifest file.  The manifest file is an xml file that follows the CAML schema and has a <Solution...> root element.  When the solution is deployed using a package, SharePoint will open up the .wsp file looking for this solution manifest.  It will then proceed to extract and register everything in the solution manifest.

The basic schema of a solution manifest

<Solution
  DeploymentServerType = "ApplicationServer"
  ResetWebServer = "TRUE"
  SolutionId = "GUID">
  <ApplicationResourceFiles />
  <Assemblies />
  <CodeAccessSecurity />
  <DwpFiles />
  <FeatureManifests />
  <Resources />
  <SiteDefinitionManifests />
  <RootFiles />
  <TemplateFiles />
</Solution>

The attributes are

What can be deployed using a solution manifest

<ApplicationResourceFiles>
  <ApplicationResourceFile Location="Text"/>
  .
  .
</ApplicationResourceFiles>

<Assemblies>
  <Assembly
    DeploymentTarget = "GlobalAssemblyCache"
    Location = "Text">
    <SafeControls>
      <SafeControl
        Assembly = "Text"
        Namespace = "Text"
        Safe = "TRUE"
        TypeName = "Text"/>
      ...
    </SafeControls>
    <ClassResources>
      <ClassResource
         FileName = "Text"
         Location = "Text">
      </ClassResource>
      ...
    </ClassResources>
  </Assembly>
  .
  .
</Assemblies>

<CodeAccessSecurity>
  <PolicyItem>
    <PermissionSet ....
      ...
    </PermissionSet>
    <Assemblies>
      <Assembly ...
       ...
    </Assemblies>
  </PolicyItem>
</CodeAccessSecurity>

<DwpFiles>
  <DwpFile
    Location= "Text">
  </DwpFile>
  ...
</DwpFiles>

Note that the SharePoint SDK indicates FileName instead of Location which is incorrect.

<FeatureManifests>
  <FeatureManifest
    Location="Text"/>
</FeatureManifests>

<Resources>
  <Resource
    Location="Text"/>
  ...
</Resources>

<SiteDefinitionManifests>
  <SiteDefinitionManifest
    Location="Text">
    <WebTempFile
      Location="Text">
    </SiteDefinitionManifest>
  ...
</SiteDefinitionManifests>

<RootFiles>
  <RootFile
    Location = "Text">
  </RootFile>
  ...
</RootFiles>

<TemplateFiles>
  <TemplateFile
    Location="Text"/>
  ...
</TemplateFiles>

Location attribute

Many of the child elements in the solution package include a Location attribute, this location is the location of the file within the solution package (.wsp) file.  In a future post I will walk you through the steps to create a .wsp file, however it is a standard cabinet file and when you open the cabinet the root directory of the cabinet is displayed. 

Example

The RSSView web part is in a folder FEATURE\GroundingRSS in the .wsp file.  You would specify the location of the <DwpFile element as  FEATURES\GroundingRSS\RSSView.webpart

See also

• SharePoint - How to provisioning a site column with CAML
• SharePoint - The TEMPLATE folder in the 12 Hive
• A series of posts on the art of provisioning in SharePoint
• The content of a SharePoint ElementManifest file
• Creating a simple SharePoint Feature.xml file

Deploying your features, sites to should not be done using a file copy as this may be an issue when you have multiple servers in your farm.  The correct way to deploy them is to create a solution package.  A solution package is a single file with an .wsp extension that contains all your resources you wish to deploy to the 12 hive.  Once you have created your solution package, simply deploy it to the farm and it will be copied into the 12 hive of all the servers in the farm.

Reasons to deploy using a solution package

Now it is important to highlight issues to the reasons why you should rather use solution packages instead of manually copying them over.

1. SharePoint tracks usage of the components and will give errors should you try to uninstall the solution package if being used.
2. Deploying to multiple servers in a farm could be prone to human error and one may forget to deploy to a server.
3. Should a server be down while deploying, you may forget to to deploy to the server when it comes up again.  However with as solution package it will automatically be deployed to the server when it comes up.
4. When installing new servers into your farm, you may forget to install your components especially if you have a lot of components that were added over time.  Provisioned solution packages will automatically be deployed to new server that are added to the farm.
5. Deploying custom DLL's to the Global Assembly Cache to a remote machine may be tricky.
6. Deploying custom DLL's to every bin folder of each web application that uses your components may be tricky especially on a server where new web applications and site collections are being used.
7. Modifying the web.config on all servers may be pose problems, using a solution package you can very easily modify the web.config especially your safe controls section.

WSS is a exceptionally strong provisioning engine which will manage the deployment of your components and resources to multiple servers in a web farm automatically.

The bottom line here is if you do not use a solution package, you are giving yourself more problems than you need.  These will definitely come back and bite you at a later date, causing you and many other people unnecessary stress.  It is easy to resolve this by creating a solution package.

How does deployment work with a solution package

The diagram below indicates what needs to be done to create a solution package.

Step 1 - Create custom features

The first thing that a developer has to do is to make the necessary features, templates, assemblies, web parts, pages and other resources that need to be placed into the 12 hive.  The developer will copy and test these features to his/her development machine to make sure it works.

For more information, see

• Creating a simple SharePoint Feature.xml file
• SharePoint - How to provisioning a site column with CAML
• Describing the ElementManifests section in a SharePoint feature.xml file
• SharePoint - Provisioning a content type with CAML
• SharePoint - The TEMPLATE folder in the 12 Hive
• The content of a SharePoint ElementManifest file
• SharePoint - Register an assembly as a safe control in the Web.config file

Step 2 - Create a solution manifest with CAML

The next step is create a CAML solution manifest that is called manifest.xml.  This solution manifest will contain all the information about the resources that need to be deployed.  When executing stsadm -o deploysolution, this manifest will be read and executed on all servers on the farm.

For more information, see

• SharePoint -  Creating a solution manifest
• SharePoint - Adding a feature to a solution manifest
• SharePoint - Adding a webpart to solution manifest
• SharePoint - Deploying assemblies with a solution manifest

Step 3 - Build a cab file (.wsp)

1. The programmer then needs to generate a data description file (ddf) with a text editor that contains a list of files to add to the .wsp (cabinet) file.  This ddf file will contain all the resources file names and the manifest.xml file that need to be deployed to the 12 hive.
2. Using makecab.exe <ddf filename>, the cabinet file with extension .wsp will be created.

For more information, see

• SharePoint - Creating a solution package with makecab.exe

Step 4 - Deploy the solution package.

1. The developer gives the single .wsp file to the administrator.
2. The administrator then uses stsadm -o addsolution -filename pathname\<package.wsp>.  This adds an asynchronous job to load the solution package file into the configuration database. 
   You can force the job to run immediately by executing stsadm -o execadmsvcjobs.  At this point the solution package is copied into the the configuration database.
3. Finally, the administrator deploys the package to the the farm, this will read the manifest.xml file in the solution package and proceed to extract the contents into the 12 hive.
   This is done by executing stsadm -o deploysolution -name <package.wsp>.  This will execute a job on every server in the farm and whereby the server opens the solution package, reads the solution's manifest.xml file and deploys what is defined in the manifest file.

Note the following

• The package is deployed to all servers in the farm, regardless of geography.  The state of what has been deployed to what server is managed in the config database.
• Should a server be offline when you deploy the solution, when it comes online there will be a job waiting for it to deploy the package. The job will be executed on startup thus ensuring the package is deployed.
• Should you add a new server to the farm, even months later. A job will be created to deploy all packages to the new server.  Thus when the new server comes online after being added to an existing farm, it will have all the packages deployed.

See Also

• SharePoint - Get to know the directory structure in the 12 Hive
• SharePoint - The TEMPLATE folder in the 12 Hive
• Overview of features, templates, site definitions, solutions in SharePoint
• SharePoint - Applications, Site Collections and Sites

Lists and libraries can be defined either to use a set of columns or it can be defined to use a content type which was introduced in WSS 3.0.  The content type defines the columns for a list item or row and a list can be set to use one or several different content types.   This effectively allows a list to contain multiple rows with each row having a different set of columns as defined in different content types.  It is important to note that content types are defined outside of lists and are consumed by a list, thus several lists can implement the same content type.

Another nice feature of content types is they are defined using an inheritance mechanism, thus a content type can is based on another content type.  In fact, you cannot create a content type from scratch, you always have to inherit from another content type.  When inheriting a content type, all the fields in the base/parent content type will be included in the new child content type you are defining.  There are several content types provided by SharePoint you can inherit from, the core two are either a item type for lists or library types for document libraries.

A final feature is that a library content type can contain a document template which will be used when creating new items for the library, e.g. you may create a word template for a proposal and a content type for the proposal.  This template document may contain default text, logos and formatting to your companies standards.  When creating a new "proposal" in the library, word will create a new document based on the template that includes all your default content.

Content types can also be associated with events and workflow's making it a really powerful feature of SharePoint.

Methods of creating a content type

There are several ways to create content types, either through the front-end, through code or through a feature.  The best method is to create it using CAML and  a feature.  This method allows you to redeploy and reuse your content type on different farms, sites and site collections.  The feature method of deployment is the preferred method of deploying your content types.

Provisioning a content type with CAML and a feature

In order to create a content type you will need to create a feature with an elements manifest file, I have already written several posts on how to do this, see the "See Also" section below if you do not know how to do this.

A simple content type is easy to provision, however the trick part is to know that content types always must inherit from another content type, thus the get the characteristics of the base content type.  The ID of your new content type must be created and I have written a post SharePoint - Content Type ID's on how to do this, please read this as it is important.

The next trick is to understand content types can include additional fields, however these fields must be defined as site columns,  you can use the site columns that ship with SharePoint, or you can create your own as described in my post SharePoint - How to provisioning a site column with CAML.  

The sample elements manifest file below, defines a site column called Customer Account Number and a Content type called Customer which inherits from a contact (0x0106).  The content type customer then also includes the a optional field for the Customer Account Number.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <!--Site Columns-->
  <Field
  ID="{63590418-87F5-4fa7-AF50-B371C88F2F56}"
  Name="CustomerAccountNumber"
  DisplayName="Customer Account Number"
  Description="A customer account number used within the company."
  Type="Text"
  MaxLength="10"
  Group="Grounding Site Columns"
    >
  </Field>
  <!--Content Types-->
  <ContentType
    ID="0x0106000BB3F82D2A624B77833C28045F765D7A"
    Group="Grounding Content Types"
    Name="Customer">
    <FieldRefs>
      <FieldRef ID="{63590418-87F5-4fa7-AF50-B371C88F2F56}" />
    </FieldRefs>
  </ContentType>
</Elements>

Verifying the content type

Once you have created the feature, installed and activate the feature.  Navigate to the Site Content Type Gallery in your site settings:

Notice the following when viewing your content type:

• The parent indicates it is a contact
• The columns defined in contact are in your contact.
• The new site column "Customer Account Number" is also in the content type.

See Also

• SharePoint - Content Type ID's
• Content Types the Core of ECM in Sharepoint
• Creating Content Types and linking them to Document Library's in Sharepoint
• SharePoint - How to provisioning a site column with CAML
• SharePoint - The TEMPLATE folder in the 12 Hive
• A series of posts on the art of provisioning in SharePoint
• The content of a SharePoint ElementManifest file
• Creating a simple SharePoint Feature.xml file

Content types are little gems within SharePoint with many useful characteristics.  The one characteristic is that content types support inheritance.  For the non programmers; inheritance is when you define a content type it must be based on an existing content type.  The new type called the child type will get all the features, i.e. fields, settings of the parent type.  The child type can then have additional types.

To illustrate this, let us say we have a business that has customers and suppliers and we need to store customers and suppliers.  We could easily create a content type for a Customer that inherits from Contact, however a customer has an additional Account number field and Account Manager field.  The Supplier is also a contact and thus inherits from contact, however it has a Customer Number field.

At this point it is important to note that content types inherit from other content types and build a tree as shown in the diagram below:

You can create your own content types that inherit from other content types in CAML by understanding the ID field. Each content type must have a unique id, however unlike many other ID's that are Globally unique identifiers, a content type ID is a mixture of the parent ID, shown in the table below an a unique GUID.  Also the GUID is contains no braces or dashes like other GUIDS.

Where to set the ID

When you define your content type in the Elements manifest file, there is a mandatory ID field which needs to be the content type.  A snipit of a content type is shown below:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <ContentType
   ID="0x0106000BB3F82D2A624B77833C28045F765D7A"
    >

  </ContentType>
</Elements>

The syntax is :

Parent ID + 00 + GUID

Examples

1. To create a content type with GUID {0BB3F82D-2A62-4b77-833C-28045F765D7A} that is based on contact (0x0106), you would se the ID to
   0x0106000BB3F82D2A624B77833C28045F765D7A
2. To create a content type with GUID {0E3E8F35-3A21-4ed7-8151-816C48E2D64F} that is a based on document (0x0101), you would set the ID to
   0x0101000E3E8F353A214ED78151816C48E2D64F
3. To create your own item with GUID {A6C62A39-E374-4d8d-9EFE-90DD65B659F9} that is based on item (0x01), you would set the ID to
   0x0100A6C62A39E3744D8D9EFE90DD65B659F9

See also

• Content Types the Core of ECM in Sharepoint
• Creating Content Types and linking them to Document Library's in Sharepoint
• SharePoint - How to provisioning a site column with CAML
• SharePoint - The TEMPLATE folder in the 12 Hive
• A series of posts on the art of provisioning in SharePoint
• The content of a SharePoint ElementManifest file
• Creating a simple SharePoint Feature.xml file

In my previous post SharePoint - How to provisioning a site column with CAML I showed you how to provision a general site column using CAML.  In this post I will show you how to provision a site column with choices choices.

The basics steps are to create a feature.xml manifest that loads a elements manifest that has a <Field ... /> element for your site column.  The manifest looks something like the XML below.  In this example, I have created a colour picker with choices of colours from the rainbow.  I have also set the default colour to green.

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <Field
    ID="{D03DFA8E-3A4E-4bc7-9D1F-E653C1D69B13}"
    Name="Colour"
    DisplayName="Colour"
    Description="A colour of the rainbow."
    Type="Choice" 
    Group="Grounding Site Columns"
    >
    <CHOICES>
      <CHOICE>Red</CHOICE>
      <CHOICE>Orange</CHOICE>
      <CHOICE>Yellow</CHOICE>
      <CHOICE>Green</CHOICE>
      <CHOICE>Blue</CHOICE>
      <CHOICE>Indigo</CHOICE>
      <CHOICE>Violet</CHOICE>
    </CHOICES>
    <Default>Green</Default>
  </Field>
</Elements>

Creating the field element

1. Create a field in an elements manifest, see my post SharePoint - How to provisioning a site column with CAML on how to do this.
2. Give your field a Name and DisplayName.
3. Set the type to Choice

Creating the choices

1. In the Field element, create a child element called <CHOICES>
2. Add a <CHOICE>Item</CHOICE> element for each item that you want to appear in the list, e.g.  <CHOICE>Red</CHOICE>

Setting the default

1. Add a <Default>Item</Default> element for the default as a child element of Field.

Testing

You will need to install and activate your feature, once done you will need to create a list and add your new site column.  Notice the site column appears under the list of Available site columns

Finally, when you add a new item to the list and you will notice that it shows the choices in a drop down list.

Related Posts

• SharePoint - How to provisioning a site column with CAML
• SharePoint - The TEMPLATE folder in the 12 Hive
• A series of posts on the art of provisioning in SharePoint
• The content of a SharePoint ElementManifest file
• Creating a simple SharePoint Feature.xml file
• SharePoint - Defining a choice site column with CAML

A SharePoint list can be thought of as a data table with columns describing the fields and rows for each record.  The columns (or fields) are defined within the list and are only defined in a single list instance.  The are many business cases where your data contains the same column in many different lists and each time you will need recreate this column in each list, an example may be a Customer Account Number which is in many lists.

In WSS 3.0 there is a site column, which simply is a reusable field definition.  The site column allows you to define the field with all it's settings, once done you simply can add it to many different lists.  This becomes really handy when you have complex fields and want reusability.

Now there are three ways to create your site columns:

1. Manually create it using the web front-end. 
   The problem with this approach is that you will have to recreate this on different web applications and server farms, e.g. dev, test and production.  This could be prone to error
2. You can write code to create the site column.
   This is the long and hard way as you will need to test your code well and will require a programmer to do this.  You most probably will land up provisioning your code through features and site definitions anyway and I feel this is just too much effort.
3. Create the column using CAML.
   This is most probably the best way when it comes to reusability as you will create an element manifest and include this manifest in a feature.  Then you can simply deploy the feature and activate it where needed.

In this post, I will only focus on the last step as this is the best way to do provision a site column.

Summary of steps

This post will walk you through the steps below in order to create a site column,  the most important step is Step 3 which

1. Create a feature project
2. Create a feature manifest
3. Create a site column elements manifest file
4. Deploy the feature
5. Provision and Activate the feature
6. Verify the columns exist

Creating a feature to provision a site column

Download the code

Step 1 - Create a feature project

In creating a project for SharePoint, I somewhat follow the project structure as defined in the Microsoft Press Book: Inside Microsoft Windows SharePoint Services 3.0 by Ted Pattison and Daniel Larson. 

1. Create a Library project in visual studio, in this example I have called it Grounding.Demo.SiteColumn
   In this project we will not be deploying the actual DLL, so I will skip the steps of creating a strong named assembly
2. Create a directory structure to mimic the feature folder in the 12 hive where we are going to deploy the feature to. 
    
3. Edit the build events to deploy your SharePoint solution onto your development box.
   Please note that you should be provisioning your solution using a site definition, however I did not want to complicate this post.
    
   
   For this demo, the post-build event command line is:
   XCOPY "$(ProjectDir)TEMPLATE" "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\" /s

Step 2 - Create a feature manifest

In this step, we need to create a SharePoint feature for our content types in order to set up a proper deployment environment for our content types.  Once completed the feature will be used to deploy to other server environments, i.e. test and production.

1. Create a feature.xml file in the TEMPLATE\FEATURES\Grounding.Demo.SiteColumns folder.
2. Add the following xml to the file.
   

   <?xml version="1.0" encoding="utf-8" ?>
   <Feature xmlns="http://schemas.microsoft.com/sharepoint/"
            Id="{1EED8F45-4FF6-473d-9B8F-99CB6599D50C}"
            Title="Grounding Demo - Provision Site Column"
            Description="This demonstration teaches you how to provision a site column using CAML"
            Version="1.0.0.0"
            Hidden="FALSE"
            Scope="Site">
     <ElementManifests>
       <ElementManifest Location="SiteColumns.xml" />
     </ElementManifests>
   </Feature></PRE< P>
    

Important points to note

• The site columns are provisioned to the "Site" scope i.e. the site collection
• The feature has a unique GUID, which you can generate from Visual Studio menu, Tools\Create GUID (Use the registry format).
• The ElementManifest points to a file (created in the next step) that includes the site columns.

Step 3 - Creating a site column

Creating a CAML site is done by placing a field element into an element manifest file which is explained in the steps below.  For demonstration purposes I have created a simple customer account number field.

1. The first thing to do is create a element manifest file using an XML editor.
   In this case the it was called SiteColumns.xml (see the ElementManifest in the feature above).
2. Add the following XML to the file

   <?xml version="1.0" encoding="utf-8" ?>
   <Elements xmlns="http://schemas.microsoft.com/sharepoint/">
     <Field
       ID="{63590418-87F5-4fa7-AF50-B371C88F2F56}"
       Name="CustomerAccountNumber"
       DisplayName="Customer Account Number"
       Description="A customer account number used within the company."
       Type="Text"
       MaxLength="10"
       Group="Grounding Site Columns"
       >
     </Field>
   </Elements> 

Important points to note

• The ID must be a unique GUID which you can create using visual studio, Tools\Create GUID.  Use the registry format.
• Type and Title are mandatory.
• You can provision several fields in a single element manifest file, just create as many <Field .... /> elements as you need.
• Grouping your fields makes them easier to find and use from the front-end

Some field attributes

Step 4 - Deploy the feature

In my sample, I have inserted a post build event into the project properties which copies the feature to the 12 hive.  This is simply for demonstration purposes and you should provision your features correctly using a site definition.

Step 5 - Provision and Activate the feature

The next step is to actually deploy the feature and then activate the feature on a site

1. Open the command console. Start, Run, cmd.exe\
2. (OPTIONAL)Create an environment variable to the STSADM.EXE by typing
   SET STSADM=C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN\STSADM.EXE
3. Install the feature by typing the following command:
   STSADM -o installfeature -filename Grounding.Demo.SiteColumn\feature.xml -force
   
4. Open your web site
5. Click Site Actions
6. Click Site Settings.
7. Click  Site collection features under Site Collection Administration.
   
8. Activate the Grounding Demo - Provision Site Column feature
   

Note you could have activated the feature using stsadm -o activatefeature

Step 6 - Verify the site columns exist

Now the feature is activated, verify the column exists

1. Open your web site (should still be open).
2. Click Site Actions
3. Click Site Settings.
4. Click Site columns under Galleries
   Scroll down to find the column
   

Related Posts

• Download the code for this article
• SharePoint - The TEMPLATE folder in the 12 Hive
• A series of posts on the art of provisioning in SharePoint
• The content of a SharePoint ElementManifest file
• Creating a simple SharePoint Feature.xml file

In the past few weeks I have been doing some consulting and giving advice to development teams starting SharePoint development. In this process I have found it a common problem that several developers misunderstand what are site pages, applications pages and web parts are used for and when to use it.  At least a dozen e-mails, MSN chats and meetings in the past few weeks has prompted me to write this post.

As a developer we have many options available to us and it is difficult at first to really understand where to use what and when to use it.  Hopefully through my trials and errors I will be able to share with you what I have found works best. 

SharePoint opportunities as a developer

SharePoint, WSS 3.0 leverages on top of the .NET 2.0 and 3.0 frameworks using many ASP.NET features to deliver a powerful portal engine.  As an ASP.NET developer there are many different approaches to develop a web site and how to go about it.  The trick with SharePoint development is to know when to use what.  What makes it a bit more confusing is that many ASP.NET developers are introduced features of the .NET framework that they never new existed and the combination of the two new technologies becomes quite confusing.  There is however one thing in common, however or whatever approach you take, you will be generating HTML, CSS and client side scripts.

Web Parts

Web Parts are really nice server side controls that give the user the following benefits

• Personalisation
• a user can move the control to different zones on the page.
• a user can customise settings of a web part allowing data to be filtered, selected or rendered by parameters
• a user can choose to put a web part on a page or not.
• Reusability
• Web parts are intended to be reused on many different site pages
• Communication
• Web Parts can communicate with other web parts on the same page, sharing information between the controls providing a master / detail set of controls
• Summaries and information sharing

Web parts are intended to be used to display summarised and management information to users in a dashboard type page.  This page should have web parts that show results, graphs, KPI's and keep with the spirit of a SharePoint site ... that is to share and make information visible and easily accessible. The primary goal is to. 

The idea of a web part has been confusing to many, and often web parts are created for the wrong reasons, these include

• data capture and entry
• one-of-a-kind web part that will be placed on a site page by an administrator and will only be used once.
• front-end controls for line of business applications.

After all, a user is not going to want to choose the location on the screen to where to capture the new account details for a new customer, nor will they choose to optionally display or hide this from their screen.

Site Pages

Site pages are aspx pages that have web part zones in them, allowing a user \ administrator to choose a web part and drop it into a zone.  A site page should not need to have code behind the page and most definitely should not be hard wired to interact with a specific web part.  In essence it as a template for a page that contains zones.  These zones will be filled with web parts.  Please do not put code into your site pages or hard wire the site pages.

Application Pages

Application pages are for all intense purposes the same as a traditional .aspx page where you can do what ever on the page you wish.  Application pages are ideal for your line of business pages and data capture pages.  Your application page can also contain as much code and complexity as you like.  You can choose to interact with SharePoint or do your own thing.

Application pages should be used for

• Data capture pages
• Line of business or system pages
• Configuration pages
• Pages that are a one-of-a kind page
• Pages that should not be customised by users
• Requires code behind the page

Now, another small mistake that many developers make is that they place complex logic into the .aspx page, instead get used to putting your logic into an .asxc page and then dropping this onto your page.

Conclusion

Create application pages for you line of business systems and implement these into your solution.  Threat these application pages as you would a traditional ASP.NET web site, however you need to play by a few Windows SharePoint Services rules.  Don't use web parts for this as it is pointless and far too much work (and pain).  Create links from the navigation system of SharePoint, other pages and web parts to your application pages.

Web Parts should be created to enhance the users SharePoint experience.  Create web parts that summarise information from your line of business applications.  The idea here is to allow users to create dashboards to quickly get the big picture of what is going on and where they should focus their attention to.  Web Parts should not be created for data capture, rather create an application page.

Site Pages should be created should you not find a suitable standard SharePoint layout for your dashboard page with all the needed zones.  In this situation create your own site page.

I can remember last year when I decided to get my act together and create the grounding site.  I went through a whole process of looking at blogging engines and finally chose Community Server as it had the features I needed to host a community site.  I had a inactive site hosted at WebHost4Life which I took down and replaced the contents with the shell for grounding.   I had previously registered the domain name and thought it appropriate to use the name grounding.co.za as to give all the readers a solid grounding on the technology. 

I started adding content a few weeks before, with a huge amount of posts on course outlines and some news around the time and some posts I had done previously.  On 16 June 2007, I brought the site online and now a year has flown by.

What has happened in the year

I did not expect the site to do as well as it has, and all credit goes to you, our readers, students and friends.  Soon after I launched, I approached Trevor and Neil to join me blogging and I sold them the idea, with some nagging they started blogging too, since then we now have 9 talented people blogging with different areas of specialities.

• Neil
• Trevor
• Pieter
• Gail
• Nico
• Barend
• Romiko
• Cara
• Brett

The content of the site has grown tremendously with 981 posts made.  The list below is an extraction of the Tag Cloud on the blog site indicating the topics posted on.

.NET Architecture ASP.NET BizTalk  C# CES Courses CPS  Delphi  Design Patterns Dynamics CRM Exchange Grade 12  OCS Office 2007 OOP Opinionated Posts SharePoint SharePoint Designer SQL Server SSIS Training Virtual PC Vista Visual Studio 

Statistics

The following statistics are from AWStats

Our membership has grown over the period and has shown, interestingly this does correspond to training courses presented and over the past few months there has been a dip as we all have not trained that much.

The total number of visitors is growing exponentially as the site is becoming more established on the Internet and ranked higher in many of the search engines such as Google and Live.

The number of "pages" has also shown a steep increase as the user visits has increased.  Not bad for a 1 year old web site from our little corner of Africa!

Personal lessons learnt

For me personally, blogging has become quite addictive an very enjoyable.  I have personally grown in my knowledge due to my blogging, forcing me to dig deeper into a subject matter than I would have done in the past.  The blog site has also helped me tremendously with my career and has opened a few doors me.  The biggest rush is to chat to someone or read a comment on the site where someone has managed to get value out of something I have posted.  The satisfaction of being able to help someone with a problem, point them in the right direction or help with improving their skill is most rewarding.

Silent Sponsors

As the site grew we approached Teligent, the company that creates and markets Community Server to get a better price.  They generously gave our community a free licence to the corporate edition of community server, again a big thank you for a great product.

Also, a big thank all the community blogger's for their contributions to the site with a big special thanks to my friends Neil and Trevor for all their help getting the site up and running to where it is today.  This site, its content is truly a community effort and collectivity our efforts have shown good results.

Related Posts

• This PowerPoint presentation was our goals last year November,  http://grounding.co.za/files/folders/documents/entry365.aspx
• About the grounding community
• Telligent - Community Server - Awesome!

Last words

The site is nothing without you and I would like to thank you for reading and supporting grounding.  Please keep visiting, referring your friends and co-workers; making comments and guiding us in what we should write on. 

Thank you!

In order for you to use your own custom assembly with your web parts and other little bits, you will need to add your safe control to the web.config file.  However, you need to think "WEB FARM" with many servers hosting the web application so I will show you a couple ways to do this.

The entry in the web.config

You need to place a SaveControl element entry into the web.config file of the web application.  The entry looks like the following:

   1: <configuration>

   2:   <SharePoint>

   3:     <SafeControls>

   4:       <SafeControl Assembly="[Assembly Name]" Namespace="[Namespace]" TypeName="*" Safe="True" />

   5:     </SafeControls>

   6:   </SharePoint>

   7: </configuration>

Sample

   1: <SafeControl Assembly="Brett.DemoParts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f03e5f7a44d50a3a" 

   2:              Namespace="Brett.SharePoint.WebParts" 

   3:              TypeName="*" 

   4:              Safe="True" 

   5:              AllowRemoteDesigner="True" />

Methods of updating the web.config file

There are three ways you can update the web.config file,

• Manually adding the SafeControl to the web.config
• Adding the SafeControl to the web.config with code
• Deploy the assembly using a solution package

Manually editing the web.config (bad)

This approach may sound the easiest and quickest way as you simply open up your favourite xml editor, find the <SafeControls> element and add your own control into it.

WARNING!
If you do it this way, you are looking for trouble in a farm as you will need to remember to change the web.config modification for all your servers in the farm as well as all the web applications on the farm that use the custom control.  So should you have a really awsome web part that is used within 5 web applications hosted on your farm of 3 servers, you will need to make the modification to 15 web.config's .. have fun.

Also should you add a new server to your farm, please remember to add the entry the web.config.

Bottom line, this is the worst possible way you can do it  and stay away from doing it this way

Adding the SafeControl to the web.config with code (good)

SharePoint provides a class called SPWebConfigModification which has a set of modification commands in a collection.  These modification commands are applied to the default web.config of the Web Application.  These configuration modification commands will also be added and applied to all servers in a farm.   Finally, should a new server be added to the farm, these modifications will also be applied.

The following code could be added to the FeatureActivated override method in your feature that deploys the web part.

   1: public override void FeatureActivated(SPFeatureReceiverProperties properties) 

   2: {

   3:     // A reference to the features Site Collection

   4:     SPSite site = null;

   5:  

   6:     // Get a reference to the Site Collection of the feature

   7:     if (properties.Feature is SPWeb)

   8:     { site = ((SPWeb)properties.Feature.Parent).Site; }

   9:     else if (properties.Feature.Parent is SPSite)

  10:     { site = properties.Feature.Parent as SPSite; }

  11:  

  12:     if (site != null)

  13:     {

  14:         SPWebApplication webApp = site.WebApplication;

  15:  

  16:         // Create a modification

  17:         SPWebConfigModification mod = new SPWebConfigModification(

  18:             "SafeControl[@Assembly=\"MyAssembly\"][@Namespace=\"My.Namespace\"]"

  19:                 + "[@TypeName=\"*\"][@Safe=\"True\"][@AllowRemoteDesigner=\"True\"]"

  20:             , "/configuration/SharePoint/SafeControls"

  21:             );

  22:  

  23:         // Add the modification to the collection of modifications

  24:         webApp.WebConfigModifications.Add(mod);

  25:  

  26:         // Apply the modification

  27:         webApp.Farm.Services.GetValue<SPWebService>().ApplyWebConfigModifications();

  28:     }

  29: }

Deploy the assembly using a solution package (best)

The preferred way to provision your features, web parts and assemblies is by creating a Solution Package (.wsp file).  You will add add your assembly, the manifest.xml file and all your other components and resources into the cabinet.

You will need to add the following entry into the manifest.xml

   1: <Solution SolutionId="{1E0FDA58-6611-423a-92EC-8E7355810CEE}"

   2:           xmlns="http://schemas.microsoft.com/sharepoint/">

   3:   <FeatureManifests  />

   4:   <ApplicationResourceFiles />

   5:   <CodeAccessSecurity />

   6:   <DwpFiles />

   7:   <Resources />

   8:   <RootFiles />

   9:   <SiteDefinitionManifests />

  10:   <TemplateFiles />

  11:   

  12:    <Assemblies>

  13:       <Assembly DeploymentTarget="WebApplication" Location="Brett.DemoParts.dll">

  14:          <SafeControls>

  15:             <SafeControl Assembly="Brett.DemoParts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f03e5f7a44d50a3a"

  16:                          Namespace="LitwareWebParts" 

  17:                          TypeName="*" 

  18:                          Safe="True"                         

  19:                          />

  20:          </SafeControls>

  21:       </Assembly>

  22:    </Assemblies>

  23: </Solution>

  24:  

Key highlights

Using this method, your assembly will be correctly deployed the servers in the farm as well as added to the safe controls of the web application.  Again any new server added to the farm will automatically get all the solution packages deployed.

See

• Preparing for exam 70-541- TS- Microsoft Windows SharePoint Services 3.0 – Application Development
• A series of posts on the art of provisioning in SharePoint
• Creating a WSS 3.0 Web Part using Visual Studio 2005
• Determine the Public Key Token for assembly

References

• SafeControl Adder utility for SharePoint
• Creating SharePoint’s SafeControl Entries in PowerShell
• Registering a Web Part Assembly as a Safe Control

This post is not in line with the technologies and products I normally blog on, however this has been a pet little irritation I have had for some time since I installed Vista. So, my apologies to the mirrors and and RSS feed readers that are not interested in this type of topic and feel it is "off topic".

On my Vista installation I have installed a several services such as SQL and BizTalk and few other products. Now as a good puppy, I installed these products I have always created specific service accounts for each service and applied security, my reason for this is I want to make sure that I take security into account in my development cycle.  The irritation is that after you boot, the welcome screen comes up showing all the accounts including the service accounts.  Now, I never wanted these to user accounts and images to appear here as I never manually logon with the account.

For several months, now I have struggled to find out how to remove them from the welcome page and only leaving the account I logon with on the screen.  With some digging and bouncing off many sites I finally found out how it is done.

1. Open up your registry editor, regedit.exe
2. Navigate to the [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon]
3. Create a key SpecialAccounts under Winlogon
4. Create a key UserList under SpecialAccounts
5. Add a DWORD Value and set the Value to the User Name.
6. Set the value to 0 to hide the username and icon from the welcome screen, or 1 to show the username and icon.

End result was a happy Brett :>>

Reference

1. Configure the login and Welcome Screen in Vista 

In Internet Information Server 6.0 there is a new user group IIS_WPG which basically gives a minimum set of permissions required to start and run worker processes on a web server.  By default, the group contains the following user accounts

• Network Service
• Local Service
• LocalSystem
• IWAM_ComputerName

Before you assign your own service account as a worker process identity for a Web site, make the user a account a member of the IIS_WPG group.  This will make your life easier as you will not have to manually assign permissions and privileges. 

Default permissions to the account

On NTFS

In the Registry

Windows policy rights

Tips

1. Remove the IIS_WPG account from the ACL list in the folder with the site content and rather add only the application pool identity to the ACL.
2. Remember any changes you make should be done on all servers in your farm and some careful thought given to how you will do this.

References

• SharePoint Services and App Pool Account Permissions from Michael O'Donovan
• Configuring Application Pool Identity in IIS 6.0 (IIS 6.0) from Microsoft Technet
• Default permissions and user rights for IIS 6.0 from Microsoft Help and Support
• You receive a "Service Unavailable" error message when you browse a Windows SharePoint Services 2.0 Web site from Microsoft Help and Support

Related certifications

The information in this post is important for the following certification exams

• Exam 70-541: TS: Microsoft Windows SharePoint Services 3.0 – Application Development

Exam news

The Technology Specialist (TS) exam, Exam 70-541: TS: Microsoft Windows SharePoint Services 3.0 – Application Development, was released in March 2007. This exam is available in English, Chinese [Simplified], French, Japanese, and Spanish.

Exam topics covered

The following list includes the topic areas covered on this exam. The percentage indicates the portion of the exam that addresses a particular skill.

Audience profile

This exam is intended for consultants who provide Windows SharePoint Services development or corporate developers who build systems using the Windows SharePoint Services platform. The qualified candidate for this exam typically has:

• Two to three years of experience working with ASP.NET
• One to two years of experience developing ASP.NET Web Parts
• Experience working with Master pages
• One to two years of experience working with XML documents
• Two to three years of experience developing and consuming Web services
• Working knowledge of Windows WorkFlow Foundation

Credit toward certification

When you pass this exam, you earn credit toward the following certifications:

MCTS: Microsoft Windows SharePoint Services 3.0: Application Development

Code languages

When the exam begins, you can choose the programming language in which the code segments will appear. The available code languages for this exam are:

• Microsoft Visual Basic 2005
• Microsoft Visual C# 2005

Skills measured

This certification exam measures your ability to build enterprise portals using Windows SharePoint Services 3.0.

Before you take the exam, you should be proficient in the job skills listed in the following table. The table lists Official Microsoft Learning Products that can help you reach competency in the skills being tested in the exam.

About the exam

The Technology Specialist (TS) exam 70-536: TS: Microsoft .NET Framework 2.0—Application Development Foundation is one of the core exams for all the .NET Framework 2.0 certifications.

This exam tests your knowledge of Microsoft .NET Framework 2.0 and the implied knowledge of the Common Language Runtime and basic functionality it provides.

Once you have mastered this contents of the exam you will truly have a good understanding of the framework and will be able to tackle a large variety of systems.  The content of the exam is intended for developers with experience in developing .NET based applications and is geared to assist them in mastering the framework.

My personal feeling is any senior developer worth his salt should know this content well and be able to mentor junior programmers and coders through this exam if you are a senior programmer.   For the junior coders and programmers, here is your chance to take a leap to the next level .. just do it!

This post and acknowledgements

I have copied information from http://www.microsoft.com/learning/exams/70-536.mspx and have added my three cents worth through the subject matter.  My intent is over time to blog on all the topics making this site a conclusive guide to the .NET Framework and developer skill.

Ambitious .. I know .. Want to help  Send me a PM and lets do it together.  If not I hope you enjoy the journey learning as I have will enjoy doing this for you.

Exam objectives

The following list includes the topic areas covered on this exam. The percentage indicates the portion of the exam that addresses a particular skill.

This objective is to test your knowledge of data types and how they work within the framework.  That is classes, structures, arrays, collections and generics.  There is a big drive in this section on the various types of collections, know them and all the associated standard interfaces.

Many core features such as garbage collection, using delegates and events are also covered.

Now that the basics are over lets get into windows and how processes are loaded, working with threads and creating services. Forget about a simple Windows Forms application, we are talking real applications here.

This section takes configuration to the next level and instead of simply using it, lets program around the configuration model. Part of this section includes understanding custom windows installers and how to develop one. The focus then changes to running your application, managing the processes running, adding diagnostics, implementing tracing and debugging and auditing events .. i.e. application management

Up to know you should have already played with serialisation, streams and general IO. This objective expects you now to master it and know the different types of streams, and the ins and outs of IO management.

Now this is were we say goodbye to the want-to-be's and for the rest let really implement security how the .NET Framework expects us to do it. Forget about rolling your own security, learn this and I am sure you will gain a new respect for the MS team and the .NET framework. Security in the framework is powerful when you know what it can do, where to find it and how to use it.

If you have not worked with reflection up to now, you do not know what you are missing ... here is your chance.

This is the "Catch All Else" objective with some very useful and good to know topics.

Audience profile

Candidates for this exam work on a team in a medium or large development environment that uses Microsoft Visual Studio 2005.

Candidates learning the materials should have at least two to three years of experience developing Web-based, Microsoft Windows-based, or distributed applications by using the .NET Framework 1.0, the .NET Framework 1.1, and the .NET Framework 2.0. Candidates should have a working knowledge of Visual Studio 2005.

Credit toward certification

When you pass Exam 70-536: TS: Microsoft .NET Framework 2.0—Application Development Foundation, you earn credit toward the following certifications:

• Microsoft Certified Technology Specialist: .NET Framework 2.0 Web Applications
• Microsoft Certified Technology Specialist: .NET Framework 2.0 Windows Applications
• Microsoft Certified Technology Specialist: .NET Framework 2.0 Distributed Applications

Code languages

When the exam begins, you can choose the programming language in which the code segments will appear. The available code languages for this exam are:

• Microsoft Visual Basic 2005
• Microsoft Visual C# 2005
• Microsoft Visual C++ 2005

Preparation tools and resources

To help you prepare for this exam, Microsoft Learning recommends that you have hands-on experience with the product and that you use the following training resources. These training resources do not necessarily cover all of the topics listed in the "Skills measured" section.

Skills measured

This certification exam measures your knowledge of the fundamentals of the .NET Framework 2.0. Before taking the exam, you should be proficient in the job skills that are listed in the following table. The table lists Official Microsoft Learning Products that may help you reach competency in the skills being tested in the exam.

Where to next

Well keep coming back to this post as I will keep editing links in it as time goes on to content to the topics.

Microsoft Learning has introduced the new Visual Studio 2008 certifications, although these exams are still in beta or about to go into beta this is the roadmap ahead of you.  Some of the exams are still in beta for the next few weeks if you are game to do them.

In a nutshell:

• There are 6 MCTS exams on different framework aspects of the .NET framework
• MCTS: .NET Framework 3.5, Windows Presentation Foundation Applications
• MCTS: .NET Framework 3.5, Windows Communication Foundation Applications
• MCTS: .NET Framework 3.5, Windows Workflow Foundation Applications
• MCTS: .NET Framework 3.5, Windows Forms Applications
• MCTS: .NET Framework 3.5, ADO.NET Applications
• MCTS: .NET Framework 3.5, ASP.NET Applications
• You still need to write the core exam 70-536: TS: Microsoft .NET Framework 2.0 – Application Development Foundation
• MCPD still have the same three categories (again you need to do the MCTS exams in each area first)
• MCPD: Windows Developer 3.5
• MCPD: ASP.NET Developer 3.5
• MCPD: Enterprise Application Developer 3.5

I will keep you posted as more exam details come out.

References

1. http://www.microsoft.com/learning/mcp/vstudio/2008/default.mspx
2. http://blogs.msdn.com/trika/archive/2008/04/18/net-framework-3-5-certifications.aspx

The Equals method is used to determine equality of two objects, however the way it does this differs from reference an value type objects.  For value type objects (structures)  the actual values of the structure is compared, i.e. its state is compared. For reference type objects, equality is determined whether the two objects are pointing to the same object in memory, thus the actual state is not compared. 

For the purposes of demonstration, the following co-ordinate class has been created with an X and Y co-ordinate

   1: /// <summary>

   2: /// The point class represents a X and Y coordinate

   3: /// </summary>

   4: public class Point

   5: {

   6:     #region // Fields

   7:  

   8:     private int _x;

   9:     private int _y;

  10:  

  11:     #endregion

  12:  

  13:     #region // Properties

  14:  

  15:     /// <summary>

  16:     /// The x coordinate.

  17:     /// </summary>

  18:     public int X { get { return _x; } set { _x = value; } }

  19:  

  20:     /// <summary>

  21:     /// The y coordinate.

  22:     /// </summary>

  23:     public int Y { get { return _y; } set { _y = value; } }

  24:  

  25:     #endregion

  26:  

  27:     #region // Constructor

  28:  

  29:     #region // -  ctor(int, int)

  30:  

  31:     /// <summary>

  32:     /// Initialises the point to the values of x and y.

  33:     /// </summary>

  34:     /// <param name="x">The initial value of the x coordinate.</param>

  35:     /// <param name="y">The initial value of the y coordinate.</param>

  36:     public Point(int x, int y)

  37:     {

  38:         _x = x;

  39:         _y = y;

  40:     }

  41:  

  42:     #endregion

  43:  

  44:     #endregion

  45:  

  46:     #region // System.Object overrides

  47:  

  48:     #region // -  ToString

  49:  

  50:     /// <summary>

  51:     /// This method converts the point to a string.

  52:     /// </summary>

  53:     /// <returns>Returns a string representation of the x and y cordinates</returns>

  54:     public override string ToString()

  55:     {

  56:         return string.Format("(x={0},y={1})", _x, _y);

  57:     }

  58:     

  59:     #endregion

  60:  

  61:     #endregion

  62: }

The problem

Create the following test program

   1: /// <summary>

   2: /// The demonstration console application

   3: /// </summary>

   4: class Program

   5: {

   6:     static void Main(string[] args)

   7:     {

   8:         // Create a Point reference varialble to point new object on the heap for point 3,5

   9:         Point A = new Point(3, 5);

  10:         // Create a Point reference varialble to point new object on the heap for point 8,6 

  11:         Point B = new Point(8, 6);

  12:         // Create a Point reference variable and point it to the same heap object as A

  13:         Point C = A;

  14:         // Create a Point reference varialble to point new object on the heap for point 3,5

  15:         Point D = new Point(3, 5);

  16:  

  17:         Console.WriteLine("A {1} == B {2} : {0}", (A==B),A,B);

  18:         Console.WriteLine("A {1} == C {2} : {0}", (A == C),A,C);

  19:         Console.WriteLine("A {1} == D {2} : {0}", (A == D),A,D);

  20:     }

  21: }

Run the program an you get the following result

Note that A and C are equal as they point to the same object on the heap.  However, A and D are not equal even though the values are the same, the reason for this is they are different objects on the heap!  Remember that when comparing reference types, the reference to the heap is compared and NOT the values.

This is a problem if you actually want to compare the values, well in .NET you can, read the solution below.

The solution

If you want to compare different objects on the heap and equality is important for you, you are going to have to override the Equals method. Overriding this is not good enough as most programmers do not type code like if( a.Equals(b) ), and would rather type if( a == b ).  Thus you will land up creating an the operator==, however the bad news is you will also need to create the operator !=.

Thus when comparing objects you will have to create three methods, these are listed below:

Override the Equals Method

The first step is to override the Equals method of system object.  This method should compare the current object with the passed object to determine whether the fields are the same.  In my example I will check this.X == obj.X a and this.Y ==  obj.Y, when both are the same I will return true otherwise I will also return false. 

You will also not that the Equals operator passes an object, so the first thing to do is determine whether we are comparing a Point with a Point.   The nice little trick here is obj is Point will return false if obj == null, thus we are ensuring the object is not null and is a point.

   1: #region // -  Equals

   2:  

   3: /// <summary>

   4: /// This method compares the equality of two objects

   5: /// </summary>

   6: /// <param name="obj"></param>

   7: /// <returns></returns>

   8: public override bool Equals(object obj)

   9: {

  10:     if (obj is Point)

  11:     {

  12:         Point rhs = (Point)obj;

  13:         return (this._x == rhs._x && this._y == rhs._y);

  14:     }

  15:  

  16:     return false;

  17: }

  18:  

  19: #endregion

Create the operator==

This is nice however the == operator still will not return what we expected, thus we have to create the == operator.  Create the operator by adding the following code to the project

   1: #region // -  operator==

   2:  

   3: /// <summary>

   4: /// The equals operator compares two points and uses the Equals method

   5: /// </summary>

   6: /// <param name="lhs">The object on the left-hand-side of the operator.</param>

   7: /// <param name="rhs">The object on the right-hand-side of the operator.</param>

   8: /// <returns>Returns true if the x,y coordinates are the same.</returns>

   9: public static bool operator ==(Point lhs, Point rhs)

  10: {

  11:     if (null == (object)lhs)

  12:         return false;

  13:     return lhs.Equals(rhs);

  14: }

  15:  

  16: #endregion

There is a bit of ugly code here that you need to be aware of, that is on line 11.  This is to make sure that the lhs argument is not null and to prevent lhs.Equals(rhs) throwing an NullReferenceException if it is null.  The ugly comes in the fact that if you had typed if (null == rhs), you would get recursive method execution method and a StackOverflowException, hence the cast (object)lhs, causing the objects operator== to execute.

Create the operator!=

When you create the operator==, you have to also code the operator!=, so you will have to add this code

   1: #region // -  operator!=

   2:  

   3: /// <summary>

   4: /// The not equals operator compares that inequality of two operators

   5: /// </summary>

   6: /// <param name="lhs">The object on the left-hand-side of the operator.</param>

   7: /// <param name="rhs">The object on the right-hand-side of the operator.</param>

   8: /// <returns>Returns true if the x,y coordinates are not the same.</returns>

   9: public static bool operator !=(Point lhs, Point rhs)

  10: {

  11:     if (null == (object)lhs) 

  12:         return false;

  13:     return !lhs.Equals(rhs);

  14:     

  15: }

  16:  

  17: #endregion

As with the operator==, we need to make sure that lhs is an object and prevent a recursive call.

The test

Compile and run your test application, this time you will notice that A == D is also true.

Summary

In summary if you are wanting to compare two different objects on the heap, i.e. reference type objects that contain the same data, you will have to override the Equals method of System.Object, then also create operator== and operator!=.   You will still be able to check whether the objects are physically the same object in memory by using object.ReferenceEquals.

As a developer learning how to provision your custom solutions to SharePoint, you will come across the TEMPLATE directory within the 12 hive.  It is exceptionally important that you master what is in the directory and where to put your own resources.  This blog post will attempt to help you master what is in the TEMPLATE directory structure.

Spend a bit of time exploring this on your own machine and having a look at the contents as this will certainly be time well spent.

The SQL folder contains a set of T-SQL files used to create the necessary database schemas for the various SharePoint databases.

This directory contains the list of themes which allows you to change the basic colour scheme and branding of the site.  However, these themes are strongly coupled to the default.master and other master pages as well as the core.css file.  Each directory will also contain graphic resources 

See

• A series of posts on the art of provisioning in SharePoint
• Overview of features, templates, site definitions, solutions in SharePoint
• SharePoint - The 12 Hive
• SharePoint - Get to know the directory structure in the 12 Hive

See Also

• Creating a simple SharePoint Feature.xml file
• Describing the ElementManifests section in a SharePoint feature.xml file
• The content of a SharePoint ElementManifest file

Windows uses a Locale Identifier (LCID) to determine the language and culture to use when displaying information to a user.  The users LCID is picked up from his/her regional settings within windows or from the language settings for the browser.  The application then displays resources, number and date formatting according to the the local.  This post lists a table of LCID's, the short name and full name of each locale.

All products, such as SharePoint, SQL, .NET all use this to assist with formatting.  As this post is focusing on LCIDS in SharePoint, there are several folders within the 12 hive that allow you to globalise and localise your application.

Table of locals

See

Learning your language for .NET programming is a challenge in its own right, learning to use and exploit the .NET framework to its fullest is even harder due the mere fact of the size of the framework.  However, there is one class in the framework you should master and that is the System.Object class.  

System.Object defines the basic behaviour of all managed data types and thus all managed data types within the framework, be it a value or reference types.  Every managed type inherits from System.Object, either directly or indirectly.  A reference type (class) may inherit from another explicit class, however ultimately they all will inherit from System.Object.

Reference Types and System.Object

Take the following set of classes:

class Animal
{ }

class Mammal : Animal
{ }

class Dog : Mammal
{ }

Dog inherits from Mammal, thus dog gains all characteristics of a Mammal and its own members.  Mammal however inherits from animal, thus both Dog and Mammal get all the characteristics of the Animal.  In this example, Animal does not inherit from anything explicitly.  Don't be fooled by this as in reality Animal does inherit from system object.  You may have written the class

class Animal: System.Object
{ }

In C#, the keyword object is an alias for System.Object, thus the code below is the same as above.

class Animal : object
{ }

Value Types and System.Object

Value types (struct) on the other hand do not support inheritance directly, let us take the following value type as an example:

struct Point
{ }

This struct automatically inherits from System.ValueType (a class) which in turn inherits from System.Object.  Thus one could theoretically say that a structure is a class, however it has a different memory model to a class. 

System.Object Members

Now we all know the rules, and it is not necessary for you to explicitly inherit from object.  It is automatically implied and all .NET programmers should know this.  This section now describes the member methods of the System.Object class and answers the begging question of what you can do with it.

public Object();

public virtual bool Equals(object obj)
public static bool Equals(object objA, object objB)

public override void Finalize()

This method is called on every instance of objects in memory when the garbage collector is in the process of freeing the memory.  This method will then be used to free up unmanaged resources used by the object.  In C#, you will not be able to override this directly as other methods as Finalize is implemented as a destructor ~Class().  When you compile your project and view the MSIL you will notice that ~Class() will be converted into a Finalize method.

public virtual int GetHashCode()

public Type GetType()

This method returns at System.Type reference to the object. This nifty little method allows you to then inspect the data type and programmatically work with the data type.  It thus returns the metadata of your object. I.e.  You will write code to interrogate the data type and adjust accordingly, welcome to the start of Reflection.

protected object MemberwiseClone()

public static bool ReferenceEquals(object objA, object objB)

public virtual string ToString()

The ToString() method is used to return a string representation of the current instance.  The default behaviour of this method is to return the fully qualified name of the Type.  Override this method to implement a better representation of data of your method.

The 12 hive is where everything in SharePoint happens and is where all the binaries, configuration, web pages, web controls, help files and other resources reside.  As a developer writing your own features for SharePoint, it is vital that you learn where things go and where you should be targeting your resources.  Without having an understanding of this, you have lost the battle before you have even started.

This article forms part on the "Series of posts on the art of provisioning in SharePoint".

A while back I posted an article SharePoint - The 12 Hive which pointed you to the location of the 12 hive, however the article was for general users and not aimed at administrators or developers.  This article however is aimed at an administrator and developer with a basic overview of what you can find where.   I will follow up on this post with a post on the TEMPLATE folder as this is the heart of the site and developers should really get familiar with the Template folder.

Below is a list of core folders in the 12 hive.

Tips and suggestions

• Open up the 12 Hive on your computer and spend the next five minutes looking through the directory structure.
• If you plan to be administrate or be a SharePoint development guru. Look at the content.
• On your server add the \bin directory to PATH environment variable, as it will search this folder when you are at a command prompt.
• As a developer you will be updating this directory structure with your own content, and it is important that you do it through the correct mechanisms.
• DO NOT CHANGE ANY FILE DIRECTLY in the 12 Hive, unless like pain, wasting time resolving bugs and having to reinstall SharePoint.
• Learn how to provision properly.

Microsoft BizTalk Server is a server side product that is aimed to provide integration between system as well as business process automation.  The product is used in many organisations to integrate system ranging from internal systems to partner, vendor and customer system. It also allows you to implement a workflow (called an orchestration) to manage, automate the flow of data throughout the organisation.

The business challenges BizTalk addresses

Companies and their systems have evolved over the past decade and the solutions that these systems need to deliver are complex.  These systems have also introduced a whole new set of challenges that professional need to look at, these are

History of BizTalk

BizTalk is definitely not a new product and it has gone through multiple releases, and as with all Microsoft products it has matured and stabilised over the past few years. Below is a short overview to the history of BizTalk.

Tools and Services

There are many tools, engines and services offered by BizTalk and I will breifly discuss each one as to give you a basic understanding to what the product entails.

Messaging engine

BizTalk processes data in the form of messages and communication between systems is based on the exchange of messages.  Thus the messages engine is essential to BizTalk Services.  The BizTalk messaging engine performs the following

• Uses adapters to physically send and receive data in the form of messages to and from different systems.
• Pass the messages through pipelines to encrypt\decrypt, compress\decompress the message
• Format the external data into XML for processing
• Map the data from one data structure to an internally understood data structure
• Extract key data from the messages that will be used for routing the messages.
• Track documents
• Deliver the message to the MessageBox.
• Route data to the necessary orchestrations for processing and finally to send adapters to be delivered to destination systems.

Adapters

BizTalk's prime objective is to route data between different systems which is controlled by a business process, this data is represented in the form of messages.  However these systems that need to be integrated run on different technologies, written by different vendors with different development tools and are transported with various different protocols. 

BizTalk has an extensive library of adapters that allow communication between systems over well defined and common industry protocols, these include SMTP, POP3, FTP, Web Services, MSMQ, MQ-Series.  There are also product specific adapters such as Siebel, SAP, SQL Server which have been written to interact with specific software.  There are also adapter such as the EDI and SWIFT adapters allowing connectivity to the SWIFT and EDI networks. 

This list of adapters is by no means extensive and is only for you to get an idea of what they are, there are many, many different adapters; some come with BizTalk others you need to pay additional licence fees to use and then there is a whole bunch of commercially available adapters.  Developers can then also write their own adapters.

Mapping

When dealing with data from different systems, there is always the need to translate data from one the source data structure to the destination data structure.  The mapping engine does exactly this, however it includes an extensive functoid library that allows you to do data manipulation, aggregation and transformation.  This too is customisable and developers are able to fully code against this mapping engine.

Internally BizTalk uses data in an XML format and translation is done through mapping; basically this is BizTalk's way of doing XSLT.  External systems may not unnecessarily use XML and this is where the Pipelines and adapters come in.

Orchestration services

The BizTalk orchestration services are used to define, manage and execute business process.  These processes included looking at the data and making decisions on the data.  Typically the orchestration will engage in a process of getting data related from others systems, correlating the data, making decisions on the data and based on the outcomes of these decisions send messages to destination systems.

A single BizTalk orchestration may engage with obtaining or updating data from many different systems.  Transactional integrity of this data can then be maintained by BizTalk across many different system. These orchestrations are also not time bound and may run for hours, weeks, months and even years. 

Pipelines

Pipelines are typically used to encrypt\decrypt messages, compress\decompress message and mime encode the messages.  Additional conversion may be done in the pipeline to get the data into a format the mappers understand for receive pipelines or to a format the adapters understand in a send pipeline.

MessageBox Database

The MessageBox is a SQL server database that BizTalk uses to store, route, pass to orchestrations and finally to send ports.  The MessageBox is thus used to track the entire life of the message over time.  The MessageBox also stores versions of the message as data may change through the orchestration.  This then allows information workers and administrators to troubleshoot data.

Application development tools

BizTalk development is development is done within the Visual Studio environment and when BizTalk is installed onto the developer's box a few project templates are added to Visual Studio.

The first thing to do is to create a BizTalk project and then add the following items to your project

• Schema.  The BizTalk Editor allows you define XSL schemas which are used to describe your data.
• Map.  The BizTalk Mapper allows you to define transformations from one schema to another schema.  The conversion allows you to add functoids to the map to perform data manipulation, conversion and aggregation.
• Pipeline.  The Pipeline designer allows you to define the process for incoming and outgoing messages.
• Orchestrations.  The Orchestration designer allows you to model your message flow according to a business process.
• SDK.  An advanced developer can use the BizTalk SDK to define custom pipelines, orchestrations and adapters for BizTalk.

Business Rule Engine

The Business Rule Engine allows developers to define basic rules that can be implemented within orchestrations.  These rules can be used to define calculations, decision structures thus affecting the branching of an orchestration based on the rule conditions.  Rules are exposed to users through the Business Rule Composer, allowing non-developers to change and adjust the rules using non-technical terminology.  These rules then are applied and orchestrations are immediately adjusted.

Business rules are ideal for giving users a way to control the execution and outcomes of orchestrations without having to engage a developer to change the orchestration.

Message activity and tracking

Health and Activity Tracking (HAT) allows administrators to monitor, track and resolve problems with business processes.  HAT provides a valuable and indispensable tool for administrators to manage and troubleshoot the BizTalk Serves.

HAT includes the following benefits

• Tracking to see start, end times of messages as well as the current status
• Health allows you to view the current state of a process
• Monitoring live data allows you to see what is happening on the server, thus identifying issues
• Analysing live and archived data and tracking the complete message flow, changes to messages and the route the message whet through and orchestration.
• Orchestration debugging
• Business rule activity tracking

Business Activity Monitoring (BAM)

BAM provides information workers the ability to view running process and draw reports on process statistics and key information.  This information is near real and can be configured with alerts and notifications, the information worker then can react to different situations based on the activity.  In 2006 R2, developers can write their own components that can publish information to BAM.  The BAM information can be extracted and manipulated within excel or through the BAM portal running on SharePoint.

BAM gives you the ability to

• Access views of data to understand what is happening
• Search for activities and query key data
• Summarise and aggregate data to draw statistics
• Drill down from summarised data to detailed data.
• Configure alerts and notifications to notify users when certain thresholds have been exceeded.
• Escalate issues to administrators from the BAM portal

Business Activity Services (BAS)

BizTalk provides a mechanism to manage relationships between trading partners.  Through trading partner management (TPM) and using the Business Activity Service, our are able to define the partners, define the protocols and formats of messages used in the relationship.  Developers use this information in orchestrations to define dynamic ports where information can be routed to and from the partners in different formats.  Through an easy interface, information workers can easily add, edit and manage partners.  BizTalk will apply these changes, thus preventing development and changes.

RFID

BizTalk RFID is an RFID device-level management set of components introduced BizTalk Server 2006 R2. Using RFID, you can eliminate many existing challenges faced with RFID devices as it allows a uniform way to discover, communicate and manage these devices. BizTalk RFID includes a SDK that developers need to build vertical applications that are reliant on RFID tag information -- everything from track-and-trace to asset tracking and inventory control.  Although independent of BizTalk Server, the RFID tag information can then be sent to BizTalk and then passed through orchestrations.

This article forms part on the "Series of posts on the art of provisioning in SharePoint".  In this post I will discuss the different ways you as a developer or administrator can package and deploy your content to SharePoint.

When learning SharePoint, it is important that you understand the difference between features, templates, definitions, solutions and configurations.  If you are new to the product and doing customisation of sites, this may be tremendously confusing and I will try to demystify this in the post.