developing on sharepoint 2010

7/27/2019 Developing on SharePoint 2010

1/27

Module 1: Getting Started Building Web Parts in SharePoint 2010

Benefits of Developing Webparts for SharePoint 2010

Web Parts are reusable and can be used on multiple pages or sites, they can be easily added to

a SharePoint webpage from the standard SharePoint interface and their development and

deployment is supported in Visual studio 2010, standard web parts do not.

Visual Web part in SharePoint 2010

Visual Webparts are ascx user controls that can be added directly to a SharePoint page. One

significant enhancement is that Visual studio 2010 manages packing and deployment of these

controls

Deployment of Visual web part

Visual Webparts are deployed directly from Visual studio 2010 by right clicking the project and

choosing deploy.

Standard Webparts in SP2010

Standard web parts are the classes that inherit from ASP.NET web part base class. When using SPSite SPWeb object in your web part code you should always call Dispose

() method of the object to ensure the underlying COM object is destroyed explicitly, or

instantiate the SPSite or SQPWeb in a Using statement.

You should override the CreateChildControls () method when creating a standard webpart.

The SPGridView Control provides a simple approach to displaying SharePoint data on aWebpage.

Module 1: Code Snippets: Getting Started: Building Web Parts in SharePoint 2010

5

The following code shows how to modify the Textproperty of a label when a Visual Web Partloads.

NOTE: This code assumes there is an ASP.NET Label control called messagein the Visual Web

Part

using System;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;


2/27

namespace BonnevilleTestBed.VisualWebPart1

{

public partial class VisualWebPart1UserControl : UserControl

{

protected void Page_Load(object sender, EventArgs e)

{

message.Text = "Welcome to SharePoint 2010 Development";

}

}

}

The following code shows how to render a welcome message when a standard Web Part loads:

using System;

using System.ComponentModel;

using System.Runtime.InteropServices;using System.Web.UI;



using Microsoft.SharePoint;

using Microsoft.SharePoint.WebControls;

namespace BonnevilleTestBed.BonnevilleStandardWP

{

[ToolboxItemAttribute(false)]

public class BonnevilleStandardWP : WebPart

{

public BonnevilleStandardWP(){

}

protected override void CreateChildControls()

{

//Get the currently logged-on user's name from the SharePoint object

model

string username = SPContext.Current.Web.CurrentUser.LoginName;

LiteralControl myMessage = new Literalcontrol("Welcome " + userName

+ " to SharePoint 2010 Development");

this.Controls.Add(myMessage);

base.CreateChildControls();

}

protected override void RenderContents(HtmlTextWriter writer)

{

base.RenderContents(writer);

}


3/27

}

}

The following code shows how to iterate through all lists and subwebs in a SharePoint site, and

add them to a treeview control in a Visual Web Part.Note:This code assumes there is a TreeView control called siteStructurein the Visual Web

Part. Note also how the addWebs()method is called recursively.

using System;

using System.Web.UI;



using Microsoft.SharePoint;

using Microsoft.SharePoint.Utilities;

using System.Web;

namespace BonnevilleTestBed.Bonneville

{public partial class BonnevilleUserControl : UserControl

{


{

SPWeb thisWeb = null;

TreeNode node;

thisWeb = SPContext.Current.Web;

//Add the Web's title as the display text for the tree node, and add

the URL as the NavigateUri

node = new TreeNode(thisWeb.Title, null, null, thisWeb.Url, "_self");

//The Visual Web Part has a treeview control called siteStructure

siteStructure.Nodes.Add(node);

//Get a reference to the current node, so child nodes can be added in

the correct position

TreeNode parentNode = node;

//Iterate through the Lists collection of the Web

foreach (SPList list in thisWeb.Lists)

{

if (!list.Hidden)

{

node = new TreeNode(list.Title, null, null, list.DefaultViewUrl,

"_self");

parentNode.ChildNodes.Add(node);}

}

foreach (SPWeb childWeb in thisWeb.Webs)

{

//Call our own helper function for adding each child Web to the tree

addWebs(childWeb, parentNode);


4/27

childWeb.Dispose();

}

siteStructure.CollapseAll();

}

void addWebs(SPWeb web, TreeNode parentNode)

{

TreeNode node;

node = new TreeNode(web.Title, null, null, web.Url, "_self");

parentNode.ChildNodes.Add(node);

parentNode = node;

foreach (SPList list in web.Lists)

{

if (!list.Hidden)

{


"_self");


}

}

foreach (SPWeb childWeb in web.Webs)

{

//Call the addWebs() function from itself (i.e. recursively)

//to add all child webs until there are no more to be added


}

}

}

}

