Archive

Archive for August, 2009

Convert Infix To Postfix Using C#

August 31st, 2009 Comments off

I remember in mid 2007 I was looking for some CSharp code to convert from infix to postfix. Unfortunately I couldn’t found any readymade code to so. At that time I have written this code. It might be of any help to you. It’s the conversion of algorithm to convert from infix to postfix. If you need any further understanding about this code you are welcome to ask me.

 

private void infixToPostfix(string strExpression)
{
  try

  {
    string strExp = strExpression;
    string
outputExp = string.Empty;
    string
strRevExp = reverseString(strExp);
    string temp = string
.Empty;    while (strRevExp.Length > 0)
    {
      if (strRevExp.IndexOf(” “
) != -1)
        temp = strRevExp.Substring(0, strRevExp.IndexOf(
” “
));
      else

        temp = strRevExp;
      if (!isOperator(temp) && temp != “(“ && temp != “)”)
        outputExp +=
” “
+ temp;
      else if (temp == “)”
)
        sExp.Push(temp);
      else if
(isOperator(temp))
      {
        while (true
)
        {
          if
(sExp.Count == 0)
          {
            sExp.Push(temp);
            break
;
          }
          else if (sExp.Peek() == “)”
)
          {
            sExp.Push(temp);
            break
;
          }
          else if
(isGreaterEqual(temp, sExp.Peek()))
          {
            sExp.Push(temp);
            break
;
          }
          else

            outputExp +=
” “ + sExp.Pop();
        }
      }
      else if (temp == “(“
)
      {
        while (sExp.Peek() != “)”
)
          outputExp +=
” “
+ sExp.Pop();
        sExp.Pop();
      }
      if (strRevExp.IndexOf(” “
) != -1)
        strRevExp = strRevExp.Remove(0, strRevExp.IndexOf(
” “
) + 1);
      else

        strRevExp =
“”;
    }
    while
(sExp.Count != 0)
      outputExp +=
” “
+ sExp.Pop();  catch (Exception ex)
  {
    WriteException(
“infixToPostfix”
, ex);
  }
}

Private string reverseString(string actualString)
{
  string reverseString = string
.Empty;
  try

  {
    string[] strRevExpArray = actualString.Split(‘ ‘);
    for (int
i = strRevExpArray.Length – 1; i >= 0; i–)
      reverseString +=
” “
+ strRevExpArray[i];
    reverseString = reverseString.TrimStart();
  }
  catch (Exception
ex)
  {
    WriteException(
“reverseString”
, ex);
  }
  return
reverseString;
}

Cheers.

Categories: .Net Tags: , , ,

SPList Bits and Pieces

August 19th, 2009 1 comment

Recently I have gone through a very informative white paper on Sharepoint SPList. I’m impressed with the deep knowledge of the author. I have this white paper with me and it’s a word document on 22 pages. I have summarized some important information from it. Hope you will enjoy it.

Maximum number of items in SPList

You might read on internet that SPList can contain maximum 2000 elements. First of all it’s definitely wrong. The maximum number of items supported in a list with recursive folders is 5 million items.
There is a limit of 2000 items, but it is for each container. You can think of container as a root folder for items. Without any folder in a list, list itself will be a container for items. So you can have 2000 items in a list without any folder. But if you create folders and sub folders then you can have millions of items in a list.
This limit is because of standard Sharepoint UI, if you have your own UI you can cross this limit of 2000 items.

Data access methods

There are eight different methods to access data from SPList. This figure is interested, I also had no idea about all the methods.

  • Browser
    The list was viewed using a browser and the predefined Office SharePoint Server 2007 interface.
  • SPList with For/Each
    This is we normally use by looping through SPListItemCollection of SPList.Items.
  • SPList with SPQuery
    The OM was used to create an SPQuery object that contained the query criteria. That object was then used to against an instance of the list in a SPList object. The results of the query were returned by calling the GetItems method on the SPList object.
    SPList.GetItems (SPQuery)
  • Browser
    In this case an instance of the list is obtained with an SPList object. The data from it is then retrieved into a DataTable by calling the GetDataTable() method on the Items property —for example, SPList.Items.GetDataTable(). The DataTable’s DefaultView has a property called RowFilter that was then set to find the items.
    SPListItemCollection.GetDataTable ()
  • SPListItems with DataTable
    This method is similar to the SPList with DataTable method, but with a twist. An instance of the list is retrieved through an SPList object. An SPQuery object is created to build a query, and that query is executed against the SPList object, which returns an SPListItems collection. The data from that collection is then retrieved into a DataTable by using the GetDataTable() method on the SPListItems collection.
  • Lists Web service
    The Lists Web service, which comes with Windows SharePoint Services 3.0 and Office SharePoint Server 2007, was used to retrieve the data. A Collaborative Application Markup Language (CAML) query was created and submitted along with the list identifier, and an XML result set was returned from the Lists Web service.
  • Search Object Model
    The search object model was used to execute a query against the Office SharePoint Server 2007 search engine and return the results as a ResultTableCollection. In order to use search for SPList, you need to create managed properties and perfrorm indexing on them.
  • PortalSiteMapProvider
    One approach to retrieving list data in Office SharePoint Server 2007 that’s not very well known is the use of the PortalSiteMapProvider class. It was originally created to help cache content for navigation. However, it also provides a nice automatic caching infrastructure for retrieving list data. The class includes a method called GetCachedListItemsByQuery. This method first retrieves data from a list based on a SPQuery object that is provided as a parameter to the method call. The method then looks in its cache to see if the items already exist. If they do, the method returns the cached results, and if not, it queries the list, stores the results in cache and returns them from the method call.
    This looks something very interesting to use.

