Visual Studio SharePoint Development Blog

Update Your Links - We’ve Moved!

2011-02-10T19:15:19Z

To make it easy for developers to make sure they're getting all the latest technical information around developing SharePoint solutions, the SharePoint, Visual Studio and Office User Assistance teams have decided to combine their blogging efforts into the new SharePoint Developer Team Blog. Think of it as your one-stop shop for developer-centric SharePoint information, straight from the product teams and user assistance folk responsible for SharePoint Foundation, Server, SharePoint Online, and the SharePoint development tools in Visual Studio.

Here's what you can expect from our new blog going forward:

Regular, detailed technical information on SharePoint development, such as walkthroughs and code samples, from the people who designed those product features and tools
Early, first-look versions of content being prepared for publication to MSDN
Cross-posts and pointers to SharePoint-centric developer content on other specialized blogs
Announcements of interest to SharePoint developers, such as content updates, service releases, or developer events.

So we're hoping you'll subscribe, and pass the following easy-to-remember URL on to your SharePoint developer friends and colleagues:

http://blogs.msdn.com/sharepointdev/

And if there are particular things you'd like to see covered or discussed, by all means leave us a comment on our new consolidated blog!

Even More Resources for SharePoint Developers

2010-10-06T21:30:30Z

Kemp first shared a lengthy list of SharePoint developer resources at http://blogs.msdn.com/b/vssharepointtoolsblog/archive/2010/08/12/resources-for-visual-studio-tools-for-sharepoint-developers.aspx. In addition to these, there are articles and videos that are published in the Technical Articles and Visual How Tos nodes. In addition to the documentation, technical articles, and visual how-tos, you can also read Book Excerpts and Quick Notes.

Here is a list of recent visual how-to videos that demonstrate how to use the SharePoint developer tools in Visual Studio. Click on the screenshot to view the visual how-to.

There are several more visual how-to articles and more posted each month, so be sure to check out the Technical Articles and Visual How Tos nodes regularly. Alternatively, you can visit the SharePoint Developer Center where there is an RSS feed called Recently Published Content, or even add the feed to your favorite RSS reader.

Mary Lee, Programming Writer.

Check out the new SharePoint in Pictures blog

2010-10-06T00:44:45Z

There is a new blog called SharePoint in Pictures that illustrates the platform and architecture of SharePoint Foundation 2010 and SharePoint Server 2010. The blog is to be updated on a weekly basis with new diagrams, so feel free to check it out and leave feedback about what you’d like to see in the near future.

Mary Lee, Programming Writer.

Resources for Visual Studio Tools for SharePoint Developers

2010-08-12T19:53:05Z

Nearly all of the tools for SharePoint development included in Visual Studio 2010 are new, so learning about them and finding help and information can be a challenge. To help you in this quest, I’ve compiled a list of links to helpful resources, including product documentation, web sites, forums, and blogs. As new resources become available, I’ll add them to the list. If you know of any other sites you think others would find useful, feel free to add them to the comments and I’ll periodically update the list.

Learning

For learning about the Visual Studio 2010 tools for SharePoint Development, check out the new Help topics. The portal page for these is: SharePoint Development in Visual Studio.
Visual Studio provides tools for developing SharePoint sites. To find out more about how SharePoint itself works, start at the portal page: SharePoint 2010. For those who don’t know, there are two versions of SharePoint: SharePoint Foundation 2010 (formerly known as Windows SharePoint Services, or WSS) and SharePoint Server 2010 (formerly known as Microsoft Office SharePoint Server, or MOSS).
To learn about extending the Visual Studio SharePoint tools, including how to create your own SharePoint project and project item templates, see Extending the SharePoint Tools in Visual Studio.
For details about the Visual Studio SharePoint project system API, see Reference (SharePoint Tools Extensibility).
Channel 9 features videos relating to SharePoint and SharePoint tools, including a great comprehensive (and free!) SharePoint 2010 Developer Training Course.
Because SharePoint sites are built on ASP.NET and IIS, having a deeper understanding of those technologies is useful.

Blogs

In addition to this blog (Visual Studio SharePoint Development Blog), there is a blog for SharePoint called the Microsoft SharePoint Team Blog that focuses on SharePoint development-related questions and issues.
Although though the list is dated, many of the blogs in SharePoint Joel’s Top 100 SharePoint Blogs of Spring 2008 are still active and involved in SharePoint 2010 development.

Forums and Newsgroups

The official forum for Visual Studio SharePoint is located at SharePoint Development with Visual Studio,
The official forum for SharePoint 2010 is located at SharePoint 2010 Forum.
The SharePoint Usenet groups are located at Microsoft.Public.SharePoint.

Other Resources

The SharePoint 2010 Developer Resource Centers page has a centralized list of resources for common tasks such as upgrading, best practices, and security.
For code samples relating to SharePoint and SharePoint tools, see the MSDN Code Gallery.
Information about upgrading and migrating to SharePoint 2010 can be found at: Upgrade Resource Center | SharePoint 2010.
For a large list of resources relating to earlier versions of SharePoint, see Heather Solomon’s SharePoint Resources page.
To query the Microsoft Knowledge Base about SharePoint and Visual Studio issues, see MSDN Troubleshooting and Support.

Kemp Brown

Walkthrough of creating association between Sharepoint BDC entities using Visual Studio 2010

2010-08-03T02:17:02Z

Up till now, we have published two blogs in this series about SharePoint 2010 external list, Walkthrough of creating a SharePoint 2010 external list using Visual Studio 2010 Beta and Walkthrough of enabling CRUD for SharePoint 2010 external lists using Visual Studio 2010. Now you are able to create external list and add basic CRUD functions. In this blog we will show how to create Association between Sharepoint BDC entities using Visual Studio 2010 and use Business Data Web Parts to display the data and the association in SharePoint page.

The same as our second blog, we will use “Northwind” database as external data source, so if you do not have an existing “Northwind” database available, please download it here and install the sample database following the instruction of the installed package or our last blog here.

If you have not read the first two blog entries, we recommend you read them before going through the following content, since this article is highly relevant with previous ones. The first several parts are very similar with the last blog, so they are simplified to only contain useful information. Please refer to the previous articles for any ambiguity.

Create BDC Project

First of all, let’s create a new C# BDC Model project and rename it “BdcAssociationSample”.

Connect to external data source

Add a LINQ to SQL model and drag-and-drop both Customers and Orders tables of Northwind database from the Server Explorer. Right click on the LINQ to SQL item and click View Code, and insert the following code.

C#:

 1 public partial class CustomersAndOrdersDataContext
 2 {
 3     private const string ConnectionString = @"Data Source=localhost\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True;Pooling=False";
 4 
 5     public CustomerDataContext() :
 6         base(ConnectionString, mappingSource)
 7     {
 8         OnCreated();
 9     }
10 }

VB:

1 Partial Public Class CustomersAndOrdersDataContext
2     Private Const ConnectionString As String = "Data Source=localhost\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True;Pooling=False"
3     Public Sub New()
4         MyBase.New(ConnectionString, mappingSource)
5         OnCreated()
6     End Sub
7 End Class

Design BDC Model

Design the Customer and Order entities according to the LINQ to SQL model. To simply the problem, we only define Specific Finder method and Finder method for both of the entities.

After this step, we get two entities as below.

The TypeDescriptors in BDC Explorer are like this:

Add Association between Customer and Order

Now we can create an association by selecting Association tool in the Visual Studio Toolbox, clicking the first entity Customer (called the source entity) and then clicking the second entity Order (called the destination entity). You can define the details of the association in the popped out Association Editor.

By default, the Association Editor adds an Association Navigation method to the source and destination entities. An Association Navigation method in the source entity enables consumers to retrieve a list of destination entities. An Association Navigation method in the destination entity enables consumers to retrieve the source entity that relates to a destination entity.

You can create two types of associations in the BDC designer: foreign key-based associations and foreign keyless associations. For detailed information, check out this on MSDN.

Now we are creating a foreign key-based associations. So check Is Foreign Key Association checkbox and find ReadItem.order.Order.CustomerID in the left column of the Identifier Mapping gird, and then select CustomerID from the Source ID column on the right to map the identifier. Now the dialog looks like below:

Click OK to finish the association creation. On the design surface we get an association CustomerToOrderAssociation which connects two entities with a dotted line.

Add code behind to access external data source

In Solution Explorer, find and open CustomerService.cs (.vb), and then replace the implementation with the following code snippet:

C#:

 1 public static Customer ReadItem(string customerID)
 2 {
 3     CustomersAndOrdersDataContext context = new CustomersAndOrdersDataContext ();
 4     Customer cust = context.Customers.Single(c => c.CustomerID == customerID);
 5 
 6     return cust;
 7 }
 8 
 9 public static IEnumerable<Customer> ReadList()
