.Net Technology Quest

SharePoint 2010 Managed Client Object Model. How to Get Site Properties?

2011-08-24T03:48:00.000-07:00

Silverlight applications use this Managed Client Object Model .In the Client Object Model, each line of statement that requires some site information is a request to the server, the server responds to the request and the Response is packed into a Client Object which is easy to use. In Client Object Model we cannot get all the required data on a single request as the data is too big SharePoint uses On Demand serve request methodology for the Client Object Model. The developer should take care when getting data from the server.He should request minimal information he needs from the Server using LINQ filter queries.

Below is the code to Get Site Properties.

PropertyValues pValues = null;

string siteCollectionUrl = string.Empty; // stores sitecollection url;

string siteUrl = http://yoursitename ; // site url, may be site under a sitecollection;

string PropertyIDValue = string.Empty;

private void LoadSite()

{

ClientContext ctx = new ClientContext(siteUrl);

siteCollection = ctx.Site;

ctx.Load(siteCollection, s => s.Url);

ctx.ExecuteQueryAsync(GetSiteRequestSucceeded, RequestFailed);

}

private void GetSiteRequestSucceeded(object sender, SP.ClientRequestSucceededEventArgs e)

{

Dispatcher.BeginInvoke(() =>

{

siteCollectionUrl = siteCollection.Url;

ClientContext ctx = new ClientContext(siteUrl)

currentWeb = ctx.Web;

ctx.Load(currentWeb, w => w.Title, w => w.ServerRelativeUrl, w => w.AllProperties);

ctx.ExecuteQueryAsync(GetWebRequestSucceeded, RequestFailed);

});

}

private void GetWebRequestSucceeded(object sender, SP.ClientRequestSucceededEventArgs e)

{

Dispatcher.BeginInvoke(() =>

{

pValues = currentWeb.AllProperties;

ClientContext ctx = new ClientContext(siteUrl) ;

ctx.Load(pValues);

context.ExecuteQueryAsync(GetPropsSuccess, RequestFailed);

}

});

}

private void GetPropsSuccess(object sender, SP.ClientRequestSucceededEventArgs e)

{

Dispatcher.BeginInvoke(() =>

{

this.PropertyIDValue = (string)pValues.FieldValues["propertyid"];

});

}

private void RequestFailed(object sender, SP.ClientRequestFailedEventArgs e)

{

Dispatcher.BeginInvoke(() =>

{

MessageBox.Show("Error occured: " + e.Exception);

});

}

How to open Modal Popup from Silverlight in Sharepoint 2010 using Visual Web part

2011-08-24T00:04:00.000-07:00

In our application we are using Silverlight to display some of the site information. I have created a Silverlight Application and deployed the XAP file in the Site root using Module.

In the Silverlight application we are showing SharePoint users as hyperlinks. When we click on the user, a SharePoint dialogue should open which opens the user info page. We know that we can call java script functions from Silverlight using the command .But if use SharePoint 2010 Built in SharePoint Silverlight Web part, we cannot define the JavaScript function that relates to this Silverlight application.

So I have created a Visual Web part which holds silver light object (the XAP file) in it, the syntax is as simple as we add Silver light Object (XAP file )to the html file.

Note: If we use Visual Web Part, then the ClientContext .Current object in Silverlight will return null value.So we need to change our code from ClientContext ctx = ClientContext.Current

to ClientContext ctx = new ClientContext(siteCollectionUrl);

Here siteCollectionUrl will be passed to the Silverlight using initparams from the Visual Web part that holds the Silverlight Object. Below is the code.

SilverVisualWPUserControl.ascx

<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %>

<%@ Assembly Name="Microsoft.Web.CommandUI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="asp" Namespace="System.Web.UI" Assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" %>

<%@ Import Namespace="Microsoft.SharePoint" %>

<%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="SilverPropertiesTabUserControl.ascx.cs" Inherits="DLRSilverTab.SilverPropertiesTab.SilverPropertiesTabUserControl" %>

function onSilverlightError(sender, args) {

var appSource = "";

if (sender != null && sender != 0) {

appSource = sender.getHost().Source;

}

var errorType = args.ErrorType;

var iErrorCode = args.ErrorCode;

var errMsg = "Unhandled Error in Silverlight 2 Application " + appSource + "\n";

errMsg += "Code: " + iErrorCode + " \n";

errMsg += "Category: " + errorType + " \n";

errMsg += "Message: " + args.ErrorMessage + " \n";

if (errorType == "ParserError") {

errMsg += "File: " + args.xamlFile + " \n";

errMsg += "Line: " + args.lineNumber + " \n";

errMsg += "Position: " + args.charPosition + " \n";

}

else if (errorType == "RuntimeError") {

if (args.lineNumber != 0) {

errMsg += "Line: " + args.lineNumber + " \n";

errMsg += "Position: " + args.charPosition + " \n";

}

errMsg += "MethodName: " + args.methodName + " \n";

}

throw new Error(errMsg);

}

function OpenDialogueWidow(url) {

var options = SP.UI.$create_DialogOptions();

options.width = 750;

options.height = 650;

options.url = url;

options.dialogReturnValueCallback = Function.createDelegate(

null, portal_modalDialogClosedCallback);

SP.UI.ModalDialog.showModalDialog(options);

}

function portal_modalDialogClosedCallback(result, value) {

}

</script>

SilverVisualWPUserControl.ascx.cs Page_Load method

protected void Page_Load(object sender, EventArgs e)

{

string siteCollectionUrl = SPContext.Current.Web.Url;

string html =string.Format("<object data=\"data:application/x-silverlight-2,\" type=\"application/x-silverlight-2\" "

+"style=\"display:block\" height=\"250px\" width=\"100%\" >"

+"<param name=\"source\" value=\"/SilverTabControl.xap\"/>"

+ "<param name=\"onerror\" value=\"onSilverlightError\" />"

+ "<param name=\"background\" value=\"white\" />"

+ "<param name=\"minRuntimeVersion\" value=\"2.0.31005.0\" />"

+ "<param name=\"initParams\" value=\"PropertyList=Property Information,PropertyContactList=Properties,PropertyID=Property_x0020_ID,PropertyIDValue=1,Duration=6000,url={0}\" />"

+ "<param name=\"autoUpgrade\" value=\"true\" />"

+ "<a href=\"http://go.microsoft.com/fwlink/?LinkID=124807\" style=\"text-decoration: none;\">"

+ "<img src=\"http://go.microsoft.com/fwlink/?LinkId=108181\" alt=\"Get Microsoft Silverlight\" style=\"border-style: none\"/>"

+ "</a></object>"

+"<iframe style='visibility:hidden;height:0;width:0;border:0px;' scrolling=no></iframe>",siteCollectionUrl);

silverlightObject.InnerHtml = html;

}

Silverlight Application MainPage.xaml.cs How to invoke JavaScript Method to open Dialogue Window.

HyperlinkButton contactLink = new HyperlinkButton();

contactLink.Click += new RoutedEventHandler(contactLink_Click);

contactLink.Tag = new Uri("/_layouts/userdisp.aspx?ID=" + spUser.Id);

contactLink.Cursor = Cursors.Hand;

void contactLink_Click(object sender, RoutedEventArgs e)

{

HyperlinkButton link= sender as HyperlinkButton;

if(link!=null && link.Tag !=null)

HtmlPage.Window.Invoke("OpenDialogueWidow", link.Tag.ToString());

}

In the above Code OpenDialogueWidow is the JavaScript function name which defined in the Visual Web part

SharePoint 2010 Getting List Item Attachments using Silverlight Client Object Model

2011-08-09T04:22:00.001-07:00

I did a lot of research to get list item attachments. I have searched in forums but found no solution.

Using Client Object Model, we cannot get List Item Attachments collection, client object model will return a list item object, but the object doesn't contain the attachments collection info and supports no methods to get attachments collection.

The alternative method is calling web service method GetAttachmentCollection from the service lists.asmx. This method returns the result in the form of XMLNode. Here is the sample code which works perfectly.
The below example Gets the list item from a given list, then Gets its first image attachment and shows it in the Silverlight Image Control.
Add the below line in the import section to import SharePoint.Client dll.

using SP = Microsoft.SharePoint.Client;

Here follows the code. This code I have copied from my Visual studio and formatted here to relate it to the post, I may forgot to declare some of the variables, but once you copy this code in to your Visual Studio, you can easily fix those compilation errors.

SP.ClientContext context;
SP.Web spWeb;
SP.Web currentWeb;
SP.List propertiesList;

string serviceUrl = string.Empty;

SP.ListItemCollection listItems;

public void LoadPropertyInfo()
{

using (context = new ClientContext(siteCollectionUrl))

{

spWeb = context.Web;

propertiesList = spWeb.Lists.GetByTitle(listName);

FieldCollection fields = propertiesList.Fields;

context.Load(fields);

SP.CamlQuery query = new SP.CamlQuery();

query.ViewXml = string.Format("<View><Query><Where><Eq><FieldRef Name=\"{0}\" /><Value Type=\"Text\">{1}</Value></Eq></Where></Query></View>", propertyID, PropertyIDValue);

listItems = propertiesList.GetItems(query);

context.Load(listItems);

context.ExecuteQueryAsync(GetRequestSucceeded, RequestFailed);

}

}