Module 2: What Developers Need to Know About SharePoint 2010?

SharePoint 2010 is based on ASP.NET 3.5 and runs on 64 bit platforms only. The _layouts location is a virtual web folder that points to file system folder on the

SharePoint server. Visual studio 2010 provides support for deploying items to the

_layouts folder.

WSP files simplify deployment across multiple servers in a farm and provide for astandard way for visual studio to open and modify functionality.


5/27

Site events enable a developer to capture events such as site deletion site provisioning,or site moving, either just before or after these operation have taken place.

Visual studio 2010 and SharePoint 2010 combine to provide full debugging interface fordevelopers.

SPWeb, SPSite and SPFarm are objects in SharePoint hierarchy.

SPFarm object provides access to all of the services and web applications in a SharePointdeployment.

SharePoint object hierarchy order from the highest to most specific: SPFarm,SPWebapplication, SPSite, and SPWeb.

Module 2 - Code Snippets: What Developers Need to Know About SharePoint 2010

The following code shows two event handlers:

- The first one (FieldAdded) updates existing list items when a field is added to a list.

- The second handler (ListDeleting) prevents the deletion of a list.

namespace ProductMarketing.ProductTaskEvents{

public class ProductTaskEvents : SPListEventReceiver

{

public override void FieldAdded(SPListEventProperties properties)

{

SPField newField = properties.Field;

Guid fieldID = newField.Id;

if (newField.Type == SPFieldType.Text)

{

SPList thisList = properties.List;

foreach (SPListItem item in thisList.Items)

{

item[fieldID] = "Please update this existing item...";

item.Update();

}

}

base.FieldAdded(properties);

}

public override void ListDeleting(SPListEventProperties properties)

{

properties.ErrorMessage = "This list is critical to the marketing

campaign and cannot be deleted.";

properties.Cancel = true;}

}

}

The following event handler shows how to update properties of a SharePoint Web site when anew Web is created


6/27

namespace ProductMarketing.ProductMarketingWebEvents

{

public class ProductMarketingWebEvents : SPWebEventReceiver

{

public override void WebProvisioned(SPWebEventProperties properties)

{

SPWeb thisNewWeb = properties.Web;

thisNewWeb.AllowUnsafeUpdates = true;

thisNewWeb.Title = "Updated in Code";

thisNewWeb.Update();

thisNewWeb.AllowUnsafeUpdates = false;

base.WebProvisioned(properties);

}

}

}

The following code shows how to enumerate the alerts in a SharePoint site, and also how toenable or disable alerts.

Note: This code is designed to run on an application page that includes:

- An ASP.NET Label control called alertCount- An ASP.NET button that includes a Clickevent handler set to the EnableAllfuntion

- An ASP.NET button that includes a Clickevent handler set to the DisableAllfuntion

namespace Alerter.Layouts.Alerter

{

public partial class Alerts : LayoutsPageBase

{


{

int enabled = 0;

int disabled = 0;

SPWeb thisWeb = SPContext.Current.Web;

foreach (SPAlert alrt in thisWeb.Alerts)

{

if (alrt.Status == SPAlertStatus.On)

{

enabled++;

}

if (alrt.Status == SPAlertStatus.Off)

{ disabled++;

}

}

alertCount.Text = "Enabled Alerts: " + enabled.ToString()

+ "\nDisabled Alerts" + disabled.ToString();

}

protected void EnableAll(object sender, EventArgs e)

{


7/27



{

alrt.Status = SPAlertStatus.On;

alrt.Update();

}

}

protected void DisableAll(object sender, EventArgs e)

{



{

alrt.Status = SPAlertStatus.Off;

alrt.Update();

}

}

}

}

The following code creates a new SharePoint site (SPWeb object):

SPSite thisSite = SPContext.Current.Site;

thisSite.RootWeb.AllowUnsafeUpdates = true;

SPWeb hrWeb = thisSite.RootWeb.Webs.Add("HRWeb",

"Human Resources Web",

"For use by HR Employees",

1033,

"STS#0",

false,false);

hrWeb.Dispose();

thisSite.RootWeb.AllowUnsafeUpdates = false;

The following code enumerates all of the services provided by the current farm's SPFarmobject

and displays them in a treeview control in an application page.