10 {
11     CustomersAndOrdersDataContext context = new CustomersAndOrdersDataContext ();
12     IEnumerable<Customer> custList = context.Customers;
13     return custList;
14 }
15 
16 public static IEnumerable<Order> CustomerToOrder(string customerID)
17 {
18     CustomersAndOrdersDataContext context = new CustomersAndOrdersDataContext();
19 
20     IEnumerable<Order> orderList = context.Orders.Where(o => o.CustomerID == customerID);
21 
22     return orderList;
23 }

VB:

 1 Public Shared Function ReadItem(ByVal customerID As String) As Customer
 2     Dim context As New CustomersAndOrdersDataContext
 3 
 4     Dim cust = (From c In context.Customers _
 5                Where c.CustomerID = customerID _
 6                Select c).Single()
 7     Return cust
 8 End Function
 9 
10 Public Shared Function ReadList() As IEnumerable(Of Customer)
11     Dim context As New CustomersAndOrdersDataContext
12 
13     Return context.Customers
14 End Function
15 
16 Public Shared Function CustomerToOrder(ByVal customerID As String) As IEnumerable(Of Order)
17     Dim context As New CustomersAndOrdersDataContext
18 
19     Dim orderList = From o In context.Orders _
20                     Where o.CustomerID = customerID _
21                     Select o
22     Return orderList
23 End Function

Then open and do the same for OrderService.cs (.vb).

C#:

 1 public static Order ReadItem(int orderID)
 2 {
 3     CustomersAndOrdersDataContext context = new CustomersAndOrdersDataContext();
 4 
 5     Order order = context.Orders.Single(o => o.OrderID == orderID);
 6 
 7     return order;
 8 }
 9 
10 public static IEnumerable<Order> ReadList()
11 {
12     CustomersAndOrdersDataContext context = new CustomersAndOrdersDataContext();
13 
14     IEnumerable<Order> orderList = context.Orders;
15 
16     return orderList;
17 }
18 
19 public static IEnumerable<Customer> OrderToCustomer(int orderID)
20 {
21     CustomersAndOrdersDataContext context = new CustomersAndOrdersDataContext();
22 
23     string customerID = context.Orders.Single(o => o.OrderID == orderID).CustomerID;
24 
25     IEnumerable<Customer> custList = context.Customers.Where(c => c.CustomerID == customerID);
26 
27     return custList;
28 }

VB:

 1 Public Shared Function ReadItem(ByVal orderID As Integer) As Order
 2     Dim context As New CustomersAndOrdersDataContext
 3 
 4     Dim order = (From o In context.Orders _
 5                Where o.OrderID = orderID _
 6                Select o).Single()
 7     Return order
 8 End Function
 9 
10 Public Shared Function ReadList() As IEnumerable(Of Order)
11     Dim context As New CustomersAndOrdersDataContext
12 
13     Return context.Orders
14 End Function
15 
16 Public Shared Function OrderToCustomer(ByVal orderID As Integer) As IEnumerable(Of Customer)
17     Dim context As New CustomersAndOrdersDataContext
18 
19     Dim customerID = (From o In context.Orders _
20                Where o.OrderID = orderID _
21                Select o).Single().CustomerID
22 
23     Dim custList = From c In context.Customers _
24                     Where c.CustomerID = customerID _
25                     Select c
26     Return custList
27 End Function

Deploy the solution and create new page to see the associated data lists

1. Go to the homepage of your SharePoint site. Typically http://localhost.

2. On the top left corner of the site, select Site Actions -> New Page, name the new page BdcAssociationSample.

3. On the ribbon, select Insert -> Web Part, and click on Business Data from the Categories panel, select Business Data List from the Web Parts panel. Click Add.

4. Repeat the step above, select Business Data Related List and click Add.

5. Click Open the tool pane on Business Data List, then select Customer from External Content Type picker and click OK. Now you should able to see the customer information from the database is displayed in the list.

6. Repeat the step above, select Order on Business Data Related List.

7. On the top-right corner of the Business Data Related List, click on the drop down menu and select Edit Web Part. After the page refreshed, from the same drop down menu, select Connections -> Get Related Item From -> Customer. Click OK.

8. Click Save & Close on the ribbon of the new page.

