SharePoint Brain Freeze

Working With SharePoint Document Templates

Joshua Carlisle — Wed, 03 Mar 2010 15:57:19 GMT

I was recently having a conversation with one of my co-workers over provisioning document templates within a feature for one of our current projects. There were several examples available from random blogs within easy reach to anyone with a browser, internet access, and you favorite search engine. Although the examples I found to be technically correct they all seemed to overly complicate the process of setting up a content type and provisioning an associated document template within a feature.

Before I jump into the approach I typically use let do a quick review of SharePoint document templates. SharePoint provides the ability to associate document content types with document templates. These can be word documents, excel documents, whatever your needs are. These content types can then be associated with a document library. This provides the ability for a new documents to be created, based on the provided template, and associated with the desired meta data found in the content type. Once configured your document template and associated content type will appear in the new item options dropdown within your document library. It’s worth mentioning that document libraries themselves can have default templates but the real power comes with the combination of multiple content types and default templates for a single document library.

Building The Feature

The core of any feature is the associated elements file(s) – this is were all the provisioning instructions are provided. For our purpose we’re going to be working with four specific elements:

<Field> – Define our Site Columns that will be part of our content type.
<ContentType> – Define our Content Type, the associated document template, and associated site columns (fields). Our content type is based on the base document content type indicated by a content type ID beginning with 0x0101.
<ListInstance> – Optionally create a new document library that our content types will be associated with.
<ContentTypeBinding> – Associates our content type with a document library.
<Module> – Provisions our document template referenced within the <ContentType> element.

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

  <!-- Provision Site Column -->
  <Field Type="Choice"
         DisplayName="DocumentType"
         StaticName="DocumentType"
         Name="DocumentType"
         Required="FALSE"
         Format="Dropdown"
         FillInChoice="FALSE"
         Group="MyCompany"
         ID="{c2cad809-5336-4d62-b8aa-ed8e55b0b200}"
         SourceID="http://schemas.microsoft.com/sharepoint/v3">
    <CHOICES>
      <CHOICE>Finance</CHOICE>
      <CHOICE>Sales</CHOICE>
    </CHOICES>
  </Field>

  <!-- Provision Content Type and associate the document template -->
  <ContentType ID="0x0101003C32228299AD46c5B47688879AEBD5AB" Name="Corporate Document" Group="My Document">
    <FieldRefs>
      <FieldRef ID="{c2cad809-5336-4d62-b8aa-ed8e55b0b200}" Name="DocumentType" Required="TRUE" />
    </FieldRefs>
    <DocumentTemplate TargetName="/_cts/Corporate Document/documenttemplate.docx" />
  </ContentType>

  <!-- Provision the document template in system content types virtual folder -->
  <Module Name="DocumentTemplates" Url="_cts/Corporate Document" RootWebOnly="TRUE" Path="DocumentTemplates" >
    <File Url="documenttemplate.docx" Type="Ghostable" />
  </Module>
  
  <!-- Optionally create a new document library and associate the new content type(s) -->
  <ListInstance TemplateType="101"
             RootWebOnly="false"
             Id="CorpDocuments"
             Title="CorpDocuments"
             Url="CorpDocuments"
             OnQuickLaunch="true"
             FeatureId="00BFEA71-E717-4E80-AA17-D0C71B360101">

  </ListInstance>

  <ContentTypeBinding ContentTypeId="0x0101003C32228299AD46c5B47688879AEBD5AB" ListUrl="CorpDocuments" />
  
</Elements>

It’s worth noting depending on your needs you may need to add a feature receiver to your feature to enable content type management on the list by default and to set default content types. Unfortunately this can’t be accomplished declaratively in the elements file.

The following is a snippet for establishing a default content type when you are just dealing with a single content type although it could be easily modified for ordering more then one content type in addition to setting the default. It also enables the management of content types on the list.

private void SetDefaultContentType(SPList list, string defaultContentTypeName)
{
       SPContentType defaultContentType = list.ContentTypes[defaultContentTypeName];
       list.ContentTypesEnabled = true;

       SPFolder folder = list.RootFolder;
       SPContentType[] orderedContentTypes = new SPContentType[1];
       orderedContentTypes[0] = defaultContentType;

       folder.UniqueContentTypeOrder = orderedContentTypes;
       folder.Update();

}

Working With Templates Through Code

For most end users new documents will be created through the browser. At times however, such as within workflows, you may want to create new documents based on the available templates dynamically through code. The following technique is the approach I typically make to creating new documents based on content type templates for libraries with multiple content types (and associated templates):

SPList docLibrary = web.Lists["CorpLibrary"];
SPContentType docContentType = docLibrary.ContentTypes["Corporate Document"];

//Get a reference to the template file for the content type and load it into a raw byte array
SPFile docTemplateFile = web.GetFile(docContentType.DocumentTemplateUrl);
byte[] rawTemplateFile = docTemplateFile.OpenBinary();

//Create the new item and file based on the template
SPFile newFile = docLibrary.RootFolder.Files.Add("newdocument.docx", rawTemplateFile);

//Update the content type for the new item and any desired fields
newFile.Item["ContentTypeId"] = docContentType.Id;
newFile.Item["DocumentType"] = "Sales";
newFile.Item.Update();

One alternative approach suggested by a co-worker is to make use of the default content type. Each library can optionally contain a default content type. New items make use of the default content type when a specific content type isn’t selected in a dropdown. By using this technique you can optionally avoid the steps of getting a reference to the template file and updating the content type because the docLibray.Items.Add will create the document for you and set the content type but this makes the assumption that your desired document template is always the default template of the list. Yes you can dynamically modify the default template of the list at run time but this could lead to some undesirable side affects in an actively use document repository with its default content type changing frequently.

As you can see the creation of default templates for content types is pretty straight forward and you can achieve more reuse in your environments by implementing the solution through a feature as opposed to manually through the browser.

Combining JQuery UI Dialogs and SharePoint WebParts

Joshua Carlisle — Mon, 01 Feb 2010 19:54:53 GMT

In case you’ve been shipwrecked on a desert island for the last few years jQuery is a javascript library that simplifies the querying of HTML elements with a web page and greatly simplifies the implementation of Ajax techniques within a web page. The functionality that jQuery represents isn’t anything new but the effort level to implement some of the same facets of functionality has been greatly reduced and simplified by the use of the jQuery library. Additionally many offshoot projects have been created that add functionality on top of the jQuery library. One of my favorites is the jQuery User Interface library that adds new rather slick UI elements onto the library. These range from Accordions, Date Pickers, and Progress Bars to Sliders, Tabs, and Dialogs. Of those elements provided by the jQuery UI Library I have found the Dialog has been very helpful in several of my projects as of late. A modal dialog that isn’t caught by popup blockers can be a great tool to quickly collect information or complex confirmations from the user.

At a high level a dialog typically collects information from the user, performs some action based on the information collected, and optionally updates user interface elements in response to that action. In our context this functionality should be able to be encapsulated within a reusable WebPart with minimal external dependencies (or more desirable – no external dependencies). Unfortunately implementing client script based solutions within custom components, specifically WebParts, can often be confusing until you get the technique down. Keep in mind these are not asp.net server controls that you can instantiate in your WebPart or drop onto an asp.net form. These are purely script based solution. The solution that I demonstrate here is one possible technique that I found to be a good compromise between a pure client script based model and the classic asp.net postback model found commonly in WebParts and asp.net pages.

In the context of a webpart we run into some of the following challenges:

The jQuery and jQuery UI library isn’t intrinsically aware of the asp.net postback model. Executing server side logic can become more problematic and often requires additional interfaces such as web services.
More then one instance of this component may exist on a web page so any script logic would need to understand this implication and be very specific when it comes to querying for specific UI elements. Due to this fact we can’t always make use of some of the powerful selectors in jQuery.
Combing the process of creating server side controls and getting the power that asp.net provides and still letting it support the great UI enhancement that the jQuery libraries can be a challenge.

To address these concerns we’ll make some compromises in our implementation that allows to get close to a best of both worlds.

GetPostBackReference
One of the first compromises we’re going to make to get a best of breed approach is the Save behavior. As I mentioned in a native scripting solution you would likely interact with server side logic via web service. To reduce the deployment overhead of this solution we want to be able to use some standard postback behavior to execute server side logic. In our case we’re going to reuse the postback event reference to execute some code in a button click event. Not only does this save us from creating the web service it also saves some client side complexity when it comes to calling the web service and also updating any appropriate UI elements from the script. Our solutions will let the page (and control) render again.

Of course this key compromise isn’t ideal in all scenarios. If you need a page update without a postback then you’ll have some extra work. This provide our desired dialog experience but the final page refresh may be a deal breaker. Not as clean of an Ajax solution that some may expect after you save.

Script Client ID References
For those developers new to the client scripting model from the asp.net server side model the first important distinction is how controls are referenced. On the server side we can reference a control through its server ID. On the client side the asp.net framework dynamically generates IDs based on where the control lives in the control hierarchy to ensure unique IDs. JavaScript of course works at the client level. This can make it tricky to interact with scripts in the client when they have different IDs. The key to this is the ClientID property on a webcontrol (textbox, panel, dropdowns,etc). The ClientID represents the ID located on the client side and any references in scripts will require this reference. Due to this nature in the lifecycle of asp.net controls we’ll need to combine scripts and apply the appropriate ID to the script before its rendered to the page.

You may be asking yourself “wait doesn’t jQuery make it easy to find a reference to an HTML element?”. That is true but because the nature of a WebPart the framework allows you to place multiple instances on a WebPart page which will mean that you are required to uniquely identify each instance within your JavaScript. In this case a selector based on the other attributes will still very likely give you multiple results, definitely not desirable.

The Solution

Using WSPBuilder we’re going to create a new WebPart project. This will give us our basic WebPart plumbing and supporting feature. WSPBuilder isn’t a requirement just my tool preference for SharePoint Feature development. You’ll also need to make sure you have references in your masterpage to the jQuery and jQuery UI libraries. For our purposes we’ve included the libraries and supporting in our project and deployed to the layouts folder. Some folks prefer to reference google’s hosted versions of the libraries found at http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js and http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js respectively. Lastly we’ve included resource files that will contain our custom JavaScript.

Our solution explorer should look like the following:

Building the Dialog and Hide\Show Button

First off we want to handle building the dialog. In the CreateChildControls we’ll need to build out the dialog that will be presented to the user and the button that will be used to hide and show the dialog. It’s worth noting that we’ll be using the same control to both hide and show the dialog using client side script AND execute server side logic on the postback event. I’ve included some standard jQuery UI CSS with the button attributes as well.

//Create the Dialog
pnlDialog = new Panel();
pnlDialog.ID = "pnlDialog";

Label lblDialogNotice = new Label();
lblDialogNotice.CssClass = "dialogNotice";
lblDialogNotice.Text = "Please fill out the following fields to create your site: </br></br>";
pnlDialog.Controls.Add(lblDialogNotice);

 //Title
pnlDialog.Controls.Add(new LiteralControl("Title:<br>"));
txtTitle = new TextBox();
txtTitle.ID = "txtTitle";
pnlDialog.Controls.Add(txtTitle);

//Title
pnlDialog.Controls.Add(new LiteralControl("<br><br>Description:<br>"));
txtDescription = new TextBox();
txtDescription.ID = "txtDescription";
pnlDialog.Controls.Add(txtDescription);

//Title
pnlDialog.Controls.Add(new LiteralControl("<br><br>Site Template:<br>"));
ddSiteTemplates = new DropDownList();
ddSiteTemplates.ID = "ddSiteTemplates";
ddSiteTemplates.Items.Add(new ListItem("Blank", "STS#1"));
ddSiteTemplates.Items.Add(new ListItem("Team", "STS#0"));

pnlDialog.Controls.Add(ddSiteTemplates);
base.Controls.Add(pnlDialog);

//Button that will initiate the dialog
btnShowDialog = new Button();
btnShowDialog.ID = "btnShowDialog";
btnShowDialog.Text = "Create New Site";
btnShowDialog.CssClass = "ui-button ui-state-default";
btnShowDialog.OnClientClick = "return false;";
btnShowDialog.Click += new EventHandler(btnShowDialog_Click);

base.Controls.Add(btnShowDialog);

The Client Script

The client script that will be used is very close to script library samples provided by the jQuery UI project. The only thing of note located in the script are some tokens, indicated by text enclosed in brackets [ ], that will be replaced at run time with valid client ID values. This is what will allow us to provide context appropriate Client IDs to account for the possibility of multiple instances of WebParts. Finally you’ll notice that I’ve placed the Dialog JavaScript within a resource file. I find this a cleaner solution for including JavaScript inside of a project rather then stitching it together with a stringbuilder or dozens of string concatenations.

JavaScript:

$(document).ready(function() {

    $('#[DialogId]').dialog({
        autoOpen: false,
        height: 500,
        width: 300,
        modal: true,
        buttons: {
            'Close': function() {
                $(this).dialog('close');
            },
            'Save': function() {
                $(this).dialog('close');
                alert("Site Successfully Created");
                [PostBackReference];

            }

        }
    });

    $('#[ShowDialogControlId]').click(function() {
        $('#[DialogId]').dialog('open');
        $('#[DialogId]').parent().appendTo($("form:first"));
    })

});

WebPart Script Registration & btnShowDialog Click PostBack Event:

string DialogScript = SiteCreationDialog.WebPartCode.Resources.DialogResources.dialog;

DialogScript = DialogScript.Replace("[ShowDialogControlId]", btnShowDialog.ClientID);
DialogScript = DialogScript.Replace("[DialogId]", pnlDialog.ClientID);
DialogScript = DialogScript.Replace("[PostBackReference]", Page.ClientScript.GetPostBackEventReference(btnShowDialog, string.Empty));

Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "DialogScript", DialogScript, true);

void btnShowDialog_Click(object sender, EventArgs e)
{
            //Assumes the current users privledges are sufficient
            SPContext.Current.Web.Webs.Add(txtTitle.Text, txtTitle.Text, txtDescription.Text, (uint)1033, ddSiteTemplates.SelectedValue, false, false);

}

Of particular importance is the replacement of the PostBackReference token to use the postback of the BtnShowDialog control. This will allow our JavaScript dialog to call our postback event when the user selects the Dialog’s Save Button. Additionally we’re injecting our appropriate client side ID references to the JavaScript.

Conclusion

As you can see with some very reusable boiler plate you can very quickly create custom dialogs using the jQuery \ jQueryUI libraries in combination with the arguably more familiar post back model with the compromise of a single postback. Not useful in all situations but a good tool for toolbox when it’s appropriate.

A couple additional suggestions on usage:

Avoid controls in your dialog that trigger a postback. You’ll lose your dialog. A common example is that of validation controls.
Place validation within the “Save” portion of the dialog JavaScript. My suggestion is to use native client side javascript validation at this point in time. If you need to you can pass additional client IDs in using the technique above. I think you’ll find some of the jquery validation libraries to more advanced as well.
Notifications to the user that occur after the postback may be tricky without losing your dialog. For simplicity sake to keep with the postback model I’ve sometimes included a label above the hide\show button to display messages about issues that occurred during a postback. It is possible to have the dialog box show on postback by making the JavaScript rendering more intelligent but this starts to compromise the quick aspect of this solution.
SharePoint 2010 provides a new SharePoint specific dialog framework that may be more desirable to use then a third party library.

The complete sample code for this example can be downloaded here.

Technorati tags: SharePoint, jQuery, jQueryUI, WebParts

Presenting at the Richmond SharePoint User Group and Webcast

Joshua Carlisle — Wed, 27 Jan 2010 19:09:15 GMT

Tomorrow I will be traveling up to Richmond Virginia to present to the Richmond SharePoint User Group. I will be presenting one of my developer discussions on the improved SharePoint 2010 developer experience.

Date:           Thursday, January 28
Time:           5:30 PM:    Meet and Greet
                   6:00-7:30: Meeting
Topic:          Reducing the Friction of SharePoint Development with SharePoint 2010
Sponsor:      Fahrenheit Technology

CLICK HERE TO REGISTER

Additionally I’m trying something new with this meeting. We’re going to attempt a simultaneous webcast with LiveMeeting that will include voice, video, screen and slide sharing. I’ve never attempted a webcast outside of a very controlled environment but if you’re interested in catching my presentation but can’t make it please give it a try and let me know how it goes so I know if its worth doing this for future presentations. You’ll be able to download the entire presentation if you’d like to as well. No registration or code is required to attend the webcast and I’ve opened it up for 100 attendees.

Live Meeting Conference URL: https://www.livemeeting.com/cc/usergroups/join?id=KBQ5S4&role=attend

You’ll need to download the client to get the full experience with sound and video. My experience also was that I had to configure the webcam\audio settings on the client before I could see\hear myself in test runs. So if you’ve never installed the LiveMeeting client I would suggest logging on a few minutes early so you have time to configure your preferences. I plan to use a wireless microphone along with a HD webcam when my desktop isn’t being shared so I’m hoping the experience should be good if our network connection can handle it.

I’m looking forward to presenting and I’m looking forward to seeing both folks in Richmond and in LiveMeeting tomorrow!

UPDATE:

I apologize for the folks who attended last nights web cast and experience connection issues. The original plan for the web cast included a LAN connection at the User Group meeting location. Unfortunatly the stars didn't line up and the local resource wasn't available to provide me that connection. I attempted to use my Verizon Wireless card but lets say the performance was less then stellar. On the next go around I'll make sure we have a good connection. I do appreciate the folks who gave it a try, hopefully we'll have better luck next time.

Technorati tags: User Group

Technorati tags: SharePoint 2010

Technorati tags: SharePoint

Upgrading Features with SharePoint 2010

Joshua Carlisle — Mon, 18 Jan 2010 21:52:25 GMT

