SharePoint Arrow (Bull's Eye)

Best Practices: Common Coding Issues with SharePoint Object Model

2012-03-31T07:25:00.000+05:30

Using SharePoint Data and Objects Efficiently

Caching is one good way to improve system performance. However, you must weigh the benefits of caching against the need for thread safety. Additionally, you should not create certain SharePoint objects within event receivers because this will cause performance problems related to excessive database calls.

This section describes these common areas of concern so that you can learn ways to optimize your use of SharePoint objects and data.

Caching Data and Objects

Many developers use the Microsoft .NET Framework caching objects (for example,System.Web.Caching.Cache) to help take better advantage of memory and increase overall system performance. But many objects are not "thread safe" and caching those objects can cause applications to fail and unexpected or unrelated user errors.

Note:

The caching techniques discussed in this section are not the same as the custom caching options for Web content management that are discussed in Custom Caching Overview.

Caching SharePoint Objects That Are Not Thread Safe

You might try to increase performance and memory usage by cachingSPListItemCollection objects that are returned from queries. In general, this is a good practice; however, the SPListItemCollection object contains an embedded SPWebobject that is not thread safe and should not be cached.

For example, assume the SPListItemCollection object is cached in a thread. As other threads try to read this object, the application can fail or behave strangely because the embedded SPWeb object is not thread safe. For more information about theSPWeb object and thread safety, see the Microsoft.SharePoint.SPWeb class.

The guidance in the following section describes how you can prevent multiple threads from attempting to read the same cached object.

Understanding the Potential Pitfalls of Thread Synchronization

You might not be aware that your code is running in a multithreaded environment (by default, Internet Information Services, or IIS, is multithreaded) or how to manage that environment. The following example shows the code some developers use to cacheMicrosoft.SharePoint.SPListItemCollection objects.

Bad Coding Practice

Caching an Object That Multiple Threads Might Read

C++

JScript

Copy

public void CacheData()

{

SPListItemCollection oListItems;

oListItems = (SPListItemCollection)Cache["ListItemCacheName"];

if(oListItems == null)

{

oListItems = DoQueryToReturnItems();

Cache.Add("ListItemCacheName", oListItems, ..);

}

Although the use of the cache in this example is functionally correct, because the ASP.NET cache object is thread safe, it introduces potential performance problems. (For more information about ASP.NET caching, see the Cache class.) If the query in the preceding example takes 10 seconds to complete, many users could try to access that page simultaneously during that amount of time. In this case, all of the users would run the same query, which would attempt to update the same cache object. If that same query runs 10, 50, or 100 times, with multiple threads trying to update the same object at the same time—especially on multiprocess, hyperthreaded computers—performance problems would become especially severe.

To prevent multiple queries from accessing the same objects simultaneously, you must change the code as follows.

Applying a Lock

Checking for null

C++

JScript

Copy

private static object _lock = new object();

public void CacheData()

{

SPListItemCollection oListItems;

lock(_lock)

{

oListItems = (SPListItemCollection)Cache["ListItemCacheName"];

if(oListItems == null)

{

oListItems = DoQueryToReturnItems();

Cache.Add("ListItemCacheName", oListItems, ..);

}

You can increase performance slightly by placing the lock inside the if(oListItems == null) code block. When you do this, you do not need to suspend all threads while checking to see if the data is already cached. Depending on the time it takes the query to return the data, it is still possible that more than one user might be running the query at the same time. This is especially true if you are running on multiprocessor computers. Remember that the more processors that are running and the longer the query takes to run, the more likely putting the lock in the if() code block will cause problems. If you want to make absolutely sure that another thread has not createdoListItems before the current thread has a chance to work on it, you could use the following pattern.

Applying a Lock

Rechecking for null

C++

JScript

Copy

private static object _lock = new object();

public void CacheData()

{

SPListItemCollection oListItems;

oListItems = (SPListItemCollection)Cache["ListItemCacheName"];

if(oListItems == null)

{

lock (_lock)

{

//Ensure that the data was not loaded by a concurrent thread while waiting for lock.

oListItems = (SPListItemCollection)Cache[“ListItemCacheName”];

if (oListItems == null)

{

oListItems = DoQueryToReturnItems();

Cache.Add("ListItemCacheName", oListItems, ..);

}

If the cache is already populated, this last example performs as well as the initial implementation. If the cache is not populated and the system is under a light load, acquiring the lock will cause a slight performance penalty. This approach should significantly improve performance when the system is under a heavy load, because the query will be executed only once instead of multiple times, and queries are usually expensive in comparison with the cost of synchronization.

The code in these examples suspends all other threads in a critical section running in IIS, and prevents other threads from accessing the cached object until it is completely built. This addresses the thread synchronization issue; however, the code is still not correct because it is caching an object that is not thread safe.

To address thread safety, you can cache a DataTable object that is created from theSPListItemCollection object. You would modify the previous example as follows so that your code gets the data from the DataTable object.

Good Coding Practice

Caching a DataTable Object

C++

JScript

Copy

private static object _lock = new object();

public void CacheData()

{

DataTable oDataTable;

SPListItemCollection oListItems;

lock(_lock)

{

oDataTable = (DataTable)Cache["ListItemCacheName"];

if(oDataTable == null)

{

oListItems = DoQueryToReturnItems();

oDataTable = oListItems.GetDataTable();

Cache.Add("ListItemCacheName", oDataTable, ..);

}

For more information and examples of using the DataTable object, and other good ideas for developing SharePoint applications, see the reference topic for the DataTableclass.

Using Objects in Event Receivers

Do not instantiate SPWeb, SPSite, SPList, or SPListItem objects within an event receiver. Event receivers that instantiate SPSite, SPWeb, SPList, or SPListItemobjects instead of using the instances passed via the event properties can cause the following problems:

They incur significant additional roundtrips to the database. (One write operation can result in up to five additional roundtrips in each event receiver.)
Calling the Update method on these instances can cause subsequent Updatecalls in other registered event receivers to fail.

Bad Coding Practice

Instantiating an SPSite Object Inside an Event Receiver

C++

JScript

Copy

public override void ItemDeleting(SPItemEventProperties properties)

{

using (SPSite site = new SPSite(properties.WebUrl))

using (SPWeb web = site.OpenWeb())

{

SPList list = web.Lists[properties.ListId];

SPListItem item = list.GetItemByUniqueId(properties.ListItemId);

// Operate on item.

}

Good Coding Practice

Using SPItemEventProperties

C++

JScript

Copy

// Retrieve SPWeb and SPListItem from SPItemEventProperties instead of

// from a new instance of SPSite.

SPWeb web = properties.OpenWeb();

// Operate on SPWeb object.

SPListItem item = properties.ListItem;

// Operate on item.

If you do not apply this fix in your code, when you call Update on the new instance, you must invalidate it with the Invalidate method in the appropriate child class ofSPEventPropertiesBase (for example, SPItemEventProperties.InvalidateListItemor SPItemEventProperties.InvalidateWeb).

Working with Folders and Lists

When folders and lists grow in size, custom code that works with them needs to be designed in ways that optimize performance. Otherwise, your applications will run slowly and even cause timeouts to occur. The following recommendations for addressing performance concerns while working with large folders and lists are based on the test results reported in Steve Peschka's white paper, Working with Large Lists in Office SharePoint Server 2007.

Do not use SPList.Items.
SPList.Items selects all items from all subfolders, including all fields in the list. Use the following alternatives for each use case.

Retrieving all items in a list

Use SPList.GetItems(SPQuery query) instead. Apply filters, if appropriate, and specify only the fields you need to make the query more efficient. If the list contains more than 2,000 items, you will need to paginate the list in increments of no more than 2,000 items. The following code example shows how to paginate a large list.
Good Coding Practice
Retrieving Items with SPList.GetItems

C++

JScript

Copy

SPQuery query = new SPQuery();

SPListItemCollection spListItems ;

string lastItemIdOnPage = null; // Page position.

int itemCount = 2000

while (itemCount == 2000)

{

// Include only the fields you will use.

query.ViewFields = "";

query.RowLimit = 2000; // Only select the top 2000.

// Include items in subfolder (if necessary).

query.ViewAttributes = "Scope=\"Recursive\"";

StringBuilder sb = new StringBuilder();

// To make it order by ID and stop scanning the table, specify the OrderBy override attribute.

sb.Append("");

//.. Append more text as necessary ..

query.Query = sb.ToString();

// Get 2,000 more items.

SPListItemCollectionPosition pos = new SPListItemCollectionPosition(lastItemIdOnPage);

query.ListItemCollectionPosition = pos; //page info

spListItems = spList.GetItems(query);

lastItemIdOnPage = spListItems.ListItemCollectionPosition.PagingInfo;

// Code to enumerate the spListItems.

// If itemCount <2000, we finish the enumeration.

itemCount = spListItems.Count;

}

The following example shows how to enumerate and paginate a large list.

C++

JScript

Copy

SPWeb oWebsite = SPContext.Current.Web;

SPList oList = oWebsite.Lists["Announcements"];

SPQuery oQuery = new SPQuery();

oQuery.RowLimit = 10;

int intIndex = 1;

{

Response.Write("
Page: " + intIndex + "
");

SPListItemCollection collListItems = oList.GetItems(oQuery);

foreach (SPListItem oListItem in collListItems)

{

Response.Write(SPEncode.HtmlEncode(oListItem["Title"].ToString()) +"
");

}

oQuery.ListItemCollectionPosition = collListItems.ListItemCollectionPosition;

intIndex++;

} while (oQuery.ListItemCollectionPosition != null);

Getting items by identifier

Instead of using SPList.Items.GetItemById, useSPList.GetItemById(int id, string field1, params string[] fields). Specify the item identifier and the field that you want.

Do not enumerate entire SPList.Items collections or SPFolder.Files collections.

Accessing the methods and properties that are listed in the left column of the following table will enumerate the entire SPList.Items collection, and cause poor performance and throttling for large lists. Instead, use the alternatives listed in the right column.

Table 1. Alternatives to SPList.Items

Poor Performing Methods and Properties

SPList.Items.Count

SPList.Items.XmlDataSchema

SPList.Items.NumberOfFields

SPList.Items[System.Guid]

SPList.Items[System.Int32]

SPList.Items.GetItemById(System.Int32)

SPList.Items.ReorderItems(System.Boolean[],System.Int32[],System.Int32)

SPFolder.Files.Count

Better Performing Alternatives

SPList.ItemCount

Create an SPQuery object to retrieve only the items you want.

Create an SPQuery object (specifying the ViewFields) to retrieve only the items you want.

SPList.GetItemByUniqueId(System.Guid)

SPList.GetItemById(System.Int32)

Perform a paged query by using SPQuery and reorder the items within each page.

SPFolder.ItemCount

Note:

The SPList.ItemCount property is the recommended way to retrieve the number of items in a list. As a side effect of tuning this property for performance, however, the property can occasionally return unexpected results. If the precise number is required, you should use the poorer performing GetItems(SPQuery query), as shown in the preceding code example.

Use PortalSiteMapProvider (Microsoft Office SharePoint Server 2007 only).

Steve Peschka's white paper Working with Large Lists in Office SharePoint Server 2007 describes an efficient approach to retrieving list data in Office SharePoint Server 2007 by using the PortalSiteMapProvider class. PortalSiteMapProviderprovides an automatic caching infrastructure for retrieving list data. TheGetCachedListItemsByQuery method of PortalSiteMapProvider takes anSPQuery object as a parameter, and then checks its cache to determine whether the items already exist. If they do, the method returns the cached results. If not, it queries the list and stores the results in a cache. This approach works especially well when you are retrieving list data that does not change significantly over time. When data sets change frequently, the class incurs the performance cost of continually writing to the cache in addition to the costs of reading from the database. Consider that the PortalSiteMapProvider class uses the site collection object cache to store data. This cache has a default size of 100 MB. You can increase the size of this cache for each site collection on the object cache settings page for the site collection. But this memory is taken from the shared memory available to the application pool and can therefore affect the performance of other applications. Another significant limitation is that you cannot use the PortalSiteMapProvider class in applications based on Windows Forms. The following code example shows how to use this method.
Good Coding Practice
Using PortalSiteMap Provider

C++

JScript

Copy

// Get the current SPWeb object.

SPWeb curWeb = SPControl.GetContextWeb(HttpContext.Current);

// Create the query.

SPQuery curQry = new SPQuery();

curQry.Query = "'Expense_x0020_Category'/>

'Text'>Hotel";

// Create an instance of PortalSiteMapProvider.

PortalSiteMapProvider ps = PortalSiteMapProvider.WebSiteMapProvider;

PortalWebSiteMapNode pNode = ps.FindSiteMapNode(curWeb.ServerRelativeUrl) asPortalWebSiteMapNode;

// Retrieve the items.

SiteMapNodeCollection pItems = ps.GetCachedListItemsByQuery(pNode, "myListName_NotID", curQry, curWeb);

// Enumerate through all of the matches.

foreach (PortalListItemSiteMapNode pItem in pItems)

{

// Do something with each match.

}

Whenever possible, acquire a reference to a list by using the list's GUID or URL as a key.

You can retrieve an SPList object from the SPWeb.Lists property by using the list's GUID or display name as an indexer. Using SPWeb.Lists[GUID] andSPWeb.GetList(strURL) is always preferable to usingSPWeb.Lists[strDisplayName]. Using the GUID is preferable because it is unique, permanent, and requires only a single database lookup. The display name indexer retrieves the names of all the lists in the site and then does a string comparison with them. If you have a list URL instead of a GUID, you can use the

GetList

method to look up the list's GUID in the content database before retrieving the list.

Writing Applications That Scale to Large Numbers of Users

You might not be aware that you need to write your code to be scalable so that it can handle multiple users simultaneously. A good example is creating custom navigation information for all sites and subsites on each page or as part of a master page. If you have a SharePoint site on a corporate intranet and each department has its own site with many subsites, your code might resemble the following.

C++

JScript

Copy

public void GetNavigationInfoForAllSitesAndWebs()

{

foreach(SPSite oSPSite in SPContext.Current.Site.WebApplication.Sites)

{

try

{

SPWeb oSPWeb = oSPSite.RootWeb;

AddAllWebs(oSPWeb );

}

finally

{

oSPSite.Dispose();

}

C++

JScript

Copy

public void AddAllWebs(SPWeb oSPWeb)

{

foreach(SPWeb oSubWeb in oSPWeb.Webs)

{

try

{

//.. Code to add items ..

AddAllWebs(oSubWeb);

}

finally

{

if (oSubWeb != null)

oSubWeb.Dispose();

}

While the previous code disposes of objects properly, it still causes problems because the code iterates through the same lists over and over. For example, if you have 10 site collections and an average of 20 sites or subsites per site collection, you would iterate through the same code 200 times. For a small number of users this might not cause bad performance. But, as you add more users to the system, the problem gets worse, as shown in Table 2.

Table 2. Iterations increase as number of users increases

Users	Iterations
10	2000
50	10000
100	200000
250	500000

Although the code executes for each user that hits the system, the data remains the same for each user. The impact of this can vary depending on what the code is doing. In some cases, repeating code might not cause a performance problem; however, in the previous example the system must create a COM object (SPSite or SPWeb objects are created when retrieved from their collections), retrieve data from the object, and then dispose of the object for each item in the collection. This can have a significant impact on performance.

How to make this code more scalable or fine-tune it for a multiple user environment can be a hard question to answer. It depends on what the application is designed to do.

You should take the following into consideration when asking how to make code more scalable:

Is the data static (seldom changes), somewhat static (changes occasionally), or dynamic (changes constantly)?
Is the data the same for all users, or does it change? For example, does it change depending on the user who is logged on, the part of the site being accessed, or the time of year (seasonal information)?
Is the data easily accessible or does it require a long time to return the data? For example, is it returning from a long-running database query or from remote databases that can have some network latency in the data transfers?
Is the data public or does it require a higher level of security?
What is the size of the data?
Is the SharePoint site on a single server or on a server farm?

How you answer the previous questions will determine in which of several ways you can make your code more scalable and handle multiple users. The intent of this article is not to provide answers for all of the questions or scenarios but to provide a few ideas that you can apply to your specific needs. The following sections offer areas for your consideration.

Caching Raw Data

You can cache your data by using the System.Web.Caching.Cache object. This object requires that you query the data one time and store it in the cache for access by other users.

If your data is static, you can set up the cache to load the data only one time and not expire until the application is restarted, or to load the data once per day to ensure data freshness. You can create the cache item when the application starts, when the first user session starts, or when the first user tries to access that data.

If your data is somewhat static, you can set up the cached items to expire within a certain number of seconds, minutes, or hours after the data is created. This enables you to refresh your data within a timeframe that is acceptable to your users. Even if the data is cached for only 30 seconds, under heavy loads you will still see improved performance because you are running the code only one time every 30 seconds instead of multiple times per second for each user who hits the system.

Security trimming is another issue to consider whenever you cache data. For example, if you cache items as you iterate through a list, you may get only a subset of the data (the data that the current user can see), or if you use a DataTable object to cache all of the items in a list, you have no easy way of applying security trimming to users who belong to groups that can see only a subset of the data. For more information about storing security trimmed data in caches, see the CrossListQueryCache class.

In addition, ensure you consider the issues described earlier in Caching Data and Objects.

Building Data Before Displaying It

Think about how your cached data will be used. If this data is used to make run-time decisions, putting it into a DataSet or DataTable object might be the best way to store it. You can then query those objects for the data to make run-time decisions. If the data is being used to display a list, table, or formatted page to the user, consider building a display object and storing that object in the cache. At run time, you need only retrieve the object from the cache and call its render function to display its contents. You could also store the rendered output; however, this can lead to security issues and the cached item could be quite large, causing increased page swapping or memory fragmentation.

Caching For a Single Server or Server Farm

Depending on how you set up your SharePoint site, you might have to address certain caching issues differently. If your data must be the same on all servers at all times, then you must ensure that the same data is cached on each server.

One way to ensure this is to create the cached data and store it on a common server or in a Microsoft SQL Server database. Again, you must consider how much time it takes to access the data and what security issues can arise from storing the data on a common server.

You can also create business-layer objects that cache data on a common sever, and then access that data by using various interprocess communications that are available in networking objects or APIs.

Using SPQuery Objects

SPQuery objects can cause performance problems whenever they return large result sets. The following suggestions will help you optimize your code so that performance will not suffer greatly whenever your searches return large numbers of items.

Do not use an unbounded SPQuery object.

An SPQuery object without a value for RowLimit will perform poorly and fail on large lists. Specify a RowLimit between 1 and 2000 and, if necessary, page through the list.
Use indexed fields.

If you query on a field that is not indexed, the query will be blocked whenever it would result in a scan of more items than the query threshold (as soon as there are more items in the list than are specified in the query threshold). SetSPQuery.RowLimit to a value that is less than the query threshold.
If you know the URL of your list item and want to query by FileRef, useSPWeb.GetListItem(string strUrl, string field1, params string[] fields) instead.

How to create Sharepoint 2010 Modal Dialog Pop up ( Popup with Faded Background )

2011-12-10T12:01:00.002+05:30

Many a times we have a requirement like we need to open a Pop-up with the Faded Background. Sharepoint 2010 has provided us a very simple way to achieve this.

Below is the JavaScript with the help of which we can open a Modal Dailog Pop Up of Sharepoint 2010.

function OpenDialog(URL) {

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

NewPopUp.url = URL;

NewPopUp.width = 700;

NewPopUp.height = 350;

SP.UI.ModalDialog.showModalDialog(NewPopUp);

}

</script>

Call the Javascript on Button click and the modal PopUp will pops up with the Page of Specified URL.

btnOpenPopUp.Attributes.Add("onClick", "javascript:OpenDialog(‘/_layouts/MyAppPage/MyPage.aspx’);");

Management of Master Lists in SharePoint with Choice Filter Lookup column

2011-11-19T14:48:00.001+05:30

Almost every SharePoint project needs Lookup column. To create each lookup column we need to create separate list. If a requirement comes where developer needs to use master lists for different data then developer needs to create multiple lists which is resource consuming and maintaining multiple list also extra effort required for developer and administrator also. For this type of requirement I have created Choice Filter Lookup column. User can create one choice column in Master list and filter lookup column based on that choice column.

You can download the Source code from here

Current Scenario

MasterList1

MasterList2

MasterList3

MasterList4

MasterConsumerList New or Edit Form

MasterConsumerList View

Now above screen shot shows the real or actual implementation of requirements which generally SharePoint developers and Administrator follow for creating relationship of multiple caregory and reusability.If user want to add one more lookup column then user needs to create one more list for the lookup. The only problem is with above implementation is that it is creating multiple lists which increase the resource utilization and maintainbilty. Now I have tried to resolve the above implementation by creating Choice Lookup filter column. Please refer below screen shots for same implemetation with Choice Lookup filter

ConsolidateMasterList and ConsolidateMasterListConsumer shows 2 new list for same implementation mentioned above

Consolidated Master List (with new column Category as Choice column with Values {Master1, Master2, Master3, Master4} for differentiate values or for filter values based on category)

Create Column of Choice Filter lookup column (Choose your filter category from the dropdown)

List Settings view after adding 4 choice filter lookup column

Consolidated Consumer New or Edit Form

Consolidated Consumer List View 2MasterConsumerList View

Happy Coding !!!!!!!!!

Add Custom Property Panel in Custom WebPart like OOB SharePoint Property Panel via Reflection

2011-11-08T13:42:00.001+05:30

Sometime we have a requirement to create custom property in WebPart. But the custom Property will add in “Miscellaneous” section or added in blank section if we add property via custom tool part. Now if you want to create panel like OOB Panel “Layout, Appearance etc.” then use below method.

Below class is static class for enabling extension method on ToolPart class. You need to add below class in your solution and add namespace in your toolpart class where you want to use this method

namespace ExtensionMethods

{

public static class CustomExtensions

{

public static Panel GetPropertyPanel(this ToolPart currentToolPart, Table table, String sTitle)

{

Panel controlPanel = new Panel();

controlPanel.ID = "propertyPanelHideDisplay";

controlPanel.Attributes.Add("id", currentToolPart.ClientID + "_" + controlPanel.ID);

controlPanel.Controls.Add(table);

Literal lt = new Literal();

String sScript = "<script language='javascript'>\n" +

" var objDiv = document.getElementById('" + currentToolPart.ClientID + "_" + controlPanel.ID + "');\n" +

" objDiv.parentNode.parentNode.parentNode.attributes.removeNamedItem('colspan');\n" +

" objDiv.parentNode.parentNode.parentNode.attributes.removeNamedItem('class'); \n" +

"</script>";

lt.Text = sScript;

controlPanel.Controls.Add(lt);

Type type = typeof(SPSite);

Assembly assembly = type.Assembly;

var bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

Panel propertyPanel = (Panel)assembly.CreateInstance("Microsoft.SharePoint.WebPartPages.TPPanel", false, bindingFlags, null,

new object[] { sTitle, controlPanel, true }, null, null);

return propertyPanel;

}

Below is the sample class for ToolPart for adding Panel by using above class

using ExtensionMethods;

namespace CustomNameSpace

{

class CustomToolpart : ToolPart

{

private DropDownList ddlDisplayType;

protected override void CreateChildControls()

{

base.CreateChildControls();

CreateControls();

}

public override void ApplyChanges()

{

EnsureChildControls();

SendDataToWebPart();

}

private void SendDataToWebPart()

{

EnsureChildControls();

CustomWebPart customWebPart = (CustomWebPart)this.ParentToolPane.SelectedWebPart;

// Send the custom text to the Web Part.

if (ddlDisplayType != null)

{

customWebPart.Property = ddlDisplayType.SelectedValue;

}

public override void SyncChanges()

{

base.SyncChanges();

}

private void SetValues()

{

ListItem item = null;

CustomWebPart customWebPart = (CustomWebPart)this.ParentToolPane.SelectedWebPart;

if (!string.IsNullOrEmpty(customWebPart.Property))

{

item = ddlDisplayType.Items.FindByValue(customWebPart.Property);

if (item != null)

{

ddlDisplayType.SelectedValue = item.Value;

}

public override void CancelChanges()

{

base.CancelChanges();

}

protected override void RenderToolPart(System.Web.UI.HtmlTextWriter output)

{

base.RenderToolPart(output);

}

public void CreateControls()

{

ddlDisplayType = new DropDownList();

ddlDisplayType.Items.Add("Property 1");

ddlDisplayType.Items.Add("Property 2");

ddlDisplayType.Items.Add("Property 3");

AddControls();

SetValues();

}

private void AddControls()

{

Table table = new Table();

TableRow tr = new TableRow();

TableCell td = new TableCell();

Literal ltStatic = new Literal();

ltStatic.Text = "Custom Property";

td.Controls.Add(ltStatic);

tr.Cells.Add(td);

table.Rows.Add(tr);

tr = new TableRow();

td = new TableCell();

td.Controls.Add(ddlDisplayType);

tr.Cells.Add(td);

table.Rows.Add(tr);

String sTitle = "Panel Title";

this.Controls.Add(this.GetPropertyPanel(table, sTitle));

}

In above class bold line will return Panel and add the Panel in ToolPart Pane. Below is the screen shot for the above implementation

Hope it help !!!!

Display Unsupported Browser Error via OOB control in SharePoint

2011-10-17T20:23:00.000+05:30

SharePoint 2010 will support many major browsers including IE7, IE8, FF3.5 and Safari4, but there is one browser that will not be supported by the out of the box SharePoint 2010 experience: Internet Explorer 6!

How can we handle this gracefully? Microsoft again comes to the rescue with a SharePoint Control to help.

<SharePoint:WarnOnUnsupportedBrowsers runat="server"/>

If you place this control at the bottom of your master page, IE6 users will be greeted with a message like this:

Happy Coding !!!!!

SPChangeQuery Class in SharePoint

2011-10-11T18:17:00.000+05:30

Gets the changes to the list from the change log as filtered by the specified query.

using (SPSite siteCollection = new SPSite("http://localhost"))
         {
            using (SPWeb webSite = siteCollection.OpenWeb())
            {
               // Get a list.
               SPList list = webSite.Lists[0];

               // Construct a query.
               SPChangeQuery query = new SPChangeQuery(false,  // limit object types
                                                       false); // limit change types

               // Specify the object type. 
               query.Item = true;

               // Specify change types. 
               query.Add = true;
               query.Delete = true;
               query.Update = true;

               SPTimeZone timeZone = webSite.RegionalSettings.TimeZone;
               int total = 0;

               // Loop until we reach the end of the log.
               while (true)
               {
                  SPChangeCollection changes = list.GetChanges(query);

                  total += changes.Count;

                  // Print info about each change to the console.
                  foreach (SPChangeItem change in changes)
                  {
                     // Get the item name.
                     string itemName = String.Empty;
                     SPListItem item = null;
                     try
                     {
                        item = list.GetItemByUniqueId(change.UniqueId);
                        itemName = item.Name;
                     }
                     catch (ArgumentException)
                     {
                        itemName = "Unknown";
                     }

                     Console.WriteLine("\nDate: {0}",
                         timeZone.UTCToLocalTime(change.Time).ToString());
                     Console.WriteLine("Change: {0}", change.ChangeType);
                     Console.WriteLine("Item: {0}", itemName);

                  }

                  // Break out of loop if we have the last batch.
                  if (changes.Count < query.FetchLimit)
                     break;

                  // Otherwise, go get another batch.
                  query.ChangeTokenStart = changes.LastChangeToken;
               }

               Console.WriteLine("\nTotal of {0} changes to {1} list", total, list.Title);
            }
         }
         Console.Write("\nPress ENTER to continue...");
         Console.ReadLine();

Migrate SharePoint List Data to Document Library without changing the Created and Modified Date

2011-09-29T10:56:00.000+05:30

SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite site = new SPSite("http://br-pc-203/"))
{
SPList customList = site.RootWeb.Lists["Custom List"];
SPList documentLibrary = site.RootWeb.Lists["Document Library"];
SPFolder folder = site.RootWeb.Folders[documentLibrary.Title];
SPFileCollection fileCollection = null;
foreach (SPListItem ltItem in customList.Items)
{
if (ltItem.Attachments != null && ltItem.Attachments.Count > 0)
{
foreach (String sFilename in ltItem.Attachments)
{
fileCollection = folder.Files;
SPListItem docItem = documentLibrary.Items.Add();
SPFile attachmentFile = ltItem.ParentList.ParentWeb.GetFile(ltItem.Attachments.UrlPrefix + sFilename);

string destFile = fileCollection.Folder.Url + "/" + attachmentFile.Name;
byte[] fileData = attachmentFile.OpenBinary();

SPFile addedFile = fileCollection.Add(destFile, fileData, site.RootWeb.CurrentUser, site.RootWeb.CurrentUser, Convert.ToDateTime(ltItem[SPBuiltInFieldId.Created]), Convert.ToDateTime(ltItem[SPBuiltInFieldId.Modified]));
SPListItem item = addedFile.Item;
item[SPBuiltInFieldId.Created] = Convert.ToDateTime(ltItem[SPBuiltInFieldId.Created]);
item[SPBuiltInFieldId.Modified] = Convert.ToDateTime(ltItem[SPBuiltInFieldId.Modified]);
addedFile.Item.Update();
}

}
}
}
});

OOB Redirect Page for Display and Edit form of ListItem : COPYUTIL.ASPX provided by SharePoint

2011-09-18T20:49:00.000+05:30

To navigate to a SharePoint list item or document, when you only got the ID's of the item, the item's container (list or document library) and the item's web? I sure did! For example when you query SharePoint data by making use of the SPSiteDataQuery class; the resulting data table includes all those ID's (and additional properties if you want), but it doesn't include a link back to the item. You could make use of the Object Model to build the link in code, but that is both resource intensive and pretty complex. In that case you have to check out the CopyUtil.aspx page, which is also used by the Content Query Web Part by the way. The CopyUtil.aspx page is an application page to which you can provide a bunch of ID's, as a result the page will redirect you to the corresponding item or document.

You just have to build a URL like this (replace the X's with the actual ID's of course):

http://yoursite/_layouts/CopyUtil.aspx?Use=id&Action=dispform&ItemId=X&ListId=X&WebId=X&SiteId=X

And the CopyUtil.aspx page will do the rest!

Action = "dispform" or Action = "editform"

List filter with URL values SharePoin

2011-09-17T10:48:00.002+05:30

Did you know that you easily can filter your Sharepoint list or library with values in your URL? This means that you can create a “view” without really creating a view. To spice up your GUI you can for instance insert some graphical boxes above your document library view that filters with URL values. Last, but not least, you can use this method to filter the content of all web parts on a page, you are not limited to filter a view in a document library (after all, a view is just a web part on a .aspx page). You can filter on a built-in column, or a column you have created yourself.

Example:

Here I have created a couple of links in the Qiuck Launch. The url for the first link could be:

/Forms/AllItems.aspx?FilterField1=_ModerationStatus&FilterValue1=2

I used a built in column (you will have to use the internal column name) in this example, if you use your own column you just use your columns initial name and the plain value. The filter sign next to the column name shows that you have made a regular filtering of the column. Ofcourse you can filter on multiple values and columns, I guess you can figure that out for yourself:)

How do I know that “2″ equals “pending”? Apply the filter manually and check out the URL, you’ll se both the internal column name and the correct value to filter on.

In other words, adding the following code to your URL makes your URL-filtering day in Sharepoint:

?FilterField1=ColumnName&FilterValue1=ValueToFilterOn

Reset the Farm Passphrase in SharePoint 2010

2011-09-10T11:53:00.000+05:30

Adding a new server to the farm and you can’t remember that new SharePoint 2010 addition called the Farm Passphrase? No problem! You can use PowerShell to reset / change that forgotten farm passphrase. Note that I said reset and not retrieve. There is currently no option to retrieve the existing farm passphrase.

Must be a member of the SharePoint_Shell_Access database role on the SharePoint Configuration database. Check Get-SPShellAdmin and Add-SPShellAdmin.
Open the SharePoint 2010 Management Shell (Start > All Programs > Microsoft SharePoint 2010 Products > SharePoint 2010 Management Shell)
Enter this at the PowerShell prompt:
- $passphrase = ConvertTo-SecureString -asPlainText -Force
Input the new passphrase and hit Enter
Enter this at the PowerShell prompt:
- Set-SPPassPhrase -PassPhrase $passphrase -Confirm
You will be asked to confirm the passphrase by re-entering it
Re-enter the passphrase and hit Enter
You will be asked if you are sure that you want to perform this action, type Y (for Yes) and hit Enter
Your farm passphrase has now been reset!

Designing pages for quicker downloads (Page Optimization in SharePoint)

2011-08-10T09:40:00.000+05:30

In an environment with limited network capacity, streamline your pages and make them as small and responsive as possible. There are different techniques to do this, most of which are not specific to SharePoint Products and Technologies. The general methods can be used on any Web site are not be discussed in great detail in this section. Instead, the section focuses on understanding the features included in SharePoint Products and Technologies, what is included in the page, and ways in which you can speed up the initial visit to a SharePoint site.

Page elements

A page on a SharePoint site consists of several unique elements, as shown in the following figure.

When the page is rendered, it brings together the master page, the layout page, and content for the page. The page content includes the values for each of the page fields, but also a number of other elements such as the theme, style sheets, images, and navigation. The following table shows an example of the files and streams that are present in a single page from a SharePoint site. This example is a capture of all the HTTP requests that were made on an initial visit to the default home page of a collaboration portal site.

URL	Size (bytes)
http://myServer/_layouts/images/topnavhover.gif	96
http://myServer/Pages/Default.aspx	1656
http://myServer/Pages/Default.aspx	1539
http://myServer/Pages/Default.aspx	66084
http://myServer/_layouts/1033/styles/controls.css?rev=EhwiQKSLiI%2F4dGDs6DyUdQ%3D%3D	1448
http://myServer/_layouts/1033/styles/HtmlEditorCustomStyles.css?rev=8SKxtNx33FmoDhbbfB27UA%3D%3D	642
http://myServer/_layouts/1033/styles/HtmlEditorTableFormats.css?rev=guYGdUBUxQit03E2jhSdvA%3D%3D	1317
http://myServer/_layouts/1033/styles/core.css?rev=5msmprmeONfN6lJ3wtbAlA%3D%3D	13596
http://myServer/_layouts/1033/init.js?rev=VhAxGc3rkK79RM90tibDzw%3D%3D	15732
http://myServer/_layouts/1033/core.js?rev=F8pbQQxa4zefcW%2BW9E5g8w%3D%3D	54367
http://myServer/_layouts/portal.js?rev=INhSs9mWTnUTqdwwIXYMaQ%3D%3D	954
http://myServer/_layouts/1033/ie55up.js?rev=Ni7%2Fj2ZV%2FzCvd09XYSSWvA%3D%3D	20508
http://myServer/_layouts/1033/search.js?rev=yqBjpvg%2Foi3KG5XVf%2FStmA%3D%3D	5092
http://myServer/_layouts/1033/EditingMenu.js?rev=eh0f0CwzvHQ7Ii0JvdsIjQ%3D%3D	2735
http://myServer/WebResource.axd?d=__WrA1TRLicJgwGEmYKqSA2&t=633214754549731034	5383
http://myServer/WebResource.axd?d=h_u9v0Coj_eDqsvEkDrdtw2&t=633214754549731034	8258
http://myServer/_layouts/images/blank.gif	43
http://myServer/_layouts/images/helpicon.gif	1025
http://myServer/_layouts/images/Menu1.gif	68
http://myServer/_layouts/images/titlegraphic.gif	1299
http://myServer/_layouts/images/gosearch.gif	19933
http://myServer/WebResource.axd?d=puevA5kEAx44yxozBd-hspPZ9eA51Rh9u95VwVGLFCc1&t=633214754549731034	224
http://myServer/WebResource.axd?d=wyTuS1folQ6wX2Tc_7NOOaeElHHqL6rtdeAeRRUR36s1&t=633214754549731034	218
http://myServer/_layouts/images/whitearrow.gif	68
http://myServer/_layouts/images/recycbin.gif	1004
http://myServer/PublishingImages/newsarticleimage.jpg	10710
http://myServer/_layouts/images/icongo01.gif	1171
http://myServer/_layouts/images/menudark.gif	68
http://myServer/_layouts/images/topnavhover.gif	96

Note the following:

· A total of 29 requests were required to download the page.

· The total page size was 235 kilobytes (KB).

· This represents the initial page load; almost all of the items in the request have a caching directive that instructs the browser not to load them again for one year. The second and subsequent page loads produce only three requests. Of those, two are part of the NTLM negotiation that occurs, so only one item is actually downloaded—the HTML for the page.

· The default IIS Compression level 0 was used, which is the least amount of compression possible. Additional compression would result in even smaller download sizes.

· Of the different file types loaded, there were:

· 4.axd resource requests

· 4.css resource requests

· 12 image resource requests

· 6.js resource requests (several of which were duplicates)

· 3 page resource requests for default.aspx (two of which are part of the NTLM negotiation)

Most of these file types are fairly obvious, with the possible exception being the.axd resource type. An.axd resource is part of a new feature in ASP.NET version 2.0. A developer can add a resource, such as script file or style sheet, to a control. In the control, the developer uses the ClientScript class to include a method called GetWebResourceUrl. When the control is rendered at runtime, it dynamically generates a URL for the resource. The resource itself is compiled into the control assembly, so this methodology provides a way to stream that resource out of the assembly and down to the client just as if it were a separate file located on the Web server.

Knowing the resource requests used by the page can help you understand where and how optimizations can be applied. You can measure this kind of information by using a variety of different tools and techniques. For this article, a freeware tool called Fiddler (http://go.microsoft.com/fwlink/?LinkId=108593&clcid=0x409) was used. Fiddler can be run on a client workstation and tracks all of the HTTP requests being made for a page. It then displays the results in a grid.

As you change your site to optimize it, test it with Fiddler. To get the most accurate idea of what items are being requested, what items are being cached, and the size of each item:

1. Delete all of your browser's temporary files.

2. Start Fiddler.

3. Request your page.

Note:

Be sure that you request the page by clicking a link. If you just click the Refresh button, the system automatically requests items again and won't accurately reflect any optimization changes that have been made.

Optimizing Page Downloads

After you understand the composition of the page, you can use different methods to optimize the download experience for that page. In general, the goal is to minimize the number of round trips between client computers and server computers and to reduce the amount of data that goes over the network. The guidance in this article includes recommendations that can be applied broadly to a variety of different implementations of SharePoint Products and Technologies.

There is an important distinction to remember when reviewing these recommendations and when reviewing any other custom optimizations that you might develop. You categorize page optimization techniques into one of two categories: first page request and subsequent page request. Optimizations for the first page request are those kinds of optimizations that are implemented the first time the page is requested, but that don't necessarily affect subsequent page requests. Subsequent page request optimizations are those that can improve the user experience whether it is the first time a user requests the page or the fiftieth time. The key is that you need to balance loss in functionality against the gain achieved. If gain is only realized the first time a user hits a site, the optimization might not be worth the loss in functionality.

BLOB cache

The binary large object (BLOB) cache is discussed in more detail later in this article. In short, it can be used to apply cache directives to items on a page that are stored in SharePoint Products and Technologies. If those cache directives are included, the browser won't try to download those items again until the cached item expires. As was illustrated with the previous home page example, almost all of the items included in the default home page for the Collaboration Portal site template had a caching directive associated with them, which is why they were not requested on subsequent page hits.

64-bit hardware

Hardware choices in the farm can affect the latency of requests as well. 32-bit systems have a memory limit of 2 gigabytes (GB) of RAM per application. Although you can extend application support to 3 GB of RAM, SharePoint Products and Technologies do not support using the /3GB switch. Low memory situations can negatively affect the request latency in the following ways:

· If the amount of memory becomes constrained, it can cause the SharePoint application pool to recycle. That forces the ASP.NET application domain to recycle as well, which can cause a long delay in responding to user requests.

· Out-of-memory errors can cause the BLOB cache to stop serving content.

By using 64-bit hardware, you can ensure that you can allocate and use enough RAM to prevent these errors.

Web garden settings

Web garden settings can also inadvertently cause the BLOB cache to work inconsistently. Because only one process can acquire the lock necessary to manage the cache, successful use the cache depends on which thread services a request. If a Web garden that does not have the BLOB cache lock services a request, the content it sends in response will not have caching directives associated with it. That increases both the number of requests and the amount of the data sent over the network. Therefore, if you intend to use the BLOB cache, you should not use Web gardens.

Minimize secured items on the page

When a user authenticates to SharePoint Products and Technologies, two things happen. First, the system validates credentials to determine who the user is. Second, the role provider enumerates the list of SharePoint groups to which the user belongs. Each time a page is requested, the role provider is called again to enumerate all of the groups to which the user belongs.

However, this call for group membership can happen multiple times on a single page. For example, the default Collaboration Portal site template page requires two calls to the role provider when you go to the home page—one for the page itself and one for the image on the page. Each image that is stored in a SharePoint library and is on the page will force an additional call to the role provider to verify permissions, even if all of the images are stored in the same image library. That verification occurs whether the images are added as fields on the page—that is, part of the page's content—or whether they are added to the master page for the site.

A site developed for a limited bandwidth or high latency environment should be designed to minimize the number of images used on the page. Many sites use several images as part of the master page to create different visual effects. Because the latency will increase with the increased number of security checks, design sites for these environments by using as few images as possible.

Minimizing the number and size of images

As described in the previous section, you should minimize the number of images in your site. To help with that effort, you can embed multiple images in a single file and then reference individual images in your page. Not only will file download size decrease, but fewer files result in less network traffic. It is more complicated to author pages by using this technique, but in situations where every round trip and file size counts, it can prove to be valuable way to help improve performance.

The following figure shows how this image is subsequently changed to display as individual pictures in a table.

Manipulation of the images was done entirely through style sheet classes. There were two primary classes used in div and img elements in each table cell. Those classes are as follows:

.cluster {

height:50px;

position:relative;

width:50px;

}

.cluster img {

position:absolute;

}

Each image has a class associated with it based on the identifier (ID) for the image. That style clips the picture and defines an offset from the initial picture in the cluster. Those classes are as follows:

#person {

border:none;

clip:rect(0, 49, 49, 0);

}

#keys {

clip:rect(0, 99, 49, 50);

left:-50px;

}

#people {

clip: rect(0, 149, 49, 100);

left:-100px;

}

#lock {

clip:rect(0, 199, 49, 150);

left:-150px;

}

#phone {

clip:rect(0,249, 49, 200);

left:-200px;

}

#question {

clip:rect(0, 299, 49, 250);

left:-250px;

}

The HTML for the table includes the div and img tags with the appropriate ID values and class names, as follows:

<tr>

</tr>

<tr>

</tr>

</table>

Multiple Microsoft Web properties and products now use this technique, including the Microsoft Passport Network and Microsoft Office Outlook Web Access (OWA). The MSN team has conducted some performance tests to analyze the impact of the changes and has seen a load time improvement for the first page of 50 to 75 percent.

There is an important point to consider if you are authoring your pages in Microsoft Office SharePoint Designer 2007. When you create a new page in Office SharePoint Designer 2007, it automatically adds the following XHTML schema markup to the page:

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

It then adds this namespace to the HTML element:

If you use this schema, the images will not line up correctly. You must remove the xmlns attribute from the HTML tag in order to make the images appear as intended.

Delay downloading core.js

The main client script file included with Office SharePoint Server 2007 is called core.js. It is the largest script file at approximately 257 KB uncompressed, and approximately 54 KB compressed. In certain situations, you may be able to delay the downloading of core.js. When you do that, the page renders more quickly because the core.js file does not start downloading until the page has been opened in the browser. That enables the user to view the page and start reading the content sooner. This technique is most useful in an Internet scenario with anonymous users. Conversely, authenticated users need to have core.js downloaded at page load time for such functionality or UI elements as the Site Actions menu.

You can use the following steps to implement this technique.

1. Create a custom layout page that doesn't use core.js. This layout page will be used with the home page so initial visitors to the site will not have to wait for core.js to download immediately. It needs to be compatible with the existing home page, so the new layout page should be have the same associated content type as the layout page currently in use.

Note:

By default, in a Collaboration Portal site, the Welcome Page content type is specified.

2. Add the following tag to the page: <SharePointWebControls:ScriptLink runat="server"/>. This instructs the system to not use core.js unless it is referenced.

3. Create a custom control to check for authenticated users. The control will be very simple, and essentially contains the following code (shown in C#):

if (HttpContext.Current.Request.IsAuthenticated) Microsoft.SharePoint.WebControls.ScriptLink.RegisterCore(this.Page, true);

4. On each Web server, put the control in the Global Assembly Cache (GAC), and then add a SafeControl entry for it in the Web.config file for the Web application in which it will be used.

5. Add the custom control to the custom layout page created in step 1.

6. Add an IFRAME to the layout page. It should reference a page that has the following content:

<body> <SharePoint:ScriptLink name="core.js" runat="server" /> <script language="javascript"> DisableRefreshOnFocus(); </script> </body>

7. Check in the custom layout page and publish it.

8. Base the home page for the site on the new layout page.

After you perform the preceding steps, test the home page for the site to verify that it works. A first-time anonymous user should not see a reference to core.js in the page source, but it should end up in browser cache.

Additionally, consider the following before employing this technique:

· The site master page and the system master page must be different; otherwise, all pages in _layouts would not work right.

· Ensure that the master page doesn't contain any controls that require core.js at load time to work.

· Ensure that the master page doesn't have any ScriptLink controls that load or reference core.js.

For additional details and sample code, see the Microsoft Enterprise Content Management (ECM) Team Blog (http://go.microsoft.com/fwlink/?LinkId=106008&clcid=0x409).

Optimizing list view pages

The Microsoft Services team has worked to quantify and improve the performance of list view page rendering times. A list view page is the AllItems.aspx page that is used by each list and library to enable browsing of content. The rendering time of that page can vary widely based on how many columns are visible in the view and what format they are. For example, display options and enabling presence icons can greatly affect rendering time. Group Collapsed took significantly longer than Group Expanded to render, and both of those were slower than no grouping at all.

These sorts of nuances are why it's important to carefully consider how views are constructed in list view pages, especially over slow network links. When working with lists that contain a lot of data, it's important to carefully tailor all views, especially the default view. In general, you can speed up the rendering time of list view pages by:

· Showing fewer columns.

· Excluding any columns that include presences information.

· Using a link (but no edit menu) to view the item details.

The following table describes customizations that reduce the time required for a view to render.

Item	Description
View type	Create a view as a datasheet view instead of a standard view.
View: Item Limit	Anything over 1,000 will likely render slowly. Over a slow connection it's important to experiment to find the right balance between the quantity of data shown at a time and the number of round trips necessary to view all the data. The more rows that are shown at a time, the fewer round trips, but larger pages.
View: Filter	Use [Today] and [Me] to filter items by freshness or assignment. Use Status fields to show only active items in default views.
View: Columns	Use as few columns as necessary. Create a default view with few columns that allows high-level browsing after which people can drill down.

The following table describes customizations that will increase the time required for a view to render. Each additional column increases rendering time by a slight amount: up to a half-second per column over a fast network connection for a list of 1,000 items. Some columns cost more, as noted in the table.

Item	Description
Group By	Grouping adds HTML and JScript, slowing down rendering for large lists. Making all groups collapsed by default actually increases rendering time further because of additional operations on the browser object model.
Column – title linked to item with edit menu	The option "linked to item with edit menu" takes the longest; the similar option "linked to item" does not increase rendering time noticeably.
Column – Lookup User with Presence	Adding a user lookup field with presence adds HTML for each link to open the presence menu. In addition it also uses bandwidth to determine presence availability.

The following table describes customizations that have a relatively small impact on the time required for a view to render.

Item	Description
Sort, Totals	Applying multiple sorts and totals will increase the rendering time by a noticeable amount, but each one typically costs less than a second for a list of 1,000 items.

Relevant Documents WebPart in SharePoint 2010

2011-08-08T22:16:00.000+05:30

SharePoint 2010 has introduced new webpart named "Relevant Documents". Sometimes we have a scenario where we need to show all those document which is checked out to me from the site or we need to show all those document which last modified or created by me. This webpart is not part of MOSS 2007 so lots of users who are in new in SharePoint 2010 does not know about this webpart. My this post will show how to configure this webpart.

Step 1. Add Relevant Documents webpart in your page

Step 2: Edit the WebPart

Step 3: Click on the properties which you want to include in the result

Results:

Done !!!

Happy Coding !!!!!

Add Custom word in Spell Checker Dictionary for Site Collection

2011-08-07T19:34:00.000+05:30

Add Custom word in Spell Checker Dictionary for Site Collection
To create a custom dictionary to supplement the dictionaries included in SharePoint,
1. Create a document library named “Spelling” in the top-level site of your portal’s site collection.
2. Create "Custom Dictionary.txt" on your desktop.
3. Add desired word(s) on new line and Save the file
4. Upload a text file named “Custom Dictionary.txt”.

Note:
1. Only one Custom Dictionary.txt file is supported for a site collection.
2. Words of any language supported by your site can be added to the Custom Dictionary.txt file.

Done !!!

Export a SharePoint Designer workflow to Visual Studio in SharePoint 2010

2011-08-07T15:15:00.000+05:30

Common situation when designing workflow is that you start to design workflow in SharePoint Designer and then you want to add some code in Visual Studio.

In the following example, I will go through the procedure to create a workflow in SharePoint Designer and then open it and deploy it from Visual Studio.

Let’s start by creating a reusable workflow in SharePoint Designer

Enter the workflow information

and then just implement one step to set the document status to approve:

Next, in order to be able to reuse it in all the sites from site collection in SharePoint, publish the workflow globally:

Save the workflow and then Save it as a template :

You should see the confirmation :

Now, if you go to the Site Library, you will see this:

Save the .wsp localy and then, open Visual Studio and choose to import a workflow:

You can deploy it as a sandbox:

and select your .wsp and all the elements included in the .wsp:

Wait for importation to be completed:

Then deploy the solution:

If you have already saved it in SharePoint Designer, you will have a conflict and see this:

Just select Resolve Automatically to delete the workflow deployed by SharePoint Designer.

From the website, you should now see that the feature corresponding to this workflow is activated:

Then add the workflow on a document library:

Then, start a workflow on a document:

Custom Sequential Approval Workflow via Visual Studio 2010

2011-08-07T02:05:00.000+05:30

My 3rd and most important contribution to Codeplex. Recently I need to work on some custom approval workflow. I didn’t get much help on net on Workflows. So I have create Custom Sequential Approval Workflow via Visual Studio 2010 and thought its nice to contribute on codeplex with that project which can help everyone, following are the screen shots of the workflow. Download Source Code

Upload Document in Document Library

Check Workflow column is In Process

Task is created in Task List

Click on Task will open the OOB Approval form Popup

Check Task list , Task is Approved and Completed

Check Workflow Status its Completed

Happy Coding !!!!!

SharePoint Escape Characters

2011-08-07T02:04:00.000+05:30

How sharepoint handles escape characters? Sharepoint internally replace escape character with some code like, if you are creating field with space in that name e.g. “my column” then sharepoint replace space with _x0020_ e.g “my_x0020_column”.
Following are the complete escape characters and their code in Sharepoint.

Blank space: _x0020_
Underscore: _x002d_
Dash: _x0027_

Here is the Format:

_x00[the escape code]_

Char Code

[space] 20
3E
# 23
% 25
{ 7B
} 7D
| 7C
\ 5C
^ 5E
~ 7E
[ 5B
] 5D
` 60
; 3B
/ 2F
? 3F
: 3A
@ 40
= 3D
& 26
$ 24

public static String GetFieldNamebyEscapeCharacter(String sName)

{

String sReturn = sName;

String sChar = "_x00{0}_";

sReturn = sReturn.Replace("_", String.Format(sChar, "2d"));

sReturn = sReturn.Replace(" ", String.Format(sChar, "20"));

sReturn = sReturn.Replace("-", String.Format(sChar, "27"));

sReturn = sReturn.Replace("#", String.Format(sChar, "23"));

sReturn = sReturn.Replace("%", String.Format(sChar, "25"));

sReturn = sReturn.Replace("{", String.Format(sChar, "7B"));

sReturn = sReturn.Replace("}", String.Format(sChar, "7D"));

sReturn = sReturn.Replace("|", String.Format(sChar, "7C"));

sReturn = sReturn.Replace("\\", String.Format(sChar, "5C"));

sReturn = sReturn.Replace("^", String.Format(sChar, "5E"));

sReturn = sReturn.Replace("~", String.Format(sChar, "7E"));

sReturn = sReturn.Replace("[", String.Format(sChar, "5B"));

sReturn = sReturn.Replace("]", String.Format(sChar, "5D"));

sReturn = sReturn.Replace("`", String.Format(sChar, "60"));

sReturn = sReturn.Replace(";", String.Format(sChar, "3B"));

sReturn = sReturn.Replace("/", String.Format(sChar, "2F"));

sReturn = sReturn.Replace("?", String.Format(sChar, "3F"));

sReturn = sReturn.Replace(":", String.Format(sChar, "3A"));

sReturn = sReturn.Replace("@", String.Format(sChar, "40"));

sReturn = sReturn.Replace("=", String.Format(sChar, "3D"));

sReturn = sReturn.Replace("&", String.Format(sChar, "26"));

sReturn = sReturn.Replace("$", String.Format(sChar, "24"));

return sReturn;

}

SharePoint Central Feature Management

2011-08-07T02:03:00.002+05:30

My 4th open source contribution to Codeplex. Currently I am working on a Project which is product wrapper top of SharePoint. I need to activate almost 20 to 30 feature on every deployment, It takes around 10-15 minute to just activate those feature in Site Collection and Sub Sites. So I created on custom Application Page which will work as a Feature Management.and thought its nice to contribute on codeplex with that project which can help everyone, following are the screen shots and description of the Project. Download Source Code

SharePoint Central Feature Management provides the functionality to manage all feature in Site Collection and all Sub Sites from one central location. also allow to Activate or Deactivate multiple feature on Single Click. Also allow user to Activate all dependent feature associated with current feature. Allow you to activate and deactivate hidden feature also.

1. Activate SharePoint Central Feature Management from Site Collection Feature

Activate SharePoint Central Feature Management from the Site Collection Features

2. After enabling the feature it will add link in Site Collection Administration

After Activating the Feature it will Show you the Link under Site Collection Administration

3. Click on Central Feature Management

Landing Page of SharePoint Central Feature Management

4. Action and Filter control

Filter Tool Bar

Functionality:

1. Type dropdown will allow you to select type of feature (Site Collection Feature or Web Feature)

2. Select Web dropdown will allow you to select specific web from the dropdown (if type is web in first dropdown)

3. Show dropdown will allow you to select which type of feature you want to display “All”,”Activated”,”Needs to Activate”

4. Hidden Checkbox will allow you set whether you want to include Hidden feature or not.

5. On Filter button click will filter the result and display the result in below grid

6. Activate Button will activate all selected feature

7. Activate with Dependency will allow you to activate all dependent feature associated with selected feature

8. Deactivate button will allow you to deactivate selected feature

Hidden feature in Highligted Color

Hope this will help everyone –

Happy Coding !!!!!!

Modify Port Number or Add Custom Domain Name of SharePoint Site

2011-08-07T02:00:00.001+05:30

There are multiple scenario where we need to host the Intranet site with domain name or change the port number of existing web application of SharePoint. But most of us don’t know the exact steps how to do that. So my this post describe all steps required for achieving above scenario’s

Step 1. Open HOSTS file in notepad from C:\Windows\System32\drivers\etc and update your domain name with IP of the server

like mysite.com

Host File Entry

Step 2: Click on Start -> Run -> Type INETMGR -> press enter -> Select you website and click on Bindings -> Click on Edit

IIS Mapping

Step 3: Enter host header value which you have mentioned in HOSTS file (mysite.com) and update the port number which you want I am using 80 port

IIS Host Header Entry

Step 4 : Go To SharePoint 2010 Central Administration -> System Settings -> Configure alternate access mappings

Alternate Access Mapping

Step 5: Select you WebApplication -> Edit the URL without port number (http://mysite.com) or with port number (http://mysite.com:2222) -> Click OK

Update URL in AAM

Done !! Access your site with new URL.

If you receive error 401.1 when you browse a Web site that uses Integrated Authentication and is hosted on IIS 5.1 or a later version then follow below steps.

SPECIFY HOST NAMES (PREFERRED METHOD IF NTLM AUTHENTICATION IS DESIRED)

To specify the host names that are mapped to the loopback address and can connect to Web sites on your computer, follow these steps:

Set the DisableStrictNameChecking registry entry to 1. For more information about how to do this, click the following article number to view the article in the Microsoft Knowledge Base:
281308 Connecting to SMB share on a Windows 2000-based computer or a Windows Server 2003-based computer may not work with an alias name
Click Start, click Run, type regedit, and then click OK.
In Registry Editor, locate and then click the following registry key:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0
Right-click MSV1_0, point to New, and then click Multi-String Value.
Type BackConnectionHostNames, and then press ENTER.
Right-click BackConnectionHostNames, and then click Modify.

Add Domain Name
In the Value data box, type the host name or the host names for the sites that are on the local computer, and then click OK.
Quit Registry Editor, and then restart IIS ( IISRESET )

Done !!!

Happy Coding !!!!

Associating a workflow with a content type programmatically : SharePoint 2010

2011-07-07T15:29:00.000+05:30

One of the common requirements in sharepoint projects using workflows is to associate the workflow with a content type so that whenever an item of that content type is created/changed, the workflow starts. Quite often ,we need to do this task programmtically using features/event receivers etc.

Well, here's the code snippet which specifies how to associate the sharepoint out of the box 'Collect feedback' workflow and the 'Approval' workflow with a content type. You'll need to use the 'Microsoft.SharePoint.Workflow' namespace to be able to run this code.

    string taskListTitle = "Tasks";
    string historyListTitle = "Workflow History";
    string collectFeedbackWorkflowName = "CollectFeedbackWorkflow";
    string approvalWorkflowName = "ApprovalWorkflow";

    SPWorkflowTemplate collectFeedbackWorkflowTemplate = null;
    SPWorkflowTemplate approvalWorkflowTemplate = null;

    //Initializing with workflow template IDs

    Guid collectFeedbackWorkflowTemplateID = new Guid("3bfb07cb-5c6a-4266-849b-8d6711700409");
    Guid approvalWorkflowTemplateID = new Guid("8ad4d8f0-93a7-4941-9657-cf3706f00409");

    //Getting workflow template based on workflow id

       foreach (SPWorkflowTemplate template in this.CurrentWeb.WorkflowTemplates)
            {
              if (template.Id.Equals(collectFeedbackWorkflowTemplateID))
                 {
                   collectFeedbackWorkflowTemplate = template;
                 }
                if (template.Id.Equals(approvalWorkflowTemplateID))
                 {
                   approvalWorkflowTemplate = template;
                 }
            }
     //--------------------------- Create collect feedback workflow association.--------------------------------------

      SPWorkflowAssociation collectFeedbackWorkflowAssociation = SPWorkflowAssociation.CreateWebContentTypeAssociation(collectFeedbackWorkflowTemplate,
                                                                                       collectFeedbackWorkflowName,
                                                                                       taskListTitle,
                                                                                       historyListTitle);
     //setting to specify that workflow can be started manually

      collectFeedbackWorkflowAssociation.AllowManual = true;
     //setting to specify that manage lists permissions is required for starting a workflow

      if (collectFeedbackWorkflowAssociation.AllowManual)
             {
                SPBasePermissions emptyMask = SPBasePermissions.EmptyMask;

                emptyMask |= SPBasePermissions.ManageLists;

                collectFeedbackWorkflowAssociation.PermissionsManual = emptyMask;
             }
     //setting to specify that workflow will be automatically started whenever a new item is added
       collectFeedbackWorkflowAssociation.AutoStartCreate = true;
      //setting to specify that workflow will be automatically started whenever an item is changed/edited
       collectFeedbackWorkflowAssociation.AutoStartChange = true;

//Adding workflow association to content type (objContentType is an object of type SPContentType)
       objContentType.WorkflowAssociations.Add(collectFeedbackWorkflowAssociation);

     //--------------------------- Create approval workflow association.--------------------------------------

       SPWorkflowAssociation approvalWorkflowAssociation = SPWorkflowAssociation.CreateWebContentTypeAssociation(approvalWorkflowTemplate,
                                                                                       approvalWorkflowName,
                                                                                       taskListTitle,
                                                                                       historyListTitle);
     //setting to specify that workflow can be started manually
       approvalWorkflowAssociation.AllowManual = true;

    //setting to specify that manage lists permissions is required for starting a workflow
       if (approvalWorkflowAssociation.AllowManual)
           {
              SPBasePermissions emptyMask = SPBasePermissions.EmptyMask;

              emptyMask |= SPBasePermissions.ManageLists;

              approvalWorkflowAssociation.PermissionsManual = emptyMask;
           }
    //setting to specify that workflow will be automatically started whenever a new item is added
       approvalWorkflowAssociation.AutoStartCreate = true;
    //setting to specify that workflow will be automatically started whenever an item is changed/edited
       approvalWorkflowAssociation.AutoStartChange = true;

    //Adding workflow association to content type (objContentType is an object of type SPContentType)
objContentType.WorkflowAssociations.Add(approvalWorkflowAssociation);

Similar code can also be used for the custom workflow templates that we deploy.It is just that in that case we will have to specify the template name for our custom workflow that we need to associate with the content type.

C# StreamReader and StreamWriter

2007-03-28T09:33:00.000+05:30

You can have a StreamWriter object as the return value from calling the method File.CreateText(). You can also create a StreamWriter object using one of its constructor overloads. The following example illustrates using a StreamWriter object with a FileStream object to write characters to the file aFile.txt

using System;
using System.IO;

namespace MyStreams
{
class Class1
{
public static void Main()
{
try
{
FileStream fs = new FileStream
("aFile.txt",FileMode.Create,
FileAccess.ReadWrite,FileShare.None);
string[] strings = {"C#", "ASP.NET", "XML"};
using(StreamWriter sw = new StreamWriter(fs))
{
Console.WriteLine("This StreamWriter instance uses {0}
to write to the file", sw.BaseStream);
Console.WriteLine("The Property sw.Encoding returns:
{0}",sw.Encoding);
sw.WriteLine("www.aspfree.com");
sw.WriteLine("contains many useful articles");
sw.WriteLine("on many different technologies like {0},
{1} and {2}", strings);
}
Console.WriteLine("Data has been written to the file");
Console.ReadLine();
}
catch(IOException ex)
{
Console.WriteLine(ex.Message);
}
}
}
}

C# Delegates Explained

2007-03-28T09:31:00.000+05:30

This may be the first time you've read about this new .NET type. A delegate is an object that refers to a static method or an instance method. In this article I discuss what delegates are, how you can create and use them, and how the C# compiler saves us time by generating the delegate's class. We will also look at the MSIL code, talk about multicast delegates and provide callback methods through the use of delegates.
A delegate is an object that is created to refer to a static method or an instance method, and then used to call this method. To start off, you create a new delegate type in a different way than you create any other class. You use the delegate keyword as in the following statement.

public delegate int DelegateToMethod(int x, int y);

It seems unusual I know, but I will explain how it's done. Let's take a look at the very first example that explains how to use a delegate.

The First Delegate Example

Copy the following code into your VS.NET class file and run the project.

using System;

namespace Delegates
{
public delegate int DelegateToMethod(int x, int y);

public class Math
{
public static int Add(int first, int second)
{
return first + second;
}

public static int Multiply(int first, int second)
{
return first * second;
}

public static int Divide(int first, int second)
{
return first / second;
}
}

public class DelegateApp
{
public static void Main()
{
DelegateToMethod aDelegate = new DelegateToMethod(Math.Add);
DelegateToMethod mDelegate = new DelegateToMethod(Math.Multiply);
DelegateToMethod dDelegate = new DelegateToMethod(Math.Divide);
Console.WriteLine("Calling the method Math.Add() through the aDelegate object");
Console.WriteLine(aDelegate(5,5));
Console.WriteLine("Calling the method Math.Multiply() through the mDelegate object");
Console.WriteLine(mDelegate(5,5));
Console.WriteLine("Calling the method Math.Divide() through the dDelegate object");
Console.WriteLine(dDelegate(5,5));
Console.ReadLine();
}

}
}

When you run the above code you will get the following:

Let's explain what's going on in this example step-by-step. We have defined a new delegate type using the statement

public delegate int DelegateToMethod(int x, int y);

You are used to defining a new class using the class keyword, then an identifier followed by {, then implementation in the form of methods, properties and fields followed by }. The case is different with delegates. When we define a new delegate type (like DelegateToMethod) the C# compiler generates a class called DelegateToMethod that derives the System.MultipcastDelegate as follows:

public sealed class DelegateToMethod : System.MulticastDelegate
{
public DelegateToMethod(object target, int method);
public virtual void Invoke(int x, int y);
public virtual IAsyncResult BeginInvoke(int x, int y,
AsyncCallback callback, object obj);
public virtual void EndInvoke(IAsyncResult result);
}

The Constructor method of this class takes two arguments. The first is an object reference of the type that defined the instance method that the delegate refers to, and the second is an int value of the function pointer to the method that the delegate encapsulates.

The Invoke() method has the same signature as our delegate declaration. This method is used to call the delegate's encapsulated method. Note that when we defined the delegate we provided a signature for the method that can be encapsulated. In other words, the delegate can't refer to a method with a different signature than the one that it is created with. The BeginInvoke() and EndInvoke() provide asynchronous calls, which are beyond the scope of this article.

The C# compiler generates the sealed class with the four virtual methods, but it doesn't generate any implementation for those methods because they have to be implemented by the Common Language Runtime. So up to the point we have discussed, the folks at Microsoft saved us a lot of time by providing the delegate keyword which we can use to generate a class based on the System.MulticastDelegate. Let's continue our example.

The Math class contains three simple methods (Add, Multiply and Divide) that accept two int values and return an int value. Note that those are static methods. The DelegateApp class creates three DelegateToMethod objects as shown next:

DelegateToMethod aDelegate = new DelegateToMethod(Math.Add);
DelegateToMethod mDelegate = new DelegateToMethod(Math.Multiply);
DelegateToMethod dDelegate = new DelegateToMethod(Math.Divide);

Those three statements create three delegate objects. I think that the issue that would confuse someone is illustrated in the following screen shot:

As you can see, the signature of the Constructor method is not shown; instead, the signature of the method that can be encapsulated by the delegate is shown, or we can say the signature of the delegate. Any method that accepts two int values can return an int. We can look at a delegate as a type-safe function pointer which means that the parameter list and the return type are known.

We create a delegate object using the new operator and pass it the method to be encapsulated. Note that we have said that the generated class' constructor is passed two parameters, and because the passed methods are static, the first parameter will be null value (if it was an instance method it would be the object reference that defined the method instead of the null value).

We have said that in order to call the delegate's encapsulated method we need to call the delegate's Invoke() method. Actually, we can't call this method directly; instead we use the object reference and pass it the arguments as we did in the above code. Take a look again:

Console.WriteLine(aDelegate(5,5));

The statement calls the encapsulated method (which is Math.Add) and passes the parameters as arguments to the method, which returns the value 10.

Put simply, to use a delegate:

Define a new type that inherits from System.MulticastDelegate class and provide the signature of the methods that can be encapsulated by the new type.

public delegate int DelegateToMethod(int x, int y);

Create an instance or static method that has the same signature as defined by the new delegate type.

public static int Add(int first, int second)
{
return first + second;
}

Create a new delegate object using the new operator and pass the method as a parameter to it.

DelegateToMethod aDelegate = new DelegateToMethod(Math.Add);

Invoke the delegate object and pass the arguments to it which in turn calls the referenced method.

Console.WriteLine(aDelegate(5,5));

Building a complete COM+ Server component using C# and .NET

2007-03-28T09:29:00.000+05:30

To develop .NET managed components that can be configured to function under the COM+ Runtime, you need to provide these components with numerous attributes defined in the System.EnterpriseServices namespace. To start off, each .NET class that's supposed to run under COM+ needs to derive from the System.ServicedComponent class. This base class provides default implementations of the classic MTS/COM+ interface IObjectControl - Activate(), Deactivate(), and CanBePooled(). You can override the default implementations if you wish to do so, just as will be seen shortly.

Once any number of COM+ centric attributes are added to the .NET component, the assembly will have to be compiled. However, to place this assembly under the control of COM+, a new utility (regsvcs.exe) will have to be used as we will see soon. In addition to installing the component into the COM+ catalog, this utility also provides a lot of other services that we shall soon see.

Finally, for the COM+ Surrogate (dllhost.exe) to locate your assembly and to host it in a given activity, it must be able to locate your binary. Therefore, you should install your assembly into the system's Global Assembly Cache (GAC).

The various steps that are involved in creating a COM+ Server Component using C# and the .NET Framework are as follows (I'm going to assume you're using the VS.NET IDE):

Create a Visual C# - Class Library project

Generate a Key-Value pair to use when deploying your Shared Assembly

Configure your Project Property Pages with the right information

Develop the AccountManager.cs library

Modify the generated AssemblyInfo.cs to add the right assembly information

Build the Project Files

Deploy the component as a Shared Assembly, and Configure the Assembly in the COM+ Catalog

The BookKeeper Module

My goal is to simplify illustration of a typical COM+ serviced component development process. I am therefore, in this article, going to reuse the BookKeeper example for all database operations. As a result, all our data is going to be maintained in an XML datastore!!! I had used the BookKeeper example in an earlier article to illustrate ADO.NET's disconnected operation facility - the DataSet. To refresh, the DataSet facilitates the client to manipulate and update a local copy of any number of related tables while still disconnected from the data source and submit the modified data back for processing using a related data adapter at a later point in time.

The AccountManager Module

Our hypothetical AccountManager Module (that we will build in this article), is actually a COM+ Server component that performs just a couple of functions. It is the module that manages creation and deletion of accounts (Checking accounts or Savings accounts) for a Large Commercial Bank Project. It offers no other services except "Create Account", and "Delete Account".

1. Create a Visual C# - Class Library project

Create a new Visual C# Class Library project. Remember that the COM+ Runtime can only host types contained in a DLL.

2. Generate a Key-Value pair to use when deploying your Shared Assembly

Shared Assemblies are those that can be used by any client application, such as a system DLL that every process in the system can use. Unlike private-assemblies, shared assemblies must be published or registered in the system's Global Assembly Cache (GAC). As soon as they are registered in the GAC, they act as system components. An essential requirement for GAC registration is that the component must possess originator and version information. In addition to other metadata information, these two items allow multiple versions of the same component to be registered and executed on the same machine. Unlike Classic COM, we don't have to store any information in the system registry for clients to use these shared assemblies.

There are three general steps to registering shared assemblies in the GAC:

The Shared Name (sb.exe) utility should be used to obtain the public/private key pair. This utility generates a random key pair value, and stores it in an output file - for example, AccountManager.key.

Build the assembly with an assembly version number and the key information in the AccountManager.key

Using the .NET Global Assembly Cache (gacutil.exe) utility, register the assembly in the GAC.

The assembly now becomes a shared assembly and can be used by any client in the system.

Therefore, as a first step, use the Shared Name Utility to obtain a public/private key pair and store it in a file (AccountManager.key, in this case) as shown below.

Command Prompt
C:\MyProjects\Cornucopia\COMplus\BankServer\AccountManager>sn -k AccountManager.key

Microsoft (R) .NET Framework Strong Name Utility Version 1.0.2914.16
Copyright (C) Microsoft Corp. 1998-2001. All rights reserved.

Key pair written to AccountManager.key

C:\MyProjects\Cornucopia\COMplus\BankServer\AccountManager>

The -k option generates the random key pair and saves the key information in the AccountManager.key file. We use this file as input when we build our Shared Assemblies.

3. Configure your Project Property Pages with the right information

Configure the Project Properties with the right information. Make sure you specify the Assembly Name that you want for the Assembly. Specifically, move to the General tab, and in the Wrapper Assembly Key File area, enter the key file to use. In this case, it is AccountManager.key.

Move to the Reference Path Properties area, and select the directory that contains the BookKeeper executable.

Go to "Project Dependancy" and select the BookKeeper as a dependancy for this project. This means the BookKeeper project has to be compiled before compiling this project.

To the AccountManager project files, also add the BookKeeper.cs, and the AccountKey.cs files from the BookKeeper project.

4. Develop the AccountManager.cs library

Transactions

To develop a .NET class that supports transactions, here's what you have to do:

The class must derive from the System.ServicedComponent class to exploit COM+ Services as shown in Line 94.
The class must be created with the correct Transaction attribute such as Transaction (TransactionOption.Required) as shown in Line 78.
Besides this, you can use the System.EnterpriseServices.ContextUtil class to obtain information about the COM+ object context as shown in Line 138. This class exposes important methods of COM+ like SetComplete() and SetAbort(), and IsCallerInRole(), and important COM+ properties like IsInTransaction, and MyTransactionVote. Additionally, while it's not necessary to specify COM+ Application installation options, you can always specify what you want. Notice that we use attributes to specify a number of things.

In the AccountManager.create() method, we simply call ContextUtil.SetComplete() - Line 138 -when we've successfully created a new account into our database. If something has gone wrong during the process, we will vote to abort the transaction by calling ContextUtil.SetAbort() as shown on Line 142.

Instead of calling ContextUtil.SetComplete() and ContextUtil.SetAbort() explicitly, we can also use the AutoComplete( true ) attribute, as shown on line 165 which is conceptually equivalent to the previously shown AccountManager.create() method.

using System;
using System.Runtime.InteropServices;
using System.EnterpriseServices;
// Include the following for the Trace class
using System.Diagnostics;
// Include the following for Windows Message Box
using System.Windows.Forms;
// Include the BookKeeper namespace
using BookKeeper;

namespace Bank {

///////////////////////////////////////////////////////////////
///

/// The Account Manager interface
///

///
/// This interface defines create and delete methods to
/// add or delete Bank Accounts
///
///////////////////////////////////////////////////////////////

/// Indicate whether a managed interface is dual, IDispatch or
/// IUnknown based when exposed to COM
[ InterfaceTypeAttribute( ComInterfaceType.InterfaceIsDual ) ]

public interface IAccountManager {

///

/// The create method
///

///
/// Method used to create a new Bank account
///
/// Either Checking or Savings
/// Customers who own this account
/// Initial Deposit
///
int create (AccountType type, string[] customerNames, float startingBalance);

///

/// The delete method
///

///
/// Method used to delete and existing Bank account
///
/// the Account Number
/// true if Account deleted, false if not
bool delete (int accountKey);
}

///////////////////////////////////////////////////////////////
///

/// AccountManager used to create new Accounts or delete accounts.
///

///////////////////////////////////////////////////////////////

/// Specify a name for your serviced component
[ ProgId( "COM+ Bank Server Account Manager" ) ]
/// Add content to hosting COM+ App's description field
[ Description( "COM+ Bank Server Account Manager" ) ]
/// Configure component's Transaction Option
[ Transaction( TransactionOption.Required ) ]
/// Configure component's object pooling
[ ObjectPooling( MinPoolSize = 5, MaxPoolSize = 10, CreationTimeout = 20 ) ]
/// Specify COM+ Context Attributes
[ MustRunInClientContext( false ) ]
/// Enable event tracking
[ EventTrackingEnabled( true ) ]
/// Enable JITA for the component
[ JustInTimeActivation( true ) ]
/// Enable Construction String Support for the component
[ ConstructionEnabled( Enabled=true, Default="Gopalan's Bank Server" ) ]
/// Configure activity-based Synchronization for the component
[ Synchronization( SynchronizationOption.Required ) ]
/// Indicate the type of class interface that will be generated for this class
[ ClassInterface( ClassInterfaceType.AutoDual ) ]

public class AccountManager : ServicedComponent, IAccountManager {

///

/// Public No-argument Default Constructor
///

public AccountManager() {
MessageBox.Show ("Bank::AccountManager() invoked...");
}

/////////////////////////////////////////////////////////////////////////
/// The Following methods support core functionality required of the
/// AccountManager component and implement the IAccountManager interface
/////////////////////////////////////////////////////////////////////////

///

/// The create method
///

///
/// Method used to create a new Bank account
///
/// Either Checking or Savings
/// Customers who own this account
/// Initial Deposit
///

/// Add content to hosting COM+ App's description field
[ Description( "Creates a new account for the Bank Server" ) ]

public int create (AccountType type, string[] customerNames, float startingBalance) {
MessageBox.Show ("Bank::create() invoked...");
AccountKey key = null;
try {
// Create the BookKeeper class
BookKeeper.BookKeeper keeper = new BookKeeper.BookKeeper();
if (null != keeper) {
// Call the BookKeeper to create a new Bank Account
key = keeper.createAccount (type, customerNames, startingBalance);
// Clean-up the BookKeeper object
keeper.Dispose();
}
else {
throw new Exception ( "BookKeeper Object could not be created." );
}
// Since everything went well, commit the changes
ContextUtil.SetComplete();
}
catch (Exception exception) {
// An Error occured, so rollback the changes
ContextUtil.SetAbort();

// Trace the current COM+ context ID (its GUID) to the output window
// use the ContextId static property of ContextUtil
Guid contextID = ContextUtil.ContextId;
String traceMessage = "Context ID is " + contextID.ToString();
Trace.WriteLine (traceMessage.ToString ());

MessageBox.Show (exception.ToString (), "Bank::create()");
}
return key.Key;
}

///

/// The delete method
///

///
/// Method used to delete and existing Bank account
///
/// the Account Number
/// true if Account deleted, false if not

/// Take advantage of COM+'s method auto-deactivation
[ AutoComplete( true ) ]
/// Add content to hosting COM+ App's description field
[ Description( "Deletes an existing account from the Bank Server" ) ]

public bool delete (int accountKey) {
bool result = false;
MessageBox.Show ("Bank::delete() invoked...", "Key Value = "+accountKey);
/*
try {
// Programming Role based security
SecurityCallContext callContext;
callContext = SecurityCallContext.CurrentCall;
string caller = callContext.DirectCaller.AccountName;
bool isInRole = callContext.IsCallerInRole ( "Manager" );
if (false == isInRole) {
throw new Exception ( "Only Managers can delete Customers" );
}
*/
BookKeeper.BookKeeper keeper = new BookKeeper.BookKeeper();
if (null != keeper) {
AccountKey key = new AccountKey();
key.Key = accountKey;
result = keeper.deleteAccount (key);
keeper.Dispose();
}
else {
throw new Exception ( "BookKeeper Object could not be created." );
}
/*}
catch (Exception exception) {
Guid contextID = ContextUtil.ContextId;
String traceMessage = "Context ID is " + contextID.ToString();
Trace.WriteLine (traceMessage.ToString ());

MessageBox.Show (exception.ToString (), "Bank::delete()");
}*/
return result;
}

/////////////////////////////////////////////////////////////////////////
/// All the Following methods support overriding functionality required for
/// implementing some of the COM+ support interfaces like IObjectConstruct.
/////////////////////////////////////////////////////////////////////////

///

/// The method is called after the component's constructor
/// and is passed in the user specific constructionString
///

///
override public void Construct (string constructionString) {
MessageBox.Show ("Bank::Construct() invoked...");
MessageBox.Show (constructionString, "Construction String");
}

///

/// Do context specific initialization in this method
///

override public void Activate () {
MessageBox.Show ("Bank::Activate() invoked...");
}

///

/// Do context specific cleanup in this method
///

override public void Deactivate () {
MessageBox.Show ("Bank::Deactivate() invoked...");
}

///

/// Object Pooling support method
///

/// true if pooling is supported, false if not
override public bool CanBePooled () {
MessageBox.Show ("Bank::CanBePooled() invoked...");
return true;
}
}
}

Object Pooling

Object Pooling is a feature that was introduced in COM+, but was missing in MTS. Object Pooling allows you to minimize the use of system resources, by pooling objects that support transactions but are expensive to create. This improves performance and helps system scalability. If you want to support object pooling in you components, you need to derive from the System.ServicedComponent class, and override any of the Activate(), Deactivate(), and CanBePooled() methods, and specify object pooling requirements in an ObjectPooling attribute as shown on Line 80. You can take advantage of the Activate() and Deactivate() methods to perform the appropriate initialization and cleanup. The CanBePooled() method is used to tell COM+ whether this object can be pooled or not. This way, you can provide any expensive object-creation functionality in the constructor of the component.

Since our COM+ components support Object Pooling, The COM+ runtime activates and deactivates them as required. After each Client call has been serviced, it puts the component object back into the object pool. As soon as a new Client call arrives, it picks the same component object back from the pool to service the new request.

5. Modify the generated AssemblyInfo.cs to add the right assembly information

You provide the compiler with your assembly information in an assembly file called AssemblyInfo.cs. The assembly information file is compiled with the rest of the project's source files. The information is in the form of assembly attributes - directives to the compiler on the information to embed in the assembly.

AssemblyInfo.cs
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
using System.Reflection;
using System.Runtime.CompilerServices;
using System.EnterpriseServices;

//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("AccountManager for Bank")]
[assembly: AssemblyDescription("Creates and Deletes Accounts for the Bank")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("eCommWare Corporation")]
[assembly: AssemblyProduct("COM+ Bank Server")]
[assembly: AssemblyCopyright("(c) 2001, Gopalan Suresh Raj. All Rights Reserved.")]
[assembly: AssemblyTrademark("Web Cornucopia")]
[assembly: AssemblyCulture("en-US")]

//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:

[assembly: AssemblyVersion("1.0.0.0")]

//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("AccountManager.key")]
[assembly: AssemblyKeyName("")]

[assembly: ApplicationName( "COM+ Bank Server Account Manager" )]
[assembly: ApplicationActivation( ActivationOption.Server )]

In particular, pay attention to the fact that we specify a version number for this library using the AssemblyVersion attribute and also specify the assembly key file using the AssemblyKeyFile attribute. The ApplicationName attribute is self-explanatory. However, the attribute of special interest is the ApplicationActivation attribute. As you may know, MTS and COM+ applications may either be hosted as a Library (e.g., Activated in the Caller's process) or Server (e.g., Activated in a new instance of dllhost.exe). The default attribute is to configure your COM+ application as a Library. Here we want to explicitly set the activation option to be specified as ActivationOption.Server.

6. Build the Project Files

Build the files that make up the project.

------ Rebuild All started: Project: BookKeeper, Configuration: Debug .NET ------

Preparing resources...
Updating references...
Performing main compilation...

Build complete -- 0 errors, 0 warnings
Building satellite assemblies...

------ Rebuild All started: Project: AccountManager, Configuration: Debug .NET ------

Preparing resources...
Updating references...
Performing main compilation...

Build complete -- 0 errors, 0 warnings
Building satellite assemblies...

---------------------- Done ----------------------

Rebuild All: 2 succeeded, 0 failed, 0 skipped

7. Deploy the component as a Shared Assembly and Configure it in the COM+ Catalog

After you've built the assembly, you can use the .NET Global Assembly Cache (GAC) utility to register this assembly into the GAC as shown below.

Command Prompt
C:\MyProjects\Cornucopia\COMplus\BankServer\AccountManager\bin\Debug>gacutil /i Bank.dll

Microsoft (R) .NET Global Assembly Cache Utility. Version 1.0.2914.16
Copyright (C) Microsoft Corp. 1998-2001. All rights reserved.

Assembly successfully added to the cache

C:\MyProjects\Cornucopia\COMplus\BankServer\AccountManager\bin\Debug>regsvcs /fc Bank.dll
RegSvcs - .NET Services Installation Utility Version 1.0.2914.16
Copyright (C) Microsoft Corp. 2000-2001. All rights reserved.

Installed Assembly:
Assembly: C:\MyProjects\Cornucopia\COMplus\BankServer\AccountManager\bin\Debug\Bank.dll
Application: COM+ Bank Server Account Manager
TypeLib: c:\myprojects\cornucopia\complus\bankserver\accountmanager\bin\debug\Bank.tlb

C:\MyProjects\Cornucopia\COMplus\BankServer\AccountManager\bin\Debug>

Successful registration against the cache turns this component into a shared assembly. A version of this component is copied into the GAC so that even if you delete this file locally, you will still be able to run your client program.

Configuring our Assembly in the COM+ Catalog

Configuring a .NET assembly in the COM+ Catalog means, you need to generate a COM Type Library (tlbexp.exe), and register the type in the system registry (regasm.exe). You also have to make sure that you enter the right information into the COM+ Catalog (RegDB). Instead of using all these tools individually, the .NET SDK provides an additional tool called the Register Services utility (regsvcs.exe). This utility simplifies the process by making sure that all required details are taken care of in a single step. It performs the following functions:

Our Assembly is loaded into memory
Out Assembly is registered (e.g., just like using regasm.exe)
A COM Type Library (.tlb file) is generated and registered (e.g., just like using tlbexp.exe)
The generated COM Type Library is installed in the specified COM+ Application
Our Components are configured according to the attributes that are specified in the type definitions
If you notice carefully, when we use the regsvcs.exe utility, we specify the /fc option (find or create) to instruct the tool to build a new COM+ application if one does not currently exist.

The Component Services Explorer

Once you have done all this, you can open up the Windows 2000 Component Services Explorer and discover that your .NET Assembly is now recognized as valid COM+ Application.

While you explore the various property windows for this COM+ Application, you realize that the various attributes that you specified in the C# class have been used to configure our component in the COM+ Catalog. Right Click the Component and check out the Activation tab for example as shown in the screen shot below.

The above settings have been automatically configured based on the following class-level attributes that you set programmatically in your original C# class from lines 82-88 in the source code above.

/// Configure component's object pooling
[ ObjectPooling( MinPoolSize = 5, MaxPoolSize = 10, CreationTimeout = 20 ) ]
/// Specify COM+ Context Attributes
[ MustRunInClientContext( false ) ]
/// Enable event tracking
[ EventTrackingEnabled( true ) ]
/// Enable JITA for the component
[ JustInTimeActivation( true ) ]
/// Enable Construction String Support for the component
[ ConstructionEnabled( Enabled=true, Default="Gopalan's Bank Server" ) ]

Now you need to build a client application that can access this COM+ Server component.

Unsafe Code in C#

2007-02-20T14:35:00.000+05:30

C# .net hides most of memory management, which makes it much easier for the developer. Thanks for the Garbage Collector and the use of references. But to make the language powerful enough in some cases in which we need direct access to the memory, unsafe code was invented.

Commonly while programming in the .net framework we don?t need to use unsafe code, but in some cases there is no way not to, such as the following:

* Real-time applications, we might need to use pointers to enhance performance in such applications.
* External functions, in non-.net DLLs some functions requires a pointer as a parameter, such as Windows APIs that were written in C.
* Debugging, sometimes we need to inspect the memory contents for debugging purposes, or you might need to write an application that analyzes another application process and memory.

Unsafe code is mostly about pointers which have the following advantages and disadvantages.

Advantages of Unsafe Code in C#:

* Performance and flexibility, by using pointer you can access data and manipulate it in the most efficient way possible.
* Compatibility, in most cases we still need to use old windows APIs, which use pointers extensively. Or third parties may supply DLLs that some of its functions need pointer parameters. Although this can be done by writing the DLLImport declaration in a way that avoids pointers, but in some cases it?s just much simpler to use pointer.
* Memory Addresses, there is no way to know the memory address of some data without using pointers.

Disadvantages of Unsafe Code in C#:

* Complex syntax, to use pointers you need to go throw more complex syntax than we used to experience in C#.
* Harder to use, you need be more careful and logical while using pointers, miss using pointers might lead to the following:
o Overwrite other variables.
o Stack overflow.
o Access areas of memory that doesn?t contain any data as they do.
o Overwrite some information of the code for the .net runtime, which will surely lead your application to crash.
* Your code will be harder to debug. A simple mistake in using pointers might lead your application to crash randomly and unpredictably.
* Type-safety, using pointers will cause the code to fail in the .net type-safety checks, and of course if your security police don?t allow non type-safety code, then the .net framework will refuse to execute your application.

After we knew all the risks that might face us while using pointer and all the advantages those pointers introduces us of performance and flexibility, let us find now how to use them. The keyword unsafe is used while dealing with pointer, the name reflects the risks that you might face while using it. Let?s see where to place it. We can declare a whole class as unsafe:

unsafe class Class1
{
//you can use pointers here!
}

Or only some class members can be declared as unsafe:

class Class1
{
//pointer
unsafe int * ptr;
unsafe void MyMethod()
{
//you can use pointers here
}
}

The same applies to other members such as the constructor and the properties.

To declare unsafe local variables in a method, you have to put them in unsafe blocks as the following:

static void Main()
{
//can't use pointers here

unsafe
{
//you can declare and use pointer here

}

//can't use pointers here
}

You can?t declare local pointers in a ?safe? method in the same way we used in declaring global pointers, we have to put them in an unsafe block.

static void Main()
{
unsafe int * ptri; //Wrong
}

If you got too excited and tried to use unsafe then when you compile the code just by using

csc test.cs

You will experience the following error:

error CS0227: Unsafe code may only appear if compiling with /unsafe

For compiling unsafe code use the /unsafe

csc test.cs /unsafe

In VS.net go to the project property page and in ?configuration properties>build? set Allow Unsafe Code Blocks to True.

After we knew how to declare a block as unsafe we should now learn how to declare and use pointers in it.

Declaring pointers

To declare a pointer of any type all what you have to do is to put ?*? after the type name such as

int * ptri;

double * ptrd;

NOTE: If you used to use pointer in C or C++ then be careful that in C# int * ptri, i; ?*? applies to the type itself not the variable so ?i? is a pointer here as well, same as arrays.
void Pointers

If you want to declare a pointer, but you do not wish to specify a type for it, you can declare it as void.

void *ptrVoid;

The main use of this is if you need to call an API function than require void* parameters. Within the C# language, there isn?t a great deal that you can do using void pointers.
Using pointers

Using pointers can be demonstrated in the following example:

static void Main()
{

int var1 = 5;

unsafe
{
int * ptr1, ptr2;
ptr1 = &var1;
ptr2 = ptr1;
*ptr2 = 20;
}

Console.WriteLine(var1);
}

The operator ?&? means ?address of?, ptr1 will hold the address of var1, ptr2 = ptr1 will assign the address of var1, which ptr1 was holding, to ptr2. Using ?*? before the pointer name means ?the content of the address?, so 20 will be written where ptr2 points.

Now var1 value is 20.
sizeof operator

As the name says, sizeof operator will return the number of bytes occupied of the given data type

unsafe
{
Console.WriteLine("sbyte: {0}", sizeof(sbyte));
Console.WriteLine("byte: {0}", sizeof(byte));
Console.WriteLine("short: {0}", sizeof(short));
Console.WriteLine("ushort: {0}", sizeof(ushort));
Console.WriteLine("int: {0}", sizeof(int));
Console.WriteLine("uint: {0}", sizeof(uint));
Console.WriteLine("long: {0}", sizeof(long));
Console.WriteLine("ulong: {0}", sizeof(ulong));
Console.WriteLine("char: {0}", sizeof(char));
Console.WriteLine("float: {0}", sizeof(float));
Console.WriteLine("double: {0}", sizeof(double));
Console.WriteLine("decimal: {0}", sizeof(decimal));
Console.WriteLine("bool: {0}", sizeof(bool));

//did I miss something?!
}

The output will be:

sbyte: 1

byte: 1

short: 2

ushort: 2

int: 4

uint: 4

long: 8

ulong: 8

char: 2

float: 4

double: 8

decimal: 16

bool: 1

Great, we don?t have to remember the size of every data type anymore!
Casting Pointers

A pointer actually stores an integer that represents a memory address, and it?s not surprising to know that you can explicitly convert any pointer to or from any integer type. The following code is totally legal.

int x = 10;
int *px;

px = &x;
uint y = (uint) px;
int *py = (int*) y;

A good reason for casting pointers to integer types is in order to display them. Console.Write() and Console.WriteLine() methods do not have any overloads to take pointers. Casting a pointer to an integer type will solve the problem.

Console.WriteLine(?The Address is: ? + (uint) px);

As I mentioned before, it?s totally legal to cast a pointer to any integer type. But does that really mean that we can use any integer type for casting, what about overflows? On a 32-bit machine we can use uint, long and ulong where an address runs from zero to about 4 billion. And on a 64-bit machine we can only use ulong. Note that casting the pointer to other integer types is very likely to cause and overflow error. The real problem is that checked keyword doesn?t apply to conversions involving pointers. For such conversions, exceptions wont be raised when an overflow occur, even in a checked context. When you are using pointers the .net framework will assume that you know what you?re doing and you?ll be happy with the overflows!

You can explicitly convert between pointers pointing to different types. For example:

byte aByte = 8;
byte *pByte = &aByte;
double *pDouble = (double*) pByte;

This is perfectly legal code, but think twice if you are trying something like that. In the above example, the double value pointed to by pDouble will actually contain a byte (which is 8), combined by an area of memory contained a double, which surely won?t give a meaningful value. However, you might want to convert between types in order to implement a union, or you might want to cast pointers to other types into pointers to sbyte in order to examine individual bytes of memory.
Pointers Arithmetic

It?s possible to use the operators +, -, +=, -=, ++ and -- with pointers, with a long or ulong on the right-hand side of the operator. While it?s not permitted to do any operation on a void pointer.

For example, suppose you have a pointer to an int, and you want to add 1 to it. The compiler will assume that you want to access the following int in the memory, and so will actually increase the value by 4 bytes, the size of int. If the pointer was pointing to a double, adding 1 will increase its value by 8 bytes the size of a double.

The general rule is that adding a number X to a pointer to type T with a value P gives the result P + X *sizeof(T).

Let?s have a look at the following example:

uint u = 3;
byte b = 8;
double d = 12.5;
uint *pU = &u;
byte *pB = &b;
double *pD = &d;

Console.WriteLine("Before Operations");
Console.WriteLine("Value of pU:" + (uint) pU);
Console.WriteLine("Value of pB:" + (uint) pB);
onsole.WriteLine("Value of pD:" + (uint) pD);

pU += 5;
pB -= 3;
pD++;

Console.WriteLine("\nAfter Operations");
Console.WriteLine("Value of pU:" + (uint) pU);
Console.WriteLine("Value of pB:" + (uint) pB);
Console.WriteLine("Value of pD:" + (uint) pD);

The result is:

Before Operations
Value of pU:1242784
Value of pB:1242780
Value of pD:1242772

After Operations
Value of pU:1242804
Value of pB:1242777
Value of pD:1242780

5 * 4 = 20, where added to pU.

3 * 1 = 3, where subtracted from pB.

1 * 8 = 8, where added to pD.

We can also subtract one pointer from another pointer, provided both pointers point to the same date type. This will result a long whose value is given by the difference between the pointers values divided by the size of the type that they represent:

double *pD1 = (double*) 12345632;
double *pD2 = (double*) 12345600;
long L = pD1 ? pD2; //gives 4 =32/8(sizeof(double))

Note that the way of initializing pointers in the example is totally valid.
Pointers to Structs and Class members

Pointers can point to structs the same way we used before as long as they don?t contain any reference types. The compiler will result an error if you had any pointer pointing to a struct containing a reference type.

Let?s have an example,

Suppose we had the following struct:

struct MyStruct
{
public long X;
public double D;
}

Declaring a pointer to it will be:

MyStruct *pMyStruct;

Initializing it:

MyStruct myStruct = new MyStruct();
pMyStruct = & myStruct;

To access the members:

(*pMyStruct).X = 18;
(*pMyStruct).D = 163.26;

The syntax is a bit complex, isn?t it?

That?s why C# defines another operator that allows us to access members of structs through pointers with a simpler syntax. The operator ?Pointer member access operator? looks like an arrow, it?s a dash followed by a greater than sign: ->

pMyStruct->X = 18;
pMyStruct->D = 163.26;

That looks better!

Fields within the struct can also be directly accessed through pointer of their type:

long *pL = &(myStruct.X);
double *pD = &(myStruct.D);

Classes and pointers is a different story. We already know that we can?t have a pointer pointing to a class, where it?s a reference type for sure. The Garbage Collector doesn?t keep any information about pointers, it?s only interested in references, so creating pointers to classes could cause the Garbage Collector to not work probably.

On the other hand, class members could be value types, and it?s possible to create pointers to them. But this requires a special syntax. Remember that class members are embedded in a class, which sets in the heap. That means that they are still under the control of the Garbage Collector, which can at any time decide to move the class instance to a new location. The Garbage Collector knows about the reference, and will update its value, but again it?s not interested in the pointers around, and they will still be pointing to the old location.

To avoid the risk of this problem, the compiler will result an error if you tried to create pointers pointing to class members in the same way we are using up to now.

The way around this problem is by using the keyword ?fixed?. It marks out a block of code bounded by braces, and notifies the Garbage Collector that there may be pointers pointing to members of certain class instances, which must not be moved.

Let?s have an example,

Suppose the following class:

class MyClass
{
public long X;
public double D;
}

Declaring pointers to its members in the regular way is a compile-time error:

MyClass myClass = new MyClass();

long *pX = &(myClass.X); //compile-time error.

To create pointers pointing to class members by using fixed keyword:

fixed (long *pX = &(myClass.X))
{

// use *pX here only.
}

The variable *pX is scoped within the fixed block only, and tells the garbage collector that not to move ?myClass? while the code inside the fixed block.
stackalloc

The keyword "stackalloc" commands the .net runtime to allocate a certain amount of memory on the stack. It requires two things to do so, the type (value types only) and the number of variables you?re allocating the stack for. For example if you want to allocate enough memory to store 4 floats, you can write the following:

float *ptrFloat = stackalloc float [4];

Or to allocate enough memory to store 50 shorts:

short *ptrShort = stackalloc short [50];

stackalloc simply allocates memory, it doesn?t initialize it to any value. The advantage of stackalloc is the ultra-high performance, and it?s up to you to initialize the memory locations that were allocated.

A very useful place of stackalloc could be creating an array directly in the stack. While C# had made using arrays very simple and easy, it still suffers from the disadvantage that these arrays are actually objects instantiated from System.Array and they are stored on the heap with all of the overhead that involves.

To create an array in the stack:

int size;
size = 6; //we can get this value at run-time as well.
int *int_ary = stackalloc int [size];

To access the array members, it?s very obvious to use *(int_ary + i), where ?i ?is the index. But it won?t be surprising to know that it?s also possible to use int_ary[i].

*( int_ary + 0) = 5; //or *int_ary = 5;
*( int_ary + 1) = 9; //accessing member #1
*( int_ary + 2) = 16;

int_ary[3] = 19; //another way to access members
int_ary[4] = 7;
int_ary[5] = 10;

In a usual array, accessing a member outside the array bounds will cause an exception. But when using stackalloc, you?re simply accessing an address somewhere on the stack; writing on it could cause to corrupt a variable value, or worst, a return address from a method currently being executed.

int[] ary = new int[6];
ary[10] = 5;//exception thrown

int *ary = stackalloc int [6];
ary[10] = 5;// the address (ary + 10 * sizeof(int)) had 5 assigned to it.

This takes us to the beginning to the article; using pointer comes with a cost. You have to be very certain of what you?re doing, any small error could cause very strange and hard to debug run-time bugs.

Reading and Writing XML Files in C#

2007-02-20T14:33:00.000+05:30

Typically, you use an XmlTextWriter if you need to write XML as raw data without the overhead of a DOM. The XmlTextWriter is an implementation of the XmlWriter class that provides the API which writes XML to file, stream, or a TextWriter. This class provides numerous validation and checking rules to ensure that the XML being written is well formed. When certain violations occur, exceptions are thrown and these exceptions should be handled. The XmlTextWriter has different constructors, each of which specifies a different type of the location to which to write the XML data. This sample uses the constructor that writes XML to a file. In particular, the following sample code constructs an XmlTextWriter with a string representing the file location for the newbooks.xml file.

XmlTextWriter myXmlTextWriter = new XmlTextWriter ("newbooks.xml", null);

C# Code:
myXmlTextWriter.Formatting = Formatting.Indented;
myXmlTextWriter.WriteStartDocument(false);
myXmlTextWriter.WriteDocType("bookstore", null, "books.dtd", null);
myXmlTextWriter.WriteComment("This file represents another fragment of a book store inventory database");
myXmlTextWriter.WriteStartElement("bookstore");
myXmlTextWriter.WriteStartElement("book", null);
myXmlTextWriter.WriteAttributeString("genre","autobiography");
myXmlTextWriter.WriteAttributeString("publicationdate","1979");
myXmlTextWriter.WriteAttributeString("ISBN","0-7356-0562-9");
myXmlTextWriter.WriteElementString("title", null, "The Autobiography of Mark Twain");
myXmlTextWriter.WriteStartElement("Author", null);
myXmlTextWriter.WriteElementString("first-name", "Mark");
myXmlTextWriter.WriteElementString("last-name", "Twain");
myXmlTextWriter.WriteEndElement();
myXmlTextWriter.WriteElementString("price", "7.99");
myXmlTextWriter.WriteEndElement();
myXmlTextWriter.WriteEndElement();

//Write the XML to file and close the myXmlTextWriter
myXmlTextWriter.Flush();
myXmlTextWriter.Close();

In creating this element, the preceding sample code also shows how, for each XML node type, there is corresponding XML write method. For example, writing an element calls the WriteElementString method and writing an attribute calls the WriteAttributeString method. For nested levels, you use the WriteStartElement / WriteEndElement pair and, for more complex attribute creation, you can use the WriteStartAttribute / WriteEndAttribute pair.

When writing XML, notice how the sample code writes the XML declaration with the version "1.0" using the WriteStartDocument method. If you want the writer to check that the document is well formed (XML declaration first, DOCTYPE in prolog, only one root level element, and so on), you must call this optional WriteStartDocument method before calling any other write method. Next, the code calls the WriteDocType method to writes the document type with the name "bookstore". The third parameter in the call to the WriteDocType specifies that the writer is to write SYSTEM "books.dtd". By writing this, the XML file indicates that there is an external DTD to validate against.

Finally, the sample code calls the Flush method to persist the XML data to a file before calling the Close method. (While this sample only really requires the Close method, there are occasions where the XML generated needs to be persisted and the writer reused.)

To check the output from the XmlTextWriter, perform a round trip test by reading in the generated file with an XmlTextReader to validate that the XML is well formed.
Reading Xml Files :

XmlReader class is the API that provides XML parsing, the XmlTextReader is the implementation designed to handle byte streams.

Typically, you use the XmlTextReader if you need to access the XML as raw data without the overhead of a DOM. Not having to access the DOM results in a faster way to reading XML. For example, an XML document could have a header section used for routing the document for processing elsewhere. The XmlTextReader has different constructors to specify the location of the XML data. This sample loads XML from the books.xml file, as shown in the following code.
XmlTextReader reader = new XmlTextReader ("books.xml");
Once loaded, the XmlTextReader moves across the XML data by using the Read method sequentially retrieving the next record from the document. The Read method returns false if there are no more records.
while (reader.Read())
{
// Do some work here on the data
...
}

To process the XML data, each record has a node type that can be determined from the NodeType property. After the NodeType enumeration returns the node type, the sample tests the node type to see whether it is either an element or document type. If the node is either one of these two types, the sample processes the node using the Name and Value properties to display details about the node. The Name property returns the node name (for instance, the element and attribute names, while the Value property returns the node value (node text) of the current node (record).
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element: // The node is an Element
Console.Write("<" + reader.Name);
while (reader.MoveToNextAttribute()) // Read attributes
Console.Write(" " + reader.Name + "='" + reader.Value + "'");
Console.Write(">");
break;
case XmlNodeType.DocumentType: // The node is a DocumentType
Console.WriteLine(NodeType + "<" + reader.Name + ">" + reader.Value);
break;
...
}
}

The XmlNodeType returned depends on the XmlReader class being used. For example, the XmlTextReader class never returns an XmlNodeType that is a Document, DocumentFragment, Entity, EndEntity and Notation node. See the .NET Framework Class Library for details on what XmlNodeType are returned by each XmlReader class.

Reading and Writing files using Microsoft .NET class libraries

2007-02-20T14:29:00.000+05:30

Writing Text Files :

Text files are the most common type of files. You can make text files in every editor, notepad is preferably used to make text files. The extension of the text file is .txt . Lets see what Microsoft .net class libraries provide us for writing and reading text files. Lets first make a simple interface that lets us enter some data in the multi-line textbox.
Button Click Code:

After making the interface let see some of the code. All the code in this example will be written in the Button click event handler since we want the file to be written when the button is clicked.
// Don't forget to import System.IO namespace

private void Button1_Click(object sender, System.EventArgs e)
{
FileStream fs = File.Create(Server.MapPath("test.txt"));
StreamWriter sw = new StreamWriter(fs);
sw.Write(TextBox1.Text);
sw.Close();
fs.Close();
}

As you can see the code is really simple. Lets examine the code and see what's going on.

1. First of all don't forget to import the System.IO namespace.
2. Make the object of FileStream class. The FileStream class is your best option when you don't care about the internal structure of the files with which you're working.
3. Next we make the object of the StreamWriter class. You can think of StreamWriter class as an additional layer of functionality on top of the FileStream class.
4. File.Create method makes a new file. The Server.MapPath means that file will be created in the virtual folder of IIS which will be located at C:\inetpub\wwwroot\YourProjectFolder\
5. Next we write the Text from the TextBox to the file using the StreamWriter Write method.
6. Finally and the most important step is to close the FileStream object explicitly using the Close method.

There are many other ways of writing text to files. One of the way is to use the TextWriter class. For more information about the TextWriter class visit this link Reading Text Files :

We have seen how we can write the Text Files lets see how we can read from the text files. Reading is also as simple as writing the text files. Lets look at the reading code below:
private void Button1_Click(object sender, System.EventArgs e)
{
FileStream fs = File.OpenRead(Server.MapPath("test.txt"));
StreamReader sr = new StreamReader(fs);

while(sr.Peek() > -1)
{
Response.Write(sr.ReadLine());
}
sr.Close();
fs.Close();
}

Lets see what the code does:

1. First we made the FileStream object and tells it to open the file "test.txt".
2. We make the StreamReader object and tell it what FileStream to read.
3. The while loop checks the end of the file when the end of the file is reached sr.Peek() returns '-1' and the loop breaks.
4. Finally we close the StreamReader and FileStream objects.