Now you can see a list of Customers on the SharePoint page, when you select a row in the Customer table, a list of orders related with this customer will showed in the second table.

Select CustomerID ALFKI by clicking the small icon in the front of each line.

The second list will display the corresponding orders.

Yanchen Wu

Deploy your BDC model to a specific BCS Service using Visual Studio 2010

2010-07-30T19:38:00Z

When deploying a BDC model in Visual Studio 2010, some people may see this error message “… There is no default Business Data Connectivity Service Proxy available for the given SPServiceContext…” or similar ones. This probably means the SiteUrl feature property is not appropriately set.

SiteUrl is a SharePoint feature property that determines where a feature will be deployed. When a BCS feature is deployed, SharePoint server will look up a BCS service (if there are more than one BCS service connected to the site, it will select the default one) connected to the appointed SiteUrl. If the SiteUrl property is omitted, it assumes the value of SiteUrl is http://localhost:80. The SharePoint BDC project in VS2010 helps you customize the feature properties like SiteUrl. Let me show you how you can easily manage SiteUrl property here.

Assume you have two BCS services, BCS1 and BCS2, and two web applications, one on port 80 (http://localhost:80) named WebApp80, and the other on port 90 (http://localhost:90) named WebApp90. In SharePoint 2010 Central Administration, you can link services up with web applications. Browse to the Web Application Management page, select the web application WebApp80 as shown in the screenshot below.

If you click the Service Connections button on the top ribbon, the Configure Service Application Associations dialog will be displayed. Now you can select BCS1 as the default BCS service for the current web application as shown in the screenshot below.

It is the same for adding BCS2 to WebApp90. Now BCS1 is the default BCS service for WebApp80 and BCS2 is the default BCS service for WebApp90.

Now let’s create a new BDC project. SiteUrl by default is not set for a new project. So the solution will be deployed to BCS1. If we want to deploy the solution to the BCS service other than BCS1, how can we do that? Here are the steps.

1. Select the BDC folder node in the Solution Explorer and view its properties in the Property Window. Click the […] at the end of Feature Properties row in the Property Window. See the screenshot below.

2. The Feature Properties dialog will be displayed. Now we can add the SiteUrl property and set its value to http://localhost:90 where BCS2 is the default BCS service.

3. Now if we deploy the solution again, it will be deployed to BCS2.

Enjoy using this feature!

Jeff Chen

Using Deployment Step events to add functionality to Deployment Configuration

2010-07-21T22:16:00Z

With the help of the extensibility features in the SharePoint tools in Visual Studio, you can add functionality to deployment configurations by subscribing to the DeploymentStepStarted and DeploymentStepCompleted events.

To learn more about deployment configurations and deployment steps in SharePoint projects, refer to the MSDN article here.

In this blog post I will show you how to use the DeploymentStepCompleted event and add you own code that is executed when a SharePoint project is either deployed or retracted.

Our scenario is the following: When retracting Web Parts we would like to delete the .webpart file from the SharePoint server. We will create a project item extension for the Visual Web Part project and from that extension we will subscribe to the DeploymentStepCompleted event. First we will need to create a SharePoint project item extension project.

To do that we will need to:

1) Install the Visual Studio SDK from: http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=47305cf4-2bea-43c0-91cd-1b853602dcc5

2) Create an empty VSIX project

3) Add a class library project which is project item extension project to the solution

4) Add the output from the project item extension project as MEF component content to the VSIX manifest in the VSIX project.

For detailed information on how to create project item extensions you can refer to the walkthrough here or Bing ‘Visual Studio 2010 How to: Create a SharePoint Project Item Extensions.

Let’s start by creating a project Item extension for Visual Web Part.

[Export(typeof(ISharePointProjectItemTypeExtension))]

[SharePointProjectItemType("Microsoft.VisualStudio.SharePoint.VisualWebPart")]

internal class ItemExtension : ISharePointProjectItemTypeExtension