One topic I’ve been somewhat surprised to not hear more then a trickle about from the community about SharePoint 2010 is the ability to upgrade Features. Features were of course introduced in SharePoint 2007 as a mechanism for provisioning elements within SharePoint. Those elements can be anything from Site Columns, Content Types, and Lists to Webparts and workflows just to name a few. It’s quite a powerful mechanism for provisioning reusable elements within SharePoint but one if its weaknesses has been the inability to formally support an upgrade process. Now that’s not to say that you couldn’t work around the issue but it was never elegant.

Old Technique #1 – Upgrade Feature In Place then Deactivate\Reactivate (Unsupported)
Although unsupported some elements of a feature didn't mind getting deactivated and reactivated to get an “update”. Although this technique is unsupported it could be used in scenarios where the provisioning engine could handle conflict resolution such as provisioning a file using the IgnoreIfAlreadyExists attribute on the File element of the Module element. However most elements such as Lists and Content Types will often throw exceptions during activation if there was a conflict so you had to be very careful in its usage. Not ideal at all.

The following is a table of a few of the common elements and how they deal with getting unprovisioned (deactivated). Keep in mind that there are many more elements within a feature that may be declared such as list definitions, controls, custom actions, etc., but these are just declarations not instances.

Element	Behavior
Content Type	Unprovisioned **
Field	Unprovisioned **
List Instance	NOT Unprovisioned
Module (File)	NOT Unprovisioned
ContentTypeBindng	NOT Unprovisioned

** These items will get unprovisioned but artifact may be left behind if instance of these definitions were already used.

As you can see this can get messy quickly. So please don’t go hitting your head against a brick wall when trying to understand why artifacts get left behind after you reactivate\deactivate your feature and you don’t get the expected results. I like to use an analogy that many developers are more familiar with – SQL Scripts. If you run a SQL script that creates a table and then update the SQL Script with a new column does the table get update – No. You have to upgrade the script to run an alter table SQL command. SharePoint is the same, once you create an instance of something you have to do something “different” to update it. Additionally SharePoint is very careful when it comes to removing elements upon deactivation of the parent feature, nobody likes data disappearing on them unexpectedly. Now it would be nice if it could perform some more advanced differencing\appending logic but unfortunately that isn’t the case (and still isn’t much with SharePoint 2010). Needless to say though this has been a sore point for many developers getting into Feature development for the first time.

Old Technique #2 – New Feature With Version Numbers (Supported)

Another common technique is to build multiple Features to mimic an upgrade process. This typically lead to Features with names such as “My Feature 1.0” and “My Feature 1.1” and so on and so forth. Although this worked this could get very messy very quickly and almost always led to code heavy Feature Receivers to get around the lack of conflict resolution in the provisioning engine. You could use Feature Dependencies to try to enforce a particular order but in the end you ended up creating your own upgrade engine\schema. Once again far from ideal.

Welcome to SharePoint 2010

So what's the big deal with with Features in SharePoint 2010? Well first off we can now make use of that previously useless Version attribute on the Feature element. Secondly, through the use of the Version attribute, SharePoint now provides the core framework for upgrading features. To support this framework SharePoint now keeps track of the version of a Feature each time it’s activated, for each scope, for each site. By keeping track of the version it can apply rules that are defined for different versions of the feature. You can also take advantage of a new query method to gain more control over who gets upgraded.

<UpgradeActions> Defining How To Upgrade – The Anatomy of the UpgradeActions Element

<Feature Id="817224F9-2209-4965-B18D-B73CA86AEFCA"
        Title="My Feature" 
        Description="My Feature Details" 
        Version="2.0.0.0"
        Scope="Site" 
        Hidden="FALSE"
        DefaultResourceFile="core"
        xmlns="http://schemas.microsoft.com/sharepoint/">
    <ElementManifests>
        <ElementManifest Location="Elements.xml" />
        <ElementManifest Location="Elements2.xml" />
    </ElementManifests>
    <UpgradeActions>
        <VersionRange EndVersion="2.0.0.0">
          <ElementManifests>
            <ElementManifest Location="Elements2.xml" />
          </ElementManifests>
        </VersionRange>
    </UpgradeActions>
</Feature>

The <UpgradeActions> action is the core to the new Feature upgrade framework and adds several new elements in the Feature.xml that define the behavior of the upgrade process including VersionRange, ApplyElementManifests, AddContentTypeField, MapFile, CustomUpgradeAction.

VersionRange
The version range element defines the version range at which the UpgradeAction is applied. The BeginVersion and EndVersion attribute define the affected version. Multiple VersionRange elements are permitted to apply different upgrade rules to different versions of the feature. If you do not provide a BeginVersion the version range applies all versions up to the version specified in the EndVersion.

<UpgradeActions>
        <VersionRange BeginVersion="2.0.0.0" EndVersion="2.5.0.0">
          <ElementManifests>
            <ElementManifest Location="Fields.xml" />
          </ElementManifests>
        </VersionRange>
</UpgradeActions>

ApplyElementsManifests
From a declarative upgrade standpoint the ApplyElementsManifests will be your opportunity to provision additional elements. Any valid element is permitted just as with a standard Feature. Keep in mind that the manifest will also need to be defined in the standard ElementManifests section of the Feature.xml as well as in the VersionRange ApplyElementsManifests elements.

AddContentTypeField
Content Types are a very powerful feature within SharePoint 2007 that allows you to declare reusable collections of meta data (columns) that can be reused across the site collection in any list. One nice feature of Content Types is the ability to push updates, such as new columns, to any list making use of the Content Type. Unfortunately from a declarative provisioning standpoint once your Feature declares a Content Type and its Site Columns (fields\columns) in SharePoint 2007 there was no out of the box mechanism to declaratively add new Site Columms to the Content Type. You had to use a Feature Receiver to drop down to code to do this.

With SharePoint 2010 you now can add additional Site Columns to a Content Type through the UpgradeActions element:

<UpgradeActions>
        <VersionRange BeginVersion="2.0.0.0" EndVersion="2.5.0.0">
          <ElementManifests>
            <ElementManifest Location="NewFields.xml" />
          </ElementManifests>
          <AddContentTypeField ContentTypeId="0x010100C568DB52D9D0A14D9B2FDCC96666E9F2007" 
                                              FieldId="{2ADDDEF9-3832-49B4-A5C4-CEDE34C37FDF}"  
                                              PushDown="TRUE" />
        </VersionRange>
</UpgradeActions>

In this example we’re applying a new elements manifest that creates a new field and then adding that field to a previously defined content type and instructing the update to be pushed down to each instance of the content type being used (pushing down the update).

MapFile
MapFile allows you to change the path or name of an existing file you provisioned to a new location. This can be useful, if for example, you decided to change the path of your images folder from pictures\img.gif to images\img.gif. Not very handy on the surface but could be usefull in specific scenarios. If you’re defining module elements in a Feature you’ve likely already identified that a feature is going to get some reuse. Modules (files) provisioned by a feature live in the file system (until possibly customization) which means you’ll get some performance benefits as well. If you then want to upgrade the “virtual” location of these files within SharePoint you now have a mechanism to apply this change across the board. A bit niche but none the less handy.

<MapFile FromPath="Pictures\Image.gif" ToPath="Images\Image.gif" />

NOTE: During the first private beta I had the impression this applied to customized elements as well. I thought this would be a great feature to get control of a customized files but unfortunately this isn’t the case. I had mentioned this in a couple of my initial presentations on the subject so I wanted to clarify\correct in case you were in one of my sessions.

CustomUpgradeAction
Similar to the use of Feature Receivers to drop to code during the activation process the CustomUpgradeAction allows you to drop to code during an upgrade process. For example if you wanted to update existing instances of a list with additional views or possibly additional columns (if you didn’t use ContentTypes). This uses the existing Feature Receiver framework but works off a new function SPFeatureReceiver.FeatureUpgrading.

<UpgradeActions
    ReceiverAssembly="ShinyNewFeatureReceiver, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3ef91b1292056a22" 
    ReceiverClass="ShinyNewFeatureReceiver.MyReceiver">
    <VersionRange EndVersion="2.0.0.0">
      <CustomUpgradeAction Name="RemoveField">
              <Parameters>
                       <Parameter Name="ContentType">MemberProfile</Parameter>
                       <Parameter Name="FieldName">SSN</Parameter>
              </Parameters>
      </CustomUpgradeAction>
    </VersionRange>
  </UpgradeActions>

CustomUpgradeActions allow you to perform actions that fall out of scope of the out of the box upgrade actions. In the example above we want to remove the SSN field from the MemberProfile content type. CustomUpgradeActions are defined in a SPFeatureReceiver as a new method called FeatureUpgrading. The following is a snippet on its usage building on the above example and simplified a bit.

public override void FeatureUpgrading(SPFeatureReceiverProperties properties, string upgradeActionName, IDictionary<string, string> parameters)
{

    SPWeb web = thisFeature.Parent as SPWeb;

    if(upgradeActionName == "RemoveField")
    {
                string contentTypeName = parameters["ContentType"];
                string fieldName = parameters["FieldName"];

                SPContentType contentType = web.RootWeb.ContentTypes[contentTypeName];
                contentType.Fields[fieldName].Delete();
                contentType.Update(true);

     }
 
}

ActivationDependencies
ActivationDependencies are available in SharePoint 2007 and SharePoint 2010 but in order to support the versioning concept have been adapted in SharePoint 2010 to specify the Minimum Version required for the dependency. So you could place an activation dependency on the 2.0.0.0 version of another Feature in case you are dependant on a new element in the latest version.

Querying for Features
In addition to the core upgrade action elements there are additional tools available through the API that allow you to programmatically query for features within a designated scope. Using the QueryFeatures method you can query for features based on the Feature ID, the scope, features yet to be upgraded, and features by version. This can be useful in cases where you want to have more fine control over which sites receive an upgrade. More details can be found on MSDN.

Some Final Thoughts

It’s great to see the Feature Upgrade path now available and although it may mean more work and planning we have a standard and supported methodology for upgrading our Features which should help out greatly for lifecycle management of your SharePoint environment and SharePoint applications. For that I’m thankful – a good step forward in the right direction.

Saying that I still question some of Microsoft’s direction when it comes to Feature upgrades. I think it would have been more appropriate to build in a more reusable provisioning framework into the Feature framework to allow us to define more flexible actions that could be reused across features (and possibly built on by the community), beyond that of just UpgradeActions. Instead of giving us a couple of new elements that may or may not be useful for many common scenarios they could have built us something flexible so it could be adapted to be more robust if needed. I think the feature receiver is meant to address this scenario but I would have rather seen something more a kin to how MSBuild works in addition to feature receivers. Allow me to build and register a custom assembly with the feature that adds a new reusable element to the feature.xml to add new ways to customize the provisioning process. With this framework something like the UpgradeActions elements could have been a value add on top of the flexible provisioning engine. That way I wouldn’t have to wait for each release every 3 years for improvements to the Features framework.
Technorati tags: SharePoint
Technorati tags: SharePoint 2010

Switched My Blogging Platform – Sorry SharePoint

Joshua Carlisle — Fri, 15 Jan 2010 23:05:02 GMT

I decided last week to abandon my current blogging platform in search of greener pastures. Being a SharePoint developer, hell a SharePoint evangelist, I really thought I had to be on the SharePoint platform to make a point. Unfortunately it didn’t work out as well as I had hoped. I had upgraded my out of the box SharePoint Blog (slightly modified) to the Community Kit for SharePoint Enhanced Blog Edition ( CKS:EBE) several months back. The developers did a lot of great enhancements to the platform, it’s a huge upgrade from the standard Blog site definition and I still believe its a powerful and appropriate solution for a corporate environment and for some bloggers out there. With some more work it could be a great blogging platform but I don’t think its quite there yet.

For me though it came down the simple fact that I needed a more powerful dedicated blogging platform. The user interface is important and some post UI enhancements are really needed for the CKS:EBE but the spam is what has been a huge problem for me in the last year to the extent where I’ve had to disable trackbacks\pingbacks and turn off comments for the most part because I don’t have enough time to moderate the comments. Spending a couple hours hunting for the good comment in the endless sea of SPAM comments isn’t really an option for me. It turned my blog into a one way information source – not my goal at all. The two methods the CKS:EBE appear to use currently, CAPTCHA and Akismet - both solid solutions, never seemed to work correctly. CAPTCHA wouldn’t render in some scenarios and Akismet seemed to be ineffective or not implemented correctly for neither post comments nor trackbacks. Now I know spam is not a problem exclusive to the CKS:EBE its a problem that every blogging platform has to deal with. Saying that other platforms seemed to have had much more success with those same tools and have brought other techniques to the battle.

After some investigation and tinkering around I decided on SubTextover WordPress. Not really from any feature standpoint- from what I understand WordPress may have some points over SubText. It turned out to be the underlying platform that sold me. I’ve had enough fun on Apache while working with subversion, I don’t need any more of that kind of fun. I really didn’t want to go down that road for my blogging platform, features be damned its just to much of a pain in the butt and out of my comfort zone for customizations. So far SubText has been a breeze to configure and customize, here is hoping the real test – it holds up to deluge of spam that will be hitting it over the next few weeks.

As for the CKS:EBE my goal isn’t to bash the project or the developers that have contributed there own time to it and I haven’t given up on it. I know there is still active development going on and being on the SharePoint platform it has HUGE amounts of potential – its just not quite there yet. I hope the CKS:EBE team continues to build and improve, I think its the best option for a SharePoint blogging platform. If I had more time I’d work around some of the issues and maybe make some improvements but for the time being I don’t want the blogging platform to keep getting in the way of blogging! Its just not about the technology in this case, its about the message.

Technorati tags: Community Kit For SharePoint, CKS, Blog, Spam

Technorati tags: SubText, WordPress

The SharePoint 2010 Developer Experience

Joshua Carlisle — Tue, 05 Jan 2010 16:18:00 GMT

I’m a developer at heart. I think i will always be a developer at heart. For those folks who haven’t been in my presentations or know me personally I’ve been known to get a little giddy when I start talking geek. Yes I can play other roles – architect, team lead, tech lead, business analyst, manager (cough!) but development will always be my passion. When I am old and gray, probably sitting in a boring management\executive position because my mind has been turned into chum from years of keeping up with the technology grind i will probably still be cruising through the forums and developer blogs.

In the last several years, as a SharePoint developer and architect, you could measure that chum/burn rate on my brain in dog years - you know 1 human year = 7 dog years. This is mostly due to the fact that SharePoint development has historically been very painful, often involving lots of pounding of fists (and sometimes foreheads) on tables (I’ll leave the churn rate on broken peripherals and office furniture for another post lol).

Now to be fair the picture got a bit better in SharePoint 2007 but it still maybe turned that down to a 1/5 year ratio and that ratio was really more due to the communities awesome contributions to the SharePoint developer space then any particular effort from Microsoft. Now with SharePoint 2010 I would now lower that ratio even further to 1/2.5 and this time it’s in large part related to efforts by Microsoft in that area – finally! Now its not perfect but still a big jump in my opinion. Although you may not agree with me you can’t deny that Microsoft has FINALLY put more then just token resources on the developer experience.

So why is it that I am so excited about this release:

Visual Studio Experience – I think everyone recognizes (or should) that Microsoft isn’t going to develop the end-all-be-all toolset. Its just too cost prohibitive for even Microsoft. Saying that its still no reason that a baseline toolset shouldn’t be established. With a strong foundation, just like a framework, it can grow more powerful over time via contributions from not only Microsoft but the community and third party vendors as well. Microsoft has recognized that and as a result SharePoint 2010 is now finally a first class citizen in Visual Studio. With Visual Studio 2010 and SharePoint 2010 they have provided this base foundation for the Visual Studio experience that both provides a minimal subset of functionality and arguably just as important - a solid\extensible framework to build upon.

As part of this toolset you now have out of the box:

A SharePoint specific project format that supports the concepts of Packages (WSP), Features, and elements.

SharePoint specific project items such as webparts, visual webparts, workflows, content types, etc.

“F5” debugging support with pre-configured AND configurable deployments steps such as resetting worker processes (clearing GAC), creating solution packages, deploying solution packages, activating features, attaching to a debugger etc.

Visual designers for configuring both packages and features that allow for both designer based configuration and just as importantly the combining of configuration that the designer doesn’t support with custom configuration elements.

SharePoint Explorer for browsing through a SharePoint site’s artifacts' such as fields, content types, lists, etc.

Instead of having to make the difficult choice of what community toolset (or home grown) your organization standardizes on you can depend on the strong foundation that Visual Studio 2010 provides for SharePoint developers.

Lastly, a good tool understands that the common tasks should be made easy but the tool should still allow access to the complex stuff under the hood. Don’t make me have to beat the tool into submission just because the original creator hadn’t had time or thought of my scenerio. Make it easy for me to change my oil but still let me drop a new transmission in if I need to. This is where I believe that Visual Studio Extensions for WSS (VSeWSS) went wrong and was never really able to overcome. This is solidly not the case with Visual Studio 2010 and SharePoint 2010.

“Developer Continuum” – In SharePoint 2010 the developer continuum refers to the ability for all the tools in the SharePoint toolbox (Browser, SharePoint Designer, Visual Studio) to be able to work together in a cooperative way and “hand-off” artifacts from one tool to another regardless of the life-cycle.

In 2007 this continuum didn’t exist. The toolset didn’t support the concept out of the box which meant once again relying on community solutions or forcing existing toolsets to be manipulated with often unexpected results. Several community projects built windows to this data through several tools (stsadm extension, windows apps) but the process was still fairly manual to get those artifacts into your project. One of the core issues, outside of developing a bruit force pure API extraction implementation, was that customizations (browser or SPD) were stored in a site template format and custom solutions were stored in a solution package format.

