Rob Windsor's Weblog

Upcoming Pluralsight Course: SharePoint 2013 Development with the Client Object Model and REST API

Next Tuesday (May 28) my newest Pluralsight course will drop. It’s a 6.5 hour epic journey through the world of SharePoint 2013 Development using the Client Object Model and REST API. Here’s the module (chapter) breakdown.

Module 1: Introduction
- Introducing the Client Object Model
- Introducing the REST API

Module 2: Programming with the Client Object Model
- Using Load and Include
- Nesting includes
- Retrieving list items
- Data-binding
- Creating a list
- Batch exception handling
- Adding and updating list items
- Using Web Proxy
- Communicating from an App Web to the Host Web

Module 3: Programming with the REST API
- OData queries
- Using expand
- Data-binding
- Creating a list
- Creating list items
- Updating list items
- Using Web Proxy
- Communicating from an App Web to the Host Web
- Continuations

Module 4: Working with Documents and Document Libraries
- Creating a custom document library
- Uploading documents

Module 5: Working with Managed Metadata
- Creating terms and term sets
- Adding taxonomy fields
- Setting taxonomy field values

Module 6: Working with Users
- Checking user permissions
- Getting user profile properties

Module 7: Working with Search
- Keyword queries

Module 8: JavaScript in Solutions
- JavaScript in farm solutions
- JavaScript in sandbox solutions

Module 9: Working with “Legacy” Services
- Custom WCF services
- SOAP (ASMX) Web services
- SharePoint 2010 REST API (ListData.svc)

If you see the course feel free to comment if you have questions or feedback

SharePoint Dev Quick Tip - Quickly and Easily Building SharePoint REST API Query URLs

Have you ever tried to build the URL for a REST API service call and ended up confused and frustrated? The OData query syntax is well documented, it’s just not that intuitive. Well, if you want to query list data I have a little trick you can use to have the appropriate URL generated for you. Unfortunately this trick doesn’t work with the SharePoint 2013 _api service since it doesn’t expose metadata.

Step 1:
Create a Console application and add a Service Reference to the ListData.svc service for your SharePoint site. I set the Namespace to DemoProxy in my example.

Step 2:
Inside the Main method, create an instance of the data context and attach the default credentials.

var context = new DemoProxy.DemoDataContext(new Uri("http://win7virtualbox/sites/demo/_vti_bin/ListData.svc/"));
context.Credentials = System.Net.CredentialCache.DefaultCredentials;

Step 3:
Write a LINQ query that retrieves the data you want. My site has some data I brought over from Northwind so I’ll use that.

var products = from product in context.Products
                where product.UnitsInStock > 0 &&
                product.Category.Title == "Condiments"
                orderby product.UnitPrice
                select product;

Step 4:
Run your program in debug mode and use the data tip or the locals windows to get the generated query. You could also use Fiddler for this.

And viola, in a minute or two you have the query you want. For me it looked like this:

/_vti_bin/ListData.svc/Products()?$filter=(UnitsInStock gt 0) and (Category/Title eq 'Condiments')&$orderby=UnitPrice

This tip and much more can be found in my SharePoint 2010 Lists and Libraries for Developers course on Pluralsight.

My Thoughts on the Developer Content at the SharePoint Conference 2012 (The Appy Hour)

Another SharePoint Conference has come and gone and it’s time for the obligatory wrap-up post (at least what I can remember). This was a very busy conference for me, almost to the point of being overwhelming. I caught some sessions live and got to spend time with my colleagues from Portal and Pluralsight, but I didn’t get nearly enough time to spend with the seemingly endless number of other people I knew at the conference.

Being an MVP, I had early access to the beta/preview bits and to training so I came into the conference with a solid understanding of the App model. What I wanted to see was if the messaging from Microsoft had changed since I wrote SharePoint 2013 Development–Microsoft has their Heads in the Clouds. It was very clear from the start that it had not – the developer sessions were all Apps and all Office 365. Aside from a brief comment here and there and one demo in one session, you wouldn’t have known that the Solutions model (farm and sandbox solutions) even existed. Also, all of the demos I saw were done on Office 365 and the presenters made claims and comments only applicable to Office 365 without qualifying that was the case. They seemed to assume that everyone had or will be moving to Office 365.

While the conference was going on I saw several Tweets and participated in or overheard conversations from attendees confused by what they had seen. Hopefully the following will help address some of the misconceptions and misunderstandings:

• Farm and sandboxed solutions are still viable options in SharePoint 2013. Apps are an alternative to solutions, not their replacement.
• Visual Studio 2012 has almost the exact same tooling for building solutions for SharePoint 2013 as Visual Studio 2010 did for SharePoint 2010.
• You can still build and use web parts in SharePoint 2013. App parts are an alternative, not their replacement. 
• Unless you only plan on building Apps for Office 365, you will need to install SharePoint on your development machine.
• Apps cannot do everything farm solutions can do. While there have been significant extensions to CSOM and REST APIs, the Server Object Model is still more powerful and extensive.
• Napa is a tool for learning and prototyping. It is not meant to be used to build production Apps.

I want to make it clear that I am not anti-App. I think the App model makes a lot of sense in several situations, I just don’t think it make sense in all situations.

SharePoint Dev Quick Tip–Finding the Internal Name of a Field

Note: For the purposes of this post I’m going to assume you know the difference between the display name and the internal name of a field and why you should use the internal name when referring to fields in code and queries.

There are several tools/tricks you can use to get the internal name of a field. In this quick tip I’ll show you two tools I like to use: Visual Studio and SharePoint Manager.

Let’s say we have a site named Demo that contains a list named Demo that contains a field named Application Type and that I want to get the internal name of this field. I can open Server Explorer in Visual Studio 2010, expand SharePoint Connections, expand the appropriate site collection (you’ll need to attach to it if there is no node), expand the Demo site, expand Lists and Libraries, expand Lists, expand Demo, expand Fields, and finally select Application Type. With this node selected I can look at the properties of the field in the Properties Window, one of these will be the internal name.

Now, let’s say we want to get the internal name of the % Complete site column in the Demo site. The Server Explorer does not contain a node for site columns so we’ll use SharePoint Manager 2010 instead. SharePoint Manager is a free tool you can download from http://spm.codeplex.com/. Once you’ve downloaded the 2010 version and unzipped (there’s no install necessary), run the program as administrator. Just like we did in the Server Explorer, navigate down the tree view until you can select the node representing the % Complete field. The window on the right will show its properties, including the internal name.

SharePoint 2013 Sandboxed Solutions Deprecated?

If sandboxed solutions could talk, I’m sure they would be uttering the famous Mark Twain line, “The reports of my death are greatly exaggerated”.

Twitter and other social media sites were a buzz early this week after the release of the SharePoint 2013 Preview. Amid the posts were some like these:

Needless to say there were many questions about what this meant. The issue was brought to the product team and they said that the text in some of the documentation did not clearly represent their position on sandboxed solutions. The documentation has since been changed to state: SharePoint sandboxed solutions are deprecated in SharePoint 2013 Preview in favor of developing apps for SharePoint. My interpretation of this is: we (Microsoft) feel that Apps can do what sandboxed solutions can do and we feel that the future of development on the SharePoint platform are Apps so we suggest you stop using sandboxed solutions.

So, are sandboxed solutions still supported in SharePoint 2013? Yes they are. What about the next version of SharePoint? Maybe, it depends on whether the App model is all it’s cracked up to be. It’s still too early to call.

SharePoint Dev Quick Tip - SharePoint 2013 Web Part Page

Took me a while to find how to create a Web Part Page in SharePoint 2013. You can create one using the New Document dropdown in the Site Pages library.

SharePoint 2013 Developer Resource Links

I’m posting these mostly so I can find them again later

Setting up a developer environment

How to: Set up an on-premises development environment for apps for SharePoint
Configuring Visual Studio 2012 RC for SharePoint 2013 Preview Development

SharePoint App Development

Apps for SharePoint overview
Developer training
SharePoint 2013 Preview for Developers (Forums)
Apps for SharePoint compared with SharePoint solutions

SharePoint 2013 Development–Microsoft has their Heads in the Clouds

The SharePoint 2013 Preview has been out for a couple days and I have it all figured out – not! But I have seen enough to get the general feel of the release, at least from a developers perspective.

The App and Solution Models

The vast majority of the material that has been released over the last couple days is on the new App model. For the purposes of this post I’m going to assume you have a general idea of what the App model is and how it will be used. If you don’t and you want an overview go to Apps for SharePoint overview, if you want details go to (SharePoint 2013) Developer Training.