Note: The code relies on there being a tree-view named farmContentsin the application page.

namespace Hierarchy.Layouts.Hierarchy

{public partial class HierarchyViewer : LayoutsPageBase

{


{

SPFarm thisFarm = SPFarm.Local;

TreeNode node;

farmContent s.Nodes.Clear();

foreach(SPService svc in thisFarm.Services)


8/27

{

node = new TreeNode();

node.Text = "(Type=" + svc.TypeName + ") " + svc.DisplayName;

farmContents.Nodes.Add(node);

}

farmContents.CollapeAll();

}

}

The following code enumerates all of the services, web applications, site collections, sites, and

lists in a SharePoint farm, and displays them in a treeview control in an application page.

Note: The code relies on there being a tree-view named farmContentsin the application page.

Also note how the addWebs() function is called recursively to ensure sites and subsites areenumerated and displyed in the treeview.

using System;

using Microsoft.SharePoint;using Microsoft.SharePoint.WebControls;


using Microsoft.SharePoint.Administration;

namespace Hierarchy.Layouts.Hierarchy

{

public partial class HierarchyViewer : LayoutsPageBase

{


{

SPFarm thisFarm = SPFarm.Local;

TreeNode node;

farmContents .Nodes.Clear();

foreach(SPService svc in thisFarm.Services)

{


node.Text = "(Type=" + svc.TypeName + ") " + svc.DisplayName;

farmContents.Nodes.Add(node);

TreeNode svcNode = node;

if (svc is SPWebService)

{

SPWebService webSvc = (SPWebService)svc;

foreach (SPWebApplication webApp in webSvc.WebApplications)

{


node.Text = webApp.DisplayName;

svcNode.ChildNodes.Add(node);

TreeNode webAppNode = node;

foreach (SPSite site in webApp.Sites)

{


9/27

try {


node.Text = site.Url;

webAppNode.ChildNodes.Add(node);

TreeNode siteNode = node;

site.CatchAccessDeniedException = false;

try

{

node = new TreeNode(site.RootWeb.Title, null, null,

site.RootWeb.Url, "_self");

siteNode.ChildNodes.Add(node);

TreeNode parentNode = node;

foreach (SPList list in site.RootWeb.Lists)

{

node = new TreeNode(list.Title, null, null,

list.DefaultViewUrl, "_self");


}

foreach (SPWeb childWeb in site.RootWeb.Webs)

{

try {


} finally

{

childWeb.Dispose();

}}

}

catch

{ }

}

finally

{

site.Dispose();

}

}

}

}

}

farmContents.CollapseAll();

}

void addWebs(SPWeb web, TreeNode parentNode)


10/27

{

TreeNode node;

node = new TreeNode(web.Title, null, null, web.Url, "_self");


parentNode = node;

foreach (SPList list in web.Lists)

{


"_self");


}

foreach (SPWeb childWeb in web.Webs)

{

try {


} finally {

childWeb.Dispose();

}

}

}

}

}

Module 3: Building Blocks for Web Part Development in SharePoint

2010

SharePoints building blocks enable faster development, proven components, and moreefficient code, and they ensure you do not end up building what already exists.

The SharePoint Controls section in the Visual Studio toolbox does not display all of thecontrols available to the developer. To see the complete list type


11/27

ListViewByQuery listTasks = new ListViewByQuery();

listTasks.List = tasks;

SPQuery taskQuery = new SPQuery(listTasks.List.DefaultView);

taskQuery.ViewFields = "";

taskQuery.Query = ""

+

SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Now.AddMonths(1))

+ "";

listTasks.Query = taskQuery;

this.Controls.Add(listTasks);


}

The following code shows how to extract the selected people in a PeopleEditorcontrol.

Note:The code runs in a Visual Web Part, and relies on there being a PeopleEditorcontrol

named peoplePicker, and an ASP.NET ListBoxcontrol called selectedPeople

namespace SharePointControls.ControlExample

{

public partial class ControlExampleUserControl : UserControl

{


{

}

protected void getPeople(object sender, EventArgs e)

{

string allPeople = peoplePicker.CommaSeparatedAccounts;

string[] selected = allPeople.Split(new string[] { "," },StringSplitOptions.RemoveEmptyEntries);

foreach (string p in selected)

{

selectedPeople.Items.Add(p);

}

}

}

}

The following code shows how to use the SPGridViewcontrol in a Web Part to display listitems from a list:


{

SPGridView taskGrid = new SPGridView();

taskGrid.AutoGenerateColumns = false;

BoundField taskTitle = new BoundField();

taskTitle.DataField = "Title";


12/27

taskTitle.HeaderText = "To Do...";

taskGrid.Columns.Add(taskTitle);

SPWeb thisWeb = SPControl.GetContextWeb(Context);

SPList taskList = thisWeb.Lists["Tasks"];

SPDataSource listSource = new SPDataSource();

listSource.List = taskList;

SPDataSourceView view = listSource.GetView();

taskGrid.DataSource = listSource;

if (view.CanSort)

{

taskGrid.AllowSorting = true;

}

taskGrid.DataBind();

Controls.Add(taskGrid);


}

Module 4: Accessing SharePoint 2010 Data with Server-Side APIs

Retrive and Manipulate list items in a SharePoint site use SPListItem andSPQuery classes.

SPQuery Class makes use of CAML query with a where clause that filters theresults that it returns.

SPMetal is a Command line tool that creates entities for use with LINQ. LINQ offers early binding to list data, fields and the data types of those

fields.LINQ is also a standard approach to querying data.

A Content type can be associated with various types of document andcompleting the additional metadata can improve the management of site data.

Some extensions of content type functionality can only be implemented in VisualStudio 2010.

Module 5: Accessing SharePoint 2010 Data with Client-Side APIs

Silverlight, .NET and JavaScript can all use SharePoint Client Object Model. XML and JSON are used to communicate between Client Object Model and SharePoint

server.


13/27

When the Client Object Model is instantiated the URL to the SharePoint site can bepassed to its constructor as a string.

Lambda Expressions can be used to filter the items in a list when calling the Listsmethod on the Client Context load.

Silver light applications should query data using an asynchronous background thread.

.Module 5 - Code Snippets: Accessing SharePoint 2010 Data with Client-Side APIs

The following code shows how to use the client object model from a console application. Thecode first of all lists the Web templates available for a specific Web, and then creates a new Web

based on a specific template:

ClientContext clientCtx = new ClientContext("http://intranet.contoso.com");

Site thatSite = clientCtx.Site;

clientCtx.Load(thatSite.RootWeb);

Web thatWeb = thatSite.RootWeb;

WebTemplateCollection templates =

thatWeb.GetAvailableWebTemplates(1033, true);

clientCtx.Load(templates);

clientCtx.ExecuteQuery();

foreach (WebTemplate template in templates)

{

Console.WriteLine(template.Id + " : "

+ template.Name + " : "

+ template.Title);

}

WebCreationInformation webInfo = new WebCreationInformation();

webInfo.Description = "My client-created Web";

webInfo.Title = "Created by Client OM";

webInfo.Url = "Client3";

webInfo.Language = 1033;

webInfo.UseSamePermissionsAsParentSite = true;

webInfo.WebTemplate = "MPS#2";

Web newWeb = thatWeb.Webs.Add(webInfo);


clientCtx.Dispose();

Console.WriteLine("Web was created");

The following code shows how to use the client object model from a Windows Presentation

Foundation (WPF) application. The code enumerates the lists in a Web, and adds them to a WPF

Expandercontrol.Note: The code relies on there being an Expandercontrol named expander1on the WPF form.

try

{

ClientContext clientCtx = new ClientContext(siteUrl.Text);


14/27

Web thatWeb = clientCtx.Web;

clientCtx.Load(thatWeb);

clientCtx.Load(thatWeb.Lists);

clientCtx.Load(thatWeb, lists => lists.Lists.Where(list => list.Title !=

null));


AllLists.Items.Clear ();

foreach (Microsoft.SharePoint.Client.List lst in thatWeb.Lists)

{

AllLists.Items.Add(lst.Title);

}

clientCtx.Dispose();

}

catch (Exception ex)

{

AllLists.Items.Clear ();

AllLists.Items.Add(ex.Message);

}

expander1.IsExpanded = false;

Note:To see code samples that use the client object model from a Silverlight application, please

see:http://blogs.msdn.com/pandrew/pages/GettingStarted2010Snippets8.aspx

Module 6: Accessing External Data with Business Connectivity

Services in SharePoint 2010

SharePoint 2010 provides a new set of technologies known as Business Connectivity Services for

retrieving, editing, updating, and deleting data from external systems. This module provides an overview

of Business Connectivity Services, and delves into development examples of using Business Connectivity

Services data in custom SharePoint solutions.