With SharePoint 2010 Site Templates are now stored in the same format as solution packages (they actually share the same extension now – wsp). This allows for tools such as Visual Studio to provide a native and compatible format for identifying artifact in a package to be imported into a project. This will allow for many types of browser and SPD based customizations to be imported in as SharePoint artifacts\elements, associated with a feature and repackaged with enhancements back into a solution package. With the addition of the ability to upgrade Features a true lifecycle process is now available to the SharePoint development platform.
"Web Standards” – Now i don’t harp on MS for there lack of standards too much but I do battle it quite regularly. I don’t blame Microsoft (well at least not too much lol) for some of their lack of design standards when it came to their use of CSS and table based layouts. Others however may harp on SharePoint 2007 for its lack of “web 2.0 features” but you need to remember at the time of SharePoint 2007’s development (probably 2004-2006) Web 2.0 features and CSS design methodologies were not mainstream yet as many of the standards\techniques we come to accept today.

With SharePoint 2010 Microsoft has taken a significant step forward and removed the table based layouts and updated much of their default implementations to CSS based layout standards and improved use of CSS and XHTML compliant rendered code. That's not to say old masterpages will break, you can still run in a compatibility mode but going forward as a developer you’ll be in much better shape.
Business Data Connections – This is not a new concept. Business Data Catalog (the original name) was introduced in SharePoint 2007. Whats important in SharePoint 2010 is that elements of it have been “demoted” (or promoted depending on your perspective) down to the core framework – SharePoint Foundation 2010 (Formerly WSS). In this case demotion is a good thing. This gives the underlying framework the out of the box ability to integrate with external systems and recognizes the importance of this functionality as a core tenant of SharePoint. External Lists and external data columns are now available. The server product adds value on top of this functionality as it should but SharePoint Foundation is now able to work more seamlessly with outside systems and just as importantly Visual Studio provides the project types to support this.
Developer Dashboard – Have you ever spent hours trying to diagnose performance issues on a SharePoint page? Trying to find out what component is misbehaving can be very time consuming. The new SharePoint Developer Dashboard is like asp.net tracing information on steroids and tweaked just for SharePoint. You can find out a lot of diagnostic information about different aspects of your page and your pages components such as:
1. Request/Response cycle timings for every operations
2. response time for database queries
3. Load times for each webpart on this page

With this tool for example you could identify a misbehaving webpart and find out that it has an inefficient query against a list or that the list is missing an index it should have available. Absolutely priceless tool to have when the situation arises.

Developer Edition (Windows 7) – SharePoint 2010 now supports the ability for a workstation installation on Windows 7 or Windows Vista. This is for development purposes and isn’t supported for production environments. For many folks, especially new SharePoint developers, this is a big win and well overdue. Sometimes licensing for the server OS product can be prohibitive or the extra hardware required for virtual machines especially for small shops.

Saying that I would argue that for serious SharePoint development you’re still going to be working on a virtual machine and you’re still going to be running a server OS. It’s always the best idea to develop as close to your target deployment platform as you can and that paired with the typically frequent need to refresh your environment - a workstation install could become a real headache.

The Grass isn’t always greener!

So there is always a “but” to everything and I have one for this seemingly SharePoint 2010 Fan boy post as well. The product is currently a beta product. i don’t want to completely judge it based on how well current aspects of the tool work but rather on how it would appear Microsoft is intending for them to work. But be that as it may I have a couple reservations with the current beta implementation and I’m hoping to see some improvements before release:

Import Solution Packages – The current UI for solution package import can be overwhelming. Visual Studio is able to pull read the artifacts but the presentation of those artifacts can be quite an enormous list even for the case of blank team sites. Additionally the import process rightfully can identify dependencies, a good thing, but does not make any determination to the source of those dependencies. You can very easily, and inadvertently, attempt to duplicate out of the box definitions for items such as site columns and content types. In short the UI is a bit over simplified for displaying a more complex structure and I think the tool needs to be a little more intelligent about how it identifies dependencies. Additionally I would like an out of the box method for importing artifact outside the need for a new Import Solution Package project, some more granularity.
Import Workflow – I recently did a presentation on SharePoint 2010 Workflow enhancements at SharePoint Saturday KC. One of the things I warn against is importing workflows developed through SPD into Visual Studio. The concept is a great one, the implementation not so much, even the most simple of workflows can turn into a hundreds of actions on the workflow design surface with not so descriptive names as R1, R2. I would argue you would spend more time cleaning up the mess that it would negate the use of the tool. You may be more inclined to expert it into Visio and use the Visio diagram to rebuild the workflow.
Server Explorer Improvements – Right now the SharePoint server explorer is completely read-only and with the ability to import artifacts limited to new SharePoint projects it would be great if server explorer would also allow you to export artifacts at a granular level. This would arguably be more powerful then the solution package import itself. I don’t see this happening but maybe it will become a project of mine in the future – hell the SharePoint integration with Visual studio is VERY extensible.

This post hasn’t even touched on some of the SharePoint 2010 server goodness but all in all though the developer experience in SharePoint 2010 is full of solid improvements and developers should find a much more pleasant experience and you just may not become an old dog before your time!

Technorati tags: SharePoint 2010, Visual Studio 2010, Developer

SharePoint Saturday Raleigh and Speaking at Sandhills SharePoint User Group November 19th.

Blog Author — Tue, 10 Nov 2009 12:09:00 GMT

I wanted to thank everyone who spoke, volunteered, and attended the first SharePoint Saturday Raleigh event. Talking to folks after the event and listening to some feedback from twitter everything seems pretty positive so far which I’m glad to hear. We’re already looking forward to another event next year and we’ll work hard to improve on our success. Look for future announcements through the Triangle SharePoint User Group.

I really apologize to the folks at my session, projector issues cut my time in half and then VM slowness and beta stability problems killed the rest of the session. The really embarrassing part came afterwards when I noticed in my rush to move rooms after the projector failed I never plugged in my laptop. No Power = Power Saving = CPU Suckage = VM Useless. Hopefully if you attended my session you got some useful information from our discussion. As promised I’ve already started to work on my webcast with the full demo\slide deck so I should have that available for download\streaming this week for folks.

On another note i will be presenting this same session (hopefully with better luck!) to the Sandhills SharePoint User Group in Fayetteville on Thursday November 19th. So if you missed my presentation or want to give it another go you may want to check out that meeting, its a smaller group so there will be lots of opportunity for questions and discussion.

Here are some pictures for the speaker social, as you can see everyone was having a pretty good time.

SharePoint Saturday Goodness

Joshua Carlisle — Tue, 27 Oct 2009 23:46:37 GMT

First off if your in the Raleigh area and you haven’t registered for SharePoint Saturday Raleigh, What are you waiting for! Go register, I promise it will be a great time!

I’m particular excited about the Raleigh event not only because its the first home town SharePoint Saturday for me and the great new SharePoint 2010 content but also because its going to kick off a couple months of speaking at other SharePoint Saturday events. The new addition to my family, Ava now 5 months old, has kept me pretty busy the last few months but I’m looking forward to getting back out in the community again. And what a great time to! I’m looking forward to sharing some of the great new developer experience available in SharePoint 2010. If anyone has ever heard me rant about the state of SharePoint 2007 developer tools (whether you agree or disagreed with me lol) then you can understand just how excited I am about the developer experience in SharePoint 2010 (and Visual Studio 2010).

On the developer experience I plan to split my sessions across a couple of developer topics:

SharePoint 2010 Developer Goodness (SharePoint Saturday Raleigh, Virginia Beach, Richmond)

Although few argue the business success of SharePoint you’ll find far fewer developers singing the praises of SharePoint. For developers the lack-luster integration with Visual Studio was often a pain point. For developers and designers alike SharePoint Designer, with all of its portability and applications lifecycle consequences were also a source of frustration. For all the heavy development environment requirements could often be a show stopper. With all that and more in mind SharePoint 2010 represents a significant step forward fore SharePoint as a development platform. SharePoint is now a first class citizen in Visual Studio 2010. SharePoint Designer can now fully participate in application development lifecycle. Windows Vista and Windows 7 are now viable development platforms for SharePoint. In this session we will be introducing the new features of Visual Studio 2010’s integration with SharePoint. We will be providing on overview of SharePoint Designer 2010 new ability to produce WSP packages. Lastly we’ll be touching on some of the new built in tools for developers including the Developer Dashboard.

SharePoint 2010 Developer Workflows – Joint Sessions with Michael Lotter (SharePoint Saturday Kansas City)

SharePoint 2007 introduced the SharePoint platform to Windows Workflow. Along with it came some first generation design tools and a very disconnected experience between developers, designers, and business and between the toolset they work with including Visual Studio, SharePoint Designer, and Visio. Did you ever wish that the Visual Studio experience wasn’t as painful, or that you could make your SharePoint Designer workflows more portable, or that you could take your workflow designs developed by your business and port them into SharePoint? Well the wait is over with SharePoint 2010. In this joint back to back session we will be showing off the new features of SharePoint 2010 that allows you to develop workflows using Visio, import them into SharePoint Designer, make modifications in SharePoint Designer, extract to Visio for further modifications and finally extracting into Visual Studio for some hardcore workflow modifications.

November 7, 2009

November 21, 2009

December 12th, 2009

January 10th, 2010

Look forward to seeing everyone there!

Technorati tags: SharePoint Saturday

So You Want To Become A SharePoint Professional?

Mon, 19 Oct 2009 12:30:08 GMT

