SharePoint Brain Freeze

Presenting at Asheville NC SharePoint & .Net User Group 1/20/2011

Joshua Carlisle — Wed, 19 Jan 2011 16:20:13 GMT

I’m very much looking forward to head out to Asheville NC tomorrow to present to both the Asheville SharePoint and .Net User Groups. For more information on time & place please checkout http://wncdotnet.com/ or http://www.wncsug.com/default.aspx .

Because of the diverse audience of SharePoint and .Net developers I will be actually combining a couple of presentations topics that include an Introduction to Visual Studio 2010 and SharePoint 2010 and Data Access with SharePoint 2010. Whether you’ve never had the opportunity to develop against SharePoint or your looking to discover some of the new features in SharePoint 2010 data access , such as LINQ to SharePoint and the Client Object Model, this presentation should include some valuable information for you.

On a side note I’m going to be spending an extra day in town so I can do some hiking at Pisgah National Forest on Friday (thinking John Rock and\or Looking Glass Rock – depending on trail conditions). If your into hiking (or even better winter hikes) and you want an excuse to get out of the office drop me a note and maybe we can coordinate.

So please join us! Looking forward to seeing everyone.

Slides and Demos from SharePoint Saturday Virginia Beach 2011

Joshua Carlisle — Mon, 10 Jan 2011 19:29:04 GMT

Thanks to everyone who attended my two sessions at SharePoint Saturday Virginia beach. A really great event, really amazing how many folks showed up on a colder winter weather warning day to learn something about SharePoint! A special thanks to Susan Lennon for putting together such a great event, yet again! I know she’ll say she had lots of help but I say a bridge won’t hold up without a keystone and Susan Lennon was the keystone for this event, big thanks Susan!

As promised I have updated my demo code and slides for my two sessions. They are both available at:

SharePoint & Windows Phone 7

SharePoint 2010 Data Access – A Developer’s Primer

A couple quick notes about the sample code provided in the download:

- There is an included wsp package provided that installs the lists used by the demos. Activate the Josh Carlisle Demo Plumbing feature.

- Both demos have hard coded urls to SharePoint. You should update those url’s to point to your environment.

- The Windows Phone 7 demonstration requires a environment with claims authentication. For further information on how to setup claims authentication using the LDAP membership provider please check this MSDN Blog Post.

If you have any feedback or questions on the demos or the material I presented on I welcome any feedback.

Raleigh Code Camp and SharePoint Saturday Richmond and Virginia Beach

Joshua Carlisle — Thu, 04 Nov 2010 21:18:45 GMT

Are you a .Net developer and live in the Raleigh Durham area? Are you going to the Code Camp this Saturday? No???? WHY NOT!! Code camps are one of the best events for the free exchange of technical knowledge, networking, and just general geek goodness. More details can be found at http://www.codecamp.org and you can register for the event at http://rducodecamp10.eventbrite.com/.

I will be presenting a session on SharePoint 2010 Development – Now With A Great Cherry Taste! This presentation is targeted for developers who have little or no experience with SharePoint and may have been scared off by the previous horror stories of SharePoint development. The developer story is vastly improved in SharePoint 2010 – come check out my session and see if I change your mind . I’m currently scheduled for the last session of the day so before you head off early, stick around for some swag and learn a little bit about SharePoint development.

SharePoint 2010 Development - Now With a Great Cherry Flavor
SharePoint development has often been a tough pill to both swallow and sell. With SharePoint 2010 that pill has become much smaller and with less aftertaste! SharePoint 2010 is now a first class citizen in Visual Studio 2010 and fully supports a greatly simplified development cycle with SharePoint project and item types, designers, "f5" debugging support, automatic package generation and much more. Additionally the OS requirements have been lifted and Windows 7 and Vista are now supported as a development platform. In this session we will provide an overview of the new functionality available in Visual Studio for SharePoint 2010 development and we'll also provide an overview of some of the new tools available to the developer such as the Developer Dashboard.

Additionally I’ll be speaking at a couple upcoming SharePoint Saturday events, my personal favorite community event but I admit to being a little biased.

SharePoint Saturday Richmond - December 4th, 2010
SharePoint Saturday Virginia Beach - January 8, 2011

Data Access with SharePoint 2010 – A Developer’s Primer
SharePoint 2007 only provided a couple core methods for accessing SharePoint list data including the SharePoint Object Model and SharePoint ASMX Web Services. In this session we’ll be exploring the new data access methods including Linq to SharePoint, REST Services, and the Client Object Model for Javascript, Silverlight, and Managed Code.

Windows Phone 7 and SharePoint 2010 – Better Together
Windows Phone 7 is Microsoft’s latest and complete rewrite of its mobile operating system. In this session we’ll be covering the basics of developing a rich user interface solution for SharePoint and Windows Phone 7 using Silverlight and SharePoint REST Services.

Hope to see you there!

SharePoint Smart 404 Project Update

