InnerWorkings announced a major addition to its Learning Platform today with the release of self-paced SharePoint 2010 training for professional developers and software teams.

Working in partnership with the USPJ Academy, InnerWorkings is offering world class SharePoint learning solutions to its customers. USPJA boasts a team of industry renowned SharePoint experts whose approach emphasizes the real-world aspects of learning SharePoint — a perfect fit with the InnerWorkings methodology.

InnerWorkings confirmed the immediate release of three SharePoint courses to its Learning Platform, covering the following topics:

• Beginning SharePoint Development
• SharePoint Data View Web Part Basics
• SharePoint Designer 2010 Workflow

Additional SharePoint courses are in development and will be released on a quarterly basis. All of the SharePoint courses include video-based instruction from USPJA experts, hand-picked e-books, and a virtual lab environment to practice important configuration tasks. In addition, a Live Guide feature connects developers and in-house SharePoint experts to facilitate ongoing support and grading of assignments.

“With over 100M users and $1B in revenue for Microsoft, SharePoint is the understated giant of Microsoft’s enterprise collaboration strategy”, said Francis McKeagney, InnerWorkings CEO. “As a server-based technology, SharePoint presents significant challenges to organizations wishing to provide deep, hands-on training to their software teams. We are really excited that our new offering addresses this issue in a rigorous and compelling way. The virtual lab capability, in particular, allows for deep learning in both generic and customizable setups. We are delighted to partner with USPJA to deliver such a comprehensive enterprise learning solution for SharePoint development teams. USPJA’s knowledge and expertise has made this offering possible.”

“The market for SharePoint developers has never been hotter”, said Bjørn Furuknap, USPJA CEO. “We’ve always been extremely confident in the depth and quality of our SharePoint learning solutions, but this partnership with InnerWorkings brings tremendous scale and reach to our efforts. Coupling the technical strength of our training with the online learning expertise and global audience of InnerWorkings is a winning combination. We are delighted to partner with InnerWorkings to offer our combined SharePoint learning services to a huge audience of SharePoint developers and teams hungry to succeed in their chosen area of domain expertise.”

About InnerWorkings
At InnerWorkings, our mission is to help our customers build great software organizations. We believe that it is possible to create a successful, efficient, and cost-effective software organization and sustain it over multiple projects. How do we do this? By providing software executives with an integrated platform to improve learning, collaboration, and software processes across your development teams. The company’s R&D facility is based in Dublin, Ireland and InnerWorkings maintains its corporate headquarters in San Francisco, California. For more information about InnerWorkings and its services, visit www.innerworkings.com.

In this issue, among other things, you can read the following articles:

• SharePoint Maturity Model: Does your intranet sound like a dial tone?
• New Column: SharePoint Hegemony with Christan Buckley
• Developing your own Silverlight Web Part
• SharePoint Web Part Development – Chapter 1
• SharePoint Tidbits for End Users

Subscribers may download the issue from here.

Thanks to ShareVis, InnerWorkings, ShareGate, and USPJ Academy for being sponsors of this issue.

Enjoy!

If you do not have a paid subscription, you can purchase or renew your subscription from the Subscription Page.

In SharePoint 2010, we can develop two different types of web parts: a visual web part or a classic web part. With a visual web part, we can design the user interface within an .ascx user control. This control is then loaded in the web part infrastructure when the web part is loaded to the SharePoint page. The .ascx user control is typically deployed to the CONTROLTEMPLATES folder of the SharePoint 14 hive.

The classic web part is the web part we still know from the SharePoint 2007 era. In general, you will develop visual web parts because they are easier to create, but in cases where you have to work with sandboxed solutions, no files can be deployed to the file system, so you will have to develop a web part in the classic way.

Creating Your Own Visual Web Part

If you need to pass extra information to the Silverlight application that cannot be handled by the out-of-the-box Silverlight application, you can create your own web part. In this article, we will build our own visual web part hosting the services banner we created in the previous article, “The Silverlight Client Object Model.” In next article, we will extend that visual web part with a custom tool pane where the user can choose the color of the service item controls. The color picker in this custom tool pane will also be a Silverlight application.

You can create a visual web part using the SharePoint 2010 tools for Visual Studio 2010.

When looking at Solution Explorer, you will see that the Visual Web Part is created with a number of files. The ServicesBannerVisualWebPart.cs class contains the code to load the user control ServicesBannerVisualWebPartUserControl.ascx. It is in this control that the user interface elements will be defined.

To be able to render a Silverlight application, a number of HTML elements must be added to the page. The Silverlight control itself is an <object> tag that must be rendered within a <div> element with a well-defined width and height. This width and height can be relative or absolute. Also, the <object> element must specify a width and height; otherwise, the Silverlight application will not be visible. The <object> element contains a number of <param> elements with name and value attributes.

• source: The value indicates the location of the Silverlight application. The out-of-the-box Silverlight application lets you specify your own location, but this example specifies the Silverlight application from the previous article, which is located in the XAPS library.
• initParams: The value of this element depends on which information you want to pass to the Silverlight application when it initializes. The services banner requests that the name of the Service Offering list is passed, but this value is constructed dynamically when the web part loads, which is the reason for the value=”<%= InitParameters %>” /> notation.
• the minRuntimeVersion and autoUpgrade attributes are also required, but their values are predefined and cannot be changed by you.
• Some Silverlight applications also have an onError parameter, requiring a Javascript function treating errors.

   <asp:Panel ID="SilverlightPanel" runat="server" >
     <div id="silverlightControlHost" style="width:100%;height:150">
       <object id="SLServicesBanner"
               data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">
           <param name="source" value="/XAPS/Sample2.ServicesBanner.xap"/>
           <param name="initParams" value="<%= InitParameters %>" />
           <param name="background" value="white" />
           <param name="minRuntimeVersion" value="4.0.50401.0" />
           <param name="autoUpgrade" value="true" />
           <a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=4.0.50401.0" style="text-decoration:none">
              <img src="http://go.microsoft.com/fwlink/?LinkId=161376" alt="Get Microsoft Silverlight" style="border-style:none"/>
           </a>
       </object><iframe id="_sl_historyFrame" style="visibility:hidden;height:0px;width:0px;border:0px"></iframe>

     </div>
   </asp:Panel>

The code behind this user control contains a Page_Load event. It is this event that is responsible for rendering the Silverlight application. It verifies whether the initParameters variable is properly filled out; if so, the Silverlight application is rendered in a panel. If the initParameters value is empty or doesn’t contain the list parameter, a message is displayed instructing the user to open the web part tool pane in order to fill out the required Silverlight properties. You can use an out-of-the-box JavaScript function to open the tool pane.

   protected void Page_Load(object sender, EventArgs e)
   {
      if (string.IsNullOrEmpty(initParameters) || !initParameters.Contains("list="))
      {
         SilverlightPanel.Visible = false;
         openEditorPartControl = new LiteralControl(string.Format(
              "To show a Silverlight control <a href=\"javascript:MSOTlPn_ShowToolPane2('Edit','{0}');\">open the tool pane</a> and set the Silverlight properties.",
              webPartID));

         this.Controls.Add(openEditorPartControl);
      }
      else
      {
         SilverlightPanel.Visible = true;
      }
    }

The InitParameters property is filled from within the ServicesBannerVisualWebPart.cs class. While the ascx user control takes care of the rendering of the visual elements, this ServicesBannerVisualWebPart.cs class  represents the web part itself. You first have to define a property that can be set from within the tool pane of the web part. It will be displayed in its own category, Silverlight Properties:

   [System.Web.UI.WebControls.WebParts.WebBrowsable(true),
   Category("Silverlight Properties"),
   DefaultValue(""),
   System.Web.UI.WebControls.WebParts.Personalizable(
   System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared),
   Description("Specify the InitParams string to initialize the Silverlight application.")]
   public string InitParameters
   {
       get { return initParameters; }
       set { initParameters = value; }
   }