Since I started speaking to groups on the subject of SharePoint at the early days of SharePoint 2007, no matter the topic of my discussion at the time, I almost inevitably got the question from the audience, “I don’t know anything about SharePoint but i want to get into SharePoint, where should I get started?”. It’s a pretty common question out there and you’re likely reading this post because you have the same question, I’ve pointed this blog post to you, or you’ve already figured out a way to answer that question and you’re curious how I suggest to approach the task.

The answer isn’t the easiest. You see SharePoint is a HUGE BEAST of an application and it can be overwhelming trying to figure out where to get started. Early on I approached this from the perspective of a web developer, specifically ASP.NET developers, in my SharePoint for ASP.NET Developers presentations last year. For me it wasn’t the most exciting or sexy of presentations to give but to date it’s still been one of my most popular. Probably for one of the most obvious reasons - there are a lot more asp.net developers then there are SharePoint developers and SharePoint is one of Microsoft’s best selling products in company history. You put the two together and you have folks wanting (or being told to) learn SharePoint.

In my presentation last week at the Hampton Roads SharePoint User Group I was once again presented with the same question. I typically have quite a few stock answers and it inevitably comes down to requests for specific resources. Instead of trying to keep my suggestions and resource links on every presentation slide deck i decided to bite the bullet and get a blog post up to reference.

First off start with the basics:
- Start with Windows SharePoint Services. WSS provides the foundation for it's big brother Microsoft Office SharePoint Server (MOSS). Understanding WSS will prepare you for the added complexity\functionary when\if it becomes time to move up to MOSS and will give you an excellent foundation.
- Learn what SharePoint can do out of the box. As a developer its very easy to start thinking about custom solutions when a customer presents you with a challenge. One of the biggest value in a truly good SharePoint professional is knowing the capabilities of the application and helping your customer avoid the complexities and cost of custom development on top of an already expensive investment. In areas where SharePoint doesn’t exactly shine, such as some of its Web 2.0 features, it may mean making suggestions for alternative ways to achieve their goals. For example the out of the box Wiki is fairly primitive to current standards (heck it was designed and coded pushing 5 years ago) but they may be able to save 100% of the custom costs by accepting 80% of the functionality they need. You’ll find as you gain experience with SharePoint its all about compromises and working with the tool not against it.
Make use of free online resources:
- Official SharePoint Forums – The official SharePoint forums are a great place to get started and ask questions. Not only are there Microsoft technical specialists who monitor and answer questions there is a very healthy community that answer questions. Its a great place to bounce ideas off of, ask about the basics, or get some help with something that is stumping you.
- SharePoint MSDN Site – This is a great aggregate of online resources, links, and articles, and videos. In the early days it’s content was fairly light but they’ve really improved it in the last year. Just this morning i noticed a great article on different tools and techniques for developing in SharePoint.
- Download a Pre-Configured SharePoint Virtual Machine – Microsoft created a time bombed virtual machine that comes preconfigured with MOSS, Search, Reporting,etc. Its a great way to play around without having to worth through the overhead of installing and configuring a new environment. If you mess up the environment all you have to do is restart and you’re back up and running. Just make sure you get your playing done in 30 days, after that you’re on your own :( .
- End User SharePoint – End User SharePoint is new in the last year to the SharePoint community. At last year’s SharePoint Saturday Virginia Beach I remember Mark Miller talking up his new community site and since then its has really grown, lots of great articles from community contributors from around the country.
- SharePoint Blogs – The SharePoint blogging community is one of the most active technical blogging communities I’ve ever seen. There are too many blog posts to mention but I’d start with the MS SharePoint Team blogs and checkout some MVP blogs. I guarantee within a few days you’ll have a couple dozen RSS feeds added to your favorite reader.
Buy some books. With all the great online resources its easy to overlook the tried and true reference guides, before heading out and dropping the $$ on some books though make sure you checkout the free online resources.

Some of my favorites include:
Attend SharePoint User Groups and Community Events:
- SharePoint User Groups – Most folks are within driving distance of a SharePoint User Group or Office Geeks user group. The ISPA site has a pretty good listing of existing user groups out there so check it out to find one in your area. SPUG’s are one of the best resources that nobody knows about. You get presentations from folks in the industry, not travelling presenters, the insight that these folks have can truly be remarkable. It’s also an invaluable resource for networking with other SharePoint professionals. If you’re in the Raleigh area check out the Triangle SharePoint User Group, we meet the 1st Tuesday of each month.
- SharePoint Saturday – SharePoint Saturday is a free, educational, informative & lively day filled with sessions from respected SharePoint professionals & MVPs, covering a wide variety of SharePoint-orientated topics. Most SharePoint Saturday events have developer, administration, end user, and power user tracks just to name a few so there is typically something for everyone. SharePoint Saturday’s are spreading like wildfire and you’re seeing them popup all over the country (and world!).
Setting up your own Virtual Machines – Once you get to a certain point you’re going to want to start playing around with SharePoint on your own without having to talk your IT folks into setting up an environment for you. Because SharePoint currently has an Server OS requirement for installation (Windows Server 2003, Windows Server 2008) the best way to go about it is to setup a local virtual machine using a tool such as VMWare Workstation, Virtual PC, or Virtual Box. Alternatively you can install Windows Server 2003\2008 on a physical machine if you have one sitting around. The final alternative is to use an unsupported tool from Bamboo to allow SharePoint to install on a workstation. I’ve never used this tool and its completely unsupported by MS but it’s out there to try if you can’t swing the hardware requirements of a virtual machine.

On the hardware topic I do have a couple suggestions if you plan to go the virtual machine route:
1. Have your Virtual Machines on a second drive dedicated drive to improve performance. This may mean a secondary internal drive (some laptops 17’ or greater like my HP have two drives) or pickup an external usb drive
2. The faster the drive the better. I usually don’t get less then 7200RPM for my VM disks. Even better if you can afford it go for a new SSD drive.
3. 4GB or grater RAM. The virtual machine uses the same recommended memory as the base OS so you want to try to give your VM at least 2GB of RAM if you can manage it. Anything below that and you’ll start to have performance issues. 8GB RAM, even on laptops, have come down in prices so if you can swing it go with 8GB.

This is by no means an definitive list but hopefully get you on your way to becoming a SharePoint Pro!. Have something you think should be on the list? Drop me a line in my comments.

SharePoint 2010: One caveat - things are going to start changing this week with SharePoint 2010 being formally introduced at the SharePoint conference, and more importantly for me, the lifting of the NDA that keeps me from talking about some of the new content and how it impacts the ramp up time, especially for developers. I’ll keep this updated with some of the latest content as it becomes available.

Speaking at Hampton Roads SPUG & DOD SPUG (Virginia) Tomorrow 10/15/2009

Wed, 14 Oct 2009 13:35:51 GMT

Tomorrow I will be heading up to Virginia to speak at the Hampton Roads SQL\SharePoint User Group and the Department of Defense SharePoint User Group for a day of SharePoint Build environment topics. The Hampton Roads group meets at the Virginia Beach City Public Schools at their Advanced Technology Center, Room 131. More details on the group and the location can be found at their website http://www.hrssug.org/default.aspx. If you’re in the military\contractor the DOD presentation will also be available on a web conference via the DCO, if you need connection information please drop me a line in my comments and I can put you in touch with the right folks.

I was originally planning to speak on some of the new integration between Visual Studio 2010 and SharePoint 2010. Although SP2010 is still under NDA (so I can’t speak much on the subject - at least until the SharePoint conference next week) I thought there was enough juicy tidbits in the content already announced by Microsoft (fair game to talk about) that I could get away with a high level topic. There have actually been a couple articles and videos released by Microsoft in the last few months, especially most recently on Visual Studio 2010 Tools for SharePoint so I felt it would be safe to present on this content in a limited fashion. As I was prepping for the talk I felt I was skirting the boundaries of the NDA a little too closely so I chose to err on the side of caution and hold off on that topic. So if you’re interested in seeing that discussion you’ll have to come to my session at the Raleigh SharePoint Saturday event.

I will however be presenting on a topic that applies to both the current and next version of SharePoint which is setting up a SharePoint Build Environment. If you’ve already seen this presentation in one of my other road trips this year I have a different spin on this presentation that will be new for tomorrow.

Easing Your Deployment Burdens With A SharePoint Build Environment

Every project can benefit from the practice of implementing a build server. From daily builds to continuous integration, the benefits have never been in dispute, but many have felt that SharePoint has too many complexities to be supported in a build environment. In this updated session we’ll be covering the use and creation of custom msbuild tasks to automate many aspects of SharePoint deployment to make the process of not only compiling but solution package creation, deployment, and feature\site creation from within the build process straight forward.

Thanks again to Susan Lennon for the invitation to speak with these groups and I look forward to seeing everyone!

Developing SharePoint Workflows for WSS – Don’t Forget To Remove Your MOSS Dependencies

Blog Author — Thu, 08 Oct 2009 13:26:58 GMT

I was working on a short workflow project for a client a couple weeks ago that was targeting WSS. Just a simple workflow to provide some enhanced blog posting features - nothing crazy. I typically spin up a new virtual machine for each project from my base developer virtual machine so I have a clean slate but I was being lazy and this was a quick module so I decided to just ride on the virtual machine that I already had spun up for another project. However this virtual machine had MOSS installed but I was already aware of some of the caveats with developing workflows targeting WSS.

I don’t use Microsoft’s SharePoint\Workflow project templates because they don’t support 32bit (boooo!) so I’m not sure if this is an issue with that project type but there are a couple things to consider especially if you're using wspbuilder’s workflow template like me. This is fairly common knowledge with a few searches so I won’t get into great detail but you will need to make some adjustments to the out of the box workflow project template to allow it to successfully deploy\run in a WSS environment as it contains some MOSS dependencies by default:

1) Remove any reference to moss\office assemblies in the project:

2) In your generated elements file remove the references to the forms (AssociationUrl, InstantiationUrl,ModificationUrl, StatusUrl). These are references to pages only available in MOSS.

You may be asking why these pages become an issue. In short these are Infopath Forms Server forms. Unfortunately WSS does not have access to forms server so these are unavailable.

On a side note I was chatting with my co-worker Michael Lotter the other day who did confirm from a MS resource that you can use InfoPath Forms Server forms in workflows for MOSS Standard but only within the context of workflow forms, anything beyond that and you’ll need MOSS enterprise.

3) Remove the default TaskListContentTypeId (unless you are implementing a custom one).

Without these steps you’ll run into problems installing the workflow. Now in my haste I neglected to remove the TaskListContentTypeId. Unfortunately for me the workflow feature successfully activated, I was able to add a workflow reference to my targeted list, but from there things got strange. It would have been easier if I just got an ugly incomprehensible error but SharePoint wanted to keep me on my toes this day.

So if you’re like me and you forget to remove the TaskListConetntTypeId you may be left scratching your head for a while with the strange behavior. The workflow feature will install, activate, and you can associate the workflow with a list but you’ll notice right away that executing the workflow does nothing,the workflow status column shows no status, and no workflow history exists. You will not receive any exceptions, no event or ULS logs, things will simply not work. As with any development error the worst kinds are the ones that don’t throw any exceptions.

So moral of the story, if you’re targeting WSS and developing in MOSS make sure catch all your moss dependencies that may be injected in by your project template of choice or you may get a few surprises when you deploy to your staging\production environment.

SharePoint Saturday Charlotte Session Follow-up

Blog Author — Fri, 26 Jun 2009 18:43:51 GMT

Well SharePoint Saturday Charlotte is now behind us. I had a really great time. Thanks again to Dan Lewis and company for putting together a great event. It was great to catch up with everyone and especially meeting some new folks like Laura Rogers, Heather Waterman, and Shadeed Eleazer. I’m hoping to make it to some more SharePoint Saturday’s soon.

A couple follow-ups on my session on using a SharePoint Build Environment. In case you missed the SharePoint Saturday Charlotte site you can also download my presentations and the demo build script project.

I also wanted to share a solution on a issue I reported in my session related to WSPBuilder. In my experience WSPBuilder at times exhibited a very long build time for solution packages, sometimes as much as 5-10 minutes. A recent community post on codeplex provides a solution to the issue. It would appear that wspbuilder historically made use of reflection to gleam information about references, in a recent release they moved over to a a mono related project called Cecil that is causing the performance impact. Checkout http://wspbuilder.codeplex.com/Thread/View.aspx?ThreadId=56751 for more details and the fix.

SharePoint Saturday Charlotte – Speakers

Charlotte SharePoint Saturday This Weekend – See Everyone There!

Thu, 18 Jun 2009 18:07:12 GMT

Wow what a busy week. Lots of activity on the community front this week for me. Had a great meeting last night with the rest of the Triangle SharePoint User Group Leadership , we’ve got some really great plans and announcements coming up for the SharePoint community in Raleigh. The new TRISPUG site is coming along nicely and we’ve just opened up registration. I’m ending the week with a trip out to Charlotte for SharePoint Saturday event with some of the rest of the B&R crew (Michael Lotter, Nas Ali, and Becky Isserman) and also my family in tow (we’re spending Sunday at the Great Wolf Lodge – fun fun fun). I’m really looking forward to the event. I’ve been doing a good bit of work behind the scenes with SharePoint Saturday but I’ve only made it to the first event. It’s been great to see the success that Michael has had with the SharePoint Saturday concept. I’m looking forward to catching up with folks that I really wish I could see more often (new and old acquaintances).

I’ve been doing my Back to Basic – Feature Development session for my last few speaking engagements and I thought a new presentation would be a good change. I recently finished an engagement with a client helping them setup a build environment for SharePoint and it was such a good experience (both challenges and fun stuff), with lots of questions from the client, that I thought the community might get some value from it as well.

Ease Your Deployment Burdens by Setting up a SharePoint Automated Build Server

Every project can benefit from the practice of implementing a build server. From daily builds to continuous integration, the benefits have never been in dispute, but many have felt that SharePoint has too many complexities to be supported in a build environment. In this session we’ll see how with the use of msbuild and some custom build tasks we can make the process of compiling, solution packaging, testing, and deployment very straightforward.

Not registered yet? Checkout http://www.sharepointsaturday.org/charlotte/default.aspx . Look forward to seeing everyone there!

The Scourge of Corporate User Group Ownership

Fri, 12 Jun 2009 13:30:18 GMT

The catalyst for this post was a comment by Chad Grieves to my previous post on the Introduction to the Triangle SharePoint UserGroup. I don’t know Chad and he doesn’t identify himself beyond his name or his company but he implies that he’s part of the leadership of the original Raleigh SharePoint User Group. It would appear that he is upset that we started a new SharePoint usergroup in Raleigh (TRISPUG). Based on searches he is or was associated with ThoughtBridge as an Account Executive (e.g. Sales) for the Carolinas and ThoughtBridge is\was the “sponsor” of that group.

Chad’s Comment:

“Josh, reading through your information I see several false statements. We started 2 1/2 years ago, the Raleigh SharePoint Users group, along with Microsoft as the "go-to" managed partner in the Carolinas. We are far from fledgling with over 50 companies in attendance. We do it every 2 months at the request of the participants. I believe you are associatted with tek Systems- are you a Managed Partner in the SOutheast for Microsoft? I know of a handful in the Carolinas and you were not one of them... it is my understanding you are a staffing firm wanting to get into the MOSS project business..please make sure you update your blog to include factual information-“

With the original groups’ last reported meeting being last year I believe, the group’s site (www.sharepointusersgroup.com/RSug) being down, no communications I’ve heard of to the community in almost a year, all of my emails going unanswered, past members saying the group fizzled, truly how can anyone assume otherwise? Is the original group still providing any type of service to the community?

Secondly there are no false statements in my post. I’m not implying I started the previous SharePoint group in Raleigh, I’m saying that myself and others are stepping up to fill the absence that currently exists for a SharePoint community in Raleigh. I am NOT associated with Tek-Systems, Tek-Systems is just very nice enough to host the facilities for our meetings and they also support other groups in the area such as the Triangle .Net User Group. A few searches with my name and reading through some of my blog can easily confirm this.

But this is really about a bigger issue beyond a single user group and probably my most important point. There is nothing that bothers me more then a company that uses a user group as an extension to their PR and Sales departments. Chad I think your comment speaks for itself. User Groups are not partners with Microsoft (managed or otherwise), they are partners with the COMMUNITY. This parasitic type of behavior that I see from companies and user groups is never a good thing for the user group in the long run because its the business interests that drive the group not the community interest. Once those business interests change or the companies goes under so does the group. In my opinion this is very self evident in the relationship between ThoughtBridge and the previous Raleigh SharePoint user group (and from what I understand the old group in Atlanta as well). In Chad’s comment he refers to a managed partner status and of course he’s referring to ThoughtBridge and his role as account executive of the Carolinas. So falsely accusing me that I’m part of a staffing firm trying to drum up business is a bit like calling the Pot calling the kettle black heh?

Now let me be very clear I have no issue with ThoughtBridge as a company nor Chad. I really don’t know much about ThoughtBridge other then what bing (you like that plug MS hehe) would tell me. The ThoughtBridge site is down so I’m not even sure if they’re around any more so it may be a mute point. I just don’t like the trend that I see out there of companies creating or taking ownership of a user groups. Consulting, Staffing, Product firms will always play a very important role with User Groups because without their sponsorship (key word sponsorship) usergroups could not exist. It’s also great outlet for company employee’s to network with others in the group and we encourage that. The networking that takes place in usergroups is one of the great benefits beyond the technical presentation but its important that usergroup leadership remain independent and impartial to the community.

As for TRISPUG, as I mentioned in my first post introducing TRISPUG but I will reiterate, we will never be associated with any company outside that of a sponsor relationship. Our group will NEVER be owned by any company. Our leadership will and is made up of members from throughout the community. We owe that much to the community as every other usergroup does.

I would encourage any company who wants to get involved with Usergroups to do so, it can be a great value, just don’t go out and try to start your own please :).

Triangle SharePoint User Group (TRISPUG) Meeting – Tuesday Jun 2nd

Blog Author — Mon, 01 Jun 2009 17:01:42 GMT