private void RequestFailed(object sender, SP.ClientRequestFailedEventArgs e)
{
Dispatcher.BeginInvoke(() =>

{

MessageBox.Show("Error occured: " + e.Exception);

});

}

private void GetRequestSucceeded(object sender, SP.ClientRequestSucceededEventArgs e)
{

Dispatcher.BeginInvoke(() =>

{

serviceUrl = e.Request.WebRequest.RequestUri.AbsoluteUri;

serviceUrl = serviceUrl.Substring(0, serviceUrl.IndexOf("_vti_bin"));

foreach (SP.ListItem item in listItems)

{

GetAttchmentCollection(item.Id.ToString());

}

});

}

private void GetAttchmentCollection(string id)
{

string RedirectHost = string.Empty;

string Host = string.Empty;

context = SP.ClientContext.Current;

RedirectHost = serviceUrl + "_vti_bin/Lists.asmx";

BasicHttpBinding binding = new BasicHttpBinding();

if (System.Windows.Browser.HtmlPage.Document.DocumentUri.Scheme.StartsWith("https"))

{

binding.Security.Mode = BasicHttpSecurityMode.Transport;

}

binding.MaxReceivedMessageSize = int.MaxValue;

EndpointAddress endpoint = new EndpointAddress(RedirectHost);

ServiceReference1.ListsSoapClient oClient = new ServiceReference1.ListsSoapClient(binding, endpoint);

oClient.GetAttachmentCollectionCompleted += new EventHandler<ServiceReference1.GetAttachmentCollectionCompletedEventArgs>(oClient_GetAttachmentCollectionCompleted);

oClient.GetAttachmentCollectionAsync(listName,id);

}

