Iteration versus Catching Expected Exceptions

Most SharePoint objects (Microsoft.SharePoint.dll) contain typed collections to store the references to other objects (example: SPList.Items is an SPListItemCollection). The problem is, that these collections implement methods for retrieving objects from these collections that throw ArgumentExceptions if the key-value (unique value: i.e. title, GUID, id, index) does not retrieve a valid element.

If you have a typical update method that has to check if the underlying object exists you will do it using one of the following two possibilities:

public static SPList GetElementTry(SPWeb web, string listName)
{
    SPList list = null;
    try 
    {
       list = web.Lists[listName];
    } 
    catch(Exception) {}
    return list;
}

public static SPList GetElementIterate(SPWeb web, string listName)
{
    SPList list = null;
    string listName = listName.ToLower();
    SPListCollection lists = web.Lists;
    foreach(SPList list in lists)
    {
        if(string.Equals(list.Title.ToLower(), listName))
        {
            return list; 
        }
    }    
    return list;
}

The problem now is: which one is better from a performance and design point of view?

I read somewhere that in Java (I used to develop in Java) if you want a basic metric (and this is a strong abstraction from reality, if it is even applicable) you can say the creation and throwing of an exception costs about 400 times more than a basic comparison (and again, please correct me if I’m wrong in this assumption).

The SharePoint magic number of storage / items / lists / objects: 2GB // 2000.

When you compare this to 400, then you will probably end up saying: I can optimize iteration a little bit so I’ll use this, because it seems more elegant, but I would rather have an internal method that does this for me and instead of throwing an exception it returns null.

Well we’re not in happy-land so you have to make a decision.

Something I would not do though is implement a method ElementExists that does the same thing as the Get-method and instead of returning null / the element it just returns true/false. You can check for null in your code instead, if you encapsulate with a boolean value you need to call your method twice. This is only sensible if you do not need to use the object further.

On how to iterate, check this blog.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: