SharePoint coding tips and tricks

The elementary thing that SharePoint developers should consider is, the correct way of using SharePoint object mode, and how to apply general programming techniques (such as caching and threading) to the SharePoint platform specifically. Generally developers who write custom code for developing the SharePoint Application will counter some issues like performance, scalability. This article makes you easier to find and fix your problem areas in the code and can avoid known pitfalls using SharePoint object model.

These are some of the areas that developers should concern
· Disposing of SharePoint Objects.
· Performance concerns related to folders, lists and SPQuery objects.
· Exact way of using SharePoint data and objects efficiently.
· Using web controls and timer jobs.

Disposable SharePoint objects:

1. Developers who are working on the windows SharePoint service object model for developing new SharePoint applications have objects that inherited from the IDisposable interface.
2. This article serves as a guide to the proper procedures for handling and disposing of SharePoint objects that implement IDisposable interface.
3. Some of the primary objects are SPWeb class and SPSite class, created as managed objects.
4. Microsoft .NET requires objects that implement the IDisposable interface to properly cleanup the unmanaged resources by explicitly calling the Dispose () or Close () method when you are finished using them.
5. Internally, SPSite and SPSite both hold references to an "internal class Microsoft.SharePoint.Library.SPRequest" which holds on to unmanaged COM resources.

Coding techniques to ensure Object Dispose:
These are some of the techniques to ensure the Object Dispose
· Dispose Method
· Using Clause
· Try, catch and finally blocks

Dispose vs. Close Method:

Both of them are same, but the dispose method internally calls the close method. For the best practice, use Dispose method instead of using close method because SPWeb and SPSite Objects implements IDisposable interface, and standard .NET framework garbage collector call the dispose method to free any resources associated with the object from memory.
Using Clause

1. Using clause will automatically dispose the SharePoint Objects. You can greatly simplify the code with using clause.
2. Common Language Run Time will convert the using clauses to try, catch and finally block, and any objects that implement the IDisposable interface are disposed for you.

Note: SPContext objects are managed from SharePoint framework and need not be disposing separately.

Try, catch and finally block:

Whenever you need to handle the exceptions we obviously use Try, catch and finally blocks. Please don’t leave the catch block empty. Declare Dispose method in the finally block, and make a note that for best practice check null before disposing the SharePoint objects as shown below.

SPSite spSite = null;
SPWeb spWeb = null;
try
{
spSite = new SPSite ("http://server");
spWeb = spSite.OpenWeb ();
}
catch (Exception e)
{

}
finally
{
if(spSite != null)
{
spSite.Dispose();
}
if (spWeb != null)
{
spWeb.Dispose ();
}
}

Respose.Redirect, with try, catch and finally block and using statements:

1. The finally block executes after calls to Response.Redirect in the try block. Response.Redirect ultimately generates a ThreadAbortException.
2. When this exception is raised, the runtime executes all finally blocks before ending the thread.
3. However, because the finally block can do an unbounded computation or cancel the ThreadAbortException, there is no guarantee that the thread will end.
4. Therefore, before any redirection or transfer of processing can occur, you must dispose of the objects. If your code must redirect, implement it in a way similar to the following code example.
SPSite spSite = null;
SPWeb spWeb = null;
try
{
spSite = new SPSite ("http://server");
spWeb = spSite.OpenWeb ();

if (spSite != null)
{
spSite.Dispose();
}
if (spWeb != null)
{
spWeb.Dispose ();
}
Response.Redirect ("www.google.com");
}

catch (Exception ex)
{

}

finally
{
if (spSite != null)
{
spSite.Dispose();
}
if (spWeb != null)
{
spWeb.Dispose ();
}
}

Performance concerns related to folders, lists and SPQuery objects:

1. To retrieve the all items from list, please don’t use SPList.Items.
2. SPList.Items will retrieve all the items from folders, subfolders including all fields in the list.
3. To eradicate this Problem use SPList.GetItems(Query).
4. Getting Items by identifier, Please use SPList.GetItemById(int) instead of using SPList.Items.GetItemById().
5. To retrieve the list from the site, It is always preferable to get the list based GUID or url i.e. SPWeb.Lists[GUID] or SPWeb.GetList(strUrl) instead of using List Name i.e., SPWeb.Lists[strListName].

Conclusion:
· Please check whether your code dispose the SharePoint objects.
· Please check that your code cache objects properly.
· Please check that your code use thread synchronization when necessary.

If you consider these issues when you write your code, your SharePoint system will run more efficiently and your users will have a much better experience. You can also help to prevent unexpected failures and errors in your system.