I get why there’s a need for the App model. We need a development model for clients who are multi-tenant hosted (read Office 365) or who have very locked down systems that doesn’t involve pushing files into the file systems of the SharePoint servers. From what I’ve seen of the App model it is a very well thought out way to solve that problem. However, these clients make up a pretty small percentage of the total number of clients using SharePoint. I’m pretty certain it’s under 25% and I might be willing to wager a penny or two that it’s under 15%. For the rest of the clients we still have the existing Solution model to use when building SharePoint applications – or do we?

As I’ve been going through the material on MSDN and TechNet (and kudos to everyone involved for getting so much material out so quickly) I’ve seen things that me go hmmmmmmm. Here are some examples:

From What you can do in an app for SharePoint (2013)

With previous versions of SharePoint, farm administrators sometimes refused to install any custom SharePoint extensions because of the danger of errant code. In SharePoint 2013 Preview, that problem is essentially eliminated because the client object models have been greatly expanded. This means that you as a developer do not have to use the server object model anymore. All your custom business logic moves "up" to the cloud or "down" to a client machine, and it uses one of the client APIs discussed in an earlier section. Because the app does not (actually cannot) contain custom code that executes on the SharePoint servers, administrators are assured of its safety.

From Apps for SharePoint compared with SharePoint solutions

The most important guidance we can give you is to develop an app for SharePoint rather than a classic solution whenever you can. Apps for SharePoint have the following advantages over classic solutions

From Apps for SharePoint compared with SharePoint solutions

SharePoint sandboxed solutions are deprecated in SharePoint 2013 Preview in favor of developing apps for SharePoint, but sandboxed solutions can still be installed to site collections on SharePoint 2013 Preview. This topic compares apps for SharePoint with farm solutions.

[RW: This text was changed after the original release of the document. The original text read: SharePoint sandboxed solutions are deprecated in SharePoint 2013 Preview. This topic compares apps for SharePoint with farm solutions.]

From Choose the right API set in SharePoint 2013

Developing new sandboxed solutions against SharePoint 2013 Preview is deprecated in favor of developing apps for SharePoint, but sandboxed solutions can still be installed to site collections on SharePoint 2013 Preview.

[RW: This text was changed after the original release of the document. The original text read: Developing new sandboxed solutions against SharePoint 2013 Preview is not supported, but sandboxed solutions developed against earlier versions of SharePoint can be installed to site collections on SharePoint 2013 Preview]

From SharePoint 2013 customization options and management (Module 10 - Video 4)

Client OS installations are not anymore supported [sic]

[RW: This means that Solutions development for SharePoint 2013 will need to be done on Windows Server]

It’s ALL about the Cloud

These resources and some others I’ve seen have led me to believe that Microsoft doesn’t consider the App model as a companion to the Solution model, they see it as a replacement for the Solution model. If that’s true then the vision moving forward is that the vast majority of SharePoint applications will be implemented using the JavaScript Client Object Model or by JavaScript that calls out to custom web services hosted outside of SharePoint that communicate back to SharePoint using the .NET Managed Client Object Model.

I think this would be fine if most clients were on Office 365, but they aren’t. As I said earlier, my experience tells me that more than 75% of companies out there don’t have an issue allowing Solutions to be deployed to their servers. If this is a case, why would they choose to use the App model over the Solution model? Client Object Model code is not as easy to write; even though Microsoft has made great strides to expand the Client Object Model APIs, they are still not as robust as the Server Object Model APIs; and, oh ya, there are all those service calls being made when you use the Client Object Model. IMHO, it doesn’t make sense.

What Me Worry?

I think that a majority, maybe even a vast majority, of development during the SharePoint 2013 timeframe will use the Solutions model. What concerns me is that Microsoft is so committed to the idea that everyone is going to the cloud that they are going to spend all their resources on developing and evolving the App model when most of the developers in the community (including me) would benefit by some of that time being spent to improve the Solutions model.

Walkthrough: Creating a Custom ASP.NET (ASMX) Web Service in SharePoint 2010

There is a walkthrough on this subject on MSDN. I’ve seen a few people comment that they have had issues trying to follow the walkthrough so I thought I’d create an alternate version.

Update: A couple of people have asked for information on how to consume the service so I’ve added an extra section at the bottom.

Creating the ASP.NET Web Service

