3. SharePoint 2010 Platform An evolved version of MOSS and WSS v3 Microsoft SharePoint Server 2010 Microsoft SharePoint Foundation 2010 Development can now be done on client OS Significant enhancement for many development teams Browser Clients Microsoft SharePoint Server 2010 MS Word Clients Microsoft SharePoint Foundation 2010 MS Outlook Clients .NET Framework and ASP.NET 3.5 SP1 Internet Information Services 7.0 Windows Server 2008 (x64 only)for Production Environments Windows 7 or Vista (x64 only) for Development Environments only

4. SharePoint Architecture

5. SharePoint 2010 Dev Enviroment Development must be done against isolated deployment of SharePoint (Virtual) Machine has: Visual Studio 2010 SharePoint Designer 2010 SQL Server 2008 Office 2010 / 2007

6. SharePoint 2010 Developer Tools Visual Studio has robust tools for SP 2010 development Project and item templates Templates for many SharePoint elements Visual Designers and Explorers Feature and Solutions Site contents F5 deployment and debugging Deployment is configurable

7. SharePoint 2010 Projects SharePoint Projects have standard properties Project File Project Folder Active Deployment Configuration Include Assembly in Package Assembly Deployment Target Sandboxed Solution Site URL Startup Item

8. DEMO Building a SharePoint 2010 project

9. Solution Packages Work done in Visual Studio packaged into a solution for deployment Package is a CAB file with a WSP extension Package contains manifest with deployment instructions

10. Sample Solution Manifest <?xml version="1.0" encoding="utf-8"?> <Solution xmlns="http://schemas.microsoft.com/sharepoint/" SolutionId="e6c7d3ce-f0a8-4f48-8d50-0cba4ae5ac9e" SharePointProductVersion="14.0"> <Assemblies> <Assembly Location="UserControlWebParts.dll" DeploymentTarget="GlobalAssemblyCache"> <SafeControls> <SafeControl Assembly="UserControlWebParts, Version=1.0.0.0, ..." Namespace="UserControlWebParts.VisualCalculator" TypeName="*" /> <SafeControl Assembly="UserControlWebParts, Version=1.0.0.0, ..." Namespace="UserControlWebParts.ListBrowser" TypeName="*" /> </SafeControls> </Assembly> </Assemblies> <TemplateFiles> <TemplateFile Location="CONTROLTEMPLATES..isualCalculatorUserControl.ascx" /> <TemplateFile Location="CONTROLTEMPLATES..istBrowserUserControl.ascx" /> </TemplateFiles> <FeatureManifests> <FeatureManifest Location="UserControlWebParts_Feature1eature.xml" /> </FeatureManifests> </Solution>

11. Farm and Sandboxed Solutions Farm Solutions Deployed at farm scope Requires administrator rights to deploy Sandboxed solutions Deployed at site collection scope Requires site collection owner rights Restricted to subset of SharePoint server API Restricted resource usage

12. Features Building blocks for creating SharePoint solutions A unit of design, implementation and deployment Contain elements e.g. menu items, links, list types and list instances Many other element types possible Can contain event handlers You can add any code which used WSS object model

13. Sample Feature Manifest <?xml version="1.0" encoding="utf-8"?> <Feature xmlns="http://schemas.microsoft.com/sharepoint/" Id="734f2957-51f6-444c-b8cc-ab165c2fa4c5" Scope="Site" Title="UserControlWebParts Feature1"> <ElementManifests> <ElementManifest Location="VisualCalculatorlements.xml" /> <ElementFile Location="VisualCalculatorisualCalculator.webpart" /> <ElementManifest Location="ListBrowserlements.xml" /> <ElementFile Location="ListBrowseristBrowser.webpart" /> </ElementManifests> </Feature>

14. User’s View of Features Support concept of activation and deactivation

15. SharePoint 2010 System Folders Root folder known as System Root May also hear term 14 Hive This term is being phased out

16. The Features Directory Features may be installed at farm level One folder per Feature Multiple Feature activation scopes Farm, Web application, Site Collection, Site

17. DEMO Revisit the simple project Deploy a sandboxed solution

18. Content Storage in SharePoint Storage is based on the concept of lists Everything is modeled in terms of rows and columns The Document Library is really just a hybrid list SharePoint adds value on top of the generic list Transparent content storage in SQL Server Automatic generation of the user interface

19. Lists

20. List Lookups Lookups form relationships between lists Referential integrity can be enforced Lookup Lookup 1 1 m m Projects Timecards Clients