Query data from large list

I have always find people in trouble when accessing large lists in Sharepoint. They always complaint that Sharepoint lists are very slow in accessing data. Actually it’s all about how you access data from SPList. We have just noticed that there are eight ways to access data from SPList. Now before using any of the option you have to see which one is more suitable in your system.

  • Methods shouldn’t use when accessing large lists
    • Browser View
    • SPList with For/Each
    • SPList with DataTable
  • Fastest methods to query large lists in WSS
    • SPList with SPQuery
    • Lists Web Service
    • SPListItems with DataTable
  • Fastest methods to query large lists in MOSS
    • PortalSiteMapProvider
    • Search API
    • SPListItems with DataTable (it seems even faster to search API, if the number of items in the list are not too much, say for 1500 items it’s a better option.)

Search performed well across all of the scenarios. One drawback to using Search is that it cannot retrieve data until indexing has completed, so if immediate data retrieval is a requirement, Search may not be the best choice. You might need to configure Managed properties.
The PortalSiteMapProvider class was one of the best performing data access methods in every scenario. However, there are a couple of limitations in using it. First, because of the way in which the data is cached, use of the PortalSiteMapProvider class is going to be most useful if the data you are retrieving is not significantly different over time. If you are trying to frequently retrieve different data sets, the PortalSiteMapProvider class will incur the overhead of constantly reading from the database, inserting data into the cache and then returning it from the method call. Clearly, the advantage of the PortalSiteMapProvider class is when it can read data directly from the cache.
Using the SPList class gives you several options to retrieve data — a For/Each enumeration, the Items collection, the GetDataTable method of an SPListItems collection, and using an SPQuery object to filter data. Some of those methods, specifically the GetListItems and GetDataTable from the results of GetListItems, routinely performed well in most scenarios. However, there are some limitations. For example, the GetListItems method won’t work across folders in a single list unless the ViewAttributes property of your SPQuery query class includes Scope=”Recursive”. For that matter, it won’t work across lists if you want to query data from multiple lists or subsites. It also requires that all code runs directly on the Office SharePoint Server 2007 computer. Other options, like the Lists Web service and the Search Web service can retrieve the data but run on remote servers.

Data maintenance considerations

There are a few other issues to consider when creating lists with more than 2,000 items per container. One is the cost of other common operations such as adding or deleting items from the list. Performance for deleting items degrades significantly when a list becomes very large. Deleting a single item from a very large list takes much more time than deleting an item from a smaller list.

Data locking

Another important consideration when using large lists is the concept of the locks that Microsoft SQL Server™ places on data tables that contain list information. Virtually all data for all Office SharePoint Server 2007 lists is contained within a single table in SQL Server. This table contains data for all the lists in all the site collections whose data is stored in that content database. When you attempt to update data on a list item, whether that is adding, editing or deleting a list item, SQL Server will attempt to lock other items (rows to SQL Server) for that particular list.
However, there is a limit to the number of individual rows that SQL Server will try to lock down. If you try to select approximately 5,000 items or more simultaneously for reading or update, SQL Server will typically lock the entire table for the duration of that change. In this event, all other reads and writes for all lists in all site collections are queued until the previous transaction is complete and the lock is released. If your query retrieves data across multiple folders within the list, the locking behavior occurs whether or not list items are recursively nested so that there are not more than 2,000 items in an individual container. To ensure that you don’t encounter this locking behavior, make sure the number of items you retrieve in a single request is well below this threshold. For example, you can control the number of records returned by setting the RowLimit on the SPQuery class.
Crawl times

Another consideration with very large lists is crawl time and crawl time-outs. As a list gets larger, the chances of the indexer timing out when crawling the contents of that list increases. If the indexer is timing out when crawling large lists, you can increase the time-out value with the following steps:

  1. In Central Administration, on the Application Management tab, in the Search section, click Manage search service.
  2. On the Manage Search Service page, in the Farm-Level Search Settings section, click Farm-level search settings.
  3. In the Timeout Settings section, in the Connection time and Request acknowledgement time boxes, enter the desired number of seconds.

I will try to add word file or post the URL of white paper for more information.

Have fun .

Categories: MOSS Tags: ,

Caching in the SharePoint BaseFieldControl

August 5th, 2009 Comments off

This is definitely a new thing for me Today. We had some issue in a page title control on a SharePoint site. This is a simple SharePoint BaseFieldControl, we are using to display the page title on different pages. This control is relying on query string values. The issue I was looking for is ‘Page title is not changing on different pages for different query string values’.

When I have started debugging this control, I have noticed that it is ignoring query string value sometimes. Seems some caching is on. But there was no caching on from the developer. After some playing around I reached to the problem. BaseFieldControl by default do caching for displaying html, and for this it has a property name ‘CanCacheRenderedFieldValue’. The default value for CanCacheRenderedFieldValue is true.  

To resolve it I simply override the OnInit method and set the value for CanCacheRenderedFieldValue to false. It sorted out the ambiguous problem.

Hope you have enjoyed it.