• In Visual Studio, click File | New | Project…
• In the New Project dialog, select the Visual C# > SharePoint > 2010 node under Installed Templates.
• Select the Empty SharePoint Project template, set the Name to WebServiceDemo and click OK.

• In the SharePoint Customization Wizard, enter the site you want to use for debugging, select Deploy as a farm solution, and click Finish. We are creating a farm solution because we need to deploy files to the SharePoint system folders (14 hive).

• In the Solution Explorer, right-click on the project and select Add | SharePoint “Layouts” Mapped Folder. You should see two new folders added to your project.

Note: Normally web services go into the ISAPI folder. However, if we do that we will need go through all of the pain steps in the Generating and Modifying Static Discovery and WSDL Files section of the original walkthrough. Instead we are going to put the web service in a folder under the Layouts folder where these steps are not required. I have used this technique in the past have have not found any reason why custom ASP.NET web services should not be deployed under the layouts folder.

• Right-click on the newly created WebServiceDemo folder, and select Add | New Item…
• In the Add New Item dialog select Visual C# > General from Installed Templates, set Name to MyCustomWebService.asmx and click Add.

• Inside the MyCustomWebService.asmx file, add the following markup. You'll have to replace #assembly strong name# with the strong name of your assembly. Sahil Malik has a blog post describing how to get the strong name of your assembly by adding an External Tool into Visual Studio.

<%@ WebService Class="WebServiceDemo.MyCustomWebService, #assembly strong name# %>

• In the Solution Explorer, right-click on the project and select Add | Class…
• In the Add New Item dialog, set Name to MyCustomWebService.cs and click Add.

• Before we add the code to the class, we need to add a reference. In the Solution Explorer, right-click on the project and select Add Reference…
• In the Add Reference dialog, select the .NET tab, select System.Web.Services, and click OK.

• Inside the MyCustomWebService.cs file, replace the code with the following.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Services;
using Microsoft.SharePoint;

namespace WebServiceDemo
{
    public class MyCustomWebService : WebService
    {
        [WebMethod]
        public string GetSiteListCount()
        {
            var web = SPContext.Current.Web;

            return (web.Title + " contains " +
                web.Lists.Count.ToString() + " lists.");
        }
    }
}

• Open Internet Explorer and navigate to your test SharePoint site. In the address bar add /_layouts/WebServiceDemo/MyCustomWebService.asmx and press Enter. You should see a service test page like the following.

• Click the GetSiteListCount link to navigate to a page that will allow you to test your service operation.

• Click invoke to test your service operation. A window should open that has XML contents that look something like this.

Creating a Sample Client Application

• In Visual Studio, click File | New | Project…
• In the New Project dialog, select the Visual C# node under Installed Templates.
• Select the Console Application template, set the Name to WebServiceClient and click OK.

Note: The next thing we need to do is add a reference to the service to create the service proxy class. Since we created an ASP.NET (ASMX) Web Service instead of a WCF Web Service we need to use the Add Web Reference dialog. The steps to do this may not be obvious if you do not know what to look for.

• In the Solution Explorer, right-click on your project and select Add Service Reference…
• In the Add Service Reference dialog, click the Advanced button.

• In the Service Reference Settings dialog, click the Add Web Reference… button

• In the Add Web Reference dialog, put the URL of your service (that is, the URL for your SharePoint site plus /_layouts/WebServiceDemo/MyCustomWebService.asmx ) in the URL bar and press Enter. You should see a page similar to the one shown below in the browser area of the form.
• Set the Web reference name to DemoProxy and click the Add Reference button.

• You should see a few changes in the Solution Explorer. The important one is the addition of the Web References and DemoProxy nodes. This indicates your service proxy has been created.

• Inside Program.cs, replace the code with the following:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WebServiceClient
{
    class Program
    {
        static void Main(string[] args)
        {
            var proxy = new DemoProxy.MyCustomWebService();
            proxy.Url = "http://win7virtualbox/sites/demo/_layouts/WebServiceDemo/MyCustomWebService.asmx";
            proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;

            var response = proxy.GetSiteListCount();
            Console.WriteLine(response);
        }
    }
}

An explanation of the code is needed.

• The first line creates an instance of the service proxy class that was generated when we added the web reference.
• The second line sets the SharePoint context. I can call this service from the context of different SharePoint sites so it is this URL which determines the site name and list count that will be returned to me. As an example, the first of the following URLs calls the service from the Demo site while the latter calls it from the Sales site
  • http://win7virtualbox/sites/demo/_layouts/WebServiceDemo/MyCustomWebService.asmx
  • http://win7virtualbox/sites/sales/_layouts/WebServiceDemo/MyCustomWebService.asmx
• The third line sets the credentials of the caller. In this case it uses the credentials of the currently logged in Windows user.
• The fourth line calls the GetSiteListCount method and the last line writes out the response.

The final step is to test the client application.

• Press F5 to run the client application. You should see results similar to the following

How To Programmatically Read Best Bets for SharePoint 2010 Search

For one of the projects I’m working on, I needed to be able to iterate search best bets programmatically. I did a quick Google search and came up with a blog post by Stefan Goßner on the subject. Turns out Stefan’s post was for SharePoint 2007 and the code uses a type that has been obsoleted. A little more Googling and I came up with the code for SharePoint 2010.

Here’s the code for a simple Console app you can use as a starting point if you need to do something similar.  You’ll need to add a reference to Microsoft.SharePoint.dll and Microsoft.Office.Server.Search.dll (which can be found in the ISAPI folder under the SharePoint system root). You’ll also need to set the build target to Any CPU.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.Office.Server.Search.Administration;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var site = new SPSite("<site collection url>");
            var proxy = (SearchServiceApplicationProxy)SearchServiceApplicationProxy.
                GetProxy(SPServiceContext.GetContext(site));
            var keywords = new Keywords(proxy, new Uri(site.Url));

            foreach (Keyword keyword in keywords.AllKeywords)
            {
                Console.WriteLine(keyword.Term);
                foreach (BestBet bet in keyword.BestBets)
                {
                    Console.WriteLine("\t{0} ({1})", bet.Title, bet.Url);
                }
            }
        }
    }
}

Creating a SharePoint Site Page With Code-Behind Using Visual Studio 2010

A while ago I was reading Kirk Evans blog post on the subject of using code-behind in SharePoint 2010 site pages. I wanted to make sure things still worked the way they did in SharePoint 2007. Everything looked the same until I saw the part about updating the web.config file.

From Kirk’s blog post:

“The problem is that SharePoint has a setting that disallows server-side code with [site] pages.  This is a security feature that is good (you really don’t want end users to arbitrarily inject server-side code), but there may be cases where you are OK with some of your users having this capability.  For instance, you can have a page that is only visible to a small team within your enterprise, and one of the team members is very technical and wants to provide some custom code for SharePoint.  Party on, have fun with it, it saves my team from having to write that code.

To enable this scenario (and enable the Button_Click event handler in our code), we need to add an entry to web.config.  Knowing that we can’t just go to every front-end web server and make the modifications (any admin worth his salt should slap you silly for even thinking about hand-modifying multiple web.config files in a production farm), we should provide this as part of our solution.”

OK, I remember that in SharePoint 2007 you could add an entry in web.config to indicate the page parser should allow inline code for a page, but you didn’t have to do so. As long as the markup didn’t have anything indicating that code should run you were good. So I took Kirk’s example and modified it a bit so it would work without changes to the web.config.

In the markup, I removed the namespace imports, the CodeBehind attribute of the Page element, and the OnClick attribute of the Button element.

<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %>
<%@ Register 
    Tagprefix="SharePoint" 
    Namespace="Microsoft.SharePoint.WebControls" 
    Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register 
    Tagprefix="Utilities" 
    Namespace="Microsoft.SharePoint.Utilities" 
    Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register 
    Tagprefix="asp" 
    Namespace="System.Web.UI" 
    Assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" %>
<%@ Assembly Name="Microsoft.Web.CommandUI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Page Language="C#" 
    Inherits="SampleToDeployAPage.MyPageTemplate" 
    Title="Testing This Page"
    MasterPageFile="~masterurl/default.master" 
    meta:progid="SharePoint.WebPartPage.Document" %>

<asp:Content ID="Main" ContentPlaceHolderID="PlaceHolderMain" runat="server">
  <asp:Button runat="server" ID="button1" Text="Click me" />
  <asp:Label runat="server" ID="label1"/>
</asp:Content>

Of course, I needed to make changes to the code behind file to compensate for what I removed from the markup – but the changes were minor. All I needed to do was hookup the Button_Click method to the Click event of the Button. In WebForms, attaching event handlers is done in the Page_Init event.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
using System.Web.UI.WebControls;