Business Connectivity Services integrates external content with SharePointCollaboration and workflow.
http://blogs.msdn.com/pandrew/pages/GettingStarted2010Snippets8.aspxhttp://blogs.msdn.com/pandrew/pages/GettingStarted2010Snippets8.aspxhttp://blogs.msdn.com/pandrew/pages/GettingStarted2010Snippets8.aspx


15/27

SharePoint Designer can be used to build basic Business Connectivity servicessolutions with many of the features managed by standard out-ofbox functionality.

More Complex requirements can be built in visual Studio 2010.

External Content from Business Connectivity Services can be displayed in theSharePoint web interface and can be taken offline in SharePoint Workspace.

Business Connectivity Services enables full data operations including updating anddeletion of records to take place if the developer chooses. Both SharePoint Designer

and Visual Studio support these actions.

Module 7: Developing Business Processes with SharePoint 2010

Workflows

SharePoint 2010 provides a powerful workflow framework that enables you to implementcustom business processes that are driven by SharePoint data.

SharePoint 2010 adds Site Workflows to the existing List Workflow capability that wasprovided in earlier versions.

The Workflow engine is based on ASP.NET 3.5 and as well as introducing workflows atSite level, SharePoint 2010 also enables workflows to be built in Visio before being

imported into SharePoint Designer or Visual Studio.

The Workflow engine supports Sequential and State Machine workflows. The Site Workflow workflows can be started from the Site Actions Menu by clicking the

Site Workflows option and then the Site workflow from the Webpage.

The Workflow initationForm allows parameters to be provided when a workflow isstarted.

Module 7 - Code Snippets: Developing Business Processes with SharePoint 2010 WorkflowsThe following code shows how to return data from a workflow initiation form to the workflow.

Note:This code relies on there being an ASP.NET Textbox on the initiation form named

MaxPrice.Note also that the code snippet that follows this one uses the data returned.

namespace ApproveRejectProducts.Workflow1

{

public partial class GetMaxPrice : LayoutsPageBase

{


16/27


{

InitializeParams();

// Optionally, add code here to pre-populate your form fields.

}

// This method is called when the user clicks the button to start the

workflow.

private string GetInitiationData()

{

return (MaxPrice.Text);

}

}

}

The following code shows how to use data returned from a workflow initiation form (as in the

above example) and use it in a code activity in a SharePoint 2010 workflow.Note:This code relies on there being a list named Productsin the current SharePoint site.

namespace ApproveRejectProducts.Workflow1

{

public sealed partial class Workflow1 : SequentialWorkflowActivity

{

public Workflow1()

{

InitializeComponent();

}

public Guid workflowId = default(System.Guid);

public SPWorkflowActivationProperties workflowProperties = new

SPWorkflowActivationProperties();

private void codeActivity1_ExecuteCode(object sender, EventArgs e)

{

double maxPrice =

double.Parse(workflowProperties.InitiationData.ToString());

SPWeb thisWeb = workflowProperties.Web;

SPList products = thisWeb.Lists["Products"];

foreach (SPListItem product in products.Items)

{

if (double.Parse(product["SellingPrice"].ToString()) > maxPrice)

{

product.ModerationInformation.Comment = "Price too high";

product.ModerationInformation.Status =

SPModerationStatusType.Denied;

product.Update();

}

else

{


17/27

product.ModerationInformation.Comment = "Price OK";

product.ModerationInformation.Status =

SPModerationStatusType.Approved;

product.Update();

}

}

}

}

}

Module 8: Creating Silver light User Interfaces for SharePoint

2010 Solutions

Silver light 3.0 provides the opportunity for developers to create the next generation of Rich

Internet Applications (RIAs). SharePoint 2010 integrates closely with Microsoft Silver light to

enable you to build compelling user interfaces that interact with SharePoint data.

The SharePoint 2010 Client Object model significantly simplifies the creation of Silverlight applications that access SharePoint 2010 sites.

Silver light offers a rich user experience and with the code running on the client browserthe workload for many operations is removed from the server.

SharePoint 2010 supports silver light applications by providing a Silver light Web partthat you can add to your page and specify the URL to the Silver light XAP file .If your

Silver light application requires additional parameters then you can write your own

control to host the Silver light application.

A Silver light application can be uploaded to a SharePoint Document Library by aninformation worker and then added to a page using the built-in Silver light web part in

SharePoint 2010,as well as being deployed to the Client Bin folder by an administrator.