{

public void Initialize(ISharePointProjectItemType projectItemType)

{

projectItemType.DeploymentStepCompleted += new EventHandler<DeploymentStepCompletedEventArgs>(projectItemType_DeploymentStepCompleted);

}

void projectItemType_DeploymentStepCompleted(object sender, DeploymentStepCompletedEventArgs e)

{

ISharePointProjectItem SPProjectItem = e.ProjectItem;

string webPartUrl = GetWebPartFileUrl(SPProjectItem);

if (e.DeploymentStepInfo.Id == DeploymentStepIds.RetractSolution && !string.IsNullOrEmpty(webPartUrl))

{

SPProjectItem.Project.SharePointConnection.ExecuteCommand<string>(DeleteWebPartFileCommand, webPartUrl);

}

Notice in above code we created a new class called Item Extension that implements the ISharePointProjectItemTypeExtension interface. In order for this class to be recognized in Visual Studio we added two attributes. With the Export attribute we are telling Visual Studio that this class is a project item extension and with second attribute (SharePointProjectItemType) we are telling Visual Studio that this extension applies to the Visual Web Part projects. Extension developers can subscribe to deployment step events in the Initialize method of the project item extension.

projectItemType.DeploymentStepCompleted += new EventHandler<DeploymentStepCompletedEventArgs>(projectItemType_DeploymentStepCompleted);

The event we subscribed to is raised for all the deployment steps that are executed in the active deployment configuration. With the help of the event args parameter passed to the event handler we can check which step is being executed and decide what code to run.

if (e.DeploymentStepInfo.Id == DeploymentStepIds.RetractSolution && !string.IsNullOrEmpty(webPartUrl))

Since this includes deleting a file on the SharePoint server, the extension uses a custom SharePoint command to call into the SharePoint server object model. For detailed information on why to use SharePoint commands is discussed here.

The line of code which uses the SharePoint command is:

SPProjectItem.Project.SharePointConnection.ExecuteCommand<string>(DeleteWebPartFileCommand, webPartUrl);

When this line of code is executed we create a new process named vssphost4.exe or use an existing one. The SharePoint command named DeleteWebpartFileCommand is executed inside this process during execution.

To create a SharePoint command class we need to:

1) Add a class library project that targets the .NET Framework 3.5 to the same solution as the VSIX and project item extension projects.

2) Add references to Microsoft.SharePoint.dll and Microsoft.VisualStudio.SharePoint.Commands.dll.

3) Add the commands project output to the VSIX manifest in the VSIX project as a Custom Content Type with Type= “SharePoint.Commands.v4”. This will include the commands project in the VSIX as custom assembly which can be used by the SharePoint project extensions.

internal class Command

{

[SharePointCommand("DeleteWebPartFile")]

private void DeleteWebPartFile(ISharePointCommandContext context, string webPartFileUrl)

{

//Append RootWeb Url

string fullWebpartFileUrl = SPUrlUtility.CombineUrl(context.Web.Site.RootWeb.Url, webPartFileUrl);

try

{

SPFile file = context.Web.Site.RootWeb.GetFile(fullWebpartFileUrl);

if (file.Exists)

{

file.Delete();

context.Logger.WriteLine(string.Format("Visual Webpart Extension:Deleted file at {0}", fullWebpartFileUrl), LogCategory.Status);

}

catch (Exception ex)

{

context.Logger.WriteLine(string.Format("Visual Webpart Extension:Exception occured when deleting file at: {0}", fullWebpartFileUrl), LogCategory.Status);

context.Logger.WriteLine(string.Format("Visual Webpart Extension:Exception occured when deleting file at: {0}; Exception:{1}", fullWebpartFileUrl, ex.Message + ex.StackTrace), LogCategory.Verbose);

}

Notice in the above code we are have an attribute SharePointCommand for the method name which will enable it to be recognized and used by the project item extension to call into. Also the first parameter should be ISharePointCommandContext which will have reference to ‘SPWeb’ to take advantage of Server object model.

You will also see the logger object is also exposed in the context parameter with which we can log back messages to the output window of Visual Studio from vssphost4.exe.

You can now install the extension located in the bin/output folder of the VSIX project after the solution is built. Once this extension is installed the DeploymentStepCompleted event will be raised each time a Visual Web Part project is being retracted after the ‘retractSolution’ step.

To test and debug the extension:

1) Download and open the extension project from MSDN code gallery.

2) Place a breakpoint in the projectItemType_DeploymentStepCompleted event handler in ItemExtension.cs file and press F5 to start debugging. This will install the VSIX extension in the experimental instance of Visual Studio.

3) The experimental instance of Visual Studio will start. Create a Visual Web Part project (select the project template under the SharePoint 2010 node) and use default values in the wizard.

4) Once the project is created, press F5.

5) Close IE or stop debugging to start executing the retraction steps.