The web part class also contains the classic CreateChildControls method with some predefined code loading the .ascx user control, which is of base type Control.

   protected override void CreateChildControls()
   {
      Control control = Page.LoadControl(_ascxPath);
      Controls.Add(control);
   }

Because we want to pass information to the InitParameters property in the user control, we have to modify this code slightly in order to load and render the more specific ServiceBannerVisualWebPartUserControl (a name created by the Visual Studio 2010 templates). When the control is loaded, the web part ID and a value for the InitParameters property is passed. The web part ID is needed when the user control needs to display a message that the InitParameters property is not properly filled out.

   protected override void CreateChildControls()
   {
       //Control control = Page.LoadControl(_ascxPath);
       ServicesBannerVisualWebPartUserControl control = this.Page.LoadControl(_ascxPath) as ServicesBannerVisualWebPartUserControl;
       if (control != null)
       {
           control.WebPartID = this.ID;
           control.InitParameters = BuildInitParameters();
           Controls.Add(control);
       }
   }

The value for the InitParameters property is constructed within a private method BuildInitParameters and needs an extra word of explanation. As we saw in the previous article, “The Silverlight Client Object Model,” you can use the ClientContext.Current to get a hold on the SharePoint context. Under the hood, the Silverlight application needs a parameter with name MS.SP.url passed in via the InitParameters. When using the out-of-the-box Silverlight web part, this parameter is passed automatically, but when developing your own custom web parts, you have to pass that parameter yourself. If you don’t pass the parameter MS.SP.url, your ClientContext will be null.

The ServicesBanner Silverlight application also requests the list parameter to be passed, but this one needs to be passed by the user in the tool pane of the custom web part.

   private string BuildInitParameters()
   {
       if (string.IsNullOrEmpty(initParameters))
          initParameters = "MS.SP.url=" + SPContext.Current.Web.Url;
       else if (!initParameters.Contains("MS.SP.url"))
          initParameters = initParameters + ",MS.SP.url=" + SPContext.Current.Web.Url;

       return initParameters;
   }

Deploying Your Visual Web Part

Your web part is now ready to deploy. If you want it to appear in its own category in the Web Part gallery, you will have to modify the .webpart file. You can also do the necessary customizations to the feature file. Once your web part is deployed, you can add it to a web part page. You will have to click the hyperlink within the message displayed under the web part title. This is because the list parameter is missing from the InitParameters string.

When you’re in the web part tool pane, locate the Silverlight Properties section and add the string list=Services Offering to the content of the text box. Don’t forget to add a comma without a whitespace to separate the two parameters:

Click the Apply or OK button to render the Silverlight application within the web part.

Conclusion

In this article, I explained how you can develop your own visual web part to host a Silverlight application. In next article, I will explain how you can create a custom tool pane that hosts a Silverlight color picker.

For many years now I have maintained a blog that focuses on SharePoint administration. I use it mainly to document tasks I’ve done or to explain weird behavior of SharePoint. If my mother is to be believed, it could possibly be the best blog on the Internet. Taking my mother’s words to heart, I refer people to my blog often.

SharePoint’s URLs have always been a bit unwieldy, but for the most part these references were in email or on web pages, where the long, scary URL could be hidden with a hyperlink. Then along came Twitter and URL-shortening services like Bit.ly and tinyurl. Now SharePoint’s long URLs were no longer just unwieldy; they were flat out uncool! Tweets are limited to 140 characters, and a link to one of my blog posts was 59 of those precious characters. Factor in the @ reply characters, and I’d barely have enough space left to explain how great the linked blog post was.

This was how I got started down the road of investigating URL shorteners in SharePoint and how I arrived at SharePoint ShortUrl from SharePoint Sense.

Full Disclosure:

The story you are about to read is true, and the facts surrounding it are 100 percent accurate. However, I feel I must make it clear that the folks at SharePoint Sense did provide me with a free copy of SharePoint ShortUrl. They also promised me a huge check and Internet stardom for writing this review. I anxiously await both. I did write the article without any input or editorial demands from them. They’re good software developers and all-around good people.

Wandering in the Desert

Once I decided that my SharePoint URLs had to go on a diet, I needed to decide which diet was best. First I tried to roll my own. I dusted off my ISO of Visual Studio 2010 and tried, fruitlessly, for several days to cobble together a solution. I even tried wiring something together with query string web parts and bubble gum. No dice. It became clear to me that developing software was complicated work and I should stick to clicking Next a lot and installing SharePoint.

My next attempt was using the IIS Rewrite tool. This tool is a free add-in for IIS 7 and 7.5 that allows for all kinds of great rewriting functionality. Unfortunately, I wasn’t able to find the correct combination of tools, rules, and guesswork to make it behave the way I wanted. It also saves its configuration to the web.config file, which would mean I’d have to configure each web front end individually. My blog, massive as it is, needs only one WFE for now. But my mom and I have big plans for it, and someday it may require two. Having a solution that scales is important when you’ve got big plans like I do.

My last futile attempt at URL shortening was to try some free software I found on CodePlex. As with a lot of CodePlex projects, it had some rough edges. It was also written for SharePoint 2007. I contacted the author, and he said it should work find on SharePoint 2010, but he hadn’t tried it. I played with it a little, but it wasn’t very customizable, and I got cut on the rough edges a couple of times. I found some Band-Aids, dried my eyes, and started thinking about Plan B.

Plan B: Letting the Experts Do It

After trying to create my own SharePoint URL software, two things were very clear to me. First, I will never be able to feed my family by becoming a software developer. Second, finding software to shorten my SharePoint URLs was best left up to the professionals. I did a few searches to see what solutions already existed. SharePoint ShortUrl from SharePoint Sense kept coming up. I decided to give it a shot. I contacted the chaps at SharePoint Sense, and I was able to sweet talk them into giving me a demo license. I think it was my mom’s recommendation that really sold it. It was on that day that my love affair with SharePoint ShortUrl began.

While the installation was not simply a WSP solution file to install, it did use a standard SharePoint installer. The installation was painless, and all I really had to tell it was which web applications I wanted the ShortUrl Feature installed to. After the installation was complete, I activated the Feature and started kicking the tires a bit.

Kicking the Tires

SharePoint ShortUrl has a few ways you can use it for your URL-shortening needs. You can enable the Features that correspond to the functionality you want. In my case, this was for an anonymously accessed blog, and I needed short URLs only for specific blog posts and various other files. I decided to only activate the Features that allowed me to create one-off short URLs. Figure 1 shows the Features that are scoped at the web level of my blog.

Figure 1: Web Scoped Features

You can see that I’ve activated only one of the Features, ShortUrl Activation. Like the description says, this adds the ShortUrl links to the Site Actions menu and all the document menus, and it’s the basis for all the other ShortUrl functions. With that Feature active, I can now go about creating all the short URLs that I’ve been craving. In my case, the goal was to create short URLs to specific blog posts so they could be easily referenced in places like Twitter. To do that, I just needed to navigate to the blog post itself and click the Site Actions menu and then click “ShortUrl this page.” Figure 2 shows the menu options ShortUrl creates.

Figure 2: Shortcuts on the Site Actions menu

After I clicked that menu item, I was taken to the screen in Figure 3. Like any good URL-shortening software, ShortUrl automatically creates a random short URL for the page. It also allows you to replace it with something more meaningful, as I did in Figure 3. You also have the option for assigning an owner of the ShortUrl, and you can make it expire as well. In my case, neither of those made sense, so I left them at their defaults and clicked Save This Url.

Figure 3: Creating the ShortUrl

The folks at SharePoint Sense know that creating the ShortUrl is only part of the battle. In order for the ShortUrl to do anyone any good, you have to be able to share it. That’s where the screen in Figure 4 comes into play. After the ShortUrl is created, you have some options to get out the good word. You can copy the ShortUrl to your clipboard or email it to someone. If you have ShortUrler’s Remorse, you can also delete it, but who would want to do that? To get past this page, you have to click Cancel, which seems odd. Clicking a button that says OK seems like it would make more sense. Clicking Cancel makes you wonder if you aren’t canceling the whole process. I assure you, it doesn’t.