void oClient_GetAttachmentCollectionCompleted(object sender, ServiceReference1.GetAttachmentCollectionCompletedEventArgs e)
{

XElement element = e.Result;

string attachments = element.Value;

string[] splitString = { "http" };

string[] attchmentArray = attachments.Split(splitString, StringSplitOptions.RemoveEmptyEntries);

for (int i = 0; i < attchmentArray.Length; i++)

{

string extension=System.IO.Path.GetExtension(attchmentArray[i]).ToLower();

if (extension == ".png" || extension == ".jpg" || extension == ".jpeg" || extension == ".tif")

{

DownloadAttachedFileFromListItem("http" + attchmentArray[i]);

break;

}

}

public void DownloadAttachedFileFromListItem(string fileName)
{

using (ClientContext clientContext = new ClientContext(serviceUrl))

{

File.OpenBinaryDirect(clientContext, "/" + fileName.Replace(serviceUrl, ""), OpenBinaryFileSuccess, OpenBinaryFileFailure);

}

}

void OpenBinaryFileSuccess(object o, OpenBinarySucceededEventArgs e)
{

Dispatcher.BeginInvoke(() =>

{

BitmapImage bitmapimage = new BitmapImage();

bitmapimage.SetSource(e.Stream);

imgPhoto.Width = bitmapimage.PixelWidth > imgPhoto.ActualWidth ? imgPhoto.ActualWidth : bitmapimage.PixelWidth;

imgPhoto.Height = bitmapimage.PixelHeight > imgPhoto.ActualHeight ? imgPhoto.ActualHeight : bitmapimage.PixelHeight;

imgPhoto.Source = bitmapimage;

});

}

void OpenBinaryFileFailure(object o, OpenBinaryFailedEventArgs e)
{
}

Create a custom workflow activity

2011-04-08T07:29:00.000-07:00

When you create a custom workflow activity you should create a separate ACTIONS file. Editing the WSS.ACTIONS file is trouble.
Generally the message "The list of workflow actions on the server references an assembly that does not exist. Some actions will not be available. the assembly strong name is ..." occurs because the ACTIONS file doesn't match the assembly it references. Normally you would see that error because someone has extended the Workflow actions available in SPD with a custom action developed in Visual Studio. These custom actions are loaded when your workstation reads the WSS.ACTIONS file on the server. The file is located in the 12 hive under Template\1033\workflow. Your WSS.Actions file contains a reference to a custom action .dll which is not available on the server.
If you have verified that the assembly strong name is correct, verify that the ACTIONS file parameters match the assembly's activity properties. Be sure to check the "DependencyProperty.Register" methods too.

Sharepoint 2010 Web Part and Linq

2011-03-31T06:41:00.000-07:00

In this exercise, you will develop and deploy a Visual Web Part that reads data from a list and displays

in a DataGrid. In this exercise, you will:

1. Create a Visual Web Part.

2. Generate Linq proxy code.

3. Use a Linq provider to read data from a SharePoint list.

4. Render the data using the SPDataGrid web control.

Task 1 - Create a new SharePoint Project

In this task, a solution and project will be created. It will contain the rest of the development work in

1. Open Visual Studio 2010 by going to Start Menu | All Programs | Microsoft Visual Studio 2010 | Microsoft Visual Studio 2010.

2. From the menu, select File | New | Project.

3. In the New Project dialog window, choose Visual C# | SharePoint | 2010 from the Installed Templates.

4. Select Visual Web Part from the Project Item

5. In the SharePoint Customization Wizard:

· Enter your SharePoint site address for the local site.(What is the site do you want to use for debugging)

· Set the trust level to Deploy as a farm solution.

· Click Finish button.

6. Visual Studio will create the new SPCHOL200-Ex1 project and add the necessary files.

7. Notice that Visual Studio also creates a Visual Web Part named VisualWebPart1. Within the Solution Explorer, expand VisualWebPart1 and open VisualWebPart1.webpart.

8.Change the value of the property element with the name attribute value of Title to SPLinqDemoTitle and the value of the property element with the name attribute value of Description to SPLinqDemoPart Description. This will change the Title and Description property of the Visual Web Part once it is deployed. Save the file.

<?xml version="1.0" encoding="utf-8"?>

<importErrorMessage>$Resources:core,ImportErrorMessage;</importErrorMessage>

</metaData>

<data>

<property name="Title" type="string">SPLinqDemoTitle</property>

<property name="Description" type="string">SPLinqDemoPart Description</property>

</properties>

</data>

</webPart>

</webParts>

Task 2 - Generate LINQ-to-SharePoint proxy class to access list data

In this task, you will use the new spmetal.exe code generation utility and generate the Linq-to-SharePoint proxy code.

1. In the Solution Explorer, right-click on the Project and select Open Folder in Windows

Explorer.

2. Hold Shift key and right click anywhere in the Explorer Window and select Open Command

Window Here to open the command prompt window in the current project directory:

3. Type the following command in the command prompt and press Enter to set the path to the

SharePoint 2010 folder:

set path=%path%;c:\program files\common files\microsoft shared\web server extensions\14\bin

4. Type the following command in the command prompt and press Enter to generate the Linq-to-

SharePoint proxy code.

spmetal.exe /web:http://your web site address /namespace:Your Project name.VisualWebPart1 /code:SPLinq.cs

Note – you may get warnings about content types for list Form Templates. You can safely

ignore this warning and continue

5. Close the command window and switch back to Visual Studio.

6. In Visual Studio, right click on the Project and select Add | Existing Item.

7. Select SPLinq.cs from the Add Existing Item dialog window and click Add:

8. In the Solution Explorer, right click on References and select Add Reference.

9. Switch to Browse tab and enter C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\ISAPI in the File Name text box. Press Enter to change directories.

10. Select Microsoft.SharePoint.Linq.dll.

11. Click OK to add the reference to your project.

Task 3 - Access the SharePoint list data in Visual Web Part

In this task, you will add code to your solution that will allow the Visual Web Part to retrieve SharePoint

list data.

1. In Solution Explorer, expand VisualWebPart1 and double-click on VisualWebPart1UserControl.ascx.

2. Visual Studio will open the Visual Web Part User Control.

3. Add the following code to the user control to construct your grid view.

<%@ Import Namespace="Microsoft.SharePoint.WebControls" %>

<SharePoint:SPGridView id="spGridView" runat="server"

AutoGenerateColumns="false">

<SharePoint:SPBoundField DataField="Id"

HeaderText="Id"></SharePoint:SPBoundField>

<SharePoint:SPBoundField DataField="Path"

HeaderText="Path"></SharePoint:SPBoundField>

<SharePoint:SPBoundField DataField="Title"

HeaderText="Title"></SharePoint:SPBoundField>

</Columns>

</SharePoint:SPGridView>

4. In the Solution Explorer, right click on VisualWebPart1UserControl.ascx and select View Code.

5. Add the following using statements to the code behind:

using Microsoft.SharePoint.Linq;

using Microsoft.SharePoint;

using System.Linq;

6. Insert the following code inside the Page_Load method:In my application I have created a Document Library with a name “Venkat Photos” ,if you observe your SPLinq.cs file, you will observe

var dc = new SPLinqDataContext(SPContext.Current.Web.Url);

var venkatPhotos = dc.GetList<VenkatPhotosPicture>("Venkat Photos");

var empQuery = from photo in venkatPhotos

select new

{

photo.Id,

photo.Path,

photo.Title

};

spGridView.DataSource = empQuery;

spGridView.DataBind();

Task 4 – Build and Deploy the Visual Web Part

1. In the Solution Explorer, right click on Your Project and select Deploy. This will build and

deploy the Visual Web Part to the local SharePoint site

2. Open Internet Explorer and browse your website

3. Click the Edit icon in the top menu to open the SharePoint Ribbon to the Editing Tools.

5. Switch to Insert tab in the Ribbon and click on Web Part to insert a Web Part to the page.

6. Under Categories, Select Custom.

7. Under Web Parts, select SPLinqDemoTitle web part.Put your cursor in the area of the page where you want the Web Part to appear. This must be a zone that accepts Web Parts.

8. Click Add to add the web part to the page. This will add the SPLinqDemoTitle web part to the

selected layout zone.

9. Click on Page, click the down arrow on the “Save and Close” button, and select Stop Editing

to save the page and stop editing. Click Yes when prompted to save the changes you made.

10.You will see list of items displaying on the Grid.

Asp.Net Page LifeCycle

2011-03-29T04:49:00.001-07:00

When a page request is sent to the Web server, the page is run through a series of events during its creation and disposal.Each request for an .aspx page that hits IIS is handed over to HTTP Pipeline. HTTP Pipeline is a chain of managed objects that sequentially process the request and convert it to plain HTML text content. The start point of HTTP Pipeline is the HttpRuntime class. The ASP.NET infrastructure creates each instance of this class per AppDomain hosted within the worker process. HttpRuntime class picks up an HttpApplication object from an internal pool and sets it to work on the request. It finds out what class has to handle the request. The association between the resources and handlers are stored in the configurable file of the application

Once the HTTP page handler class is fully identified, the ASP.NET runtime calls the handler's ProcessRequest to start the process. This implementation begins by calling the method FrameworkInitialize(), which builds the control trees for the page. This is a protected and virtual member of TemplateControl class, class from which page itself derives.

Next the processRequest() makes page transits various phases: initialization, loading of viewstate and postback data, loading of page's user code and execution postback server-side events. Then page enters in render mode, the viewstate is updated and HTML generated is sent to the output console. Finally page is unloaded and request is considered completely served.

Page_PreInit: Raised after the start stage is complete and before the initialization stage begins.

Use this event for the following:

Check the IsPostBack property to determine whether this is the first time the page is being processed. The IsCallback and IsCrossPagePostBack properties have also been set at this time.
Create or re-create dynamic controls.
Set a master page dynamically.
Set the Theme property dynamically.
Read or set profile property values.

Page_Init : This is fired after the page's control tree has been successfully created. All the controls that are statically declared in the .aspx file will be initialized with the default values. Controls can use this event to initialize some of the settings that can be used throughout the lifetime of the incoming web request. Viewstate information will not be available at this stage. This Event Raised after all controls have been initialized and any skin settings have been applied. The Init event of individual controls occurs before the Init event of the page.Use this event to read or initialize control properties.

Page_PreLoad: Raised after the page loads view state for itself and all controls, and after it processes postback data that is included with the Request instance.

Page_Load: After initialization, page framework loads the view state for the page. Viewstate is a collection of name/value pairs, where control's and page itself store information that is persistent among web requests. It contains the state of the controls the last time the page was processed on the server. By overriding LoadViewState() method, component developer can understand how viewstate is restored.Once viewstate is restored, control will be updated with the client side changes. It loads the posted data values. The PostBackData event gives control a chance to update their state that reflects the state of the HTML element on the client.

At the end of the posted data changes event, controls will be reflected with changes done on the client. At this point, load event is fired.

btnSubmit_Clicked: Key event in the life cycle is when the server-side code associated with an event triggered on the client. When the user clicks on the button, the page posts back.

RaisePostBackEvent: Page framework calls the RaisePostBackEvent. This event looks up for the event handler and run the associated delegate.

Page_PreRender: After PostBack event, page prepares for rendering. PreRender event is called. This is the place where user can do the update operations before the viewstate is stored and output is rendered. This Event Raised after the Page object has created all controls that are required in order to render the page, including child controls of composite controls. (To do this, the Page object calls EnsureChildControls for each control and for the page.)

The Page object raises the PreRender event on the Page object, and then recursively does the same for each child control. The PreRender event of individual controls occurs after the PreRender event of the page.

Use the event to make final changes to the contents of the page or its controls before the rendering stage begins.

SaveViewState: Next stage is saving view state, all the values of the controls will be saved to their own viewstate collection. The resultant viewstate is serialized, hashed, base24 encoded and associated with the _viewstate hidden field.

Render: Next the render method is called. This method takes the HtmlWriter object and uses it to accumulate all HTML text to be generated for the control. For each control the page calls the render method and caches the HTML output. The rendering mechanism for the control can be altered by overriding this render method. This is not an event; instead, at this stage of processing, the Page object calls this method on each control. All ASP.NET Web server controls have a Render method that writes out the control's markup to send to the browser.

If you create a custom control, you typically override this method to output the control's markup. However, if your custom control incorporates only standard ASP.NET Web server controls and no custom markup, you do not need to override the Render method. For more information, see Developing Custom ASP.NET Server Controls.

A user control (an .ascx file) automatically incorporates rendering, so you do not need to explicitly render the control in code.

Page_Unload: This is called just before the page object is dismissed. In this event, you can release critical resources you have such as database connections, files, graphical objects etc. After this event browser receives the HTTP response packet and displays the page. At this time Response object not available. During the unload stage, the page and its controls have been rendered, so you cannot make further changes to the response stream. If you attempt to call a method such as the Response.Write method, the page will throw an exception. If you observe the given sample, if we use Response in this event, the system raises an error that says 'Response Object not available at this stage'

To understand the page life cycle clearly, create a website and add a PageLifeCycle.aspx page to the website. Add the below lines of code to the page and view it in the browser.

PageLifeCycle.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="PageLifeCycle.aspx.cs" Inherits="PageLifeCycle" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<table>
<tr>
<td>Name</td><td><asp:TextBox ID="tbName" runat="server" ></asp:TextBox></td>
</tr>
<tr>
<td>Designation</td><td><asp:DropDownList ID="ddlDesignation" runat="server" ></asp:DropDownList> </td>
</tr>
<tr>
<td> </td><td><asp:Button ID="btnSubmit" runat="server" Text="Submit" OnClick="btnSubmit_Clicked" /> </td>
</tr>
</table>
</div>
</form>
</body>
</html>

PageLifeCycle.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class PageLifeCycle : System.Web.UI.Page
{
int counter = 1;

protected void Page_PreLoad(object sender, EventArgs e)
{
WriteOutput("Page_PreLoad");
}

protected void Page_Load(object sender, EventArgs e)
{
}

protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (!IsPostBack)
{
BindDesignation();
}
WriteOutput("Page_Load");
}

private void BindDesignation()
{
List<Info> infoList = new List<Info>();
for (int i = 1; i <= 5; i++)
{
infoList.Add(new Info("Venkat"+i,"Software Engineer"+i));
}
ddlDesignation.DataSource = infoList;
ddlDesignation.DataValueField = "Designation";
ddlDesignation.DataTextField = "Designation";
ddlDesignation.DataBind();
}

protected override void LoadControlState(object savedState)
{
base.LoadControlState(savedState);
WriteOutput("LoadControlState");

}

protected void Page_LoadViewState(object sender, EventArgs e)
{
WriteOutput("LoadViewState");
}

protected override void LoadViewState(object viewState)
{
base.LoadViewState(viewState);
WriteOutput("LoadViewState");
}

protected override object SaveViewState()
{
WriteOutput("SaveViewState");
return base.SaveViewState();
}

protected override void RaisePostBackEvent(IPostBackEventHandler sourceControl, string eventArg)
{
base.RaisePostBackEvent(sourceControl,eventArg);
WriteOutput("RaisePostBackEvent");
}

protected override void Render(HtmlTextWriter writer)
{
base.Render(writer);
WriteOutput("Render");
}

protected void btnSubmit_Clicked(object sender, EventArgs e)
{
WriteOutput("btnSubmit_Clicked");
}

protected void Page_PreInit(object sender, EventArgs e)
{
WriteOutput("Page_PreInit");
}
protected void Page_Init(object sender, EventArgs e)
{
WriteOutput("Page_Init");
}

protected void Page_PreRender(object sender, EventArgs e)
{
WriteOutput("Page_PreRender");
}
protected void Page_Unload(object sender, EventArgs e)
{
//WriteOutput("Page_Unload");
}

private void WriteOutput(string eventName)
{
Response.Write("Step no: " + counter++ + "--> "+eventName+"<br/>");
Response.Write("Name: " + (tbName.Text == null ? "Null" : tbName.Text + "<br/>"));
Response.Write("Designation: " + (ddlDesignation.SelectedValue == null ? "Null" : ddlDesignation.SelectedValue + "<br/><br/>"));
}

}

public class Info
{
public string Name { get; set; }
public string Designation { get; set; }
public Info(string name,string designation)
{
Name = name;
Designation = designation;
}
}

If you view the page in the browser , the below screen will be shown,

Click on the Submit Button to Postback the page, then the below screen will be shown.

Why IsPostBack Check?

2011-03-28T07:34:00.000-07:00

Binding Data

We often bind data to Dropdown lists and Repeater etc, in ‘PageLoad’ event. Sometimes we bind data without checking page ‘IsPostBack’ value.Due to this small mistake, the changes that we made to dropdown selection will be lost. When trying to catch the selected value of the dropdown list in the ‘Post back’ event, it will be set to default value. Any novice learner of .Net will get surprised to see, if their changes were not effecting.

Here what happens is the ’Page Load’ events occurs first, and then the ‘Post back’ event. Here the drop down list (in our case) binds two times. Whenever we submit a page by clicking on the button, the first event that takes place is ‘Page Load’ event then the ‘Button click’ event. So the BindDropDown() will executes again and the changes that we made will get lost.

So here the conclusion is Data Binding operation should be done before page post back.

Here is the Sample Code:Binding the data by checking the page ‘Post Back’ event.

Default.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<title>Page Post back and Databinding</title>

</head>

<body>

<div>

<asp:Label ID="lblStatus" runat="server"></asp:Label>

<br />

<asp:DropDownList ID="ddlBooks" runat="server" EnableViewState="true" ></asp:DropDownList>

<asp:Button ID="btnSubmit" OnClick="BtnSubmitClicked" Text="Submit" runat="server" />

</div>

</form>

</body>

</html>

Default.aspx.cs

using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Web.UI.HtmlControls;

using System.Collections.ObjectModel;

using System.Collections.Generic;

public partial class _Default : System.Web.UI.Page

{

protected void Page_Load(objectsender, EventArgs e)

{

if (!IsPostBack)

{

BindDropDown();

}

private void BindDropDown()

{

List<string> books = new List<string>();

books.Add("C# fundamentals");

books.Add("Masteringin Styles");

books.Add("C#Advanced");

books.Sort();

ddlBooks.DataSource = books;

ddlBooks.DataBind();

ddlBooks.Items.Insert(0,new ListItem("Select ne","select"));

}

protected void BtnSubmitClicked(object sender, entArgs e)

{

lblStatus.Text =ddlBooks.SelectedValue;

}

Try to remove the IsPostBak condition and run the code.see the difference.

Another mistake we often do is forget to ‘Enable View State’ of the page. By default view state is enabled for all controls, there is no need to explicitly enable it. However, if we disable it in ‘web.config’ file, we have to explicitly enable it where ever we want. Here are some guide lines to enable view state of drop down list.

‘View State’ can be disabled/enabled in

I. Web.config file (to disable ‘view sate’ of all pages)

II. Master page

III. Aspx Page.

IV. User control

V. With in the Control itself.

Take an example of ‘drop down list’, when the view state set to false for all pages in ‘web.config’ file,

view state won’t work for all pages. After submitting the page the drop down will have no items bound to it.

To enable view state for a particular page , we have to enable it on both Master page, and the Aspx Page. If the drop down list is placed in a user control, then we have to enable the view state in the user control also, other wise the view state of the drop down will get disabled.

Even if it is set to true in all, but disabled in the control, then it get disabled but the converse is false.

Conclusion:If you want to enable view state on dropdown list when the view state get disabled in web.config file; We should explicitly enable it on the Master page, Aspx Page where it’s being declared and the user control(if it is declared in User control). Then only the viewstate of the control get enabled.

If Viewstate enabled in web.config and disabled in either of master page or Aspx Page, then viewstate of dropdown list get disabled. If the view state enabled on both Master page and Aspx Page, then no need to explicitly enable it in user control and the control itself.

How to debug silverlight webpart in sharepoint 2010.?

2011-03-25T00:30:00.000-07:00

SharePoint Silverlight debugging in Visual Studio is not supported by default, due to Script debugging settings turned on. It means that you can’t set breakpoints and step into your code in VS if you are not deploying Silverlight controls via feature. Such functionality is supported when you host your SL project in external Web Project (another reason not to host in SharePoint during development)

To provide the SharePoint SL debugging capabilities you need to package your .XAP file in SharePoint Project (in VS) and deploy as a Feature. Such approach allows to enable “Siverlight Debugging” instead of client one, and step into your .cs code from Visual Studio 2010. This options is set from the VS IDE. Navigate to the SharePoint project properties –> SharePoint Tab –> click “Enable Silverlight Debugging”. That checkbox will activate the Remote Debugger and you will be able to debug SL hosted in SharePoint using Visual Studio 2010 (but you need to configure the Remote Debugger first, opening the firewall ports. On the 64bit windows you need to configure the x86 version of msvsmon.exe because the Visual Studio is x86)

Note: Debugging doesn’t work if you don’t have another instance of the the SL page opened in browser. Seems there is a bug resolving assemblies, because when you start debugging your solution might be re-builded , IIS restarts, thus remote debugger can’t attach to the right assemblies. To fix it just open another tab in browser, navigate to page with SL control you are debugging and only after that start debugging which will open the second instance of that page.

Debug both silverlight and javascript together

Sometimes you need to debug both silverlight and javascript together, especially when you’re doing HTML bridge development where requests seamlessly pass between SL and JS

Use Chrome instead of IE,
Rig your SharePoint project to use Silverlight debugging,
Inside Chrome press CTRL_ALT_J to open the javascript debugger, and use chrome’s SL debugger.

SP 2010 PowerShell Commands

2011-03-24T05:13:00.000-07:00

Windows PowerShell is a command-line scripting tool that provides an administrator full access to applicable application programming interfaces (APIs), along with the ability to unlock the capability to interact directly with SharePoint 2010 Products to manipulate Web applications, site collections, sites, lists and much more. In addition, the administrator has the ability to script cmdlets (pronounced "command-lets"), which makes for an improved experience from past product versions.

Windows PowerShell 2.0 is a pre-requisite for installing SharePoint 2010 Products. It will be installed, if necessary, when you run the Microsoft SharePoint Products Preparation Tool. By default, Windows PowerShell is located at the following path: <%SystemRoot%>\System32\WindowsPowerShell\v1.0\PowerShell.exe.

Windows PowerShell 2.0 includes the following new features.

Remoting

      Windows PowerShell 2.0 lets you run commands on one or many remote
      computers with a single Windows PowerShell command. You can run
      individual commands, or you can create a persistent connection
      (a session) to run a series of related commands. You can also start a
      session with a remote computer so that the commands you type run
      directly on the remote computer.

      The remoting features of Windows PowerShell are built on Windows
      Remote Management (WinRM). WinRM is the Microsoft implementation of
      the WS-Management protocol, a standard SOAP-based, firewall-compatible
      communications protocol.

      The remote computers must have Windows PowerShell 2.0, the Microsoft .NET
      Framework 2.0, and the WinRM service. Remote commands are supported
      on all operating systems that can run Windows PowerShell. The
      current user must have permission to run commands on the remote
      computers.

      To support remoting, the Invoke-Command, Enter-PSSession, and
      Exit-PSSession cmdlets have been added, along with other cmdlets
      that contain the PSSession noun. These cmdlets let you create and manage
      persistent connections.

      The ComputerName parameter has also been added to several cmdlets,
      including the Get-Process, Get-Service, and Get-Eventlog cmdlets. This
      parameter allows you to get information about remote computers.
      These cmdlets use .NET Framework methods to get their data,
      so they do not rely on Windows PowerShell remoting. They do not require
      any new programs or configuration.



Background Jobs

      Background jobs are commands that run asynchronously. When you run a
      background job, the command prompt returns immediately, even if the
      command is still running. You can use the background job feature to run a
      complex command in the background so that you can use your session for
      other work while the command runs.

      You can run a background job on a local or remote computer and then save
      the results on the local or remote computer. To run a job remotely, use
      the Invoke-Command cmdlet.


      Windows PowerShell includes a set of cmdlets that contain the Job noun
      (the Job cmdlets). Use these cmdlets for creating, starting, managing,
      and deleting background jobs and for getting the results of a background
      job. To get a list of the job cmdlets, type the following command:

          get-command *-job

Script Debugger

      Windows PowerShell 2.0 includes a cmdlet-based debugger for scripts and
      functions. The debugger is supported by a fully documented public API
      that you can use to build your own debugger or to customize or extend
      the debugger.

      The debugger cmdlets let you set breakpoints on lines, columns,
      variables, and commands. These cmdlets let you manage the breakpoints
      and display the call stack. You can create conditional breakpoints and
      specify custom actions at a breakpoint, such as running diagnostic and
      logging scripts.

      When you reach a breakpoint, Windows PowerShell suspends execution
      and starts the debugger. The debugger includes a set of custom commands
      that let you step through the code. You can also run standard Windows
      PowerShell commands to display the values of variables, and you can use
      cmdlets to investigate the results.

Data Section

      Scripts designed for Windows PowerShell 2.0 can have one or more
      DATA sections that isolate the data from the script logic. The data in
      the new DATA section is restricted to a specified subset of the Windows
      PowerShell scripting language.

      In Windows PowerShell 2.0, the DATA section is used to support
      script internationalization. You can use the DATA section to isolate
      and identify user message strings that will be translated into
      multiple user interface languages.

Script Internationalization

      Windows PowerShell 2.0 script internationalization features allow you
      to better serve users throughout the world. Script internationalization
      enables scripts and functions to display messages and Help text to users
      in multiple languages.

      The script internationalization features query the operating system user
      interface culture ($PsUICulture) during execution and then import the
      appropriate translated text strings so you can display them to the user.
      The Data section lets you store text strings separate from code so that
      they are easily identified. A new cmdlet, ConvertFrom-StringData,
      converts text strings into dictionary-like hash tables to facilitate
      translation.

WMI Cmdlets

      The Windows Management Instrumentation (WMI) functionality of
      Windows PowerShell 2.0 is improved with the addition of the following
      cmdlets:

          - Remove-WmiObject
          - Set-WmiInstance
          - Invoke-WmiMethod

      New parameters have been added to the Get-WmiObject cmdlet. All the WMI
      cmdlets now support the following parameters:

          - EnableAllPrivileges
          - Impersonation
          - Authentication
          - Authority

      These new parameters give you more refined control over the security
      configuration of your WMI operations without requiring you to work
      directly with the types in the .NET Framework Class Library.

      For a list of WMI cmdlets, type the following command:

          get-help *wmi*

      To get help for each cmdlet, type get-help followed by the cmdlet name.


The Get-WinEvent Cmdlet

      The Get-WinEvent cmdlet gets events from Event Viewer logs and from
      Event Tracing for Windows (ETW) event log files on local and remote
      computers. It can get events from classic event logs and from the
      Windows Event Logs that were introduced in Windows Vista.

      You can use Get-WinEvent to get the objects that represent event logs, event
      log providers, and the events in the logs. Get-WinEvent lets you combine
      events from different sources in a single command. It supports
      advanced queries in XML Path Language (XPath), XML, and hash table
      format.

      Get-WinEvent requires Windows Vista or Windows Server 2008 and the
      Microsoft .NET Framework 3.5.

The Out-Gridview Cmdlet

      The Out-GridView cmdlet displays the results of other commands in an
      interactive table in which you can search, sort, group, and filter the
      results. For example, you can send the results of a Get-Process,
      Get-WmiObject, Get-WinEvent, or Get-Eventlog command to Out-GridView and
      then use the table features to examine the data.

        help out-gridview -full

The Add-Type Cmdlet

      The Add-Type cmdlet lets you add .NET Framework types to
      Windows PowerShell from the source code of another .NET Framework
      language.

      Add-Type compiles the source code that creates the types and generates
      assemblies that contain the new .NET Framework types. Then, you can use
      the .NET Framework types in Windows PowerShell commands along with the
      standard object types provided by the .NET Framework.

      You can also use Add-Type to load assemblies into your session so that
      you can use the types in the assemblies in Windows PowerShell.

      Add-Type allows you develop new .NET Framework types, to
      use .NET Framework types in C# libraries, and to access Win32 APIs.



Event Notification

      Windows PowerShell 2.0 introduces event notification. Users can register
      and subscribe to events, such as Windows PowerShell events, WMI events,
      or .NET Framework events. And, users can listen, forward, and act on
      management and system events both synchronously and asynchronously.

      Developers can write applications that use the event architecture
      to receive notification about state changes. Users can write
      scripts that subscribe to various events and that react to the content.


      Windows PowerShell provides cmdlets that create new events, get
      events and event subscriptions, register and unregister events,
      wait for events, and delete events. For more information about these
      cmdlets, type the following command:

          get-command *-event


Modules

      Windows PowerShell modules let you divide and organize your
      Windows PowerShell scripts into independent, self-contained,
      reusable units. Code from a module executes in its own context,
      so it does not add to, conflict with, or overwrite the variables,
      functions, aliases, and other resources in the session.


      You can write, distribute, combine, share, and reuse modules to build
      simple scripts and complex applications.

      Windows PowerShell 2.0 includes cmdlets to add, get, and remove modules
      and to export module members. For more information about the cmdlets
      that are related to modules, type the following command:

          get-command *-module*

Transactions

      Windows PowerShell 2.0 includes support for transactions. Transactions
      let you undo an entire series of operations. Transactions are available
      only for operations that support transactions. They are designed for
      applications that require atomicity, consistency, isolation, and
      recoverability, like databases and message queuing.

      Cmdlets and providers that support transactions have a new
      UseTransaction parameter. To start an operation within a transaction,
      use the Start-Transaction cmdlet. Then, when you use the cmdlets that
      perform the operation, use the UseTransaction parameter of each cmdlet
      when you want the command to be part of a transaction.

      If any command in the transaction fails at any point, use the
      Rollback-Transaction cmdlet to undo all the commands in the transaction.
      If all the commands succeed, use the Commit-Transaction cmdlet to make
      the command actions permanent.

      Windows PowerShell 2.0 includes cmdlets to start, use, commit, and roll
      back transactions. For information about these cmdlets, type the
      following command:

          get-command *transaction*

Accessing Windows PowerShell for SharePoint 2010 Products

After installing SharePoint 2010 Products, the applicable Windows PowerShell cmdlets are available by using the SharePoint 2010 Management Shell, or by using the Windows PowerShell console. With the management shell, you can manage every aspect of SharePoint 2010 Products. You can create new site collections, Web applications, user accounts, service applications, proxies, and more. The commands from the management shell output SharePoint objects based on the Microsoft .NET Platform. These objects can be applied as input to subsequent commands or stored in local variables for later use.

With the management shell, you do not have to register the snap-in that contains the cmdlets. Registration of the Microsoft.SharePoint.PowerShell.dll module for SharePoint 2010 cmdlets is automatic, as a result of the line Add-PSSnapin Microsoft.SharePoint.PowerShell in the SharePoint.ps1 file located in %CommonProgramFiles%\Microsoft Shared\Web Server Extensions\14\Config\PowerShell\Registration. If you choose to use the Windows PowerShell console, you must register this snap-in manually.

Whether you are using the management shell or the Windows PowerShell console, you can also load additional snap-ins. For more information, see Customizing Profiles (http://go.microsoft.com/fwlink/?LinkId=183166).

To access the SharePoint 2010 Management Shell

   1.On the Start menu, click All Programs.
   2.Click Microsoft SharePoint 2010 Products.
   3.Click SharePoint 2010 Management Shell.

The SharePoint 2010 Management Shell and the Windows PowerShell console also differ in the use of the ReuseThread option, which defines how the threading model is used. The management shell's use is defined by this line, {Host.Runspace.ThreadOptions = "ReuseThread"}, which is in the SharePoint.ps1 file. For more information, see PS Thread Options (http://go.microsoft.com/fwlink/?LinkId=183145).

Permissions

Before you can use the management shell and the Windows PowerShell cmdlets, verify that you meet the following minimum requirements:

If you do not have membership in the SharePoint_Shell_Access role or WSS_Admin_WPG local group, use the Add-SPShellAdmin cmdlet. When the Add-SPShellAdmin cmdlet is used, the user is added to the WSS_Admin_WPG group in all front-end Web servers and is added to the SharePoint_Shell_Access role. If the target database does not have a SharePoint_Shell_Access role, the role is automatically created. Once the Add-SPShellAdmin cmdlet has been run, the user can run SharePoint 2010 Windows PowerShell cmdlets in a multiple-server farm environment.

When you run the Add-SPShellAdmin cmdlet to add a user to the SharePoint_Shell_Access role, you must have the following security permissions:

    * Securityadmin server role access on the SQL instance and the db_owner role in a database.

    * Administrative permission on the local computer.

Typically, the person that will use the Add-SPShellAdmin cmdlet must be associated with the user account that was used for Setup.

You must run the Add-SPShellAdmin cmdlet for all databases to which you want to grant access. If no database is specified, the farm configuration database is used. If you do specify a database, the farm content database will be included in addition to the farm configuration database you specify.

To see a list of all of the *SPShellAdmin cmdlets, from a Windows PowerShell command prompt, type Get-Command -Noun SPShellAdmin.

Scripts and execution policies

Although you can use Windows PowerShell to perform a single administrative task, the real benefit of using Windows PowerShell cmdlets is the ability to use a script to automate a series of tasks. A script is a plain text file that contains one or more Windows PowerShell commands. Windows PowerShell scripts have a .ps1 file name extension.

When using a script, be aware that the minimum required execution policy for SharePoint 2010 Products is RemoteSigned, while the default policy for Windows PowerShell is Restricted. If the policy is left as Restricted, the SharePoint 2010 Management Shell will change the policy for Windows PowerShell to RemoteSigned. This means the SharePoint 2010 Management Shell must be launched with elevated administrative permission by selecting Run as administrator. This change will apply to all Windows PowerShell sessions.

Web Site vs Web Application project in .Net

2011-03-24T04:57:00.000-07:00

Website project type was introduced in the VS 2005 and Web Application model introduced in VS 2003. Website project type is based on folder structure and does not require a project file. Later in VS 2005 sp1 project file was introduced for the VS 2005 website project type. Now in VS 2008 we can create both project types.A common question by asp.net developers is what project model should I use for asp.net application?Every project model has it's own advantages and disadvantages.

Major difference between Web Application and Website is when you deploy the WebApps, you can just copy the Compiled Assembly and Visual elements to the IIS folder where as in Website you need to copy everything to the IIS to work.

Website:
It is a collection of web pages and other information such as images, sound, and video files, etc. that are made available to end users using different browsers like IE, FireFox, Chrome etc. through a single web server.

Web Application:
A web application serves a specific function such a shopping cart or a blogging application.

A web site can be a collection of several web applications.

Web Application project model

Provides the same Web project semantics as Visual Studio .NET 2003 Web projects.
Has a project file (structure based on project files).
Build model - all code in the project is compiled into a single assembly.
Supports both IIS and the built-in ASP.NET Development Server.
Supports all the features of Visual Studio 2005 (refactoring, generics, etc.) and of ASP.NET 2.0 (master pages, membership and login, site navigation, themes, etc).
Using FrontPage Server Extensions (FPSE) are no longer a requirement.

Web Site project model

No project file (Based on file system).
New compilation model. (Read here or here for more details) and ...
Dynamic compilation and working on pages without building entire site on each page view.
Supports both IIS and the built-in ASP.NET Development Server.
Each page has it's own assembly.
Different code model. (Read here for more details)

Which model should I use?

You need to migrate large Visual Studio .NET 2003 applications to VS 2005? use the Web Application project.
You want to open and edit any directory as a Web project without creating a project file? use Web Site project.
You need to add pre-build and post-build steps during compilation? use Web Application project.
You need to build a Web application using multiple Web projects? use Web Application project.
You want to generate one assembly for each page? use Web Site project.
You prefer dynamic compilation and working on pages without building entire site on each page view? use Web Site project.
You prefer single-page code model to code-behind model? use Web Site project.

Sharepoint server 2010 vs Sharepoint Foundation 2010

2011-03-24T04:15:00.000-07:00

Here is an image showing differences between sharepoint 2010 versions.You can find all these in the below link
http://sharepoint.microsoft.com/en-us/buy/Pages/Editions-Comparison.aspx

How to Deploy a SharePoint site from one server to another?

2011-03-24T03:16:00.000-07:00

Some times we need to deploy our share point Site on Staging server for client access to test the website.

Follow the below steps to migrate Sharepoint site from Dev Server to Staging.

Method I

1. Use SQL Management Studio to backup the Content Database
How to: Back Up a Database (SQL Server Management Studio):
http://msdn.microsoft.com/en-us/library/ms187510.aspx

2. Restore the Content Database to your new SQL server
How to: Restore a Database Backup (SQL Server Management Studio):
http://msdn.microsoft.com/en-us/library/ms177429.aspx

3. Create a new web application in Central Admin on the new farm:

Create a Web application (SharePoint Foundation 2010):
http://technet.microsoft.com/en-us/library/cc288705.aspx

4. Delete the content Database that get's created by the new web application(from step 4)
Central Admin > Application Management > Content Databases > delete the empty db from your web application (created in step 3)

5. Use SharePoint Management Shell(Mount-SPContentDatabase), Stsadm(-o addcontentdb) or Central Admin to add the contentdatabase:
Add a content database (SharePoint Server 2010):
http://technet.microsoft.com/en-us/library/cc825314.aspx

6. Make sure that your account has administrative permissions on the site collection(update site collection administrator)

Add or remove site collection administrators (SharePoint Server 2010):

http://technet.microsoft.com/en-us/library/ff631156.aspx

Method II

We can use Central Adminstration to take back up of a farm or site collection to a shared location and we can restore the backup file into a new server farm using the new server farm's Central Administration as shown in the below images.

Sitefinity 3.7 - Custom Url Rewrite Module

2011-03-24T00:23:00.000-07:00

In our application we need to redirect the user from a old website page to the new website page. Sitefinity has built in Module to rewrite the url. The below link clearly explains it.

http://www.sitefinitywatch.com/blog/09-01-08/URL_Rewriting_with_Sitefinity_s_AdvancedUrlRewriter.aspx

In our application we have plenty of URLS to rewrite and we dont want to put all these stuff in web.config. So We have created a Custom Module to rewrite the URLs. This module reads the xml file (which contains a set of url rewrites and the format is same as url rewrites defined in the web.config.) and rewrites the URL.

In our application we have two xml files, one is for pdf documents and the other is for page re-directions.

Code :

App_Code/RedirectModule.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using System.Configuration;
using System.Text.RegularExpressions;

namespace Ramp.UrlRedirect
{

/// <summary>
/// Summary description for RedirectModule
/// </summary>
public class RedirectModule : IHttpModule
{
public void Init(HttpApplication app)
{
app.BeginRequest += new EventHandler(OnBeginRequest);
}

private void OnBeginRequest(object src, EventArgs e)
{
HttpApplication app = src as HttpApplication;
string requestedUrl = app.Request.Url.AbsolutePath.ToLower();
if (requestedUrl == "/index.html")
{
try
{
app.Response.StatusCode = 301; // make a permanent redirect
app.Response.AddHeader("Location", "/");
app.Response.End();
return;
}
catch { }
}

if (!requestedUrl.Contains(ConfigurationManager.AppSettings["SearchResultsPage"].ToLower()))
{

DataSet dataset = new DataSet();

Regex pdfRegx = new Regex("(.pdf)$", RegexOptions.IgnoreCase);

if (pdfRegx.IsMatch(requestedUrl))
{
dataset.ReadXml(app.Server.MapPath("~/Res/Redirections/doc_redirections.xml"));
}
else
{
dataset.ReadXml(app.Server.MapPath("~/Res/Redirections/page_redirections.xml"));
}

for (int i = 0; i < dataset.Tables[0].Rows.Count; i++)
{
try
{
string sourceUrl = dataset.Tables[0].Rows[i].ItemArray[0].ToString();
string targetUrl = dataset.Tables[0].Rows[i].ItemArray[1].ToString();

Regex targetRegex = new Regex(targetUrl, RegexOptions.IgnoreCase);

if (targetRegex.IsMatch(requestedUrl))
{
return;
}

Regex sourceRegex = new Regex(sourceUrl, RegexOptions.IgnoreCase);
if (sourceRegex.IsMatch(requestedUrl))
{
string destinationUrl = sourceRegex.Replace(requestedUrl, targetUrl, 1);
app.Response.StatusCode = 301; // make a permanent redirect
app.Response.AddHeader("Location", destinationUrl + app.Request.Url.Query);
app.Response.End();
break;
}
}
catch { }
}
}

}

public void Dispose()
{
}
}
}

web.config changes
<system.webServer>
<validation validateIntegratedModeConfiguration="false" />
<modules>
<remove name="ScriptModule" />
<remove name="Cms" />

<remove name="RadUploadModule" />
<add name="ScriptModule" preCondition="managedHandler" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
<add name="Cms" type="Telerik.Cms.Web.CmsHttpModuleUrlRewrite, Telerik.Cms" />
<add name="RedirectModule" type="Ramp.UrlRedirect.RedirectModule, App_Code" />



<add name="RadUploadModule" preCondition="managedHandler" type="Telerik.Web.UI.RadUploadHttpModule, Telerik.Web.UI" />
</modules>
...............................
.................................

Xml file URL rewrite element format

<?xml version="1.0" standalone="yes"?>
<urlrewrites>
<rule>
<url>subscribe.html</url>
<rewrite>subscribe.aspx</rewrite>
</rule>
<rule>

. . . . . . .

</rule>
.. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
</urlrewrites>

Sitefinity - Custom Pollbox

2011-03-23T02:56:00.000-07:00

I have created a custom PollBox for Sitefinity to display Poll Questions and Results.

Why Custom PollBox?

Sitefinity had its Rad Control to display poll questions and poll results.But the default RadChart control to display the results, uses images to display graphical results.This is fine and working properly when we host our application on a single Web server. If we use Server farm with Load balance, We will get an error "RadChart image not found" and the results box will not display properly.

Even if we set the property 'Use Session" to false, the same error remains on the Web Farm.

Then I came up with a Custom poll box, which displays the poll results in pure html.It avoids the images and the error vanished.

Custom Pollbox Advantages:

1.)As it is showing all poll results in pure html, we have full control on Bar colors and width and heights.We can manipulate these with css.
2.) On the admin Side u can add this user control by drag and drop as we add the default poll box.
3.) We can select the poll Id as we select it for default PollBox.
4.) We can specify User Blocking time in Hours .If we set this time, a cookie will be created on the user machine and will block the user to vote again for a specified time in Hours.
5.) We can give our own Bar Colors and Main Colors and Horizontal Width of the Graph.
6.) We can customize this Custom Pollbox according to our requirements.