6) Once the retraction steps start executing, you will see the breakpoint being hit after “Retract Solution” step.

7) You will see the file being deleted after the code is executed.

For more information on how to extend the SharePoint project system in Visual Studio you can refer to MSDN topic here or Bing “Visual Studio 2010 Extending the SharePoint Project System“.

Murali Madala.

Extending the SharePoint Tools in Visual Studio: An Overview

2010-07-08T18:26:00Z

Since you’re reading this blog, you’re probably aware that Visual Studio 2010 includes an all-new set of tools for creating SharePoint solutions for Microsoft SharePoint Foundation 2010 and Microsoft SharePoint Server 2010. These tools include a set of project and item templates for developing various types of solutions, integrated Feature and packaging support (with designers), and the SharePoint Connections node in Server Explorer.

However, you might not know that the SharePoint tools include a comprehensive extensibility model. This extensibility model is public and fully documented. In fact, all of the built-in tools were implemented by using same extensibility model that you can use to create your own extensions. A number of Visual Studio extensions that were built by using this extensibility API are already available, such as VSeWSSImport and vsixforsp.

The purpose of this post is to provide a high-level overview of the different ways you can extend the SharePoint tools, with some pointers to relevant topics and code examples in the documentation.

Introduction to the Extensibility Model

To extend the SharePoint tools in Visual Studio 2010, you use types in three assemblies that are included with Visual Studio:

Microsoft.VisualStudio.SharePoint.dll
Microsoft.VisualStudio.SharePoint.Commands.dll
Microsoft.VisualStudio.SharePoint.Explorer.Extensions.dll.

For the rest of the post I'll refer to these collectively as the SharePoint tools API. You can think of this API as an abstraction layer on top of the Visual Studio automation object model (DTE and related types) and integration object model (VSPackages and related types). When you create extension for the SharePoint tools, you always work directly with the SharePoint tools API, but you can also call into the automation and integration object models if you need to leverage functionality that is provided only in those object models.

The SharePoint tools API consists of two main groups of types:

Extensibility interfaces that you implement as the basis for an extension of the SharePoint tools. To extend a particular feature of the SharePoint tools, you implement an interface that is defined by the SharePoint tools and apply the Export attribute (and additional attributes as necessary) to your interface implementation. There are a handful of extensibility interfaces provided by the SharePoint tools, including ISharePointProjectItemTypeExtension, ISharePointProjectItemTypeProvider, and ISharePointProjectExtension. The SharePoint tools use the Managed Extensibility Framework (MEF) to expose extensibility interfaces and to manage extensions.
Other types that represent components that you can modify or automate in extensions (such as ISharePointProject and ISharePointProjectItem, which represent a SharePoint project and project item, respectively), and other supporting types such as delegates, attributes, and enumerations. Most of the types in the SharePoint tools API fall into this category.

There are two main feature areas that you can extend: the SharePoint project system and the SharePoint Connections node in Server Explorer.

SharePoint Project System

The SharePoint project system refers to the components and functionality that are available in a SharePoint project. At the highest level, this includes the project itself, each SharePoint project item in the project, and other contents of the project such as mapped folders, Feature definitions, and the package definition. A SharePoint project item (or SPI for short) represents a specific SharePoint customization - for example, a Web Part, an event receiver, or list definition. In a SharePoint project that is open in Solution Explorer, each SharePoint project item is represented by a node with an icon that identifies the item type. This node can contain additional files that are associated with the project item, such as Elements.xml files or code files.

The Microsoft.VisualStudio.SharePoint namespace contains most of the main types in the SharePoint project system, such as ISharePointProject and ISharePointProjectItem. Other project system types are also provided in the Microsoft.VisualStudio.SharePoint.Deployment, Microsoft.VisualStudio.SharePoint.Features, Microsoft.VisualStudio.SharePoint.Packages, and Microsoft.VisualStudio.SharePoint.Validation namespaces.

You can extend the SharePoint project system in the following ways:

Create an extension for a particular type of SPI, such as the built-in List Definition project item. Your extension is loaded only when an instance of the targeted SPI type is in a project that is open in Visual Studio. For more information and related code examples, see Extending SharePoint Project Items in the MSDN documentation.
Create your own new type of SPI, which you can associate with an item template or project template. You can even implement your own wizard that appears when a customer adds your SPI to a project, or creates a new project that includes your SPI. For more information and related code examples, see Defining Custom SharePoint Project Item Types in the MSDN documentation.
Create an extension for SharePoint projects. Your extension is loaded whenever any type of SharePoint project is open in Visual Studio. For more information and related code examples, see Extending SharePoint Projects in the MSDN documentation.
Extend the packaging and deployment behavior of a SharePoint project or SPI. For example, you can create your own deployment steps or deployment configurations, handle various deployment-related events, or create your own validation rules for Features and package definitions. For more information and related code examples, see Extending SharePoint Packaging and Deployment in the MSDN documentation.

There are a number of tasks you can perform in extensions of the SharePoint project system. For example, you can add custom properties to SharePoint projects or particular types of SPIs (these properties appear in the Properties window when a project or SPI is selected in Solution Explorer), add your own context menu items to SharePoint projects or particular types of SPIs (these menu items appear when you right click the project or SPI in Solution Explorer), and you can handle many different events that are raised by SharePoint projects and SPIs in various scenarios. The MSDN topics I link to above provide how-to topics and walkthroughs that demonstrate all of these tasks.

SharePoint Connections Node in Server Explorer

The new SharePoint Connections node in Server Explorer is intended to be used to browse the contents of local SharePoint sites on your development computer. After you add a connection to a local SharePoint site, many (but not all) of the components of the site are displayed here in a hierarchical tree view. This can help provide a quick, comprehensive view of the site while you are working on a new SharePoint solution that you plan to deploy to it. For an overview of how this feature is used, see Browsing SharePoint Connections Using Server Explorer.

The Microsoft.VisualStudio.SharePoint.Explorer and Microsoft.VisualStudio.SharePoint.Explorer.Extensions namespaces contain the types that you can use to extend the SharePoint Connections node.

You can extend the SharePoint Connections node in the following ways:

Extend a node, such as the node that represents fields, lists, or content types. For a code example and step-by-step instructions, see How to: Extend a SharePoint Node in Server Explorer in the MSDN documentation.
Create a new type of node. For example, you might want to do this if you want to create an extension that can display components of SharePoint sites that the built-in SharePoint Connections node does not support, such as Web Parts. For a code example and step-by-step instructions, see How to: Add a Custom SharePoint Node to Server Explorer in the MSDN documentation.

As with the project system, you can also add custom properties and context menu items to nodes, and there are a number of different events you can handle. The MSDN topics I link to above provide how-to topics and walkthroughs that demonstrate all of these tasks.

Important Features

The following features play an important role in most extensions of the SharePoint tools.

SharePoint Commands

Most extensions need to call into the SharePoint APIs to perform some work, such as determining whether a particular file exists on a SharePoint site or adding or deleting content from a site. Although the 2010 releases of SharePoint now include a client object model, most SharePoint tools extensions should use the "traditional" server object model, because the client object model was designed to be used to call into remote SharePoint installations, not local installations. However, the SharePoint server object model cannot be called directly from SharePoint tools extensions, because the SharePoint server object model can be called only from 64-bit processes that target the .NET Framework 3.5, but SharePoint tools extensions are run in the Visual Studio process, which is a 32-bit process that targets the .NET Framework 4.

To bridge this gap, the Visual Studio tools include the concept of a SharePoint command. A SharePoint command is essentially an intermediary method that can call into the SharePoint server object model directly, and that can be called by your extension. For a nuts-and-bolts explanation of how this works, see Calling into the SharePoint Object Models, How to: Create a SharePoint Command, and How to: Execute a SharePoint Command in the MSDN documentation.

SharePoint Service

The Visual Studio tools provide a special service object, called the SharePoint service, which provides a number of different features such as the ability to convert some types in the SharePoint tools API to types in the Visual Studio automation and integration object models, execute a SharePoint command, and access any open SharePoint project or project item. For more information, see Using the SharePoint Project Service in the MSDN documentation.

Related Walkthroughs

For end-to-end walkthroughs that demonstrate how to implement, deploy, and test different types of SharePoint tools extensions, see the following walkthroughs in the MSDN documentation.

Project System Extensions