Figure 4: Sharing the ShortUrl

After you click Cancel, you’re taken back to the page you ShortUrled. In my case, that was a blog post. That’s all there was to it. At that point, I leaned back, put my feet up on my desk, and basked in the afterglow of the victory of finally successfully shrinking a SharePoint URL.

As we’ve seen, creating ShortUrls for blog pages is a pretty simple task. Creating ShortUrls for documents or list items is just as simple. Figure 5 shows the how the item drop-down menu includes new links for the ShortUrl software. Clicking them walks you through the same pages we saw in the figures earlier.

Figure 5: ShortUrls are for documents, too.

Managing ShortUrls

I was impressed with many aspects of ShortUrl. One of those aspects is that SharePoint ShortUrl is written as SharePoint software, and it stores all the ShortUrls as items in a SharePoint list. When the ShortUrl Feature is activated at the Web Application scope, a list named “shorturl” is created at the root of the web application. That list stores all the ShortUrls and allows some management of them. Figure 6 shows the shorturl list from my website. Not only does this list give you the obvious information about the ShortUrl, like the ShortUrl and where it points, but it also adds a HitCount column, as well as a link to open the URL. If you want to delete a ShortUrl, you can simply delete it from this list, like you would any other SharePoint list item. Backing up SharePoint also backs up all your ShortUrls, so there’s nothing new to add there.

Figure 6: The shorturl list

Support

It’s a sad fact, but software isn’t perfect. OSs have exploits that need to be patched, browsers have security holes to close, and for some reason my MP3 player refuses to play Barry Manilow songs. While it would be great if software didn’t have bugs, that expectation isn’t realistic. With that in mind, when I’m evaluating software, or hardware for that matter, I always try to get an idea what the service on that software will be. SharePoint Sense exceeded my expectations in this regard. When I was testing their software, I noticed a bug. When an anonymous user clicked a ShortUrl, they were prompted for authentication. After some testing, it turned out this was because of how ShortUrl updated the Hit Count for the ShortUrl. ShortUrl was not written for anonymous sites in mind. It was written with internal users in mind, I was trying to use the software in a way it wasn’t necessarily intended. I reported that to the SharePoint Sense folks and thanked them for allowing me to test their software, but unfortunately it wasn’t a good fit. About a week later I got an email back from them; they had fixed the bug and wanted me to take another look at the software. I was amazed by this. Not only was my use case not what the software was designed for, but even if I loved the software, they had given me a free license, so there was no money in it for them. The only thing they stood to gain was my undying gratitude and admiration. The fact that they followed up on it makes me think they’ll attack any other bugs they find with the tenacity of a British bulldog.

Convinced Yet?

I’m a big fan of the ShortUrl software. It does exactly what I want, and it does it easily and without any negative side effects that I’ve discovered. Now the URLs for my blog that I put on slides at conferences or on Twitter are smaller, look better, and are easier to remember. As a SharePoint consultant, I routinely recommend ShortUrl software for customers who are looking to give SharePoint a more professional appearance.

Read more about SharePoint ShortUrl at the web site http://sharepointshorturl.com/

The first mistake you made was ignoring the advice you received from Microsoft, from your consultants, and from the expert community, to build out a governance strategy as part of your overall SharePoint planning. Like flood insurance, most people don’t think about governance until they’re waist-deep in SharePoint sprawl and waking up at night in a cold sweat with change management nightmares. Don’t get me wrong—you probably have really smart administrators and developers who know the technology inside and out. And yet here you are, wondering how you’re going ever to clean up, get things organized, and get your SharePoint environment back on track.

There’s the real issue. In your head you’re thinking “Yeah, I need to insert some governance, and that’ll fix everything.” But you have no idea what it is. Or where to start. Or whether the things you do now will have any impact.

The fact is that governance has less to do with the technology and more to do with defining your goals for the system and how you plan to proactively manage SharePoint toward meeting those goals. Governance has as much to do with defining the business values you’d like to achieve as the day-to-day tactical steps of monitoring and managing your platform. But most companies don’t think this broadly. They see it as a set of policies and procedures around things such as content database size, permissions management, and compliance monitoring. If you’re like most companies, you don’t have a plan for how you engage with your users, you don’t have a method for tracking and measuring the value of your SharePoint initiatives, and you don’t have a procedure for how to engage with your leadership team. But those are all critical aspects of a successful governance strategy.

So, admit it. Admit that you have no idea what governance is and that you are powerless. It’s the first step in the 12-step program toward governance sobriety, and I’m here to help you through it.

Seek to Understand

Everyone is talking about SharePoint governance these days. The topic is popping up at SharePoint events around the globe, with the search term SharePoint governance returning 3,220,000 results on Bing. Even those who are known more for their deep technical expertise are being drawn into the conversation and are sharing their limited perspectives on what governance means to them and how it should be managed (usually at a very granular level) within SharePoint.

Your corporate governance strategy is an organized, orderly way to approach business problems and quickly come to an agreement on solutions. In a perfect system, it would be part of your company culture, where everyone is involved (at some level) in the decisions being made around IT. Unfortunately, most governance models fall short of what is needed for the organization, if it exists at all.

The primary reason governance has become the topic du jour is because of the SharePoint history associated with end user adoption. We are having a discussion at this point in SharePoint’s maturity because the platform has grown so rapidly—both as a product in Microsoft’s portfolio and within the organizations where it has been embraced by passionate end users. Although sales of SharePoint licenses may be reaching a certain saturation level, licenses sold don’t always equal platform deployed, much less end users fully engaged. As user adoption increases, the platform reaches the limits of its default settings, introducing concerns around managing and scaling the platform, business productivity, and, inevitably, governance issues. More end users on the platform + more activity per user = more companies needing to think about proper SharePoint management and governance.

The purpose of governance in an organization is to create a decision support system to encourage desirable behaviors in system usage. Properly designed governance models follow a specific strategy, such as better customer responsiveness, improved innovation, or identification and measurement of the cost effectiveness of your IT programs. Successful organizations are proactive in their design and use of a governance infrastructure, including committees, financial reviews, approval workflows, and other organizational tools that drive the decision-making process. An effective governance model will help your company manage and measure your systems and will play a significant role in helping your IT organization perform its role in the company’s competitive strategy.

A broad governance model also helps the organization to recognize cost, time, and technology benefits across the entire system, instead of requiring teams and business units to track and measure on their own—which can lead to imbalanced and improper resource allocations. A properly constructed and executed governance framework provides your company with a decision support system for managing IT projects successfully.

We’ve all heard the complaints: “We spend so much time on process, but I just don’t see any value here,” or “I’m not going to waste another dime on this black hole.” Your governance framework should be one of the core components of your organizational nervous system. These kinds of comments may indicate poor visibility into the process or—more likely—an immature (or nonexistent) governance model. As with any business activity, building without a clear purpose, defined roles, and some sense of what the end result should look like might just be a big black hole.

Value Creation

Many organizations have a difficult time evaluating the business value of their IT projects. Expanding SharePoint may fall under this description and raise questions from the business—whether adding new servers to improve performance (Do we really need to buy more hardware?), add new or improved functionality (Why do we need FAST? Doesn’t SharePoint already include search?), or customize SharePoint to meet specific business needs (Why are we building that in SharePoint when we can go buy another tool?). Historically, IT organizations cannot readily demonstrate the return on investment for these activities, which impacts executive buy-in as well as end-user support. Executives want to see that they are getting the biggest bang for their buck. End users want to know that the tools you provide will solve their business needs. You want a way to demonstrate value to both.

Value comes from three activities:

• By incremental improvements to the system over time
• By stretching your team, your processes, and your technology to meet customer demands.
• By responding to competitive demands

But it can be difficult to measure these values prior to development. While SharePoint offers a quick and relatively inexpensive way to build out a proof of concept (PoC) before going down the path of a full-blown development effort, you still need a way to identify the problem to be solved, organize and articulate the measurements, and then drive the review process.

There are some key components to successful governance:

• For one, it requires senior management leadership. They must understand and agree to the framework and drive accountability through all levels by following the recommendations that come out of the framework. Nothing will cause your process to lose legitimacy more quickly than the executive override.
• On that note, the process should be transparent so that everyone understands and follows the process and gets behind the end result.
• Following closely on the heels of transparency is a change management mechanism, which is the key to gaining end-user support. Give people a voice, and they are more likely to accept the changes that occur.
• Successful governance empowers decision making at lower levels, distributing accountability and control broadly to the teams that own the action—and are impacted by the decisions that are made.
• Finally, governance frameworks should be continually improved so that users don’t “game” the system and so gaps can be filled as they are identified. Transparency here is also essential—tweaks and changes to the process should also be visible and broadly communicated.

A successful governance framework helps show value by providing a framework through which these POCs can be tracked, measured, and evaluated to help demonstrate value. It provides a common denominator—a sandbox, if you will—for system planning.

Governance Applied

For the most part, governance has absolutely nothing to do with SharePoint. These are the same rules and procedures that should be in place for every enterprise application or system. Your SharePoint governance activities should be a reflection of your broader IT governance framework, allowing you to trace the path between SharePoint activities and your high-level corporate strategies.

Corporate governance influences many factors within IT, and a strong IT governance model will help your organization to effectively manage SharePoint, influencing/managing/enforcing the following:

• How SharePoint is used within the organization
• How SharePoint is architected
• How SharePoint infrastructure is deployed
• How SharePoint meets specific business requirements
• How the company invests in and prioritizes SharePoint requests

How you execute your governance strategy inside SharePoint depends entirely on the details surrounding your corporate and IT governance framework. The reality is that some of the decisions you make about how to manage SharePoint will be very difficult to execute based on certain technology limitations in the platform. Although these granular items are not the point of this introductory article, I will be addressing some of these things in future articles.

The goal of this article has been to help you understand the what about governance. My next installment will address the who.

What Is a Site Definition?

The best way to think about site definitions is to envision them as master site templates for your SharePoint environment. No, these aren’t the site templates you find in your site collection’s template gallery. The site templates you create and store in your gallery have their place in SharePoint processes but are localized to the site collection level. Site definitions are holistic to the entire environment. They can standardize your SharePoint look, feel, operation, and purpose. Consider Microsoft’s PowerPoint application. Once installed, you can use PowerPoint, but you’ve got nothing in there but a plain, white master slide. Even more critically, your presentations lack direction. Now apply master slides, and you get a standard look, feel, and purpose for your presentation. SharePoint is much the same. Upon installation, you’ve got a few standard out-of-the box definitions (team sites, blank sites, meeting workspaces, and so on) that are packed with all the collaborative capabilities you need at your fingertips, but they are not tailored for your business. By customizing existing site definitions or creating and adding new ones, you can create the master templates you’ll need to make SharePoint work for your company.

How Do These Site Definitions Work?

In a nutshell, when you create a new site, SharePoint will reference a master list of site definition configuration files. From there, it looks for the selected WEBTEMP.xml file and the respective folder containing the actual site definition.

This will give you a new site that appears to have its own unique pages. However, the pages are actually shared across all sites that use that definition. When you customize site definitions for your company, you are actually duplicating the WEBTEMP.xml file, renaming it, assigning it a new ID, and creating its matching site definition directory in the proper location along with all the changes you want for that specific definition. This allows it to be referenced during the site provisioning process. As a result, you are using this referencing process to optimize SharePoint’s performance by minimizing duplicate files, which are often referenced as “unghosted” sites.

Site definitions are stored in the following location:

C:\Program Files\Common Files\Microsoft Shared\webserver extensions\60\Template\SiteTemplates

The WEBTEMP file is stored in the following location:

C:\Program Files\Common Files\Microsoft Shared\web server extensions\60\Template\1033\XML

Here’s the winning difference between site definitions and site templates. Along with performance optimization, SharePoint site definitions are a very powerful way of ensuring that updates and changes reach all your sites. For example, if you create 100-plus sites using the same site definition, you can then push out any changes, such as a new logo, new content type, and so on, to all sites by updating a single .aspx file. The opposite would be true for site templates where each site created with the site template would have to be updated individually.

Numerous components of a site definition are available for customization. Some of these include the following:

• Branding: The general look and feel of the site, including logos, color schema’s graphics, and more.
• Site provisioning: The available site definitions that can be referenced as subsites. This proves useful for industries wanting to centrally locate certain sites with specific purposes.
• Permission levels: Many companies find the permission levels inside a standard site unnecessary and not applicable to their governance or business needs. Custom site definitions can remove unnecessary permission levels and add new ones.
• Site columns: Some industries are subject to mandatory compliance standards, such as the Privacy Act, security classifications, and more. Many of the out-of- box site columns cannot be used in these industries. Site definition enables you to remove unwanted site columns and add custom ones that are better suited for your business’ needs.
• Content types: Standardize your content types and tailor them for your environment.
• SharePoint groups: Provides a blueprint for which groups are created and what permission levels are automatically applied to those groups.

There are a lot of standard approaches to customizing site definitions. When considering what should go into a new site definition, it is best to first evaluate what comes standard with the out-of-box site definitions. Then, you can remove any unwanted materials and add where needed.

I know my own name: Bjørn Furuknap (technically, it’s Bjørn Christoffer Aulie Thorsmæhlum Furuknap).

I am currently sitting in my home office in Oslo, Norway, and it’s Monday afternoon (5ish p.m.).

So, I am not mad, at least not more than usual, but I’ll still argue that lists and libraries make no sense in SharePoint.

SharePoint Lists and Libraries as Taxonomy Features Considered Harmful!

Before we become further acquainted, let me clarify the title slightly. Lists and libraries are mandatory in SharePoint, but you should never use them to classify content. Let me elaborate on what that means.

Before the days of content management, we had file shares, with the idea of storage location as the taxonomy option of choice. After all, beyond filenames, storage location was the only option.

The idea was as simple as it was a bad idea. You created hierarchies of drives, shares, and folders to structure the content you wanted to store. Put your content inside said folders, and poof, you had an archive of sorts.

However, when you stop to think about it, this is an incredibly stupid idea. Consider the following folder structure, epitomizing the idea of location as taxonomy:

Essentially, you start at the root with a Clients folder, containing in turn one folder per client, which in turn contains folders for the various types of documents.

This isn’t a bad idea, but the implementation is horrible.

First, this structure makes it very difficult to find all the invoices for all the clients, except if you were to use filenames as an additional taxonomy element (in itself a rather ludicrous idea, but I’ll get to that in a moment). The problem is that you can only ever store a file in one location, so if a file needs two taxonomy definitions, for example being classified both by type (invoice) and by year (2010), you’re out of luck.

Granted, there are ways around these issues. You could use the created date of the file to classify it by year, hoping that nobody ever copies the file to a different location. In Windows, you can also use shortcuts, or in Linux a symlink, but basically those options force you to retain a file in a specific location forever, lest the links break loose, along with all hell.

Second, and this is the important bit, you say that “Inside this folder are invoices,” but frankly, it’s only the discipline of users that makes this true. Were I or anyone to put images of my pets inside those folders, those pictures wouldn’t turn into invoices, would they? Of course not, that’s a silly idea! Everything remains what it is, regardless of where you store it.

A Coffee Cup Is a Coffee Cup

Let me explain with another example. On my desk I usually have at least two glasses of water, and I mostly keep them together on the left side of my desk. The glasses contain water, which glasses of water usually do. Nothing magical or earth-shattering, really.

I also drink at times insane amounts of coffee, even for a Norwegian. When I’m working actively, I often drink 15 to 20 cups per day. I keep my cup of coffee on the right side of my desk, simply because drinking coffee is more of a ceremony and requires more attention than drinking water, and thus I want to interrupt whatever it is I am doing while drinking coffee. When I need to use my right hand, that means I can’t use the mouse while drinking coffee, creating a natural break, albeit only for a few seconds.