Screen shots:

Code:

you can download the code files from the below link

https://docs.google.com/leaf?id=0B0LGUQrVMkGoNzc4ZGFhNzUtNjE4Yy00MDYyLThiYmQtM2E2MjU0YjA4MTc2&hl=en

CustomPollBox.ascx

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="CustomPollBox.ascx.cs" Inherits="UC_CustomPollBox" %>
<div class="pollBox" >
<asp:Repeater runat="server" ID="rptPoll" OnItemDataBound="rptPoll_ItemDataBound" >
<ItemTemplate>
<div class="pollQuestion" >
<asp:Literal ID="litQuestion" runat="server" ></asp:Literal>
</div>
<asp:RadioButtonList ID="rblAnswers" runat="server" ></asp:RadioButtonList>
</ItemTemplate>
</asp:Repeater>

<asp:Repeater runat="server" ID="rptResults" OnItemDataBound="rptResults_ItemDataBound" Visible="false" >
<ItemTemplate>
<div class="pollQuestion" >
<asp:Literal ID="litQuestion" runat="server" ></asp:Literal>
</div>
<asp:Panel ID="pnlGraph" runat="server" ></asp:Panel>
</ItemTemplate>
</asp:Repeater>
<div class="pollBtnContainer" >
<asp:Literal ID="litTotalVotes" runat="server" Visible="false"></asp:Literal>
<asp:PlaceHolder ID="plhVoteButton" runat="server">
<a class="buttonLeftNew btn_BlueLeftNew" onmouseover="javascript:AddUndeline(this.id);" onmouseout="javascript:RemoveUndeline(this.id);" id="btnVoteLink" >
<asp:Button ID="btnVote" runat="server" Text="Submit" CssClass="btnMiddleNew btn_BlueMiddleNew buttonInput" OnClick="btnVote_Clicked" CausesValidation="true" onmouseover="javascript:AddUndeline(this.id);" onmouseout="javascript:RemoveUndeline(this.id);" />
</a>
</asp:PlaceHolder>
</div>
</div>