Module 8 - Code Snippets: Creating Silverlight User Interfaces for SharePoint 2010 Solutions

The following code shows how to use the SharePoint client object model in a Silverlight

application. The code performs the following actions in the Silverlight application:

- Obtains a reference to the current SharePoint site in the application's APP.XAML file

- Updates a progress bar and status label in real time, based on accessing and retrieving datafrom SharePoint

- Renders media files (images and videos) from SharePoint in the Silverlight application


18/27

Note: Silverlight code must call methods of the client object model asynchronously, so that the

main UI thread in Silverlight is not blocked while waiting for responses from SharePoint. In this

way, the progress bar (and status label) can be updated appropriately. However, becausethe results from SharePoint are returned on background threads (becuase of the asynchronous

nature of the calls) and because updating the UI must be performed back on the main UI thread,

the code switches back to the main UI thread by using the Dispatcher.BeginInvoke() calls thatyou can see below.

Also note that the code relies on there being the following controls in the Silverlight User

Control:- A Silverlight ProgressBar named Loader

- A Silverlight TextBlock named Status- A Silverlight StackPanel named MyContainer

// The following using statements are in the application file (APP.XAML.CS)

using Microsoft.SharePoint.Client;

using System.Threading;

//The following line of code is in the Startupevent for the

//Silverlight application in the application file (APP.XAML.CS)

ApplicationContext.Init (e.InitParams, SynchronizationContext.Current);

//The following using statements are in a Silverlight user control

using Microsoft.SharePoint.Client;

using System.Threading;

//The following code is in a Silverlight user control

ClientContext clientCtx;

Microsoft.SharePoint.Client.List docs;

int fileTracker = 0;

int rowTracker = 0;

private void LayoutRoot_Loaded(object sender, RoutedEventArgs e)

{

Loader.Maximum = 3;

Loader.Value = 0;

Status.Text = "Connecting to Web...";

clientCtx = new ClientContext(ApplicationContext.Current.Url);

clientCtx.Load(clientCtx.Web);

clientCtx.ExecuteQueryAsync(updateConnectionStatus, null);

}

void updateConnectionStatus(Object sender, ClientRequestSucceededEventArgs e)


19/27

{

//This method starts on a background thread, but needs to update the progress bar and label in the UI

//Therefore, it calls Dispatcher.BeginInvoke() to perform the UI updating on the main thread

Dispatcher.BeginInvoke(makeProgressWebConnection);

}

void makeProgressWebConnection()

{

//Called by Dispatcher.BeginInvoke() in the function above

//The code is now running back on the main UI thread, and so can update the UI

Loader.Value++;

Status.Text = "Web Connected. Connecting to Lists...";

clientCtx.Load(clientCtx.Web.Lists);

clientCtx.ExecuteQueryAsync(updateListStatus, null);

}

void updateListStatus(Object sender, ClientRequestSucceededEventArgs e)

{



Dispatcher.BeginInvoke(makeProgressListConnection);

}

void makeProgressListConnection()

{



Loader.Value++;

Status.Text = "Lists Connected. Getting List data...";

MyContainer.Children.Clear();

docs = clientCtx.Web.Lists.GetByTitle("Shared Documents");

clientCtx.Load(docs);

clientCtx.Load(docs.RootFolder);

clientCtx.Load (docs.RootFolder.Files);

clientCtx.ExecuteQueryAsync(getListData, null);

}

void getListData(Object sender, ClientRequestSucceededEventArgs e)

{



Dispatcher.BeginInvoke(loadFiles);

}

private void loadFiles()

{



20/27


Loader.Maximum = docs.RootFolder.Files.Count;

Loader.Value = 0;

Status.Text = "Loading Files...";

fileTracker = 0;

foreach (File fle in docs.RootFolder.Files)

{

clientCtx.Load(fle);

clientCtx.ExecuteQueryAsync(addFileToUI, null);

}

}

void addFileToUI(Object sender, ClientRequestSucceededEventArgs e)

{


//It can now also render the files, which is another UI operation


Dispatcher.BeginInvoke(addFile);

}

StackPanel row = new StackPanel();

void addFile()