namespace SampleToDeployAPage
{
    public class MyPageTemplate : WebPartPage
    {
        protected Button button1;
        protected Label label1;

        protected void Page_Init(object sender, EventArgs e)
        {
            button1.Click += new EventHandler(Button_Click);
        }

        protected void Button_Click(object sender, EventArgs e)
        {
            label1.Text = System.DateTime.Now.ToLongTimeString();
        }
    }
}

I kept everything else the same (minus the web.config changes of course), deployed, navigated to the page, clicked the button and SHAZAM! -  the date showed.

Getting Started with SharePoint 2010 Development at DevTeach and Prairie DevCon

SharePoint for ASP.NET Developers–Recorded Session from DevLink

Here’s another recorded session from the DevLink conference.

SharePoint is an awesome tool. It allows you to build web sites, manage lists of data, collaborate on documents, and so much more – all done through a simple, easy to use, web interface. When you need to go beyond the built in capabilities of the product, SharePoint also provides a rich set of APIs to code against. This session is designed to introduce you to the foundational topics required to build customizations on the SharePoint platform. Specifically we will cover: Features, the solutions framework, the server object model, and building simple Web parts. This session will be valuable for those working with SharePoint 2007 or 2010.

SharePoint 2010 Client-Side Development with the JavaScript Client Object Model (JSOM) and jQuery – Recorded Session from DevLink

It’s been a busy month since DevLink but I finally have time to clear some tasks off my to-do list. One was to post this recording of my SharePoint 2010 Client-Side Development talk. I have a couple other partially edited session recordings. Hopefully it won't take a month to get those posted.

SharePoint Saturday: The Conference–Session Resources

Got back yesterday from SharePoint Saturday: The Conference. I met a lot of people I only knew electronically, learned a ton, and had a great time overall. That said, there were some issue that I guess you had to expect from such a large event being run by an all volunteer group.

“Even if we had prior experience in organizing 1-day SharePoint Saturday events, we underestimated the exponential amount of effort required to organize a 3-day event like this. As a result, there were some miscommunication issues, logistical inconsistencies and unmet expectations that was experienced by sponsors, speakers and attendees.” – Dux Raymond Sy from http://sp.meetdux.com/archive/2011/08/14/3-lessons-learned-from-spstcdc.aspx

It’ll be interesting to see if future multi-day SharePoint Saturday events are able to take the lessons learned and work them out.

Anyway, that’s for the future. For now, here are the links to the resources from my sessions:

SharePoint User Interface Development
One hour from the Developer 101 Workshop
Slides and demos:  http://bit.ly/oKWP66
Video recording:  http://vimeo.com/27724271

SharePoint for ASP.NET Developers
​SharePoint is an awesome tool. It allows you to build web sites, manage lists of data, collaborate on documents, and so much more - all done through a simple, easy to use, web interface. When you need to go beyond the built in capabilities of the product, SharePoint also provides a rich set of APIs to code against. This session is designed to introduce you to the foundational topics required to build customizations on the SharePoint platform. Specifically we will cover: Features, the solutions framework, the server object model, and building simple Web parts. This session will be valuable for those working with SharePoint 2007 or 2010.
Slides and demos:  http://bit.ly/roZeFn

Integrating SharePoint 2010 and Visual Studio LightSwitch
Visual Studio LightSwitch is a tool that's designed to let power users build data-centric business applications for the desktop and cloud. The tooling takes care of code generation, data access and common infrastructure needs, allowing the application builder to focus on business logic. If enhanced functionality is required, developers can extend the application with custom .NET code. In terms of data access, LightSwitch applications can use many data sources including SharePoint 2010 list data. The tooling uses a combination of the client object model and the REST API, so the integration is rich and powerful. In this session, you'll see how to build LightSwitch applications that use data from SharePoint 2010.
Slides and demos:  http://bit.ly/rutyHM

Enabling Intellisense for the JSOM and jQuery in SharePoint 2010

This blog post was requested by Mark Rackley (@mrackley) at his jQuery session at SharePoint Saturday New York. Mark mostly does middle-tier SharePoint development and he wanted to see what life was like inside the wonderful world of an Integrated Development Environment like Visual Studio.