CustomPollBox.ascx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.ComponentModel;
using Telerik.Cms.Web.UI;
using Telerik.Polls;
using System.Collections;
using System.Drawing;

public partial class UC_CustomPollBox : System.Web.UI.UserControl
{
[Description("Gets or sets the ID of the poll which will be displayed")]
[Bindable(true)]
[WebEditor("Telerik.Polls.WebControls.PollBoxEditor, Telerik.Polls")]
[DisplayName("Poll ID")]
public Guid PollID { get; set; }

[PersistenceMode(PersistenceMode.Attribute)]
[Description("Chart background main color")]
[NotifyParentProperty(true)]
[TypeConverter(typeof(ColorConverter))]
[DefaultValue(typeof(Color), "240, 248, 255")]
[DisplayName("Main Color")]
public Color MainColor { get; set; }

[NotifyParentProperty(true)]
[DefaultValue(150f)]
public float Width { get; set; }

[Description("Chart plot area main color")]
[NotifyParentProperty(true)]
[TypeConverter(typeof(ColorConverter))]
[PersistenceMode(PersistenceMode.Attribute)]
[DefaultValue(typeof(Color), "153, 209, 248")]
[DisplayName("Bar Color")]
public Color BarColor { get; set; }

[Description("Block user to resubmit the poll (in hours)")]
[DisplayName("Block Time")]
public int BlockTime { get; set; }

PollManager pollManager;

protected void Page_Load(object sender, EventArgs e)
{
pollManager = new PollManager();

if (BarColor.A == 0 && BarColor.B == 0 && BarColor.G == 0 && BarColor.R == 0)
BarColor = Color.FromArgb(153, 209, 248);

if (MainColor.A == 0 && MainColor.B == 0 && MainColor.G == 0 && MainColor.R == 0)
MainColor = Color.FromArgb(240, 248, 255);
if (Width == 0)
Width = 150;

if (BlockTime == 0)
BlockTime = 120;

if(!IsPostBack)
{
if (PollID != null)
{
double total = pollManager.GetPollById(PollID).VoterNumber;
if (Request.Cookies[PollID.ToString()] != null && total > 0)
{
DisplayPollResults();
}
else
BindQuestionsRepeater();
}
}
}

protected void rptPoll_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
PollQuestion question = e.Item.DataItem as PollQuestion;
List<PollAnswer> answersList = PollHelper.GetAnswersByQuestionID(question.ID);
RadioButtonList rblAnswers = e.Item.FindControl("rblAnswers") as RadioButtonList;

Literal litQuestion = e.Item.FindControl("litQuestion") as Literal;
litQuestion.Text = question.Text;

rblAnswers.DataSource = answersList;
rblAnswers.DataTextField = "Text";
rblAnswers.DataValueField = "ID";
rblAnswers.DataBind();

}
}