21. Column Validation Validation Formula can be specified on List and Columns Similar to Excel formulas Example: =[Discount] < [Cost] Column uniqueness constraint

22. Large List Support Check query before execution If Index is not used and number of scanned rows is greater than a limit then block query If number of Joins is greater than limit then block query If enabled on the Web Application, the developer can turn off throttling using:SPQuery.RequestThrottleOverride and SPSiteDataQuery.RequestThrottleOverride

23. Overview of Data Technologies REST APIs Strongly-typed ClientOM Weakly-typed Client-side Data Platform Farm Site List Data External Lists ServerOM Server-side Weakly-typed New in 2010 Improved LINQ Strongly-typed

24. Working with SharePoint 2010 SharePoint Server Application SharePoint API Web Service Client.svc JSON XML Client Application Client OM WPF/WinForm/Office Silverlight JavaScript Client Application

25. Server Object Model The SharePoint version of “Hello, World” Show the root site of a collection and it’s lists using (var site = new SPSite("http://localhost/sites/demo/")) { var web = site.RootWeb; ListBox1.Items.Add(web.Title); foreach (SPList list in web.Lists) { ListBox1.Items.Add("" + list.Title); } }

26. Resource Usage SPSite and SPWeb objects use unmanaged resources Vital that you release resources with Dispose General rules: If you create the object, you should Dispose var site = new SPSite(“http://localhost”); var web = site.OpenWeb(); If you get a reference from a property, don’t Dispose var web = site.RootWeb There are exceptions to these rules Use SPDisposeCheck to analyze code

27. DEMO Working with the Server Object Model

28. Managed Client Object Model <System Root>SAPI Microsoft.SharePoint.Client 281kb Microsoft.SharePoint.Client.Runtime 145kb To Compare: Microsoft.SharePoint.dll – 15.3MB

29. Managed Client Object Model The SharePoint version of “Hello, World” Show the root site of a collection and it’s lists using (var context = new ClientContext("http://localhost/sites/demo")) { var site = context.Site; var web = site.RootWeb; context.Load(web, w => w.Title); context.Load(web.Lists); context.ExecuteQuery(); ListBox1.Items.Add(web.Title); foreach (var list in web.Lists) { ListBox1.Items.Add("" + list.Title); } }

30. Retrieve Data Client Context methods wrap service calls Context.Load(object, paramsLinqExpression) Fills out the objects in the context: in-place Context.LoadQuery(IQueryable) Use Linq query to return custom objects Not filled into the context var query = from list in clientContext.Web.Lists where list.Title != null select list; var result = clientContext.LoadQuery(query); clientContext.ExecuteQuery();

31. Silverlight Client Object Model <System Root>EMPLATEAYOUTSlientBin Microsoft.SharePoint.Client.Silverlight 262KB Microsoft.SharePoint.Client.Silverlight.Runtime 138KB

32. Silverlight Client Object Model Web web; ClientContext context; void MainPage_Loaded(object sender, RoutedEventArgs e) { context = new ClientContext("http://localhost/sites/demo"); web = context.Web; context.Load(web); context.ExecuteQueryAsync(Succeeded, Failed); } void Succeeded(object sender, ClientRequestSucceededEventArgs e) { Label1.Text = web.Title; } void Failed(object sender, ClientRequestFailedEventArgs e) { // handle error }

33. JavaScript Client Object Model <System Root>EMPLATEAYOUTS SP.js (SP.debug.js) 380KB (559KB) SP.Core.js (SP.Core.debug.js) 13KB (20KB) SP.Runtime.js (SP.Runtime.debug.js) 68KB (108KB) Add using <SharePoint:ScriptLink>

34. JavaScript Client Object Model <SharePoint:ScriptLink ID="SPScriptLink" runat="server" LoadAfterUI="true" Localizable="false" Name="sp.js" /> <script src="js/jquery-1.3.2.min.js" type="text/javascript"></script> <script type="text/javascript"> _spBodyOnLoadFunctionNames.push("Initialize"); var web; function Initialize() { var context = new SP.ClientContext.get_current(); web = context.get_web(); context.load(web); context.executeQueryAsync(Succeeded, Failed); } function Succeeded() { $("#listTitle").append(web.get_title()); } function Failed() { alert('request failed'); } </script>

35. DEMO Working with the Managed Client Object Model

36. Event Handlers Override methods on known receiver types SPFeatureReceiver SPListEventReceiver SPItemEventReceiver Register receiver as handler for entity Use CAML or code Synchronous and asynchronous events ItemAdding ItemAdded

37. Sample Feature Receiver public class Feature1EventReceiver : SPFeatureReceiver { public override void FeatureActivated(SPFeatureReceiverProperties properties) { var web = properties.Feature.Parent as SPWeb; if (web == null) return; web.Properties["OldTitle"] = web.Title; web.Properties.Update(); web.Title = "Feature activated at " + DateTime.Now.ToLongTimeString(); web.Update(); } public override void FeatureDeactivating( SPFeatureReceiverProperties properties) { var web = properties.Feature.Parent as SPWeb; if (web == null) return; web.Title = web.Properties["OldTitle"]; web.Update(); } }

38. DEMO Working with Event Handlers

39. Overview of Data Technologies REST APIs Strongly-typed ClientOM Weakly-typed Client-side Data Platform Farm Site List Data External Lists ServerOM Server-side Weakly-typed New in 2010 Improved LINQ Strongly-typed

40. REST APIs Work with data via Representational State Transfer (REST) SharePoint list data Other data sources as well Excel spreadsheets Azure cloud store Powered by ADO.NET Data Services “Astoria” REST Protocols: Atom, AtomPub, and JSON Integration and Standardization

41. REST APIs

42. Consuming Data via REST APIs

43. Consuming Data via REST APIs private DemoProxy.DemoDataContext _context = new DemoProxy.DemoDataContext(new Uri( "http://localhost/sites/demo/_vti_bin/ListData.svc")); private void Form1_Load(object sender, EventArgs e) { _context.Credentials = System.Net.CredentialCache.DefaultCredentials; productsBindingSource.DataSource = _context.Products; } private void productsBindingNavigatorSaveItem_Click(object sender, EventArgs e) { _context.SaveChanges(); } private void productsBindingSource_CurrentItemChanged(object sender, EventArgs e) { _context.UpdateObject(productsBindingSource.Current); }

44. DEMO Using the REST APIs

45. LINQ to SharePoint No CAML Required Entity classes form Business Layer Strongly-typed queries, compile-time check Intelligence helps query construction Microsoft.SharePoint.Linq.dll

46. SPMetal Entities generated using SPMetal utility SPMetal located in <System Root>in spmetal /web:<site Url> /code:Projects.cs Create classes and add them to project

47. Consuming Data with LINQ to SharePoint varsiteUrl = "http://localhost/sites/demo"; var context = new SPNorthwind.SPNorthwindDataContext(siteUrl); var query = from p in context.Products where p.Category.Title == "Beverages" select p; foreach (var item in query) { Console.WriteLine(item.Title); }

48. DEMO LINQ to SharePoint

49. Web Parts Modular and reusable building blocks typically used in portal style applications Support for customization and personalization Web Part infrastructure required Not specific to SharePoint Not specific to ASP.NET

50. DEMO PageFlakes.com

51. Web Part History Windows SharePoint Services 2.0 Designed with its own Web Part infrastructure WSS serializes/stores/retrieves personalization data ASP.NET 2.0 Includes Web Part infrastructure Serializes/stores/retrieves personalization data More flexible and more extensible than WSS ASP.NET 2.0 does not support WSS v2 Web Parts SharePoint Services 3.0 / SharePoint Foundation 2010 Supports WSS V2 style Web Parts Supports ASP.NET 2.0 style Web Parts (preferred)

52. Web Part Gallery Site collection scoped Both .DWP and .WEBPART files as items SharePoint can discover new candidates from Web.config Maintain metadata Available out-of-the-box parts determined by edition and site template

53. Web Part Gallery

54. Visual Web Part Project User interface described with markup in User Control Web Part loads User Control dynamically Page.LoadControl Not natively compatible with Sandboxed Solutions There are workarounds

55. Visual Web Part Project

56. Web Part Deployment Deploy assembly to: in folder of IIS Web Application Executes in a sandbox Global Assembly Cache Register Web Part as Safe Control in Web.config Add Web Part to Gallery Process automated by Visual Studio 2010

57. DEMO Visual Web Parts

58. SharePoint 2010 and Silverlight Presentation Silverlight Client Integration Security App Model SharePoint Data Layer Logic Layer

59. Silverlight/SharePoint Solution Silverlight application Build SilverlightUserControl SharePoint application Deploy XAP via Module Add custom project output Use OOB Silverlight Web Part Enable Silverlight Debugging

60. XAP File Deployment Options Virtual file system Document Library Virtual folder structure Limits scope to site or site collection Works with sandboxed solutions Physical file system LAYOUTS folder LAYOUTSlientBin folder Farm scope Does not work with sandboxed solutions

61. DEMO Silverlight Web Parts