However, if I were to change this scheme, and to be honest I often do, it would not create chaos. My coffee wouldn’t suddenly turn into water simply because I put the coffee container where the water container usually resides. The break I need to take to avoid burning my lips off is still required of the coffee but not of the water. The coffee doesn’t change simply by putting it in another location. It is what it is.

That’s Why We Have Filenames!

In the previous folder example, we can assume that something is not an invoice if it was named something like “Pet Picture 0001.jpg,” even if it was stored inside the invoices folder. Similarly, we can assume that something is an invoice if it was called something like “Invoice 0001.pdf.” We’ve been doing this for decades, identifying file contents based on the names.

The use of filenames and our incredibly naïve trust of filenames as indications of content is a problem, though, because the filename isn’t at all a decisive factor in the content of the file. If I were to put a Post-it note on my coffee cup with the words “Glass of Water,” the coffee cup would still remain a coffee cup. If you name your pet pictures “Invoice 000N.jpg,” they are still pet pictures.

However, most of us would still blindly believe that the content was an invoice and happily open the file. This has been used successfully by malware authors also for decades, for example in the Anna Kournikova virus, where recipients were tricked to believe that a file with a certain name contained certain content. It did not.

Filenames, in fact, are also rather ancient and should not be necessary.

Fine, They’re Documents!

Hold your horses a bit. In SharePoint, with a team site, we get a Shared Documents library. We can create additional document libraries extremely easily. However, this is actually just as silly, once you start thinking about it.

Most organizations work to a much greater extent with logical entities than they work with documents. An employee isn’t a document nor are the lunchroom chairs or the CEO’s parking space. Our clients aren’t documents nor are the invoices we send.

“Hold on!” I hear you say, with my superhuman hearing, knowing full well that you likely didn’t even think that. “An invoice is exactly a document, and it’s what I send!”

Well, you may think you send invoices as documents, but in fact, those documents are really just manifestations of the entity that is the invoice. The invoice itself is actually defined as several metadata properties, such as the invoice number, the line items, the sum, and the due date. Those pieces of metadata are the actual invoice; the paper on which you print the invoice is simply a carrier of that metadata information.

In fact, prior to printing specific metadata information on it, the paper is simply pulp. Without the specific pieces of metadata required to make the paper an invoice, the only way you can categorize the paper is by “Paper.” Imagine the archiving nightmare if everything was simply categorized as that.

Calling something paper is about as useful as calling something a document. It adds absolutely nothing of value, no more than calling something “an item.” That’s why I hate the idea of having “Shared Documents” in a team site.

Consider this: replace the word Document from use in SharePoint with the word Paper. Both are equally meaningless in a taxonomy sense. Doing so leaves you with “Shared Paper,” a “Paper Library,” “Paper Sets,” and “Paper Information Panel.” See how silly it sounds?

Granted, there is a slight different between paper and document, but the point remains; neither says anything about the contents and describes only the form or carrier.

So, What’s So Perfect Then?

The purpose of this article is primarily to show you how ridiculous the idea of location as a taxonomy feature really is and additionally show you how the default mind-set of many SharePoint installations really serves more to confuse than to clarify. We shouldn’t work with “documents” anymore; we should work with “Invoices,” “Contracts,” “Clients,” and “Employees.”

For this purpose, SharePoint has the coolest little invention called content types. In essence, content types are, you guessed it, types of content, such as “Invoices,” “Contracts,” “Clients,” and “Employees.” In fact, if you’re curious about what these weird little creatures really are, there’s already an article on SharePoint Magazine titled “SharePoint Content Types:  Why Should I Care?”

In closing, however, I would like to mention this: in most of the projects in which I am involved, I end up creating custom lists and document libraries far more than any of the other types of lists and libraries. I’ll talk more about that in a future article.

.b

• jQuery Core
• Selectors
• Attributes
• Traversing
• Manipulation
• CSS
• Events
• Effects
• Ajax
• Utilities
• jQuery UI

Events

As your users interact with pages in their browser, various events occur. The most familiar to you might be the click event or the hover event. However, the JavaScript event model provides you with a whole range of events into which you can hook your own script. This lets you set things up so that the page reacts to what the user is doing. You see this all the time on web pages, but may not give much thought to how it actually works. jQuery builds upon the JavaScript event model, providing a clean abstraction and making it far easier to react to events.

The JavaScript events that are available to you for any particular element in the DOM vary with the element’s type. You will want to learn what events are available for each type of element, because not all events are available for all elements. I frequently use the w3schools.com site to look up information about JavaScript events (and many other things), if you are looking for a good reference.

Let’s take a look at a simple example, as usual. Say that you would like to show the user an alert when they click the title of a web part (not terribly practical, but it shows the concept). The following code selects for the web part titles on the page—yes, all of them at once—and then binds to the click event for those H3 elements. When the user clicks any of the titles, they will see the alert.

$("h3.ms-WPTitle").click(function() {
 
alert("You'll now be taken directly to the list.");
 
});

The same script should work in SharePoint 2007 or 2010. In addition, if the title is a hyperlink to the default list view, they will still end up there after they close the alert.

That is a basic little example, but it should show you how you could start to think about what a user does in their browser and how you might want the page to react to those actions. We could choose to bind to different events for the same web part title, too. For instance, if we replace “click” with “mouseover,” then we will get the alert whenever we put the cursor over the text.

$("h3.ms-WPTitle").mouseover(function() {
 
alert("You just put your cursor on me.");
 
});

You can see all of the available events on the Events documentation page on the jQuery site.

Effects

With effects, you can make things happen, like you can by changing element attributes. jQuery’s effects may be what most people think of when they hear about jQuery. They include such nice stuff as fading in or out, sliding up or down, and animation. These effects are difficult to show you in a text article, so you’ll have to take my word for some things, but even better, you should try them yourself.

Showing an alert like I did previously is not likely to be a big goal; instead, you can execute any script you want in the function you have bound to the event. For instance, you might want to expand or collapse part of the visible page content based on the user’s click. This is where effects can come in.

Take a look at this example code:

$("h3.ms-WPTitle").find("nobr").unwrap("<a></a>");
 
$("h3.ms-WPTitle").click(function() {
 
$(this).closest("table").closest("tr").next().toggle();
 
});

Here I am first removing the hyperlinks on all of the web part titles using the .unwrap() function (just so that I stay on the page when I click them). Next, I am binding to the click event on those titles (as I did earlier). The new piece is that I am then traversing up and across the DOM to find the table row that contains the web part body, and then I’m using the .toggle() function to collapse or expand the contents. (I have tested this script in both WSS 3.0 and SharePoint 2010 with a few common List View web parts.)

The .toggle() function figures out whether the selected element is visible or not and switches the visibility. This nets out to each web part expanding or collapsing—based on its current state—when I click its title. This is a nice little trick to gain some screen real estate for the user. Of course, you would probably want to dress it up a little bit with some nice icons and such in a real situation.

This simple script should give you a glimmer what you can start to do with effects. This is the sort of enhancement I often talk about to make the page feel more “tactile” for the user. Rather than clicking a setting and waiting for a postback, we can make changes to the page in real time with jQuery; they end up interacting with the page rather than the server.

The following are other useful effect “families”:

.hide(), .show(), .toggle(): These three functions simply change the visibility.

.slideUp(), .slideDown(), and .slideToggle(): These functions slide elements up or down and work best with divs.

.fadeOut(), .fadeIn(), and .fadeToggle(): These functions fade elements in or out, basically animating their opacity from 0 to 100 percent, or the reverse.

.animate(): With animate, you can “move” CSS properties from one value to another over time. By combining changes to multiple CSS properties into a single animation, you can do things like moving elements around the page, increasing or decreasing them in size, or changing their color or shape.

Summary

By attaching your script to events and using effects, you can provide a high level of interactivity for your users. They are used to seeing these sorts of interactions on other commonly used websites, and by using them in SharePoint, you can improve the overall user experience. By carefully using selectors and traversing to locate the right elements in the DOM, you can react to user actions and alter the DOM in real time.