Walkthrough: Extending a SharePoint Project Item Type: Demonstrates how to extend the built-in Business Data Connectivity Model project item type.
Walkthrough: Creating a SharePoint Project Extension: Demonstrates how to add a custom property to all SharePoint projects. Developers can use the property to add or remove a mapped folder.
Walkthrough: Creating a Custom Action Project Item with an Item Template, Part 1: Demonstrates how to define a SharePoint project item type for creating a custom action in SharePoint, and associating an item template with the new project item type.
Walkthrough: Creating a Custom Action Project Item with an Item Template, Part 2: Demonstrates how to create a wizard for a custom SharePoint project item type that is associated with an item template.
Walkthrough: Creating a Site Column Project Item with a Project Template, Part 1: Demonstrates how to define a SharePoint project item type for creating a site column in SharePoint, and associating a project template with the new project item type.
Walkthrough: Creating a Site Column Project Item with a Project Template, Part 2: Demonstrates how to create a wizard for a custom SharePoint project item type that is associated with a project template.
Walkthrough: Creating a Custom Deployment Step for SharePoint Projects: Demonstrates how to define a custom deployment step that can be used to upgrade SharePoint solutions.

Extensions of the SharePoint Connections Node in Server Explorer

Walkthrough: Extending Server Explorer to Display Web Parts: Demonstrates how to add new nodes for displaying Web Parts in SharePoint sites that are displayed in Server Explorer. This walkthrough also demonstrates how to create a SharePoint command to call into the SharePoint server object model.
Walkthrough: Calling into the SharePoint Client Object Model in a Server Explorer Extension: Demonstrates how to add new nodes for displaying Web Parts in SharePoint sites that are displayed in Server Explorer. This walkthrough also demonstrates how to use the SharePoint client object model.

McLean Schofield

Deploying documents with content types and associating content types with libraries (Part III)

2010-06-24T21:55:09Z

Part III: Using Feature Event Receiver to create a library and associate a content type

In previous post we showed how to use ContentTypeBinding to bind the content type to an existing document library. In this post, we will learn how to achieve similar results but using the feature event receiver. In this post we will create a new document library, remove all existing content types from the created library and then add our content type to the list. Instead of create a new library from the code, you could also reference an existing one that’s already on the SharePoint server. In this example we will use the same project we created in Part I. So, let's start by opening that project which contains the content type and a document. When project opens, expand the Features folder, right click the Feature1 folder and finally select the Add Event Receiver option to add a feature event receiver to the project. Next, uncomment the FeatureActivated method and add the following code:

SPWeb web = properties.Feature.Parent as SPWeb;

string libraryName = "Sample library name - " + DateTime.Now.Millisecond.ToString ();

Guid listGuid = web.Lists.Add(libraryName, string.Empty, SPListTemplateType.DocumentLibrary);

SPList list = web.Lists[listGuid];

// Delete all content types from the list

for (int i = 0; i < list.ContentTypes.Count; i++)

{

list.ContentTypes[i].Delete();

}

SPContentType myContentType = web.ContentTypes[new SPContentTypeId("0x010100a9fe27b0556b4de8a60d9e04c6db71de")];

list.ContentTypes.Add(myContentType);

list.ContentTypesEnabled = true;

list.Update();

In the above code we are adding a library to the SharePoint site. The Add method returns the Guid of the created list/library. In the for statement, we iterate through all the content types that are in the list (since we created a new document library there should be only 1 content type (Document) in the library) and we delete them.

After we removed all content types from the list, we add a new content type to the list (similar as in Part II, we are referring to the content type by its ID). You can use the Server Explorer to get the content type ID. Finally, we enable the content type management in the list and we update the list to save the changes.

If you press F5 you will notice that the "My New Document Library" is created on SharePoint. If you click the Documents tab and then open the New Document menu you will notice a document we associated with the content type shows up.

Peter Jausovec

The Visual Studio 2010 SharePoint Power Tools are now available!

2010-06-17T19:29:00Z

The Visual Studio team that brought you the SharePoint developer tools in Visual Studio 2010 is happy to announce we have created a set of power tools that make developing SharePoint 2010 sandboxed solutions even easier. Below is the list of features included in the current release of the power tools.

Sandboxed-compatible Visual Web Part
This item template enables you to use a visual designer to create SharePoint web parts that can be deployed in a SharePoint 2010 sandboxed solution.

Sandboxed Compilation
This extension displays build errors when you use types or members in a SharePoint 2010 sandboxed project which are not allowed in the SharePoint sandbox environment.

The Visual Studio 2010 SharePoint Power Tools are available immediately on the Visual Studio Gallery.

Mike Morton - Program Manager - Visual Studio