protected void btnVote_Clicked(object sender, EventArgs e)
{
foreach (RepeaterItem item in rptPoll.Items)
{
RadioButtonList rblAnswers = item.FindControl("rblAnswers") as RadioButtonList;
if (!string.IsNullOrEmpty(rblAnswers.SelectedValue))
{
pollManager.IncrementAnswerCount(new Guid(rblAnswers.SelectedValue), 1);
}
}

IPollItem poll = pollManager.GetPollById(PollID);
if (poll != null)
{
poll.VoterNumber++;
pollManager.UpdatePoll(poll);
}
DisplayPollResults();
SetCookie();
Response.Redirect(Request.RawUrl);
}

private void BindQuestionsRepeater()
{
rptPoll.DataSource = PollHelper.GetQuestionsByPollID(PollID);
rptPoll.DataBind();
}

private void DisplayPollResults()
{
rptPoll.Visible = false;
plhVoteButton.Visible = false;
rptResults.Visible = true;

rptResults.DataSource = PollHelper.GetQuestionsByPollID(PollID);
rptResults.DataBind();
}

protected void rptResults_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
PollQuestion question = e.Item.DataItem as PollQuestion;
List<PollAnswer> answersList = PollHelper.GetAnswersByQuestionID(question.ID);

Literal litQuestion = e.Item.FindControl("litQuestion") as Literal;
litQuestion.Text = question.Text;

Panel chartPanel = e.Item.FindControl("pnlGraph") as Panel;
chartPanel.Controls.Add(LoadGraph(question));
}

private Table LoadGraph(PollQuestion questionItem)
{
double total = pollManager.GetPollById(PollID).VoterNumber;
litTotalVotes.Text = string.Format("Total Votes: {0}", total);
litTotalVotes.Visible = true;
IList<PollAnswer> answersList = PollHelper.GetAnswersByQuestionID(questionItem.ID);

Table table = new Table();
table.CssClass = "pollBoxTable";

double iWidth = 0;
Unit uWidth = 0;
string sWidth = (int)Width + "px";
table.Width = Unit.Pixel((int)Width);

if (sWidth.IndexOf("%") > -1)
{
iWidth = Convert.ToInt32(sWidth.Substring(0, sWidth.IndexOf("%")));
iWidth = iWidth / 10;
}
else
{
if (sWidth.IndexOf("px") > -1)
{
iWidth = Convert.ToInt32(sWidth.Substring(0, sWidth.IndexOf("px")));
}
else
{
iWidth = Convert.ToInt32(sWidth);
}
iWidth = iWidth / 100;
}

for (int i = 0; i < answersList.Count; i++)
{
TableRow tr = new TableRow();

TableCell td1 = new TableCell();
tr.Cells.Add(td1);

Panel container = new Panel();
container.BackColor = MainColor;
container.BorderColor = Color.White;
container.BorderWidth = Unit.Pixel(1);

Label lblBar = new Label();
double dblPercentage = (answersList[i].VoteCount/total) * 100;
lblBar.Width = Unit.Pixel(Convert.ToInt32(dblPercentage * iWidth));
lblBar.Height = Unit.Pixel(20);
lblBar.BackColor = BarColor;
lblBar.Text = answersList[i].VoteCount.ToString();
lblBar.CssClass = "chartBar";

Label lblPercentage = new Label();
lblPercentage.Text = answersList[i].Text + " / " + Math.Round(dblPercentage, 2).ToString() + "%<br/>";
td1.Controls.Add(lblPercentage);

td1.Controls.Add(container);
container.Controls.Add(lblBar);

table.Rows.Add(tr);
}

return table;
}

/// <summary>
/// Returns the width set as pixels or percentage
/// </summary>
/// <param name="width"></param>
/// <returns></returns>
private Unit GetWidth(string width)
{
Unit retVal = new Unit(0);
try
{
int iWidth = 0;
if (width.IndexOf("%") > -1)
{
iWidth = Convert.ToInt32(width.Substring(0, width.IndexOf("%")));
retVal = Unit.Percentage(iWidth);
}
else
{
if (width.IndexOf("px") > -1)
{
iWidth = Convert.ToInt32(width.Substring(0, width.IndexOf("px")));
}
else
{
iWidth = Convert.ToInt32(width);
}
retVal = Unit.Pixel(iWidth);
}
return retVal;
}
catch { return retVal; }
}

/// <summary>
/// Sets a cookie. Prevents multiple entries from a computer
/// </summary>
private void SetCookie()
{
HttpCookie cookie = new HttpCookie(PollID.ToString(), DateTime.Now.ToString());
cookie.Expires = DateTime.Now.AddHours(BlockTime);
Response.Cookies.Set(cookie);
}

}

App_Code/PollHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.Configuration;

/// <summary>
/// Summary description for PollHelper
/// </summary>
public class PollHelper
{
//public static PollHelper PollHelper = new PollHelper();
    public PollHelper()
    {

    }

public static List<PollQuestion> GetQuestionsByPollID(Guid pollID)
{
List<PollQuestion> pollQuestions = new List<PollQuestion>();
SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["Sitefinity"].ConnectionString);
using (connection)
{
try
{
connection.Open();
SqlCommand commad = new SqlCommand(string.Format("select * from dbo.sf_Polls_QuestionData where PollID = @PollID"), connection);
SqlParameter parameter = new SqlParameter("PollID", System.Data.SqlDbType.UniqueIdentifier);
parameter.Value = pollID;
commad.Parameters.Add(parameter);
SqlDataReader reader = commad.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

while (reader.Read())
{
pollQuestions.Add(new PollQuestion((Guid)reader["ID"], (string)reader["Text"], (Guid)reader["PollID"]));
}
}
finally
{
connection.Close();
}
}
return pollQuestions;
}