Next up will be the .ajax() function. The .ajax() function is at the core of my SPServices jQuery library. Using Ajax, you can request pieces of content from the server during the current page’s life span. Those pieces can be entire web pages, results from a web service call, or anything you can request over the HTTP protocol.

Through this series of articles we will build a SharePoint demo application that allows members to offer their services and accept another service in return. For example, John likes to garden, but he is lousy in the kitchen. Through the application he can offer his services as a gardener. Hanne likes to cook but needs a hand in the garden. She can accept his offer and cook him a delicious meal. All data will be stored in a SharePoint list called Service Offering.

In this part of the series we will build a Silverlight application that renders a scrolling banner displaying the services offered that day. Because the offered services are stored in a SharePoint list, they need to be retrieved by the Silverlight application before they can be displayed in the scrolling banner. This can be achieved by using the Silverlight client object model.

You can download the complete source code here.

The Silverlight Banner

 You can create a simple Silverlight 4 application using Visual Studio 2010. If you need a more complex design, you will need tools like Microsoft Expression Blend, but the sample Silverlight application for this article can easily be built in Visual Studio 2010 using the Silverlight Application template.

The Silverlight application consists of a canvas with a panel. For each service offer, a control like the following will be populated with the information about who offers what and which services are desired in return. Some services need to be fulfilled within a certain time frame; therefore, a countdown control will indicate how much time is left. All service controls will be added to the panel and will scroll over the page. If members see an interesting offer, they can check which they want to fulfill.

I’m not going to dive into the XAML of the Silverlight application, because that is not the subject of this article, but I’m going to walk you through the code where interaction with SharePoint is needed.

The point of entry of the Silverlight application is the Application_Startup method. The StartupEventArgs argument contains information on how to initialize the Silverlight application. One of these elements is the InitParams dictionary. In this sample we will pass the name of the SharePoint list where all service offerings will be stored. The value will be stored in a static variable that can be consulted from within the different controls that make up the Silverlight application.

public static string ListName = null;

The Application_Startup method looks as follows:

private void Application_Startup(
 object sender, StartupEventArgs e)
{
   if (e.InitParams != null)
   {
       if (e.InitParams.ContainsKey("list")
         && !string.IsNullOrEmpty(e.InitParams["list"]))
       {
           ListName =
              e.InitParams["list"].Replace("%20", " ");
       }
   }
  this.RootVisual = new MainPage();
}

The last statement initializes the main user control of the Silverlight application. The XAML of this control is very simple and contains the following elements:

• A Canvas: This is the root control of the user control.
• A Storyboard: This element is responsible for making the service offerings scroll over the screen from right to left.
• A StackPanel: This element will be used to add a custom control (as shown in the picture) for each service offering.
• A status border: This has a start/pause button to start/pause the storyboard.

The code-behind of the MainPage user control is stored in the MainPage.xaml.cs file and populates the ServiceItemPanel stack panel by calling the Silverlight client object model for SharePoint and binding the list item to a separate ServiceItemControl, which is displayed here.

picture

Using the Silverlight Client Object Model

SharePoint 2010 comes with three different client object models:

• One for use within .NET applications like a WPF application
• One for use from within JavaScript
• One for use from within Silverlight applications

Before you can start using the Silverlight client object model for SharePoint, you have to reference two assemblies:

• Microsoft.SharePoint.Client.Silverlight.dll
• Microsoft.SharePoint.Client.Silverlight.Runtime.dll

Both assemblies are located in the 14\TEMPLATE\LAYOUTS\ClientBin folder of the SharePoint root.

Calls to the SharePoint server using the Silverlight client object model  execute asynchronously and on a different thread. Therefore, you first have to capture the current SynchronizationContext to make sure you can come back on the UI thread.

    public MainPage()
    {
        InitializeComponent();
        ResizeCanvas();
        this.SizeChanged += new SizeChangedEventHandler(MainPage_SizeChanged);
        uiThread = System.Threading.SynchronizationContext.Current;
        if (uiThread == null)
           uiThread = new System.Threading.SynchronizationContext();
        PopulateBanner();
    }

The uiThread variable is declared as a class-level variable of type SynchronizationContext. This class resides in the System.Threading namespace:

private System.Threading.SynchronizationContext uiThread;

The client context is the starting point for the communication between Silverlight and SharePoint and is located in the Microsoft.SharePoint.Client namespace. When you host your Silverlight applications within SharePoint artifacts, you can use ClientContext.Current, instead of passing in the URL to the SharePoint site and creating a ClientContext based on that URL. This will be explained later when hosting the Silverlight application within the out-of-the-box Silverlight web part.

The code contains a property for the client context in order to encapsulate code that verifies the existence of a client context.

private ClientContext clientContext;
private ClientContext ClientCtxt
{
    get
    {
        if (clientContext == null)
            clientContext = ClientContext.Current;
        if (clientContext == null)
            throw new Exception("Connection failed!");
        return clientContext;
    }
}

The PopulateBanner method retrieves the list items from the SharePoint list. Before you can start retrieving list data, you have to load the current web from the client context. Also, the current user is retrieved for later use. The purpose will become clearer later in the article.

   web = ClientCtxt.Web;
   ClientCtxt.Load(web);
   currentUser = ClientCtxt.Web.CurrentUser;
   ClientCtxt.Load(currentUser);

Once the web is loaded, the list is retrieved using the GetByTitle method of the client object model using the list name passed in when the Silverlight application is initialized. This list contains all services offered by members of the site. The GetByTitle method is available on the Lists collection of the Web object of the current client context.

   serviceList = ClientCtxt.Web.Lists.GetByTitle(App.ListName);

The list items are retrieved by means of a CamlQuery object. The ViewXml property can be used to specify a sort order and/or a filter criteria. In this sample only, the list items with a start date before today and no expiration date or an expiration date after today are retrieved. 

     camlQuery.ViewXml = "<View><Query>"
                + "<OrderBy>"
                + "   <FieldRef Name='PublishDate' Ascending='False' />"
                + "   <FieldRef Name='Title' />"
                + "</OrderBy>"
                + "<Where>"
                + "   <And>"
                + "      <Leq><FieldRef Name='ServicePublishDate'/>"
                + "         <Value Type='DateTime' IncludeTimeValue='FALSE'><Today /></Value>"
                + "      </Leq>"
                + "      <Or>"
                + "         <Geq><FieldRef Name='ServiceExpirationDate' />"
                + "          <Value Type='DateTime' IncludeTimeValue='FALSE'><Today /></Value>"
                + "         </Geq>"
                + "         <IsNull><FieldRef Name='ServiceExpirationDate' /></IsNull>"
                + "      </Or>"
                + "   </And>"
                + "</Where>"
                + "</Query></View>";

The GetItems method is then executed using the CamlQuery object. The returned object is of type ListItemCollection:

   listItems = newsList.GetItems(camlQuery);

To actually retrieve the list items, you have to execute the Load method on the client context. Together with the Load method, you have to specify which columns of the list items you want to see returned. This allows you to limit the columns returned over the wire. In this sample, columns like the title, the short description, the publish date, the expiration date, and so on, are retrieved because these are the columns that will be displayed within the service item control.

     ClientCtxt.Load(listItems,
           items => items.Include(
                item => item["Title"],
                item => item["ServiceShortDescription"],
                item => item["ServicePublishDate"],
                item => item["ServiceExpirationDate"],
                item => item["ServicesInReturn"],
                item => item["Author"],
                item => item["ServiceTaker"],
                item => item["SelectedService"]
     ));

The ExecuteQueryAsync method of the client context is responsible for starting the call to the server. Because this method runs asynchronously, you have to specify two methods on which the call can come back when it returns from the server: one method for when the call returns successfully and another method for when the call to the server fails.

     ClientCtxt.ExecuteQueryAsync(HandleClientRequestSucceeded, HandleClientRequestFailed);