Joshua Carlisle — Fri, 01 Oct 2010 04:44:00 GMT

By now most of the industry is probably aware of the asp.net vulnerability that was recently announced by Microsoft (see Microsoft Advisory for more details) . Of course because SharePoint is just an asp.net application it is affected by the vulnerability as well although the Microsoft SharePoint team blog has announced some specifics steps for SharePoint to ensure the vulnerability doesn’t expose your SharePoint site to the wilds with this vulnerability. The core of the issue revolves around how asp.net presents exceptions and under the right scenarios hackers using the exception information to access restricted files on your site such as the web.config.

From Scott Guthrie’s Blog Post:

“Important: It is not enough to simply turn on CustomErrors or have it set to RemoteOnly. You also need to make sure that all errors are configured to return the same error page. This requires you to explicitly set the “defaultRedirect” attribute on the <customErrors> section and ensure that no per-status codes are set.”

In an additional post he also states:

“If the responses that are sent out from your custom logging module do not let the client distinguish between error responses either through its content or time that it takes to serve out, then such a module is an adequate replacement for the customErrors workaround. These responses include both the entire HTTP response and the HTTP error code. If any of the above is not true at all times, then this is not sufficient. Instead you should send out the same error response for all errors until the security update is available to fix the underlying vulnerability.”

This got me to thinking about one of my projects, the SharePoint Smart 404 Project on CodePlex, which as one of its core components, provides a custom 404 and a custom error handling module which traps unhandled exceptions, logs them, and present the user with a generic friendly error message. The Smart 404 modules do not pass on any http responses, error codes, or exception details to the browser or to the UI. If my understanding of the above statement is correct the SharePoint Smart 404 Project falls into the “safe” category. NOTE: This is not a warranty, just my interpretation of the statement, please ensure you follow the advice provided by the Microsoft Advisory.

I was recently working on some updates in response to some feedback over the last year so I thought this might be a good time to publish the update out and provide some better guidance on how to use and deploy the SharePoint Smart 404 packages\features. The main goal of this release was to improve, simplify, and standardize the deployment experience. Due to the amount of questions related to deployment and functionality I thought a webcast covering the functionality, configuration, and deployment would be helpful.

So just a quick summary of some of the improvements:

- Several aspects of the functionality required elevated permissions including the registration of the custom 404 page and web.config updates. The application is now split between two Features, a web application level feature and a site collection level feature, to support more standard environments that have application pools permissions configured according to best practices.

- Additional configuration items in the web.config are pushed down as part of the feature which will negate the need for manual web.config updates which will indirectly better support larger farm deployments.

- Localization: All literals within the user interface are now driven by resources files. Only US English is deployed with the package but additional resources files to support different locals can be added as needed. (see the webcast for some limitations on deployment to other locals).

The latest packages and code base can be downloaded at http://sharepointsmart404.codeplex.com/. As is always feedback is welcomed.

SPS Baltimore Follow-up And Triangle SharePoint User Group (Raleigh) with Steve Pietrek

Joshua Carlisle — Fri, 03 Sep 2010 14:32:53 GMT

SharePoint Saturday Baltimore by all accounts (and mine personally) was an huge success. Truly one of the nicest facilities and accommodations (especially the lunch!) of any SharePoint Saturday event I’ve been to. Kudos to Eric Harlan, Fabian Williams, and the rest of the crew of volunteers and sponsors. Great Job!

Unfortunately the shorter session (60 vs 75 minutes) and the fact that ice cream and snacks were being given out prior to my session causing a late start which together conspired against me to keep me from finishing off my session – only made it through 3/4 and barely at that – just too much content for 45 minutes. Because of this I’ve just finished off recording a webcast for those folks who would like to catch the entire session. With some minimal editing I should have it up over the long weekend, especially now that the hurricane missed most of North Carolina and I’ll have power (always a good thing!). I’ll have it posted at my blog.

Finally I wanted to give a quick mention to Next week’s Triangle SharePoint User Group speaker Steve Pietrek who will be speaking on Silverlight 4 with SharePoint 2007 & 2010. The genera meeting is held on the first Tuesday of each month which is next Tuesday September 7th. If your in\from the RTP area and want to catch a great presentation you should check it out. More information can be found at http://www.trispug.com.

Lastly I apologize for my lack of posts on my blog, I’ve been working on a community project that in the end will have much more impact on the community as a whole then anything I could probably post on my blog – more to come soon .

Working Around SharePoint Folder Limitations with Custom Actions

Joshua Carlisle — Tue, 20 Apr 2010 19:48:42 GMT

So we all know that folders in document libraries can be very evil things. On the surface they look like a good way to organize files, just like your inbox, but really in the end they just hide things and make it take longer to find what your looking for. It’s typically a better practice to define your site columns and content types for a document and simply filter as needed through the judicious use of views and the list’s filtering/sorting functionality. I generally use that as a rule of thumb when it comes to managing document meta data –no folders if it can be helped.

