- Lesson 1 - Getting Started with SharePoint 2010 Development Training
-
In this lesson, you’ll meet the instructor for this course, Eric Skaggs, and learn what will be covered in this course and how to best use this course.
- About Your Instructor
- About the Course
- Getting the Most Out of This Course
- Get Involved in the SharePoint Community
- Lesson 2 - Lab Setup
-
To become an expert SharePoint developer, it’s crucial to get hands-on experience. In this lesson, we will talk about what hardware and software you’ll need in order to follow along with the demos in your home or work environment.
- Hardware and Software Requirements
- System and SharePoint Configuration Settings
- Lesson 3 - The Course Scenario
-
This lesson will give a high level overview of the application that we'll build in this course and introduce the fictitious company we’ll work with, Globomantics.
- Our Scenario - Building a Training Site for Globomantics, Inc.
- Lesson 4 - The Core SharePoint Objects
-
In this lesson, we'll introduce the core SharePoint objects, which form the foundation for all the programming we'll do throughout the course. We'll explain what these objects are and why we would programmatically create/modify/delete them. Specifically, the objects mentioned here will include - SPFarm, SPService, SPWebApplication, SPSite, SPWeb, SPList, and SPListItem.
- SPFarm
- SPService
- SPWebApplication
- SPSite
- SPWeb
- Using SPContext
- SPList
- SPListItem
- Iterating Through the Core SharePoint Objects
- Lesson 5 - Visual Studio 2010
-
Visual Studio 2010 is the preferred development tool for SharePoint 2010. In this lesson, we'll explain how Visual Studio 2010 and its features streamline the SharePoint development process. Specifically, we'll introduce web parts by creating a “Hello, World!” web part from start to finish with two different approaches. The first approach will show the “old way” of developing web parts in previous versions of Visual Studio, demonstrating how long it used to take. The second approach will show the new, streamlined way of developing web parts with Visual Studio 2010. This lesson will also introduce the Feature and Package designers within Visual Studio that will be explored in more detail throughout the rest of the course.
- Before Visual Studio 2010
- SharePoint Development with Visual Studio 2010
- Creating a Web Part with Visual Studio 2010 - the Old Way
- Creating a Web Part with Visual Studio 2010 Using Built-in Enhancements
- Lesson 6 - SPSite and SPWeb Objects and Disposal
-
When not properly disposed, SPSite and SPWeb objects are prone to memory leaks. This is because they reference other unmanaged code that is not always properly released. It’s important to be aware of how to properly dispose of these two objects and use SPContext to alleviate potential memory issues. In this lesson we’ll discuss best practices for referencing and disposing of SPSite and SPWeb Objects. We’ll build a web-scoped Feature that simply changes the title of an SPWeb when activated and, when deactivated, changes the SPWeb’s title back to its original title.
- SPSite Objects
- Referencing and Disposing of SPSite Objects
- SPWeb Objects
- Referencing and Disposing of SPWeb Objects
- MSDN Disposal Best Practices
- Using the SharePoint Dispose Checker Tool
- Using the Property Bag of SPWeb Objects
- Creating SPSite and SPWeb Objects
- Deploying and Testing Our Site Collection
- Changing the Title and Description of an SPWeb Programmatically
- Debugging and Deploying Our Property Bag Application
- Lesson 7 - SPList and SPField Objects
-
In this lesson, we’ll examine the SPList and SPField objects and show how to create and delete SPList objects and how to add/remove SPField objects to and from SPList objects. For our scenario site, we’ll create a “Trainers” list and a “Registrations” list. These two lists will be based on the built-in “Custom List” list template and we’ll add appropriate columns to build out these lists.
- The SPList and SPField Objects
- Creating Lists Programmatically
- Modifying Lists and Views
- Deploying and Testing Our List Modification Solution
- Lesson 8 - SPListItem Objects
-
SPListItem Objects represent one row within an SPList, comparable to one record in a database. In this lesson, we’ll discuss how to reference and add SPListItem objects programmatically, and how the recycle bin and deletion methods work.
- Working with SPListItem Objects
- Building an SPListItem Console Application
- Adding an SPListItem Object to an SPList Programmatically
- Modifying an Existing SPListItem Object Programmatically
- Recycling an SPListItem Object Programmatically
- Deleting an SPListItem Object Programmatically
- Adding Trainers to the Trainers List Programmatically
- Lesson 9 - Content Types
-
In this lesson, we’ll look at programmatically creating and customizing content types. To map to our scenario, we’ll programmatically create a custom “Course” content type that inherits from the built-in “Item” content type. This new content type will include all of the appropriate columns to define a course. Next, we’ll create a “Class” content type that inherits from the previously created “Course” content type and adds the necessary columns to define a class. Then we’ll create new lists to use these content types, and then we’ll demonstrate how content types can be further customized in the browser even after they’ve been created.
- What is a Content Type?
- The Built-in Content Types
- Creating Content Types in Internet Explorer
- List Definitions
- List Instances
- Creating Custom Content Types Programmatically
- Creating List Definitions Programmatically
- Creating List Instances Programmatically
- Creating the ""Class"" Content Type Programmatically
- Creating the ""Classes"" List Definition Programmatically
- Creating the ""Classes"" List Instance Programmatically
- Modifying Fields in a List Instance Programmatically with an Event Receiver
- Lesson 10 - Web Parts
-
In this lesson, we’ll discuss what a web part is and how to create one from scratch using the built-in Web Part project item template in Visual Studio 2010. We’ll walk through the creation of the “Hello, World!” web part step by step and then show how to create connectable web parts. We’ll create a provider web part that has a custom property called “Message” and a consumer web part designed to receive and display the message from the provider. We’ll explain how an Interface is required to allow the two web parts to communicate and explore debugging web parts.
- Accessing the Web Part Gallery
- Creating a Standard Web Part Programmatically
- Creating a Visual Web Part Programmatically
- Creating Connected Web Parts Programmatically
- Debugging Web Parts
- Lesson 11 - Permissions
-
In this lesson, we’ll discuss how to create SPGroup objects, add SPUser objects to those groups, and configure permission inheritance. As part of the demonstration, we’ll cover the various securable objects in SharePoint, SPRoleDefinition objects, and SPRoleAssignment objects. We’ll create the SharePoint groups for our scenario application and give each of these groups the appropriate permissions to the lists in the site based on their roles.
- SharePoint Groups, Permission Levels and Permissions
- SPUser, SPGroup, SPRoleDefinition and SPRoleAssignment Objects
- Creating Groups and Assigning Permissions Programmatically
- Deploying and Testing Our Permissions Solution
- Lesson 12 - Event Receivers
-
In this lesson, we’ll look at how to programmatically create event receivers to run custom code based on a particular event. We’ll walk through creating an event receiver for our scenario site to increase the number of registrations for a course when a student registers to attend a course. Another event receiver will be created to decrease the number of registrations for a course when a student cancels a registration from a course. We’ll also discuss the various types of event receivers that can be created for SharePoint objects.
- Types of Events
- Creating a Custom Item Event Receiver
- Bulk Adding List Items
- Creating an Event Receiver to Set Unique Registration IDs
- Creating Event Receivers to Tally the Number of Registrations
- Lesson 13 - Creating a Custom Ribbon Control
-
In this lesson, we’ll discuss the core concepts involved with creating a custom control on the ribbon. To map to our scenario, we’ll create a custom ribbon control that will only be visible within the Trainers list. This control will only be enabled when a Trainer within the list has been selected and will link to that particular Trainer’s user profile page.
- Customizing the Ribbon
- Building a CustomAction for a Ribbon Control
- Defining the Custom Ribbon Control with CommandUIDefinition
- Setting the Ribbon Control Behavior with the CommandUIHandler Properties
- Setting the Appearance and Visibility of the Ribbon Control
- Setting the Location of the Custom Ribbon Control
- Deploying and Testing the Custom Ribbon Control
- Lesson 14 - Timer Jobs
-
In this lesson, we’ll cover how to programmatically create and schedule a timer job so you’ll have an idea of how timer jobs can be used to process data in bulk and on a regular schedule. We’ll also show how to debug a timer job by attaching to the timer service process, OWSTIMER.exe. To map to our scenario, we’ll create a timer job that will generate weekly “schedule reports” that will be sent to trainers so that they can keep track of their upcoming schedules.
- Requirements and Logistics for Creating Timer Jobs
- Creating a Custom Timer Job
- Programming the Timer Job - Retrieving Trainer and Class Information
- Programming the Timer Job - Building and Populating an Email from the Classes List
- Installing the Timer Job
- Activating the Timer Job Feature with PowerShell
- Testing the Timer Job Deployment
- Debugging Timer Jobs
- Lesson 15 - Creating a Custom Dialog
-
In this lesson, we’ll cover how to use JavaScript to create a custom dialog that presents a form to the user for data entry. To map to our scenario, we’ll create a custom dialog for the “Trainers” list to allow users to add new trainers.
- JavaScript and the Client Object Model
- Modal Dialogs
- Creating a Custom Dialog
- Controlling the Client Side Behavior and Visibility of the Dialog
- Adding Server Side Functionality to the Dialog
- Deploying and Testing the Dialog User Control
- Lesson 16 - Navigation
-
In this lesson, we’ll cover how to programmatically modify the Top Link Bar, the Quick Launch Bar, and we’ll explore custom actions to demonstrate how they can be used to add links to the Site Actions and Site Settings menus. For our scenario site, we’ll hide the site’s main lists from navigation, but modify the Site Settings page to include custom actions in a CustomActionGroup that link to all of these lists.
- Top Link Bar
- Quick Launch Bar
- Menus and Custom Actions
- Hiding the Left Navigation Programmatically
- Adding Links to the Top Link Bar Programmatically
- Adding Links to the Quick Launch Bar Programmatically
- Deploying and Testing the Custom Navigation Feature
- Displaying Contextual Navigation with a CustomAction
- Lesson 17 - User Profiles
-
In this lesson, we’ll show how to programmatically create and edit user profiles. For our scenario site, we’ll programmatically generate a user profile for every trainer in the “Trainers” list.
- Referencing a User Profile
- Referencing and Editing User Profile Properties
- Creating a Web Part to Update and Display User Profile Properties
- Working with the User Profile Service Application
- Activating and Implementing Our User Profile Web Part
- Lesson 18 - Branding
-
In this lesson, we’ll show how to programmatically apply a theme to an SPWeb. Next we’ll do some basic customizations to a master page and programmatically apply the master page to an SPWeb object. We’ll customize the master page by using SharePoint Designer 2010. We’ll also take time in this lesson to talk about the best way to deploy a custom master page out to production by using a solution package in Visual Studio.
- Options
- SharePoint Designer 2010
- Best Practices
- Using SharePoint Designer 2010 to Customize the Master Page
- Creating a Branding Solution with Visual Studio 2010
- Deploying Our Visual Studio Branding Solution and Activating Through SharePoint Designer
- Implementing an Event Receiver to Create a One-Click Branding Solution
- Lesson 19 - Delegate Controls
-
In this lesson, we’ll discuss what a delegate control is and take the time to identify the built-in SharePoint delegate controls. We’ll replace the built-in SmallSearchInputBox delegate control with a customized search delegate control that has a different styling, which is one of the most common changes organizations want to make.
- What is a Delegate Control?
- Overriding a Delegate Control with a Custom Control
- Deploying and Testing Our Custom Delegate Control
- Lesson 20 - Workflows
-
In this lesson, we’ll discuss the basics of creating a workflow in Visual Studio 2010. To map to our scenario, we’ll create a simple workflow that will send the student a confirmation email with class details when the student registers for a class.
- Types of Workflows
- Workflow Tools
- Designing a Workflow with the Visual Studio Workflow Toolbox Controls
- Adding Behavior to the Workflow Steps Programmatically
- Deploying and Testing Our Workflow
- Lesson 21 - Working with Business Connectivity Services
-
In this lesson, we will walk through creating a Business Data Connectivity Model so that external data can be surfaced to the SharePoint user interface. To map to our scenario, we’ll create a SQL database that will contain a table of technologies. Every trainer in the “Trainers” list will be associated with a technology. We’ll use BCS to surface this data as an external list in SharePoint to demonstrate how external data can still have significance and meaning without moving it into SharePoint.
- Operations and Methods
- Creating a Simple SQL Data Source
- Creating and Working with a Business Data Connectivity Model in Visual Studio
- Working with the Service Class and Entity Class
- Writing the CRUD Methods for Our Entity with the Design Model
- Coding the CRUD Methods
- Debugging the BCS Application in Visual Studio
- Deploying and Testing Our BCS Application
- Lesson 22 - RESTFUL Services
-
In this lesson, we’ll show how to connect Visual Studio 2010 to a SharePoint list using REST and then how easy it can be to add and edit data. To map to our scenario, we’ll create a Windows Forms Application that allows users to add and edit Courses.
- REST in SharePoint 2010
- Creating a Forms Application to View Course Information Using RESTFUL Services
- Enabling Adding and Editing of Courses through the RESTFUL Forms Application
- Lesson 23 - Client Object Model
-
In this lesson, we’ll talk about the three different implementations of SharePoint 2010’s client object model - .NET, Silverlight, and JavaScript. We’ll build an application that uses the .NET implementation of the client object model, which in the case of our scenario will be a client-side application that adds new trainers to the “Trainers” list.
- Using the JavaScript Implementation
- Using the Silverlight Implementation
- Creating a Client-Side Application with the .NET Implementation
- Lesson 24 - Working with Documents
-
In this lesson, we’ll talk about working with the following objects – SPDocumentLibrary, SPFile, SPFolder, and SPVersion. We’ll also look at programmatically turning versioning on and off for a particular document library. To map to our scenario, we’ll create a document library for storing course outlines and we’ll configure these settings appropriately.
- SPDocument Library, SPFolder and SPFile Objects
- Programmatically Creating a Document Library
- Deploying and Testing the Documents Application
- Lesson 25 - Metadata
-
In this lesson, we’ll examine the different objects that make up the Managed Metadata Service Application and discuss how to manipulate them programmatically. To map to our scenario, we’ll build in some terms that we can use to tag content. Specifically, we’ll create “Topics” in the Managed Metadata Service Application, and then create a new column in the “Courses” list that will point to those topics. When a new course is created, the creator will have the option to tag that course with an appropriate topic.
- Programming Managed Metadata
- Managing Metadata Manually in SharePoint 2010
- Writing a Visual Web Part to Add Terms to Managed Metadata
- Deploying and Testing Our Managed Metadata Visual Web Part
- Lesson 26 - Creating a Search Interface
-
In this lesson, we’ll create Full Text and Keyword queries to return data from SharePoint. We’ll show how to query data in a SharePoint list using CAML in an SPQuery object and also how to use SPMetal to generate entity classes for SharePoint so that we can use LINQ to query the same data. To map to our scenario, we’ll build a visual web part that allows students to query available classes.
- SPQuery and SPSiteDataQuery
- LINQ to SharePoint
- Keyword Query and Full Text Query
- Creating a Visual Web Part for Search Using CAML
- Creating a Visual Web Part for Search Using LINQ and SPMetal
- Lesson 27 - Storing Configuration Data
-
In this lesson, we’ll explore the various options available to store configuration data for an application. We’ll work with the SPWebConfigModification class to store application settings in the web.config file. To map to our scenario, we’ll store the value that will be used in email signatures when the application sends out its weekly “schedule reports” to instructors. When a “schedule report” is generated, it will use the ConfigurationManager object to read this value from the web.config file and append it to the bottom of the report before sending it to the trainer.
- Options for Storing Configuration Data in SharePoint 2010
- About Web.config
- Creating the Demo Project and Copying the Timer Job Email Application Code
- An In-Depth Look at the Web.config File
- Manually Adding a Key to the Web.config File Application Settings
- Using SPWebConfigModification and WebConfigurationManager Classes to Programmatically Store and Reference Values in the Web.config File
- Deploying and Testing the Configuration Data-based Email Timer Job Application
- Lesson 28 - Creating a Site Definition
-
Taking the time to create a site definition initially can save SharePoint admins and users time later when creating and managing new sites and site layouts. In this lesson, we’ll look at how to create a custom site definition that includes a custom master page.
- Working with Site Templates
- Site Definitions vs. Site Templates
- Creating a Custom Site Definition to Set the Master Page URL Programmatically
- Deploying and Testing Our Custom Master Page Site Definition
- Creating Sites Based on Our Site Definition
- Lesson 29 - Sandboxed Solutions
-
Sandboxed solutions can be helpful if you need to deploy custom code solutions but cannot use a farm solution. In this lesson, we'll discuss situations where you might need or want to use a sandboxed solution, what limitations sandboxed solutions face, and then walk through creating and debugging a sandboxed solution.
- What are Sandboxed Solutions?
- Limitations of Sandboxed Solutions
- Benefits and Other Considerations with Sandboxed Solutions
- Working with Sandboxed Solutions in Visual Studio and SharePoint 2010
- Deploying and Testing Sandboxed Solutions
- Lesson 30 - Preparing for the TS: SharePoint 2010, Application Development (70-573) Exam
-
This lesson will provide information about the exam objectives, the candidate profile and some additional resources you may want to consult before sitting the exam.
- Overview of the 70-573 Exam Objectives
- Study Recommendations and Exam Preparation Tips
- Lesson 31 - Next Steps
-
This lesson will wrap up the course by recapping what we accomplished in the course and will point you to additional resources that will help you continue learning and mastering SharePoint application development.