The HandleClientRequestFailed method will be executed when the call to the server fails. The EventArgs argument contains an error message that is temporarily stored in a private string message. Then the Post method on the main UI thread is called to redirect the request to the OperationFailed method on the main UI thread. There a message box will be displayed rendering the error message.

    private string errorMessage;
    private void HandleClientRequestFailed(object sender, ClientRequestFailedEventArgs e)
    {
        errorMessage = e.Message;
        uiThread.Post(new System.Threading.SendOrPostCallback(delegate(object state)
        {
            EventHandler h = OperationFailed;
            if (h != null)
                h(this, EventArgs.Empty);
        }), null);
    }
    public void OperationFailed(object sender, EventArgs e)
    {
        MessageBox.Show(string.Format("Failure! /n{0}", errorMessage));
    }

The HandleClientRequestSucceeded method will be executed when the call to the server returns successfully. Also, here the Post method on the main UI thread is used to redirect the request back to the main UI thread. The OperationSucceeded method is called to handle the result:

    private void HandleClientRequestSucceeded(object sender, ClientRequestSucceededEventArgs e)
    {
        uiThread.Post(new System.Threading.SendOrPostCallback(delegate(object state)
        {
            EventHandler h = OperationSucceeded;
            if (h != null)
                h(this, EventArgs.Empty);
        }), null);
    }

The OperationSucceeded method calls the BuildBanner method, which loops through the list items collection returned by the server.

    public void OperationSucceeded(object sender, EventArgs e)
    {
        BuildBanner();
    }

The BuildBanner Method

The BuildBanner method loops through the list items collection, which got populated by executing the ExecuteQueryAsync method of the client context. For each list item in this collection, a Silverlight user control is instantiated, setting its DataContext property to the list item.

private void BuildBanner()
{
   // Load the services banner          
   foreach (ListItem item in listItems)
   {
       ServiceItemControl itemControl = new ServiceItemControl();
       itemControl.DataContext = item;
       // the other code comes hereafter
   }
}

Data like ServicesInReturn is passed to the item control through a property. This is because the data is stored as a #;-separated string and some extra code needs to be executed before it can be rendered as check boxes.

       // pass the services in return
       if (item["ServicesInReturn"] != null)
          itemControl.ServicesInReturn = GetServicesInReturn(item["ServicesInReturn"].ToString());

The ExpirationDate is also passed through a property because it needs to be passed to the countdown control on the item control. We also pass an empty expiration date because in that case the countdown control will not be displayed.

       // pass the expiration date
       DateTime? expirationDateTime = null;
       if (item["ServiceExpirationDate"] != null)
          expirationDateTime = System.Convert.ToDateTime(item["ServiceExpirationDate"]);
       itemControl.ExpirationDateTime = expirationDateTime;

The username of the current user is also passed through a property. When the services offered scroll over the screen, the current user can select one of the services asked for in return. At that time, the SharePoint list item that corresponds with the item control will be updated with the name of the current user and the selected service in return.

       // pass the name of the current user
       itemControl.UserName = currentUser.LoginName;

When the service is already honored by a user, the selected service in return is passed through a property, and the corresponding check box will be checked.

       if (item["SelectedService"] != null)
           itemControl.SelectedService = item["SelectedService"].ToString();

A custom event handler is added to the item control. When a user decides to accept a service and offer a service in return, this choice should be stored in SharePoint. I could have passed the client context to the item control, but I prefer to raise an event and handle all SharePoint communication from within MainPage.xaml.cs:

       itemControl.ServiceSelected += new ServiceSelectedHandler(itemControl_ServiceSelected);

Then the control is added to the ServiceItemPanel stack panel control of the Silverlight application.

       ServiceItemPanel.Children.Add(itemControl);

When all service item controls are created, the size of the stack panel and the status borders need to be recalculated based on the width of one single service item control and the number of list items. The To and From properties of a DoubleAnimation storyboard indicate from where to where a certain control is moved. To avoid that the banner scrolls as fast as light when a lot of  services are offered,  the duration of the DoubleAnimation is recalculated.  Then the storyboard is started.

The ServiceItemControl

The ServiceItemControl is a Silverlight user control and looks like the following:

The DataContext property of this user control is used for data binding purposes. As explained in the previous section, when an instance of this control is created, a SharePoint list item is passed to this property. The properties of the incoming list item are data bound in XAML. Strings and other primitive data types can easily be bound to Silverlight controls. For example, the service offered, which is stored in the Title property of a list item, is data bound as follows:

<TextBlock x:Name="TitleTextBlock" Margin="3,0,0,0"
           Foreground="Yellow"
           FontFamily="Comic Sans MS"
           FontSize="14"
           Text="{Binding [Title]}"
           TextAlignment="Left" Width="160" />

But some properties have a more complex data type like, for example a user. In that case, we need to define a data-binding expression. The following code snippet shows the TextBlock that is used to bind the username of the demander by using a ListItemConverter. The ConverterParameter defines to which list item property you want to bind:

<TextBlock x:Name="DemanderTextBlock"
           Foreground="Yellow" 
           FontFamily="Comic Sans MS" 
           FontSize="14"
           Text="{Binding Converter={StaticResource listItemConverter}, ConverterParameter='Author'}" />

The ListItemConverter is a class that inherits from IValueConverter. The Convert method accepts the value, the data type, and the name of the column. If the column is of type Text or Number, the value will be returned without conversion. If the incoming data is of type user, then the incoming value is cast to the type FieldUserValue. The LookupValue property contains the username and is returned for display. If the incoming column is of type URL, then the incoming value is cast to the type FieldUrlValue, and the Url property is returned for display.

The ListItemConverter class in this sample does not convert all types of columns and contains only the conversions necessary in this sample. It looks as follows:

    public class ListItemConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            // get the list item's field to be displayed
            string fieldToDisplay = parameter as string;
            if (string.IsNullOrEmpty(fieldToDisplay))
                fieldToDisplay = "Title";
            ListItem sourceListItem = value as ListItem;
            if (sourceListItem == null)
                throw new ArgumentException("value");
            if (fieldToDisplay.StartsWith("Lookup."))
            {
                string lookupFieldName = fieldToDisplay.Replace("Lookup.", string.Empty);
                FieldLookupValue lookupValue = sourceListItem[lookupFieldName] as FieldLookupValue;
                if (lookupValue != null)
                    return lookupValue.LookupValue;
                else
                    throw new ArgumentException("Invalid lookup field.");
            }
            else if (sourceListItem[fieldToDisplay] is FieldUrlValue)
            {
                FieldUrlValue urlValue = sourceListItem[fieldToDisplay] as FieldUrlValue;
                if (urlValue != null)
                    return urlValue.Url;
                else
                    throw new ArgumentNullException("Invalid URL field.");
            }
            else if (sourceListItem[fieldToDisplay] is FieldUserValue)
            {
                FieldUserValue userValue = sourceListItem[fieldToDisplay] as FieldUserValue;
                if (userValue != null)
                    return userValue.LookupValue;
                else
                    throw new ArgumentNullException("Invalid User field.");
            }
            else
            {
                // return what's being asked for
                return sourceListItem[fieldToDisplay];
            }
        }
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        { throw new NotImplementedException(); }
    }

To be able to use the ListItemConverter from within Silverlight user controls, you have to add an extra element to the Resources element of the user control:

<UserControl.Resources>
   <local:ListItemConverter x:Key="listItemConverter" />
</UserControl.Resources>

As a side node, in Silverlight 3 you had to add all SharePoint data types, but since Silverlight 4 you can data bind list item properties using square brackets.

The code behind the ServiceItemControls defines a delegate and an event handler that is raised when a user selects one of the checkboxes populated with the services wanted in return.

public delegate void ServiceSelectedHandler(ListItem item, string service);
public partial class ServiceItemControl : UserControl
{
    public event ServiceSelectedHandler ServiceSelected;
    // rest of the code omitted for brevity
    …
}