I’d put together some content on enabling and using intellisense for the JavaScript client object model and jQuery in my Pluralsight On-demand course on the SharePoint 2010 Client Object Model so I took a few clips and put them together to make this video blog post. Big thanks to the people at Pluralsight for letting me use the content in this post.

Enabling Intellisense for the JSOM and jQuery in SharePoint 2010 from Rob Windsor on Vimeo.

TVBUG Becomes North Toronto .NET User Group (NorthTorontoUG)

This is one of those good news/bad news posts.

The bad news (at least for me) is that, after more than 10 years, I’m stepping down as leader of the Toronto Visual Basic User Group. My work is taking me on the road more and more and I’m not in the city enough to be able to do the job.

The good news is that the group will continue on as the North Toronto .NET User Group. Big thanks to Luis Duran, Ryan Kajiura, Jack Lee, Obi Oberoi and Tony Cavaliere for stepping up and taking over the management of the group. Also, thanks to Graham Marko for helping out in an advisory role during the transition. Along with the name change will be a new website and a new URL. Jack Lee is working on getting everything up an running at NorthTorontoUG.com. Until the site is complete continue to visit tvbug.com to get information on the group and upcoming events.

Even though I’m no longer running the group I do plan to attend when I can. In fact, as I mentioned in a pervious post, I’ll be speaking at the September 8 meeting on Building Business Application with Visual Studio LightSwitch. I hope to see you there.

Getting Started with SharePoint 2010 Development–Links and Resources

A few people have asked for advice on resources to help them get started with SharePoint development. Here are a few I like to suggest, add a comment if you have others.

Videos

Get Started Developing on SharePoint 2010

SharePoint 2010 Developer Training Course

How Do I Videos for Office Developers

SharePoint for ASP.NET Developers

Pluralsight On-demand Library (Subscription required)

Books

Inside Microsoft Windows SharePoint Services 3.0
This book is on SharePoint 2007 but I had to list it because it’s the book that helped me get started.

Inside Microsoft SharePoint 2010
The SharePoint 2010 version of the book above.

Beginning SharePoint 2010 Development

Professional Visual Basic 2010 and .NET 4
There’s only one chapter on SharePoint in this book but it was authored by yours truly so I had to list it.

Blogs

Microsoft SharePoint Team Blog

Other

Setting Up the Development Environment for SharePoint 2010 on Vista, Windows 7, and Windows Server 2008

StackExchange – SharePoint
A great place to ask SharePoint questions.

Advanced SharePoint Web Part Development–Recorded Session from SPSNY

Got back from SharePoint Saturday New York yesterday afternoon. What a great event – the organizers and volunteers really went all out and everything went like clockwork.

I recorded my session and spent a good chunk of yesterday editing it so I could publish it today. If you have any questions or comments, please let me know.

Advanced SharePoint Web Part Development from Rob Windsor on Vimeo.

Web parts are the foundation of user interfaces in SharePoint. As a developer it's relatively easy (particularly with the visual web part in SharePoint 2010) to build something simple and get it deployed. But what do you do when you need to add editable properties or when you need to connect two web parts together? This fast-paced, demo-heavy session covers the more advanced aspects of building web parts for SharePoint 2007 and 2010. We’ll take a look at creating custom editor parts, building visual web parts, constructing connected Web parts, and making web parts asynchronous.

Upcoming Community Events: Seven Talks in Five Cities

I spent the last few weeks getting settled in and working on the developer part of my new gig at Allin Consulting, now it’s time to work on the evangelist part. Over the next two months I’ll be speaking at events in five different cities. If you’re attending and want to have a chat you can ping me on Twitter (@robwindsor) or send me an email using the Contact link on the left side of the page. I hope to see you there.

SharePoint Saturday New York
July 30 in New York, NY
- Advanced SharePoint Web Part Development

SharePoint Saturday: The Conference
August 11 to 13 in Washington, DC
- SharePoint for ASP.NET Developers
- Integrating SharePoint 2010 with Visual Studio LightSwitch

DevLink
August 17 to 19 in Chatanooga, TN
- What’s New for Developers in SharePoint 2010
- Integrating SharePoint 2010 with Visual Studio LightSwitch

North Toronto .NET User Group
September 8 in Toronto, ON
- Building Business Applications with Visual Studio LightSwitch

SharePoint Saturday New Hampshire
September 24 in Manchester, NH
- SharePoint for ASP.NET Developers