One area I do make an exception at times with folders is when item level security becomes a requirement. Item level security is a very powerful mechanism to secure your documents on a per item\entity basis but can quickly become both a maintenance burden on the individuals who have to manage the permissions and also a performance burden on the list. As the number of files protected by individual security principal assignments continue to grow performance can decrease. You can mitigate some of the maintenance burden’s with some intelligent post processing and assignment of security through a event receiver or a workflow. You can also reduce the overhead in some scenarios by grouping documents into a folder and securing only the folder and allowing the files within the folder to inherit the permissions of the parent. Less unique permission assignments equates to less overhead. Unfortunately you are also back to your documents being hidden because their meta data that you took so long to define isn’t surfacing through the folder.

One way around this is to sync up meta data from your folder contents to the folder. I don’t particularly like this approach as it duplicates meta data and requires a synchronization process. The common way I get around this is to design a view that removes the folder and only shows the content. It’s really straight forward, out of the box, and is pretty close to being a best of both worlds. Unfortunately one area where it becomes a problem is when you want to get back to the folder view so you can upload documents into the correct folder. An especially important use case when you’re trying to secure documents by placing them in the correct folder. In this case you need to switch to a different view that shows folder, try to remember what the parent folder is, and then hunt for that folder paying careful attention not to place your very important document in the wrong folder – not the best of solutions.

To make this last use case a bit easier to digest for my users we thought it would be helpful to give them a short cut navigation to the parent folder in the form of a new menu option located in the Edit Control Block (ECB) – the dropdown menu displayed when you hover over a list item. We did this through a custom action and some simple javascript. Although it requires a feature to work it is a no-code (compiled) solution so the development effort is quite minimal.

The Solution:

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

<CustomAction
        Id="MyFile.ParentFolder"
        Location="EditControlBlock"
        Title="Open Parent Folder"
        RegistrationType="ContentType"
        RegistrationId="0x0101">
        <UrlAction Url="javascript:function process()
                               {
                                      var itemUrl = '{ItemUrl}'; 
                                      var index= itemUrl.lastIndexOf('/',itemUrl.length); 
                                      var folder=itemUrl.substr(0,index); 
                                      window.location=folder;
                                };
                                process();"/>
    </CustomAction>

</Elements>

Take note of a couple key points:

This custom action will be displayed for any document content type. If you need to be more specific, for example only content types you know will live in folders, then you should specify the content type ID in the RegistrationId element of document content types you are targeting.
The UrlAction makes use of inline javascript and most importantly the SharePoint Custom Action Token {ItemUrl} . This is a variable provided by the Custom Action framework and provides the url of the current item. This is key to parsing the url and building a link to the parent folder.

In the end it allows us to turn this:

Into this:

It’s worth mentioning that there is a great feature in SharePoint 2010 called document sets that may mean once and for all I can ditch the folder when I want to put all related documents into a “bucket” but for the time being in SharePoint 2007 this solution works well for me and has low development overhead. Granted this is a bit of a specific scenario but the subject of folders and SharePoint isn’t rare and its always good to know what your options are.

SharePoint Saturday Charlotte and Atlanta

Joshua Carlisle — Tue, 13 Apr 2010 14:39:42 GMT

I wanted to thank everyone who attended my session at SharePoint Saturday Charlotte last weekend on SharePoint 2010 Business Connectivity Services (BCS). I heard that some folks missed the session because my time got shuffled around at the last minute – sorry about that. I think its the nature of the beast when you get occasional no-shows from speakers and the schedule needs adjusting. I also appreciated the discussion and questions during the session – sometimes the last session of the day can be very quite :) A special thanks out Brian Gough and Dan Lewis for putting another great event together in Charlotte.

My slide deck for the BCS presentation at Charlotte is available here and my demo code can be downloaded here.

Moving onto this coming weekend, to the chagrin of my neighbors, I’ll be getting out of mowing the lawn for one more weekend to present at SharePoint Saturday Atlanta where I know Dan Attis and Lee Reed are working hard to put together a good event as well. It’s been a while since I’ve been to Atlanta so I’m looking forward to catching up with folks. I have two new SharePoint 2010 presentations that I will be giving in Atlanta including:

Feature Framework Enhancements with SharePoint 2010 – 200 Level
Features provide the core provisioning framework for SharePoint. Introduced in SharePoint 2007 Features provide a mechanism to define elements within your SharePoint site. SharePoint 2010 provides several enhancements to the Features framework. In particular the new support for upgrading features. In this session we’ll be covering some of these new enhancements paying particular close attention to the new feature upgrade framework.

An Introduction to SharePoint 2010’s Linq to SharePoint – 200 Level
Querying SharePoint lists through code has historically been a painful process with the CAML query syntax. With SharePoint 2010 we now have formal support for Linq which allows for a SQL like syntax for querying against SharePoint data. In this session we will be covering the basics of using Linq to SharePoint.

Have some feedback or questions on my past\future sessions? Feel free to drop me a comment.

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!