Some list item properties cannot be data bound using the list item converter. They are handled in the code-behind. For example, the ServicesInReturn property contains a semicolon-separated string and needs to be rendered as a list of checkboxes. The PopulateCheckBoxPanel method creates a checkbox for each string in the list of services. Each CheckBox has a TextBox with its Text property set to the service. To each checkbox the custom event handler is added.

        private void PopulateCheckBoxPanel()
        {
            ReturnStackPanel.Children.Clear();
            if (servicesInReturn != null)
            {
                foreach (string service in servicesInReturn)
                {
                    CheckBox chkbox = new CheckBox();
                    chkbox.Foreground = new SolidColorBrush(Colors.White);
                    chkbox.FontFamily = new FontFamily("Comic Sans MS");
                    chkbox.FontSize = 12.0;
                    chkbox.Width = 220.0;
                    // use a textblock to be able to wrap the text
                    //chkbox.Content = s;
                    TextBlock textblock = new TextBlock();
                    textblock.Text = service;
                    textblock.Width = 195.0;
                    textblock.TextWrapping = TextWrapping.Wrap;
                    chkbox.Content = textblock;
                    chkbox.Checked += new RoutedEventHandler(checkbox_Checked);
                    ReturnStackPanel.Children.Add(chkbox);
                }
            }
        }

I could have done this differently by creating a list box with a data template containing a checkbox. In that case I would have been able to bind the list of services to the list box using the ItemsSource property.

The ExpirationDateTime property handles the countdown control. If there is no expiration date, the control is hidden.  When a service is already offered in return, the SetSelectedService method displays a “Served!” label over the list of checkboxes. When a service offer is not yet honored, a user can click one of the services offered in return, which fires the event handler checkbox_Checked to place the label “Served!” over the checkboxes. This label is wrapped in its own Silverlight user control. 

The label is moved smoothly over the list of services using a storyboard. The event handler also raises another custom event: the ServiceSelected event. It returns the impacted list item and the selected service. This ServiceSelected event is caught by the MainPage user control, which will save the information to SharePoint. Also, the update executes asynchronously and on a different thread.

        private void itemControl_ServiceSelected(ListItem item, string service)
        {
            // Save to SharePoint
            item["SelectedService"] = service;
            item["ServiceTaker"] = ClientCtxt.Web.CurrentUser;
            item.Update();
            serverAction = ServerAction.UpdateService;
            clientContext.ExecuteQueryAsync(HandleClientRequestSucceeded, HandleClientRequestFailed);
        }

In this sample, the ExecuteQueryAsync method points to the same success and failed handlers. Therefore, I added an enumeration to the code indicating which server action is taking place. In the HandleClientRequestSucceeded event handler, I test upon the value of this enum variable to decide what to do. Only when the services are retrieved on initialization of the Silverlight application is the scrolling banner built up.

        public void OperationSucceeded(object sender, EventArgs e)
        {
            switch (serverAction)
            {
                case ServerAction.RetrieveServices:
                    BuildBanner();
                    break;
                default:
                    break;
            }
        }

That’s it for the code in the Silverlight application. The compiled Silverlight application is a file with the extension .xap. It is in fact a package, which you can rename with the .zip extension and take a look at what’s inside. You’ll see that both assemblies for the Silverlight client object model are packaged within the .xap file. The Silverlight application also contains an assembly containing the compiled code.

When extracting the AppManifest.xaml file from the package, you’ll notice the entry point is App.xaml. It also contains a list of all assemblies that make up the Silverlight application.

<Deployment
   xmlns="<a href="http://schemas.microsoft.com/client/2007/deployment">http://schemas.microsoft.com/client/2007/deployment</a>"
   xmlns:x="<a href="http://schemas.microsoft.com/winfx/2006/xaml">http://schemas.microsoft.com/winfx/2006/xaml</a>"
   EntryPointAssembly="Sample1.ServicesBanner"
   EntryPointType="ServicesBanner.App"
   RuntimeVersion="4.0.50401.0">
  <Deployment.Parts>
    <AssemblyPart x:Name="Sample1.ServicesBanner" Source="Sample1.ServicesBanner.dll" />
    <AssemblyPart x:Name="Microsoft.SharePoint.Client.Silverlight" Source="Microsoft.SharePoint.Client.Silverlight.dll" />
    <AssemblyPart x:Name="Microsoft.SharePoint.Client.Silverlight.Runtime" Source="Microsoft.SharePoint.Client.Silverlight.Runtime.dll" />
  </Deployment.Parts>
</Deployment>

Now it is time to deploy the Silverlight application to SharePoint. I upload the Silverlight application to the XAPS document library. I place a Silverlight web part on a web part page and specify the path to the Silverlight application.

In the editor part of the web part, you have to enter the initParams string requested by your Silverlight application. In this sample, that means passing the name of the list where the service offerings are stored.

Once the initialization parameters, you can click the OK button of the web part. The Silverlight application will  be rendered on the page.

Conclusion

In this article, I explained how to use the Silverlight client object model to retrieve and update data stored in SharePoint. The Silverlight application is hosted in the out-of-the-box Silverlight web part. In the next article, I will explain how you can build your own Silverlight web part using the Visual Web Part item template available in Visual Studio 2010.

SharePoint Magazine Issue 3 Cut-Off Date

First of all, because this is of some urgency, the cut-off date for getting issue 3 of SharePoint Magazine print is on Wednesday, July 20. That means that if you want to get print issue 3 as part of your subscription, you need to sign up before then.

Sign up here: http://spm.to/sub.

Of course, even if you miss that date (or you read this after the cut-off date has passed), you can get single issues shipped now. You can see all of our purchase option on our new Purchase page.

Oh, and that means that just after July 20, we’ll start shipping issue 3. I know, I know, it’s been two months since the previous issue, but it was always the plan to have a one-month break during the summer. We had planned to have that in July, but as mentioned, some last-minute change of plans made June that break-month.

Aspiring Authors Competition Results

In May this year, we ran a competition called Aspiring Authors Competition, in which we invited some very skilled authors to submit their articles for evaluation and judgment by the SharePoint community. And you did, so I’m happy now to present the results of the competition.

The finalists all get both publishing contracts with SharePoint Magazine as well as a scholarship at USPJ Academy. The winner gets a longer contract and scholarship and in addition inclusion in an upcoming author mentoring program that USPJA Publishing will run.

Well, I’m guessing it’s time to announce the results.

In order, from least to most votes, they are as follows:

• Josh McCarty’s “Best Practices for SharePoint Groups” (third place, 51 votes)
• Mikael Svenson’s “Three Main Reasons Why You Should Upgrade to FAST for SharePoint” (runner-up, 112 votes)
• Andrew Vevers’ “A Guide to Leaving Lotus Notes and Moving to Microsoft SharePoint” (winner, 125 votes)

Congratulations to Andrew Vevers as our Aspiring Author Competition winner for 2011 and thanks to you, the community, for helping us decide the winner.

New Column: Leading Change with Kerri Abraham

We’re also proud to announce that we have a new resident author on the team. User adoption expert Kerri Abraham joins us to write in a new column called Leading Change, where she discusses the strategies, tools, and methods she has used to create her amazing results in user adoption.

Kerri will be adding additional posts in her column on a regular basis, starting with her already published article that also gives name to the column, namely, Leading Change.

However, I know Kerri to be a person of strong convictions, so I’m sure that she’ll contribute far more than just her tasked user adoption content, and I’m sure she appreciates topic suggestions in the comments too.

Check out Leading Change with Kerri Abraham.

New Commenting System

Speaking of comments, you may notice that we’ve moved away from the forum-based commenting system to Facebook comments. Frankly, the forum commenting system didn’t work as we had hoped. Now, commenting is much quicker, and you have an easy option to post the comment to your Facebook wall too, to drive even more comments and keep the conversations going. If you’re not on Facebook, you can sign in using Hotmail, AOL, or Yahoo too.

I happen to know that Kerri is particularly fond of the new commenting system, and I’ll take her silence as agreement.

That’s actually it for this update. I hope you won’t let the new commenting system sit there all by itself but instead comment and let us know your thoughts.

And by all means, keep watching this space for more updates now that summer is if not over then at least well underway.

.b