{



string fName = docs.RootFolder.Files[fileTracker].Name;

string fUrl = docs.RootFolder.Files[fileTracker].ServerRelativeUrl;

fUrl = clientCtx.Url + fUrl;

//Simple logic to lay out the files in a three-column configuration

if ((rowTracker % 3) == 0)

{

row = new StackPanel();

row.Orientation = Orientation.Horizontal;

MyContainer.Children.Add(row);

}

if ((fName.EndsWith(".png")) || (fName.EndsWith(".jpg")))

{

Image img = new Image();

img.MaxWidth = 100;

img.Stretch = Stretch.Uniform;

BitmapImage bitMap = new BitmapImage(new Uri(fUrl, UriKind.Absolute));

img.Source = bitMap;

HyperlinkButton mediaButton = new HyperlinkButton();


21/27

mediaButton.Margin = new Thickness(5);

mediaButton.Content = img;

mediaButton.TargetName = "_blank";

mediaButton.NavigateUri = new Uri(fUrl);

mediaButton.Cursor = Cursors.Hand;

row.Children.Add(mediaButton);

rowTracker++;

}

if (fName.EndsWith(".wmv"))

{

MediaElement media = new MediaElement();

media.MaxWidth = 100;

media.Stretch = Stretch.Uniform;

media.Source = new Uri(fUrl, UriKind.Absolute);

media.AutoPlay = true;

HyperlinkButton mediaButton = new HyperlinkButton();

mediaButton.Margin = new Thickness(5);

mediaButton.Content = media;

mediaButton.TargetName = "_blank";

mediaButton.NavigateUri = new Uri(fUrl);

mediaButton.Cursor = Cursors.Hand;

row.Children.Add(mediaButton);

rowTracker++;

}

Loader.Value++;

fileTracker++;

if (fileTracker >= docs.RootFolder.Files.Count)

{

Status.Text = "All files have now been loaded";

}

}

Module 9: Sandboxed Solutions for Web Parts in SharePoint

2010

SharePoint 2010 provides a new sandboxed environment that enables you to run user

solutions without affecting the rest of the SharePoint farm. This environment means

that users can upload their own custom solutions without requiring intervention from

administrators, and without putting the rest of the farm at risk.


22/27

Sandboxing provides non-developers and organizations with agility stability andsecurity.

The Sandbox type for a particular solution can be set in the wizard during projectcreation. It can also be set from the properties window in visual studio when you

are developing the project.

The Sandboxed code is run in the context of a specific worker process calledSPUCWorkerProcess.The code is then reviewed against a set of allowed objects

and methods on the subset of the object model and ,where allowed calls are

made against the full object model.

The Sandboxed feature offers advanced resource management that is capable ofidentifying code that is consuming more resources than acceptable and the

reducing the impact of that code by notifying the administrator and if necessary

disabling code.

Number of operations is not allowed in sandboxed solution. These include usingthe SPFarm object and performing asynchronous post backs.

Module 9 - Code Snippets: Sandboxed Solutions for Web Parts in SharePoint 2010

The following example shows code that attempts to run in a sandboxed solutuon. There are four

buttons, each of which attempt a different type of action, as follows:- renderWebInfo_Click: This operation will be allowed to run in the sandbox.

- renderWebInfoElevated_Click: This operation will notbe allowed to run in the sandbox.

The sandbox will catch the exception, so the catch{} block will not run.- accessProhibitedNamespace_Click: This operation will notbe allowed to run in the

sandbox. However, the exception will be caught by the catch{} block.

- renderCrossSiteData_Click: This operation will notbe allowed to run in the sandbox. Thesandbox will catch the exception, so the catch{} block will not run

namespace SBWebPart.SandboxedWebPart

