Introduction
This article is the Part 2 of the SharePoint. Please feel free to download my free 500 question and answer ebook which covers .NET, ASP.NET, SQL Server, WCF, WPF, WWF @ http://www.questpond.com/SharePoint Quick Start FAQ Part 2
Pre-requisiteYou need to read the previous article to understand the basics
In the previous session of SharePoint article we had discussed about the basics of SharePoint. In this session we will:-
• create site / site collection
• Understand the ready made functional reusable modules
• Learn how we can display a simple page and later apply master pages of SharePoint.
• Host a Inline code and behind code page in SharePoint
• Understand the concept of features and understand step by step how to enable / disable a feature
• How do display a feature in Admin
How can I create my first site in SharePoint?
When you want to create any site in SharePoint we need to prepare a site collection and define site inside the site collection. Ok, that’s a simple four step procedure and can be easily achieved by using the SharePoint central administration.Step 1:- Click on start and you should find the SharePoint central administration menu.
Step 2:- Once you click on the central administration menu you need to click on the ‘application management’ tab and then click ‘Create site collection’.
Step 3:- Once you click ‘Create site collection’ you should see a form which needs all necessary details to create a site. All details are almost self-understandable. We have just stressed on three points one is the site name, the other is a template and the last is the username in which SharePoint will run. All sites in SharePoint need to be inherited from some master they can not stand on their own.
Step 4:- Once you have clicked ‘Ok’ you can now run the URL with your SharePoint name you should see something as shown below. As we have created from a blank site currently we do not have anything. Below is how a blank site looks like.
What is Quick Launch menu?
Below figure shows what is the quick launch menu. In this question we just wanted to make sure you know the terminology and where it maps to. In the further section we will be using this terminology for the left hand menu shown in the figure below.
We have heard that we can customize SharePoint sites how do we do that?We will continue with the same example of our blank site which we discussed previously. On the left hand side corner you will see a site actions menu. So click on the site action menu and click on site settings menu link. Once you click on the link you will be popped with different settings by which you can do customization. We will not discuss right now what every setting is, but in the later section we will understand some important settings by which we can achieve customization.
To increase your confidence you can play around with the ‘Look and feel’ settings. But this will be the landing page when we want to implement customization in SharePoint.
We have heard it has ready made functional modules for collaboration?Oh, yes you have heard it loud, right and clear. The best part about SharePoint is collaboration. Collaboration has four major entities people, task, data and communication.
So below are some key points of enterprise:-• We have people in our organizations.
• People are assigned task.
• To complete task we need to exchange data.
• We also need to plan/monitor tasks.
• To communicate data we need a communication channel like email, WIKI etc.
SharePoint has lot of ready made function which can help us to accommodate all the requirements of collaboration. To see those ready made functionalities click on site actions and click on create. You will be popped with a list of reusable functionality page which you can pick up and achieve collaboration.
Now let’s map the ready made functionalities with collaboration requirements.
How can we enable these reusable components in my site?
Ok, now that we are familiar with the reusable components and how they map to the collaboration requirements. Its time add one reusable functionality in your website. We will add a link inside the documents menu called as ‘SharePoint tutorial’. In this section team can upload tutorials for SharePoint in word document format. It’s a simple three step process so let’s understand the same step by step.
Step 1:- Click on the site actions and click on create link from the menu. You will be displayed reusable functionalities provided by SharePoint. Select ‘Document library’ from the libraries section.
Step 2 :- Give the link name as ‘SharePoint tutorial’ and select document types to be unloaded as word format. For this you need to select the document template to be of type ‘Microsoft word’.
Step 3:- Bravo! You can now see the SharePoint tutorial link and you can click on upload to push in a word document inside this library collection.
You can see from the figure below how we have uploaded a word document i.e. “SharePoint tutorial”. You can right click and experiment with more functionalities like check out , versioning , workflow , send alerts when document is modified etc etc.
Note: - You can try adding other functionalities like WIKI, announcement board, picture library and lot more. So feel free to experiment and see how you can easily leverage the reusable functionalities to meet the collaboration requirements.How can we display a simple custom page in SharePoint?
Ok first thing there is no concept of simple page in SharePoint. There are two types of pages in SharePoint as we discussed in the previous article one is an Application page and the other is the site page.
Application page is a generic page while site pages are custom to a website. To just cool you off lets display a simple Application page first.
Some points to be noted about Application pages:-
• They are pages which are shared across sites like ‘settings.aspx’ , which will helps us set generic properties across sites in a site collection.
• The second important part is that we need to save application pages in ‘C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS’ folder. If you browse to the folder you will find SharePoint’s own application pages.
Ok, what we will do is that to build confidence let’s make a simple page called as ‘SimplePage.aspx’. We are not doing anything great in this we will just write this simple sentence inside the page. Ohhhh I never Knew SharePoint is so easyOnce you have saved the page just browse to the IIS application and browse to the _layouts folder as shown in the figure below. If you open the page in browser you should see your display message.
Note: - For the next question you need to understand the concept of master pages. If you have not please read it once. Consistent look and feel is one of the most important factor in enterprise portal and SharePoint achieves the same using Master pages. The above page does not look like a standard SharePoint page?
In order to get the SharePoint look and feel we need to inherit from a SharePoint master page. As a rule you should always inherit from a SharePoint master page so that your sites have a consistent look and feel. So let’s modify our ‘SimplePage.aspx’. To get the SharePoint style we need to inherit from the SharePoint master page ‘Application.Master’.
We have now tailored the ‘simplepage.aspx’ source code as shown below. We need to do the following:-• First refer the assembly using the ‘Assembly directive.
• Refer the masterpage files as ‘Application.master’.
• Import the sharepoint namespace. If we had used the behind code we would have imported this in the behind code itself.
• There are three placeholder one for title , one for centre area and one for the page title. We need to define the placeholders in the child page.
<!— First refer the assembly using the Assembly directive -> <%@ Assembly Name="Microsoft.SharePoint,Version=12.0.0.0, Culture=neutral,PublicKeyToken=71e9bce111e9429c" %> <!— Refer the master page from the _layouts directory -> <%@ Page Language="C#" MasterPageFile="~/_layouts/application.master" Inherits="Microsoft.SharePoint.WebControls.LayoutsPageBase" %> <!—Import the sharepoint namespace -> <%@ Import Namespace="Microsoft.SharePoint" %> <!—This is the content holder for page title -> <asp:Content ID="Content3" ContentPlaceHolderId="PlaceHolderPageTitle" runat="server"> Let's learn SharePoint.... </asp:Content> <!- This is the place holder for data for main page area -> <asp:Content ID="Content1" ContentPlaceHolderId="PlaceHolderMain" runat="server"> Oh its Damn Simple..... </asp:Content> <!- This is the placeholder for page title area -> <asp:Content ID="Content2" ContentPlaceHolderId="PlaceHolderPageTitleInTitleArea" runat="server"> SharePoint is Simple..... </asp:Content>
LOL !...Your SharePoint page now looks like a page.
You can get the source of the simple inline ASPX file attached at the end of the article. Above code is completely inline, how can we implement behind code in SharePoint?
Some couple of points we need to take care regarding implementing behind code in ASP.NET are the following:-• The first and foremost requirement is that behind code should be registered in to the GAC assembly. In other words we need to code the behind code in a separate assembly / namespace and then compile the same in a DLL. Later we need to register the DLL in GAC.
• Second we need to use the assembly directive to refer the behind code.
Step 1:- So the first step is to make two solution files one is the behind code which goes in separate assembly ‘ClassLibrary1’ namespace and the other is the ASP.NET web project which has the ‘SimplePageCodeBehind.aspx’. We also need to register this DLL in a GAC. So you need to generate a strong name give to the assembly and register the same using the ‘GACUTIL’ provided by the .NET framework.
Step 2:- The behind code is in a separate assembly as need to register the same in the GAC. We have kept the behind code simple. We have create two label objects and set the value. One of the important points to be noted is that we have referenced the ‘System.Web.UI’ namespace DLL and ‘Microsoft.SharePoint’ namespace DLL. The other point to be noted is that the class inherits from ‘LayoutsPageBase’ class which belongs to ‘Microsoft.SharePoint’ namespace.using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
// need to refer the UI objects of ASP.NET
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
// Need to refer the SharePoint DLL
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
namespace ClassLibrary1
{
// Inherit the behind code from ‘LayoutsPageBase’ class of SharePoint
public partial class _Default : LayoutsPageBase
{
protected Label lblSiteQuestion;
protected Label lblSiteAnswer;
protected override void OnLoad(EventArgs e)
{
lblSiteQuestion.Text = " How can we implement behind code in SharePoint ?";
lblSiteAnswer.Text = " We need to register the behind DLL in GAC";
}
}
}
We need to also register the above DLL in GAC. So we need to generate a strong name and register the same using GACUTIL.
Step 3:- Now comes the UI part of the ASP.NET i.e. the ASPX page. Below is the code snippet which shows how the ASP.NET UI looks like.
The first thing to note is that behind code is not referred as code behind but is referred using the GAC public token key. In order to refer it using GAC key we need to use the ‘Assembly’ attribute for the same.
We have also inherited from the master page file i.e. ‘Application.Master’ so that we have a consistent look and feel.
<!—Refer the sharepoint assembly -> <%@ Assembly Name="Microsoft.SharePoint,Version=12.0.0.0, Culture=neutral,PublicKeyToken=71e9bce111e9429c" %> <!—Refer the behind code, Note that the behind code is coded in a different assembly and registered in the GAC -> <%@ Assembly Name="ClassLibrary1, Version=1.0.0.0, Culture=neutral,PublicKeyToken=af6d081bf267e17e" %> <!— In order to maintain consistent look and feel we need to inherit from the Application.Master page -> <%@ Page Language="C#" MasterPageFile="~/_layouts/application.master" Inherits="ClassLibrary1._Default" EnableViewState="false" EnableViewStateMac="false" %>
Once we have referred the Assembly and set the Page attributes. Its time to fill the content in the placeholders defined in the master page ‘Application.Master’.
<asp:Content ID="Main" contentplaceholderid="PlaceHolderMain" runat="server"> <table border="1" cellpadding="4" cellspacing="0" style="font-size:12"> <tr> <td>Question</td> <td><b><asp:Label ID="lblSiteQuestion" runat="server" /></b></td> </tr> <tr> <td>Answer</td> <td><asp:Label ID="lblSiteAnswer" runat="server" /></td> </tr> </table> </asp:Content> <asp:Content ID="PageTitle" runat="server" contentplaceholderid="PlaceHolderPageTitle" > SharePoint Behind code implementation </asp:Content> <asp:Content ID="PageTitleInTitleArea" runat="server" contentplaceholderid="PlaceHolderPageTitleInTitleArea" > When we want to implement behind code we need to register the same in GAC. </asp:Content>
Note: - Do not try to compile the project in VS.NET IDE. You can only compile the class assembly. The ASPX file you need to later paste it to the ‘_layout’ directory i.e. ‘C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS’.
Once you have copied the ASPX file and registered the behind code assembly in GAC, you can run and enjoy how it looks like.
If you are thinking that behind code pages implementation is lot of pain in SharePoint. Hang on as we move ahead you will see better way of implementation. Second we can not rule out the benefits as compared to the pain incurred in implementing behind code pages in ASP.NET.What is the concept of features in SharePoint?
Whenever we think about SharePoint think in terms of collaboration. One of the much needed features in collaboration is on-demand functionality / feature activation. Feature makes it easier to activate and deactivate functionality in SharePoint.Some points which you should note about features:-
• All features needs to be copied in “C:\Program Files\Common Files\Microsoft Shared\Web server extensions\12\Template\FEATURES\” directory. Microsoft Share reads the features from this directory. If you open the directory you can find pre-installed features by Share Point as shown below.
• Every feature will have two XML files one is the ‘Feature.xml’ and the other is ‘ElementManifest.xml’.
• Share point understands there is a feature by reading the feature XML file from the features folder.
• All features are identified by a unique GUID number.
• Features emit events which can be captured to write custom code. These events are captured in assembly which needs to be registered in a GAC.
kya
• Summarizing what we discussed we have a ‘feature.xml’ which points to an assembly which captures the feature events for custom code. It also other XML file which defines what exactly this feature will do.
Can you explain the broader steps for deploying / activating a feature?
In order to understand the feature concepts lets deploy the simple application page i.e. ‘SimplePageCodeBehind.aspx’ as feature. So when the user activates this feature he will be able to browse the ‘SimplePageCodeBehind.aspx’.Step 1:- Let’s create a project ‘SharePointFeature’. You can find the source code of the same attached with this article. So below is the project tree which has the two XML files and a class file which will process the four events i.e. ‘FeatureInstalled’,’FeaturesUnInstalling’ , ‘FeatureActivated’ and ‘FeatureDeactivating’.
Let’s understand these three files first.Feature.XML :- This is the most important file because it helps SharePoint identify the feature. All features in SharePoint are identified by the GUID key.
<Feature Id="48DEF2C4-33F9-4885-B0DE-6FE82E9FDCD8" Title="Go to Custom Pages" Description="This features enables us to goto Custom Page" Scope="Web" Hidden="FALSE" ImageUrl="menuprofile.gif" ReceiverAssembly="SharePointFeature, Version=1.0.0.0, Culture=neutral, PublicKeyToken=af83741e324f585c" ReceiverClass="SharePointFeature.clsFeatureReceiver" xmlns="http://schemas.microsoft.com/sharepoint/" > <ElementManifests> <ElementManifest Location="ElementManifest.xml" /> </ElementManifests> </Feature>
To generate a new GUID click on Tools à Create GUID and click ‘New GUID’. Tools menu you will get from within the IDE. We have marked the GUID value which you need to copy and paste in the ‘feature.xml ‘file.
Other than feature description and title there are two important things in the XML file. The first it points towards some other XML file and second it points to an assembly which captures events.ElementManifest.XML file :- ElementManifest.xml file actually specifies how the implementation will look like. There are two important points to be noted for the ElementManiFest.XML file. The custom action tag specifies on which control the feature will be activated. The control we are targeting at this moment is the ‘SiteActionsToolBar’. This tool bar is the one which you see on the right hand side corner of your SharePoint portal. There is also a URLaction property which specifies which URL it redirect to.
<Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <CustomAction Id="SiteActionsToolbar" GroupId="SiteActions" Location="Microsoft.SharePoint.StandardMenu" Sequence="10" Title="Display Custom Pages" Description="This links helps to display Custom Page" ImageUrl="_layouts/SharePoint2/menuprofile.gif"> <UrlAction Url="_layouts/SimplePageCodeBehind.aspx"/> </CustomAction> </Elements>
In other words ‘ElementManifest.xml’ specifies the location of the feature and which page it should redirect to.
FeatureReceiver.cs :- This class listens and implements custom actions of the feature.
We need to first refer the share point namespace as shown in the below code snippet.
using System; using System.Collections.Generic; using System.Text; // Refer the SharePoint namespace using Microsoft.SharePoint;
We need to implement the ‘SPFeatureReceiver’ class and implement all the events.
namespace SharePointFeature
{
// Inherit from the 'SPFeatureReceiver" class
public class clsFeatureReceiver : SPFeatureReceiver
{
// Implement the four events of SPFeatureReceiver class
public override void FeatureInstalled(SPFeatureReceiverProperties properties){}
public override void FeatureUninstalling(SPFeatureReceiverProperties properties) { }
// This event fires when the feature is activated
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
....
....
....
....
}
// This event fires when the feature is deactivated
public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
{
....
....
....
...
}
}
}
As a sample in the ‘FeatureActivated’ event we have set the description and title of the website.
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
// get the object of SharePoint Web
SPWeb site = (SPWeb)properties.Feature.Parent;
// Set the description ,properties , titile and update the SpWeb object
site.Description = "Click on the SiteActions to See how the custom page display";
site.Properties["OriginalTitle"] = "Display CustomPage";
site.Properties.Update();
site.Title = "This Site now has the custom page display";
site.Update();
}
In ‘FeatureDeactivating’ we have reverted back the title and description.
public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
{
// Get hold of the SharePoint web object and reset back the values
SPWeb site = (SPWeb)properties.Feature.Parent;
site.Description = "Custom Page display is disabled";
site.Title = site.Properties["OriginalTitle"];
site.Update();
}
Step 2 :- We need to register the compiled assembly in GAC and provide the token value in the ‘Feature.XML’ file. You need to use GACUTIL to register. You can get the token by browsing to ‘c:\Windows\Assembly’ and then viewing the properties of the assembly.
Step 3:- Copy the two XML file i.e. ‘Feature.xml’ and ‘ElementManisfest.xml’ in the ‘C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\FEATURES\DisplayCustomPage’ directory.
Step 4:- Now we need to install the feature using STSADM.exe. So go to dos prompt à and go to ‘C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN’ directory.
>cd C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BINTo install the feature run the below command using ‘STSADM’. Please note that you need to specify the relative directory path and not the physical path of ‘Feature.xml’ file.
>stsadm -o installfeature -filename DisplayCustomPage\Feature.xml
To ensure that SharePoint registers about this feature run IISRESET on the machine.
Step 5:- Now click on the Site Action à Site Settings à Site Features and Activate the feature.
Now you can see your feature enabled in the site actions menu. If you click on the feature i.e ‘Display Custom Pages’ it will redirect you to ‘SimplePageCodeBehind.aspx’.
The other point to be noted is that the events have fired and set the title and description as described in the code.
Try to experiment and deactivate the feature and you will see the title and description changing.Note: - You can get the source for the feature in the ZIP file provided with the article
I want that the feature should be only displayed to admin?
If you want only administrators to view the features set RequireSiteAdministrator="True" as shown in the below ‘ElementManifest.XML’ file.<Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <CustomAction Id="SiteActionsToolbar" GroupId="SiteActions" RequireSiteAdministrator="True" Location="Microsoft.SharePoint.StandardMenu" Sequence="10" Title="Display Custom Pages" Description="This links helps to display Custom Page" ImageUrl="_layouts/SharePoint2/menuprofile.gif"> <UrlAction Url="_layouts/SimplePageCodeBehind.aspx"/> </CustomAction> </Elements>
Source code
The source code has the following things:-• Simple SharePoint behind code.
• Inline Share Point behind code
• SharePoint feature code
Download The Source Code Click here
