Creating SharePoint 2010 Solutions by Using Visual Studio 2010
· Overview of SharePoint 2010
· Creating a SharePoint 2010 Project in Visual Studio 2010
· SharePoint 2010 Projects and Project Items
· Sandboxed Solutions for SharePoint 2010
Deploying SharePoint 2010 Solutions by Using Visual Studio 2010
· SharePoint 2010 Solution and Feature Packages
· Deploying a SharePoint 2010 Solution by Using Visual Studio 2010
· Identifying Features of SharePoint 2010 Solutions
Module Summary
Lesson Introduction
The tight integration between Visual Studio 2010 and SharePoint 2010 helps you to create SharePoint solutions more easily than ever before. With the tools and development features provided by Visual Studio 2010, you no longer need to spend your time understanding the internal architecture of SharePoint solutions. Instead, you can concentrate your development efforts on building solutions that meet your business requirements.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe important features of SharePoint 2010.
- Describe the types of SharePoint 2010 projects and project items in Visual Studio 2010.
- Identify features of SharePoint solutions.
- Create a SharePoint 2010 project in Visual Studio 2010.
- Describe sandboxed solutions in SharePoint 2010
Lesson Introduction
The tight integration between Visual Studio 2010 and SharePoint 2010 helps you to create SharePoint solutions more easily than ever before. With the tools and development features provided by Visual Studio 2010, you no longer need to spend your time understanding the internal architecture of SharePoint solutions. Instead, you can concentrate your development efforts on building solutions that meet your business requirements.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe important features of SharePoint 2010.
- Describe the types of SharePoint 2010 projects and project items in Visual Studio 2010.
- Identify features of SharePoint solutions.
- Create a SharePoint 2010 project in Visual Studio 2010.
- Describe sandboxed solutions in SharePoint 2010
Although you can build various types of SharePoint solutions, the most common development efforts can be categorized into four general types: Single Web Part solutions, full collaborative solutions, portals for LOB data, and customized SharePoint workload solutions.
The following table describes the rationale for using each of these solution types
- Single web parts:
Single Web Part solutions can range from a very simple solution that displays data on a page to a Web Part that queries several lists to display consolidated information to users.
You can create Web Part solutions by using Visual Studio 2010. You can deploy such solutions directly from the integrated development environment to a SharePoint site on your local machine for testing and debugging. When a Web Part has been deployed, you can add it to a SharePoint page from the Web Parts gallery.
-
Full collaborative solutions:
Full collaborative solutions may consist of multiple features within SharePoint. These features can be enabled or disabled by an administrator.
You can build full collaborative solutions that use multiple lists and consist of several Web Parts that are packaged together and deployed to a SharePoint site. Full collaborative solutions may also make use of the workflow features within SharePoint.
An example of a full collaborative solution is a human resources (HR) recruitment solution that uses document libraries for managing candidate resumes and job descriptions, lists for recording activities and interviews, and workflow elements that track candidates to the end of the recruitment process.
-
Portals for LOB Data:
Portal solutions that extract and manipulate data from external LOB systems are a very common type of application for SharePoint 2010. When you build a portal for external data, users can view, insert, update, and delete data from SharePoint pages.
You can use the built-in features, services, and tools provided by Business Connectivity Services of SharePoint 2010 to build portals for LOB data
-
Customized SharePoint work load solutions:
SharePoint 2010 includes several core workloads, such as:
- Sites
- Search
- Composites
- Content
- Insights
- Communities
As a developer, you will often develop solutions that are built on these workloads but modify their default behavior to meet your specific business requirements. For example, you may build a search results Web Part to customize the search workload, or you might apply branding and styling to the sites workload to achieve a look and feel that is consistent with the corporate identity of your organization.
-
SandboxedSolutions for SharePoint 2010
SharePoint solutions can be built, assembled, and adapted rapidly to meet changing business objectives. In previous versions of SharePoint, this agility had to be balanced with the requirements to deliver a stable environment. IT departments were often concerned that deploying a solution with badly written code might introduce errors, security issues, or performance degradation. These concerns were magnified in a multi-tenanted infrastructure, where other customers might be affected by poorly designed or malicious code.
With SharePoint 2010, you can deploy sandboxed solutions. Consequently, you gain the benefits of building agile solutions without compromising platform stability or security. Because sandboxed solutions are deployed to the Solution gallery, information workers can now assemble their own solutions from safe, prebuilt components without requiring administrator approval.
Code in a sandboxed solution is run against a subset of the application programming interfaces (APIs) that are available to a full-trust solution. A special worker process executes your sandboxed code against a subset of the object model. The subset object model contains classes below SPSite, except for security sensitive classes such as SPSecurity, SPSite construction, and auditing. The subset object model explicitly excludes the SPFarm class, which helps protect other Web applications and site collections in the farm.
As a developer, you can create sandboxed solutions from Visual Studio 2010, either by selecting the Sandboxed Solution option in the SharePoint Customization Wizard during project creation, or by setting the Sandboxed property in the Properties window for a project after you have created it.
Additionally, the sandboxing architecture has advanced resource monitoring functionality, which helps administrators to monitor the number of resource counters used by a sandboxed solution. Proactive action can be taken against solutions that consume more resources than have been allocated to them. When thresholds are reached, e-mail messages can be sent to the administrator or the sandboxed code can be deactivated
-
SharePoint2010 Solutions and Feature Packages The integration of Visual Studio 2010 and SharePoint 2010 simplifies the deployment of solutions in development environments. Visual Studio can build and package your solution Features into a Windows SharePoint Package (WSP) file, and can deploy the package to a SharePoint site for easy testing and debugging. Visual Studio 2010 provides feature designers and package designers to help you manage the artifacts in your SharePoint solution
-
Feature designer
A feature is a SharePoint artifact containing code and other resources that can be activated or deactivated by a site administrator. Features reduce the complexity involved in making modifications to a site and allow and administrator to enable or disable functionality using the SharePoint administration pages.
You can develop Features by using the Visual Studio 2010 Feature Designer. This tool enables you to specify the scope of the feature along with the items in the solution that should be included or excluded from the Feature. It also enables you to specify Feature activation dependencies.
-
Package Designer
You can use Visual Studio 2010 to package one or more features into a WSP file. A WSP file is a specialized installer for SharePoint solutions. Unlike traditional Microsoft Installers (MSI), WSP installers support deployment to SharePoint farms, and automatically ensure that artifacts are deployed to all applicable servers in the farm.
You can use the Package Designer in Visual Studio 2010 to manage how features are deployed. You can also include additional assemblies, such as dynamic link libraries (DLLs), which your features depend upon.
-
Module Overview
SharePoint 2010 provides new and improved application programming interfaces (APIs). These APIs and their new development features enable you to build compelling solutions that meet your business requirements.
For example, you can use the new and improved event and workflow capabilities to build powerful business processes that are driven by collaborative data. You can also use the new user interface capabilities to build rich compelling user experiences. Furthermore, you can use the new LINQ to SharePoint technologies to manipulate SharePoint data in an efficient and intuitive manner
Module Objectives
Module Objectives
After completing this module, you will be able to:
- Describe the new event and workflow capabilities for SharePoint 2010 developers.
- Develop user interfaces for the new dialog platform and server ribbon.
- Create solutions that use LINQ to SharePoint
New Process Capabilities for SharePoint 2010
· New Event Capabilities
· New Workflow Capabilities
Developing New User Interfaces for SharePoint 2010
· New User Interface Platforms for SharePoint 2010
· Creating Dialog and Ribbon Controls
· Identifying Features of SharePoint 2010 User Interfaces
Using LINQ to SharePoint
· LINQ to SharePoint Fundamentals
· Using SPMetal to Create SharePoint Entities
Lesson Introduction
SharePoint 2010 provides an improved set of events and more powerful workflow capabilities over previous versions.
For example, the new events enable individual workflows to be chained together to represent potentially complex business processes. Furthermore, SharePoint 2010 supports new types of workflows that can be associated with sites rather than just lists.
You can use events and workflows to add business processes to SharePoint collaborative data.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe the new event capabilities for SharePoint 2010 developers.
- Describe the new workflow capabilities for SharePoint 2010 developers
Creating event receivers for SharePoint events by using Visual Studio 2010 is now easier than in previous versions. SharePoint 2010 provides new events and event capabilities that enable you to build more complex business processes in a shorter development time.
The following table describes the new event support that Visual Studio offers for event receivers and the new SharePoint 2010 events and capabilities.
- New Visual Studio support for eventReceivers
SharePoint 2010 has introduced new events that provide more functionality when you create workflows. For example, SharePoint 2010 enables you to start one workflow following the completion of another using the WorkflowCompleted event. This enables you to build a set of modular workflows, which, when chained together, satisfy complex process requirements.
The ability of a workflow to provide an event that an event receiver can handle enables you to monitor the status of individual workflows. These monitoring receivers can then notify site administrators of the status of a workflow, or start their own set of actions.
Another new event, the WorkflowStarting event, provides you with the option of pre-event handling. This enables you to add logic to intercept schema or serialization errors before the workflow starts.
-
New eventsand capabilities for SharePoint 2010
SharePoint 2010 introduces new events that provide more functionality when you create workflows. For example, SharePoint 2010 enables you to start one workflow following completion of another using the WorkflowCompleted event. This enables you to build a set of modular workflows that, when chained together, satisfy a complex process requirements.
The ability for a workflow to provide an event that an event receiver can handle enables you to monitor the status of one workflow by another. These monitoring receivers can then notify site administrators of a workflow's status or start their own set of actions.
Another new event, the WorkflowStarting event, provides you with the option of pre-event handling. This enables you to add logic to intercept schema or serialization errors before the workflow starts
SharePoint 2010 has introduced new workflow events that enable you to build complex business processes without compromising on development time. The WorkflowCompleted event, for example, enables you to build a set of modular workflows in which one workflow can begin where another one ends, and where information can be passed back to the calling workflow.
SharePoint 2010 provides the following workflow events:
- WorkflowStarting
- WorkflowStarted
- WorkflowCompleted
- WorkflowLoading
- WorkflowUnloading
- WorkflowPostponed
The workflow concept can be used when working with external systems as well. You can call an external system from a workflow and wait for that external system to complete its work. SharePoint 2010 supports integration with external systems using the pluggable External Data Exchange (EDE) service. The EDE service handles task management and correlates the originating request from a workflow to the response received from the external system
Lesson Introduction
SharePoint 2010 provides compelling, efficient, and context sensitive user interfaces, such as the new server ribbon and the new client-side dialog platform.
As a developer, you can create new ribbon controls so that information workers can access your functionality in a context-sensitive way. You can also create dialogs based on the new dialog platform, to help users perform operations in an extremely efficient manner.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe the new user interfaces that can be used and extended by developers.
- Create dialog and ribbon controls.
- Identify features of SharePoint 2010 user interfaces
SharePoint 2010 provides new user interface concepts that enhance the user's experience when working with SharePoint. For example, the new server ribbon platform provides context-sensitive commands to help information workers and administrators perform specific tasks in SharePoint sites.
Furthermore, the new client-side dialog platform provides a rich Web experience for information workers and administrators as they work with SharePoint data and objects.
From the perspective of the developer, it is important to understand that the new ribbon and dialog platforms run in the Web browser of the end user. This means that the new user interfaces respond very rapidly to user actions, without continually requiring full page post-backs to SharePoint Web servers.
When the new user interfaces do need to communicate with SharePoint servers, the communication is performed in a very efficient, batched manner
Lesson Introduction
LINQ to SharePoint provides developers with an intuitive and efficient approach for working with SharePoint data. For example, a LINQ to SharePoint tool called SPMetal can generate code-based entities that represent lists, libraries, and their fields. You can then use these entities in your development project so that the LINQ to SharePoint IntelliSense features enable you to early bind to those entities and their fields.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe LINQ to SharePoint.
- Use SPMetal to create SharePoint entities.
LINQ to SharePoint is a new data access technology provided by SharePoint 2010. LINQ to SharePoint provides the ability for you, as a developer, to early-bind to SharePoint data such as list items and their fields, from within Visual Studio 2010.
SharePoint 2010 provides a command-line utility called SPMetal that can help you develop solutions based on LINQ to SharePoint. SPMetal generates a code-based file that contains entities to represent each list and its fields in a SharePoint site.
After you have run the SPMetal utility, you can import the generated entities file into your Visual Studio 2010 projects. You can then develop LINQ statements to access SharePoint data from lists and libraries.
For example, SharePoint lists are represented as objects in your code, and the fields contained in a list are represented as strongly-typed properties for the specific object. The early-binding nature of LINQ statements means that you can identify errors in your code at compile-time, rather than needing to deploy and debug your solution at run time.
Module Overview
SharePoint 2010 provides a completely new set of client-side APIs called the client object model.
You can use the client object model to build applications that are driven by SharePoint data, but that do not necessarily need to run on a SharePoint server.
Module Objectives
After completing this module, you will be able to:
- Develop remote clients for SharePoint 2010 by using the client object model.
- Access SharePoint data in Silverlight clients by using the Silverlight implementation of the SharePoint 2010 client object model.
Developing Remote Clients by Using the Client Object Model
· Remote Clients for SharePoint 2010
· SharePoint 2010 Client Object Model Architecture
· Building a Console Application by Using the Client Object Model
Accessing SharePoint Data in Silverlight Applications
· Silverlight and SharePoint Data Architecture
· Developing Silverlight Solutions for SharePoint 2010
· Identifying Remote Clients and Technologies
Lesson Introduction
In previous versions of SharePoint, it was not an easy task to consume SharePoint objects and data in an application that did not run on a SharePoint server. Essentially, you were required to make Web service calls, and those Web services were not simple to use and did not always provide the required functionality.
With SharePoint 2010, you can now take advantage of the client object model. This means that you can now develop .NET applications, Silverlight applications, and JavaScript applications that can consume and manipulate SharePoint data very easily, regardless of where they run.
For example, you can build .NET console applications, Windows Forms applications, and Windows Presentation Foundation applications that run on the desktop of the user, but are still driven by SharePoint data. Similarly, you can use the client object model to create compelling Silverlight applications and ASP.NET Web applications that consume SharePoint data.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe the types of remote clients for SharePoint 2010.
- Describe the architecture of the client object model.
- Build a console application for SharePoint 2010 by using the client object model.
Remote Clients for SharePoint 2010
SharePoint 2010 supports remote clients accessing objects on the SharePoint platform using the client object model. This allows various types of remote clients to access and manipulate SharePoint data without those clients having to run on the SharePoint platform.
|
Remote Client |
Description |
Microsoft .NET applications |
.NET applications can interact with SharePoint objects by using the .NET implementation of the client object model.
.NET applications that can use the client object model include:
- Console applications
- Windows Forms applications
- Windows Presentation Foundation applications
- ASP.NET Web applications and Web services
These applications instantiate a ClientContext object and use the URL of a SharePoint site in the constructor of that object. Typically, applications then make use of the Site objects, Web objects, and List objects to interact with SharePoint. These objects are client-side versions of the SPSite, SPWeb, and SPList objects that are available on in the server-side object model.
The communication between the client application and the SharePoint server takes place over Extensible Markup Language (XML) and JavaScript Object Notation (JSON). |
.NET applications can interact with SharePoint objects by using the .NET implementation of the client object model.
.NET applications that can use the client object model include:
- Console applications
- Windows Forms applications
- Windows Presentation Foundation applications
- ASP.NET Web applications and Web services
These applications instantiate a ClientContext object and use the URL of a SharePoint site in the constructor of that object. Typically, applications then make use of the Site objects, Web objects, and List objects to interact with SharePoint. These objects are client-side versions of the SPSite, SPWeb, and SPList objects that are available on in the server-side object model.
The communication between the client application and the SharePoint server takes place over Extensible Markup Language (XML) and JavaScript Object Notation (JSON). |
|
|
Silverlight applications offer a rich user interface that can be hosted in a Web page within the SharePoint site, or even in a non-SharePoint site. Furthermore, Silverlight applications can run outside of the browser environment completely.
With any of the deployment environments, Silverlight applications actually run in their own local .NET environment.
Silverlight applications, therefore, use the Silverlight implementation of the client object model to communicate with SharePoint objects and data. The objects, methods, properties, and events in the Silverlight implementation of the client object model are extremely similar to those in the .NET implementation of the client object model. |
|
|
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. |
- Microsoft .NET applications
.NET applications can interact with SharePoint objects by using the .NET implementation of the client object model.
.NET applications that can use the client object model include:
- Console applications
- Windows Forms applications
- Windows Presentation Foundation applications
- ASP.NET Web applications and Web services
These applications instantiate a ClientContext object and use the URL of a SharePoint site in the constructor of that object. Typically, applications then make use of the Site objects, Web objects, and List objects to interact with SharePoint. These objects are client-side versions of the SPSite, SPWeb, and SPList objects that are available on in the server-side object model.
The communication between the client application and the SharePoint server takes place over Extensible Markup Language (XML) and JavaScript Object Notation (JSON). |
|
|
Silverlight applications offer a rich user interface that can be hosted in a Web page within the SharePoint site, or even in a non-SharePoint site. Furthermore, Silverlight applications can run outside of the browser environment completely.
With any of the deployment environments, Silverlight applications actually run in their own local .NET environment.
Silverlight applications, therefore, use the Silverlight implementation of the client object model to communicate with SharePoint objects and data. The objects, methods, properties, and events in the Silverlight implementation of the client object model are extremely similar to those in the .NET implementation of the client object model. |
|
|
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. | .NET applications can interact with SharePoint objects by using the .NET implementation of the client object model.
.NET applications that can use the client object model include:
- Console applications
- Windows Forms applications
- Windows Presentation Foundation applications
- ASP.NET Web applications and Web services
These applications instantiate a ClientContext object and use the URL of a SharePoint site in the constructor of that object. Typically, applications then make use of the Site objects, Web objects, and List objects to interact with SharePoint. These objects are client-side versions of the SPSite, SPWeb, and SPList objects that are available on in the server-side object model.
The communication between the client application and the SharePoint server takes place over Extensible Markup Language (XML) and JavaScript Object Notation (JSON).
.NET applications can interact with SharePoint objects by using the .NET implementation of the client object model.
.NET applications that can use the client object model include:
- Console applications
- Windows Forms applications
- Windows Presentation Foundation applications
- ASP.NET Web applications and Web services
These applications instantiate a ClientContext object and use the URL of a SharePoint site in the constructor of that object. Typically, applications then make use of the Site objects, Web objects, and List objects to interact with SharePoint. These objects are client-side versions of the SPSite, SPWeb, and SPList objects that are available on in the server-side object model.
The communication between the client application and the SharePoint server takes place over Extensible Markup Language (XML) and JavaScript Object Notation (JSON). |
|
|
Silverlight applications offer a rich user interface that can be hosted in a Web page within the SharePoint site, or even in a non-SharePoint site. Furthermore, Silverlight applications can run outside of the browser environment completely.
With any of the deployment environments, Silverlight applications actually run in their own local .NET environment.
Silverlight applications, therefore, use the Silverlight implementation of the client object model to communicate with SharePoint objects and data. The objects, methods, properties, and events in the Silverlight implementation of the client object model are extremely similar to those in the .NET implementation of the client object model. |
|
|
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. |
Silverlight applications offer a rich user interface that can be hosted in a Web page within the SharePoint site, or even in a non-SharePoint site. Furthermore, Silverlight applications can run outside of the browser environment completely.
With any of the deployment environments, Silverlight applications actually run in their own local .NET environment.
Silverlight applications, therefore, use the Silverlight implementation of the client object model to communicate with SharePoint objects and data. The objects, methods, properties, and events in the Silverlight implementation of the client object model are extremely similar to those in the .NET implementation of the client object model.
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. |
|
|
Silverlight applications offer a rich user interface that can be hosted in a Web page within the SharePoint site, or even in a non-SharePoint site. Furthermore, Silverlight applications can run outside of the browser environment completely.
With any of the deployment environments, Silverlight applications actually run in their own local .NET environment.
Silverlight applications, therefore, use the Silverlight implementation of the client object model to communicate with SharePoint objects and data. The objects, methods, properties, and events in the Silverlight implementation of the client object model are extremely similar to those in the .NET implementation of the client object model. |
|
|
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. |
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions.
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. |
|
|
Silverlight applications offer a rich user interface that can be hosted in a Web page within the SharePoint site, or even in a non-SharePoint site. Furthermore, Silverlight applications can run outside of the browser environment completely.
With any of the deployment environments, Silverlight applications actually run in their own local .NET environment.
Silverlight applications, therefore, use the Silverlight implementation of the client object model to communicate with SharePoint objects and data. The objects, methods, properties, and events in the Silverlight implementation of the client object model are extremely similar to those in the .NET implementation of the client object model. |
|
|
JavaScript applications can also make use of a similar client object model approach to .NET and Silverlight applications. However, the actual implementation details differ. The capability to communicate with the server-side service that handles client requests is contained in the following files:
- SP.js
- SPCore.js
- SP.Runtime.js
These files have been compressed for performance reasons, but corresponding uncompressed versions are available to help you debug your solutions. |
SharePoint 2010 Client Object Model Architecture
In previous versions of SharePoint, you were faced with some difficult choices if you wanted to consume and manipulate SharePoint data and objects in an application that did not run on a SharePoint server. For example, you could choose to consume SharePoint Web services but these were not always easy to use and did not always support the required data or operations. Furthermore, calling Web services did not follow the same coding approaches that you may have already become familiar with when accessing SharePoint data from server-side solutions, such as Web Parts or workflows.
Alternatively, you could choose to create your own architectural solutions for consuming SharePoint data from a remote client but this approach could be complex and would distract you from concentrating on meeting your business requirements.
SharePoint 2010, however, provides the client object model that enables you to build solutions that consume SharePoint data and objects from applications that do not run on a SharePoint server. You can use the client object model to build remote clients without requiring that you use SharePoint Web services and without requiring that you invent communication architecture. This means that you can concentrate on fulfilling business requirements while working with objects that you will be familiar with from your server-side coding.
For example, the client object model provides a Web object that is analogous to the server-side SPWeb object, and it provides a Site object that you can use like the server-side SPSite object. Additionally, the client object model provides a List object that is similar to the SPList object with which you may be familiar from your server-side projects.
The architecture for enabling this communication is provided by the client object model and a server-side service called client.svc. The client object model batches operations that you specify in your client code and sends them to the server for processing. The commands are sent using XML over Hypertext Transfer Protocol (HTTP), and the results of the operations are returned to your application by JSON.
Lesson Introduction
The integration between Microsoft Silverlight and SharePoint 2010 provides you with opportunities to create rich, compelling user interfaces for working with SharePoint data and objects.
For example, while the Silverlight implementation of the client object model enables you to consume and manipulate SharePoint data in Silverlight, the new Silverlight Web Part enables you to host Silverlight applications on Web Part pages.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe the architecture for consuming SharePoint 2010 data in Silverlight applications.
- Develop Silverlight solutions for SharePoint 2010.
- Identify remote clients and technologies.
Silverlight and ShaerPoint DataArchitecture
Silverlight offers you the opportunity to build rich, compelling user interfaces for your SharePoint solutions. Your Silverlight applications can use the client object model to retrieve, manipulate, and update SharePoint data in an engaging and useful manner.
Typically, you may choose to run your Silverlight applications in SharePoint using the Silverlight Web Part provided by SharePoint 2010, but you can also choose to create your own Web Parts to host your Silverlight application. Furthermore, you can still use the client object model to consume and manipulate SharePoint data even if your Silverlight application runs outside the browser environment.
Although using the client object model from Silverlight is very similar to using it from a .NET application, you must ensure that you reference the correct DLLs from the ClientBin folder. Furthermore, you cannot communicate with SharePoint in a synchronous manner on the main user interface (UI) thread from Silverlight. Instead, you are required to execute SharePoint queries asynchronously and to provide callback methods where the results from the query are returned to your Silverlight application.
Your callback method is always executed on a background thread on which you cannot update the user interface. So, if you then want to update the user interface in Silverlight with the results returned from SharePoint, you must switch your thread context back to the main UI thread. Switching back to the main thread from the callback method is a relatively simple task; you can achieve this by calling Dispatcher.BeginInvoke(). You will pass in the name of one of your methods to the BeginInvoke call, and the code in that method can safely update the user interface.
Incorporating External Data in SharePoint 2010 Solutions
Module Overview
SharePoint 2010 provides Business Connectivity Services that enable you to connect to external data sources, such as databases, Web services, and other LOB systems.
You can use Business Connectivity Services to enable users to view, insert, update, and delete data from external data sources directly from SharePoint solutions. You can use SharePoint Designer 2010 to create connections to the external data sources and to generate the data retrieval and modification operations without requiring you to develop code. Furthermore, you can use Visual Studio 2010 to create .NET solutions that interact with external data sources and make the data in those sources available in Business Connectivity Services.
Module Objectives
After completing this module, you will be able to:
- Configure Business Connectivity Services for SharePoint 2010.
- Develop .NET Solutions that can be used by Business Connectivity Services
Configuring Business Connectivity Services for SharePoint 2010
· Overview of Business Connectivity Services
· Configuring Business Connectivity Services
· Self Test
Developing .NET Solutions for Business Connectivity Services
· Overview of Business Connectivity Services and .NET Solutions
· Developing Business Connectivity Services Solution by using Visual Studio 2010
· Identifying Features of Business Connectivity Services
Lesson Introduction
Visual Studio 2010 and Microsoft SharePoint Designer 2010 both provide powerful tools that enable you to implement solutions based on business data that is stored in external systems. However, before you start using these tools to create Business Connectivity Services solutions, you must understand the architecture and features provided by Business Connectivity Services in SharePoint 2010.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe Business Connectivity Services.
- Describe the Business Connectivity Services architecture.
- Use SharePoint Designer 2010 to configure Business Connectivity Services
Overview of Business Connectivity Services
Lesson Introduction
Visual Studio 2010 and Microsoft SharePoint Designer 2010 both provide powerful tools that enable you to implement solutions based on business data that is stored in external systems. However, before you start using these tools to create Business Connectivity Services solutions, you must understand the architecture and features provided by Business Connectivity Services in SharePoint 2010.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe Business Connectivity Services.
- Describe the Business Connectivity Services architecture.
- Use SharePoint Designer 2010 to configure Business Connectivity Services
Lesson Introduction
You can build your own .NET solutions for the Business Connectivity Services of SharePoint 2010.
For example, Visual Studio 2010 provides Business Data Catalog project types and project item types that enable you to create entities for use in external lists. The data for those entities are typically provided by external systems, and you can add code for representing the data in the entity model.
You can develop your solutions by using Visual Studio 2010 to handle more complex scenarios and custom data operations than is possible by just using SharePoint Designer 2010.
Lesson Objectives
After completing this lesson, you will be able to:
- Describe the purpose of .NET solutions for Business Connectivity Services.
- Develop a .NET solution for Business Connectivity Services.
- Identify features of Business Connectivity Services.
Overview of Business Connectivity Services and .Net Solutions
The ability to create solutions for Business Connectivity Services by using Visual Studio 2010 enables you to build custom back-end connectivity. You can use this approach to deal with complex data models with many external content types and complex associations.
The Business Data Catalog Model project type in Visual Studio 2010 provides a starting point for your .NET solution. A new entity is created for you and you can then set properties for this entity and provide the necessary code to work with the external data. For example, you can specify the unique identifier for the external content type and the code to retrieve data from the external system along with any other functionality you intend to support.
Additionally, you can use Visual Studio 2010 to develop .NET types that can then be reused in other Visual Studio Business Data Catalog Model projects or in SharePoint Designer 2010 to connect to dynamic or complex external systems.
|
|