{

[ToolboxItemAttribute(false)]

public class SandboxedWebPart : WebPart

{

public SandboxedWebPart()

{

}

LiteralControl output;


{


23/27

Button renderWebInfo = new Button();

renderWebInfo.Text = "Access data in this site";

renderWebInfo.Click += new EventHandler(renderWebInfo_Click);

Button renderWebInfoElevated = new Button();

renderWebInfoElevated.Text = "Use elevated privileges";

renderWebInfoElevated.Click += new

EventHandler(renderWebInfoElevated_Click);

Button accessProhibitedNamespace = new Button();

accessProhibitedNamespace.Text = "Create an HTTP connection ";

accessProhibitedNamespace.Click += new

EventHandler(accessProhibitedNamespace_Click);

Button renderCrossSiteData = new Button();

renderCrossSiteData.Text = "Access data in other site collections";

renderCrossSiteData.Click += new

EventHandler(renderCrossSiteData_Click);

output = new LiteralControl();

output.Text = "";

this.Controls.Add(output);

this.Controls.Add(new LiteralControl("
"));

this.Controls.Add(renderWebInfo);

this.Controls.Add(renderWebInfoElevated);

this.Controls.Add(accessProhibitedNamespace);

this.Controls.Add(renderCrossSiteData);


}

void renderWebInfo_Click(object sender, EventArgs e)

{

try

{


string message = string.Format("This web contains {0} subwebs",

thisWeb.Webs.Count);

output.Text = message;

}

catch(Exception ex)

{

output.Text = ex.Message;

}

}

void renderWebInfoElevated_Click(object sender, EventArgs e){

try

{

SPSecurity.RunWithElevatedPrivileges(showWebCount);

}


{

output.Text = "My Caught Error: " + ex.Message;


24/27

}

}

void showWebCount()

{


string message = string.Format("This web contains {0} subwebs",

thisWeb.Webs.Count);


}

void accessProhibitedNamespace_Click(object sender, EventArgs e)

{

try

{

System.Net.HttpWebRequest.Create("http://intranet.contoso.com");

output.Text = "Success";

}


{


}

}

void renderCrossSiteData_Click(object sender, EventArgs e)

{

try

{


SPSiteDataQuery crossSiteQuery = new SPSiteDataQuery();

crossSiteQuery.Lists = "";

crossSiteQuery.Webs = "";

string message = string.Format("There are {0} lists",

thisWeb.GetSiteData(crossSiteQuery).Rows.Count.ToString());


}


{


}

}

protected override void RenderContents(HtmlTextWriter writer)

{ base.RenderContents(writer);

}

}

}
http://intranet.contoso.com/http://intranet.contoso.com/http://intranet.contoso.com/


25/27

Module 10: Creating Dialogs and Ribbon Controls for SharePoint 2010

SharePoint 2010 provides new user interface components, such as server ribbons, and the new

dialog platform. As a developer, you can create controls for the server ribbon and dialog boxes

for the dialog platform.

Modifying Server Ribbon is supported task in SharePoint 2010. The server ribbon uses AJAX, Dynamic Scaling as well as CSS Layouts, styling and hover

effects.

The Dialog user interface is a visual interface that helps users maintain context wheninteracting with content on the SharePoint site. The dialog user interface can be

accessed by developers using the HTML elements and JavaScript.

The dialog control is typically implemented in an HTML DIV that is made visibleprogrammatically when required.

Module 10 - Code Snippets: Creating Dialogs and Ribbon Controls for SharePoint 2010

The following markup is a simple example of how to add a control to the Site Actions menu.This example adds a menu item that navigates the user directly to the Solutions Gallery, without

requiring them to go to the Site Settings page first:

The following markup shows how to add a control to the server ribbon. This example adds a

'Help' button to the ribbon in the same group as the built-in 'New Document', 'New Folder', and

'Upload Document' ribbon controls:
http://schemas.microsoft.com/sharepoint/http://schemas.microsoft.com/sharepoint/http://schemas.microsoft.com/sharepoint/http://schemas.microsoft.com/sharepoint/http://schemas.microsoft.com/sharepoint/http://schemas.microsoft.com/sharepoint/


26/27

The following code is the source for a Visual Web Part that includes a dialog control that enablesthe user to change the site title. The JavaScript code uses the client object model to make the

changes requested by the user.Note:The code shows good practice by only showing the hyperlink for changing the site titleafter the client object model has loaded the Web object.

Change Site Title

Site Title Changer

var clientCtx;

var thisWeb;

var thisDialog;


27/27

_spBodyOnLoadFunctionNames.push("Initialize()");

function Initialize() {

clientCtx = SP.ClientContext.get_current();

thisWeb = clientCtx.get_web();

clientCtx.load(thisWeb);

clientCtx.executeQueryAsync(onWebLoaded,null);

}

function onWebLoaded() {

var linkChanger = document.getElementById("linkChanger");

linkChanger.style.display = "inline";

}

function showTitleChanger() {

var divEditSiteTitle = document.getElementById("divEditSiteTitle");

divEditSiteTitle.style.display = "block";

var dialog = { html: divEditSiteTitle, width: 200, height: 200};

thisDialog = SP.UI.ModalDialog.showModalDialog(dialog);

}

function hideTitleChanger() {

thisDialog.close();

}

function changeTitle() {

thisWeb.set_title(siteTitle.value);

thisWeb.update();

clientCtx.executeQueryAsync(onTitleUdated, null);

}

function onTitleUdated() {

hideTitleChanger();

}