public static List<PollAnswer> GetAnswersByQuestionID(Guid questionID)
{
List<PollAnswer> pollAnswers = new List<PollAnswer>();
SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["Sitefinity"].ConnectionString);
using (connection)
{
try
{
connection.Open();
SqlCommand commad = new SqlCommand(string.Format("select * from dbo.sf_Polls_AnswerData where QuestionID = @QuestionID"), connection);
SqlParameter parameter = new SqlParameter("QuestionID", System.Data.SqlDbType.UniqueIdentifier);
parameter.Value = questionID;
commad.Parameters.Add(parameter);
SqlDataReader reader = commad.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

while (reader.Read())
{
pollAnswers.Add(new PollAnswer((Guid)reader["ID"], (string)reader["Text"], (Guid)reader["QuestionID"], (int)reader["VoteCount"]));
}
}
finally
{
connection.Close();
}
}

return pollAnswers;
}

}

public class PollQuestion
{
private Guid iD;
private string text;
private Guid pollID;

public Guid ID
{
get
{
return iD;
}
set
{
iD=value;
}
}

public Guid PollID
{
get
{
return pollID;
}
set
{
pollID=value;
}
}

public string Text
{
get
{
return text;
}
set
{
text=value;
}
}

public PollQuestion()
{
}

public PollQuestion(Guid ID,string Text,Guid PollID)
{
this.iD = ID;
this.pollID = PollID;
this.text = Text;
}
}

public class PollAnswer
{
private Guid iD;
private string text;
private Guid questionID;
private int voteCount;

public Guid ID
{
get
{
return iD;
}
set
{
iD = value;
}
}

public Guid QuestionID
{
get
{
return questionID;
}
set
{
questionID = value;
}
}

public string Text
{
get
{
return text;
}
set
{
text = value;
}
}

public int VoteCount
{
get
{
return voteCount;
}
set
{
voteCount = value;
}
}

public PollAnswer()
{
}

public PollAnswer(Guid ID, string Text, Guid QuestionID,int VoteCount)
{
this.iD = ID;
this.questionID = QuestionID;
this.text = Text;
this.voteCount = VoteCount;
}
}

Billiards Game developed in Silverlight

2009-09-09T05:13:00.000-07:00

I have developed Billiards game in Silverlight .This game supports 8 ball and Pool. Below are the screens of this game and to play this game please click here

How to get content and text of each element of a Window

2009-09-09T03:17:00.000-07:00

Some times it is needed to get the content/text of the children of a control.Then we have to iterate through all elements and should know its type.After comparing its type with the predefined types, we can cast that UIElement object to the particular object type.Then we can get/set its text/content values.Here is the sample code.

foreach (UIElement oObject in this.LayoutRoot.Children)

{

Type type= oObject.GetType();

string name=oObject.GetValue(NameProperty).ToString();

if (type == typeof(TextBlock))

{

TextBlock textBlock = oObject as TextBlock;

if (textBlock != null)

{

MessageBox.Show(textBlock.Text);

}

if (type == typeof(TextBox))

{

TextBox textBox = oObject as TextBox;

if(textBox != null)

{

MessageBox.Show(textBox.Text);

}

if(type == typeof(ComboBox))

{

ComboBox comboBox = oObject as ComboBox;

if(comboBox != null)

{

MessageBox.Show(comboBox.SelectedItem.ToString());

}

if(type==typeof(Button))

{

Button button = oObject as Button;

if(button != null)

{

MessageBox.Show(button.Content.ToString());

}

}
}

.Net Technology Quest: Silverlight ComBoBox Selected Item not Setting

2009-09-08T23:21:00.000-07:00

.Net Technology Quest: Silverlight ComBoBox Selected Item not Setting

Silverlight ComBoBox Selected Item not Setting

2009-09-08T04:17:00.000-07:00

Here is the code I developed to Bind data to a ComboBox and set the selected Item. This code is tested and working fine. Xaml page

</Canvas>

</UserControl>

Code behind in C#

public partial class Page : UserControl

{ public Page()

{

InitializeComponent(); BindComBoBox(); }

private void BindComBoBox()

{

List<Country> coutries = new List<Country>();

Country India = new Country(1,"India");

Country USA = new Country(2, "USA");

Country Canada = new Country(3,"Canada");

coutries.Add(India);

coutries.Add(USA);

coutries.Add(Canada);

comBoBox.ItemsSource = coutries; comBoBox.DisplayMemberPath = "Name"; comBoBox.SelectedItem = Canada;

}

public class Country

{

public int ID { get; set; }

public string Name { get; set; }

public Country(int id,string name)

{

ID = id;

Name = name;

}

} }

Fix Windows Live Messenger Not Remembering ID and Password

2009-07-16T22:47:00.000-07:00

Suddenly my Windows live messenger stopped 'Auto login' even when I select the check boxes 'Remember me' and 'Remember my password'.This is because of Yahoo tool bar. Here is the fix for this problem.Please go through the below article posted by Raymond. Fix Windows Live Messenger Not Remembering ID and Password

How to Enable Silver light Debugging

2009-02-19T02:27:00.000-08:00

If we try to add a new silver light project to a solution, then Visual studio prompts with the following dialogue box.

So that we can enable debugging on this newly created silver light application. However if we wanted to add an existing silver light application to a solution which contains a website project then we have to explicitly enable debugging on this silver light application, otherwise Visual studio wont debug this silver light application, when we set the Web application as the start up project.

To enable debugging on this newly added existing silver light project.

1) In solution Explorer, Right click on the Web Project and select ‘Property Pages’ .Here is the screen shot to select ‘Property Pages’

2) In ‘Property pages’ Window in ‘Start Options’ , make sure that the check boxes ‘ASP.NET’ and ‘Silverlight ‘ both are selected.

3) Select ‘Silverlight Application’ then Click on the ‘Add’ button, it will open the following window. Select the check box ‘Enable Silverlight Debugging’ then press ‘Apply’ then ‘Ok’.

CSS: Shared Classes

2009-02-03T05:19:00.000-08:00

CSS: Shared Classes

Summary: You can group styles common to different rules into their own classes to save repeating yourself. By applying multiple classes to one element in CSS you can modularize your code to help optimize your style sheets.

You can group styles common to different rules into their own classes to save repeating yourself. CSS2-compliant browsers can reference multiple classes within individual elements.

For example:

This ability to reference multiple classes gives authors newfound options when styling their content. For elements that share the same styles (text-align:center for example), you can group these shared styles into one shared class. So this:

.nav{color:red; text-align:center;}

.main{color:#000; text-align:center;}

</style>

...

Becomes this after grouping the common center style into one shared class:

.nav{color:red;}

.main{color:#000;}

.ctr{text-align:center;}

</style>

...

The third .ctr class groups the common styles (in this case the center declaration) into a class now shared by two elements. The additional class saves space by eliminating redundant common declarations, which can add up for larger style sheets. In effect, you are normalizing your CSS.

Here is a small example about styles with classes and Id.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default2.aspx.cs" Inherits="Default2" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>Shared Classes</title>

body {

width: 40em;

font-family: Arial, Helvetica, sans-serif;

}

h1 {

font-size: 1.5em;

}

h2 {

font-size: 1.2em;

margin-top: 40px;

}

h3 {

font-size: 1.0em;

font-weight: bold;

}

h4 {

text-transform: uppercase;

font-size: 1.0em;

}

/*----these are the test classes and ids----*/

.orange {

color: orange;

}

.bold {

font-weight: bold;

}

#boldness {

font-weight: bold;

}

.orangegrouped.boldgrouped {

color:orange;

font-weight: bold;

}

#boldgroup.orangegroup {

color: orange;

font-weight: bold;

}

</style>

</head>

<body>

<h1>Applying multiple styles to HTML elements</h1>

<h2>Case I: Two separate classes applied to one element</h2>

<p class="orange bold">This text should be orange and bold. Two classes are applied to the <p> tag, "orange"

and "bold."</p>

<h2>Case II: A class and an ID applied to one element</h2>

<p class="orange" id="boldness">This text should be orange and bold. The <p> tag has the class "orange"

applied to it, and is assigned the id "boldness."</p>

<h2>case III: Two grouped classes applied to one element</h2>

<p class="orangegrouped boldgrouped">This text should be orange and bold. Two classes are applied to the <p>

tag, "orangegrouped" and "boldgrouped", which are defined together in the CSS.</p>

<h2>Case IV: Two grouped classes applied to one element in the opposite order</h2>

<p class="boldgrouped orangegrouped">This text should be orange and bold. Two classes are applied to the <p>

tag, "orangegrouped" and "boldgrouped", which are defined together in the CSS but in

the opposite order than they are applied in the <p> tag.</p>

<h2>Case V: A class and an ID grouped and applied to one element</h2>

<p class="orangegroup" id="boldgroup">This text should be orange and bold. The <p> tag has the class "orangegroup"

as well as the id "boldgroup" applied to it, which are defined together in the CSS.</p>

</body>

</html>

Conclusions

Netscape 4.x for Windows and Mac cannot support the application of multiple classes to a single element. It results in ignoring all classes. (Cases I, III, IV) It can, however, understand the application of a class and an id to a single element. (Case II) This technique only works, however, if the class and id are defined separately in the style sheet, not grouped together. (Test Case V)

Internet Explorer 4.x for Windows cannot support the application of multiple classes to a single element. It results in ignoring all classes. (Cases I, III, IV) It can, however, understand the application of a class and an id to a single element. (Case II) This technique works even if the class and id are grouped together in the style sheet, not defined separately. (Test Case V) In this respect IE 4.x differs from NN 4.x.