This months meeting will be a little more informal then usual. We had several requests for some general discussion and since we have speakers booked up for the next few months I thought this was a good time. Unfortunately my son’s first T-Ball game is tomorrow night so i won’t be able to attend but I’ll be interested to hear about any spirited discussions that may occur. Look forward to seeing everyone next month.

For more details on the meeting and the Triangle SharePoint User Group please visit http://www.trispug.com.

Introducing Ava

Blog Author — Fri, 22 May 2009 17:55:58 GMT

No this isn’t a new CodePlex project but it is a project of sort. Last Thursday, May 14th, my wife brought a beautiful little girl to the world – Ava Mae Ruth Carlisle. A healthy 7.4 pounds and 21 inches long. It’s been a few years since we’ve had a newborn in the house (our son Evan is 5) but it’s a strange thing how your mind represses the memories of lack of sleep and just keeps the cute baby moments. Well the cute baby moments are definitely here but also are the sleepless nights and changing 5 diapers in a row lol. Needless to say I may be quite for a few weeks. Anyway here’s to cute kids!

Introducing the Triangle SharePoint User Group (Raleigh NC)

Wed, 06 May 2009 23:05:07 GMT

I’ve had so many questions in the last few weeks related to the Triangle SharePoint User Group, formerly the Triangle Developer’s Guild, formerly the TRINUG SharePoint Focus Group (AKA SIG) so I thought I’d clear up the confusion and share some of the future plans for the group.

TRINUG SharePoint Focus Group

Last year I started chatting with some of the the other leadership at TRINUG about possibly having a short series on SharePoint. There seemed to be some interest from the membership and I felt that although there was another fledgling SharePoint User Group in Raleigh it was very IT and Business focused (like many other SharePoint user groups IMO) and that it didn’t cover very many developer related topics. With the base of TRINUG largely being made up of developers I thought this could be a nice niche to fill. A few months later we kicked off the first SIG meeting, not really a user group meeting, but more of a coordinated topical discussion. To my surprise we had more then 25 people show up when i was only expecting a dozen at most. This got me thinking that there was a bigger community in the area then I thought that needed an outlet such as a user group. This is the basis of why many folks still refer to us as the TRINUG SharePoint SIG (which is perfectly fine – I love the association with TRINUG).

Raleigh SharePoint Developers Guild

After a couple meetings I decided that with the amount of interest and participation reaching small user group levels that it would be a good time maybe to try to formalize the group into a user group, hence the Raleigh SharePoint Developers Guild. I was sensitive to the fact that there was already a SharePoint User Group in Raleigh and I didn’t want to step on anyone’s toes. I reached out to some contacts I found on their website but didn’t get any responses and unfortunately they had day time meetings (middle of working hours for many folks) and met every two months which made it difficult to reach out to them personally. As i worked to get some speakers, scheduling meetings, and building an organization I found I quickly got overwhelmed. After a couple last minute cancellations by speakers that caused me to cancel a couple meetings I decided I needed to take a step back and regroup and get some help. This takes us up to the current.

Triangle SharePoint User Group (TRISPUG)

A colleague of mine, Michael Lotter, offered to provide his assistance to the group and I think that provided a much needed injection of motivation and support. As we started planning out the year we were recently speaking with some other SharePoint community folks. I found out that the main sponsor for the previous Raleigh SharePoint User Group had been acquired by another company and that it appeared to have fizzled out (not confirmed but general consensus). With this knowledge Michael and I decided to go forward with attempting to pick up the reigns in Raleigh for the SharePoint community and broaden not only our focus but also our community reach, hence the latest (and final incarnation lol) the Triangle SharePoint User Group.

What is the goal of the Triangle SharePoint User Group

Very simple, providing an outlet for the SharePoint community in the greater Raleigh Durham area. Just like any other user group we will be bringing together speakers from not only our local area but from the greater region, and at times national and in the process we’ll be bringing together our own SharePoint community. In the near future we will be sponsoring local SharePoint events as well.

Although both Michael Lotter and I work for the same company this user group will not in any way be affiliated with our company outside the role of sponsorship that is available to any other company. I think there is an impression that many SharePoint user groups (and sometimes correct IMO) are nothing more then just an extension of the marketing arm of a company. This will not ever be the case with TRISPUG period. I feel very strongly that a user group must be paired with the community it serves and its priorities and goals and not that of any company.

Although most of our base at the moment are developers anyone involved with SharePoint, especially SharePoint developers, understand the importance of being well rounded and that means having an understanding of IT, business, and end user related challenges as well. With this in mind we will be broadening our topics to include IT and business related topics with the hope of additionally expanding the community to include topics also of interest to that category of folks.

Where does TRINUG now fit in? I think we’ll always have a relationship with SharePoint. Heck we use both the TRINUG site and their distribution list to help get the word out. Very soon they will both be running off of the same SharePoint User Group Portal application. Many of our attendees hear about SharePoint from TRINUG meetings and announcements. Without TRINUG there would be no TRISPUG and our relationship will continue.

Have some thoughts? Like to make some suggestions? I’d love to hear them. Drop me a line.

We meet the first Tuesday of each month, interested in attending? Checkout the group’s site at http://www.trispug.com.

Michael Gannotti – Raleigh SharePoint Dev Guild – Tuesday May 5th.

Thu, 30 Apr 2009 14:17:58 GMT

Michael Gannotti will be presenting at the next Raleigh SharePoint Developers Guild meeting on Tuesday May 5th. More details can be found at http://www.sharepointdevelopersguild.com.

Baby Steps – Implementing Knowledge Portals and Communities in the Enterprise

In this meeting Mike will be covering how to implement a phased approach to leveraging SharePoint social computing features to create knowledge portals and communities. Coverage will include corp cultures and resistance, changing perceptions and work habits, as well as the technical implementation (all using out of the box components with no coding required - config vs custom).

The meeting starts at 6:00. Pizza and beverage will be available courtesy of TekSystems. Hope to see everyone there.

SharePoint Smart404 Project Update

Blog Author — Fri, 17 Apr 2009 17:24:00 GMT

The SharePoint Smart 404 Project is a free project located on Codeplex that provides enhanced 404 support, Vanity Redirection, and custom exception logging and error pages to SharePoint (Both WSS and MOSS). The main goal of the project was to provide a simple to activate Feature and customizable user experience for “Page Not Founds” (404) and simplified vanity redirects. Although I had additional ideas for the project shortly after the launch, as is typically the case, both family and work scheduled forced me to set it a side for a while. The initial release of the project was functional but had some limitations and annoyances that this latest release will hopefully help out.

The latest version can be found at http://sharepointsmart404.codeplex.com/ .

For those of you who have already installed the project you may want to consider deactivating the feature and removing the solution. I unfortunately do not have an upgrade process from the previous version to the current but if requested I could probably provide you some manual steps if needed.

Some of the new\fixed features include:

1) WSS Support: The 404 page no longer has a MOSS search control by default on the page. A custom simple webpart that is part of the project now provides “Best Bets” search functionality.

2) FireFox: Firefox 404 redirects should now work properly

3) Exception Handling: Custom error pages and error logging is now supported.

4) Vanity Redirects: Vanity redirects no longer require absolute URLs.

5) General: The project now uses WSPBuilder and general quality and reliability updates have been made.

I’ve created a short introductory webcast showing an overview of the functionality provided by the Smart404 Feature and also a quick overview of the Visual Studio project and its moving parts.

Introduction to the SharePoint Smart 404 Feature Webcast

Before getting started, please note that I have not done extensive testing of the deployment of this release. I plan to spin up some VMs with different configuration to ensure that installation and deployment is smooth. Because of this I have labeled this release as a beta release. Over the next few weeks I hope to find some time for additional testing and fine tuning prior to the final 1.0 release. Saying that I’ve had no problems with the installation on my 2 development VMs and one of my production environments.

Some Sample Screenshots of the Smart 404 in action:

Custom 404 Page

Custom Error Page

Error Log

I want to thank everyone for their feedback and suggestions. Keep it coming. Feel free to drop a line in the discussion threads at the project site http://www.codeplex.com/sharepointsmart404 or drop a line on my blog.

Raleigh SharePoint Developers Guild – CLEAR!!!!

Tue, 07 Apr 2009 18:24:19 GMT

For those of you who have never watched House or an episode of ER “Clear” is what is called out prior to jump starting a heart back to life. Well the Raleigh SharePoint Developer’s guild, which has been on life support for the past few months , is now showing signs of life again with some help from new volunteers. As many of you know my travel schedule for work frequently came into conflict with coordinating activities for the guild and being available for events. Fortunately some great community folks such as Michael Lotter of SharePoint Saturday fame have stepped up and will be helping to coordinate and schedule events. I’m very much excited to get things rolling with the group again and growing the SharePoint community in the Raleigh/Durham area.

We have a tentative event scheduled for May 5th (First Tuesday of the Month), with specifics coming out in the next couple days which will be available at http://www.sharepointdevelopersguild.com . Interested in speaking? Got suggestions? Want to volunteer? Drop me a line in my blog comments. I’d love to hear from you.