Amit Narula's Blog

Requirement Gathering Tips for designing successfull software architecture

2009-07-13T11:42:00.000-07:00

Software requirements analysis is critical to the success of a software project. Inappropriate gathering of software requirements is a major reason for projects not achieving the desired results. A META group research indicates that approximately 60-70 percent of IT project failures occur directly as a result of poor gathering of requirements, analysis, and management. Unclear requirements often increase the tendency amongst software designers and architects to over-engineer the solution. Here we will take a look at the ‘software over-engineering trap’ and the ways to avoid it.

In a recent recovery project, we were called to ‘fix’ the software developed by the customer’s own team. The testing team found that the software, though claimed to be highly scalable, was too slow and unresponsive, especially on smaller number of users. On investigating, we found that though the software architecture used the most fanciful technologies, implemented nifty design principles, and seemed ‘perfect’, it did not work when deployed. This is a classic example of what I call the ‘software over-engineering trap’. Let us take a closer look at why we fall into this trap.

Top Reasons for Getting into the ‘Over-engineering’ Trap

1. Lust for using latest technologies: Being abreast of all latest technologies available in the market, it is natural for software architects to have an inclination to use them. But in the eagerness to use the latest technologies, one should not lose sight of whether it is actually required for the project at hand.

2. Lack of clarity on non-functional requirements: Often the customer is not able to convey the requirements in the best possible way and may also be not sure on the levels of performance and scalability required. In such situations, the software architects may tend to take the safest route: create a software architecture that is straight from the textbook.

3. Limited understanding of technology at client-side: Customers may not always have a tech-savvy member working directly with them to objectively review what the architects produce.

4. Background of the architects or designers: Many times, architects play on their strength. They propose what they know the best.

All problems have a solution. We can avoid the trap, by enforcing some simple and effective steps. I call them ‘powers’ and I believe in them as if they were God sent. Nothing fanciful, but they really work.

The Power of Non-functional Requirements
In contrast to the functional requirements that determine how the system would behave, non-functional requirements (NFRs - that specify things like performance, scalability, and security requirements) are more intangible and ambiguity prone. But they are critical to the overall success of the software project and can dominate the design and architectural decision. Unfortunately, we tend not to give them their due importance because of the reasons discussed earlier. Both customers and analysts are very good at capturing functional requirements, but capturing non-functional requirements is not as easy. In many projects, NFRs are either not defined or defined very vaguely with fancy sounding open statements or defined very late in the game, almost after the software has been developed. Thanks to Mr. Murphy, the process of capturing non-functional requirements is paved with unusually high number of hurdles and speed-breakers. The end result is that we ignore the NFRs and move ahead in order to avoid delays in the project.

For example, if the customer has minimal scalability requirements, then one must carefully evaluate the need of service-orientedness (assuming no other pressing need for service orientation exists). In our recovery project example, we found that the scalability requirements were not captured properly. In reality, the customer had very minimal scalability requirements, but due to unclear requirements the designers ended up designing a highly scalable multi-layered service oriented system. As a result the system became too slow when deployed in production environments. Most architects know that each design decision comes with a trade-off and clarity in non-functional requirements help us make that decision meaningful to the customer situation.

Here are some guidelines that, when followed, can help us exploit the power of NFRs and make our architecture much closer to the real customer requirements:

1. Make NFRs non-negotiable: Irrespective of how many hurdles you may face in gathering accurate NFRs, one rule I always follow is to define a clear ‘must-achieve’ milestone by which the customer must give you all non-functional and operational requirements before the team moves to the coding phase. No sign off on NFRs, no movement in the project.

2. Document NFRs in the form of data: Document NFRs in the form of real numbers and not as open statements. For example, rather than saying, “The new system must be as good in performance as the legacy system,” one must get customers to give data in the forms such as - ‘the new system must load in less than 1 second’ or ‘the search page must provide all matching employee records in no more than 3 seconds’. Adopt this data-centric approach for scalability, installation, performance, security, and other non-functional requirements.

3. Focus on deployment: Look at the way the customer is going to deploy the software after you develop. Would it be deployed on one machine, or multiple servers, or a cluster of machines? Get an agreement on the physical deployment of the software early in the game. I particularly recommend that each team member prints the physical deployment diagram and pins it up on his or her desk.

4. Data flow diagrams and threat modeling for security: Look at the security aspect very carefully. What level of security is needed? Which portions of the system should be more secure than the others? What access levels and permissions you must provide to various roles that exist in the application? I found preparing a basic ‘data flow diagram’ very helpful in determining what type of security is needed at each level of the software. Using this simple data flow diagram, it’s very easy to figure out where a customer is exchanging personal information that requires higher security versus normal information. Many architects also perform what is known as ‘threat modeling’ based on such diagrams and other inputs before proceeding ahead with design.

The Power of Traceability Matrix
The capability to map the requirements increases the likelihood of delivering a software product that fulfills the customer’s needs. Using a ‘traceability matrix’ for this purpose is highly recommended. Most likely, you may have heard about this many times before. However, the simple submission here is that most companies either do a mere lip service to it or prepare this matrix in later phases of the lifecycle.

When used right from the start, this matrix helps us trace back the architectural considerations to real customer needs. Whether the customer asked you to prepare a traceability matrix or not, you should do it in your own interest. In this matrix, one would write down specific aspects of the architecture like componentization, service-oriented-ness, configurability, and dynamic discovery and map them to the customer requirement, especially the NFRs captured earlier. In the next column, one would also write what the drawback of using each of these architectural considerations is. In the end, you would write down what type of hardware and deployment environment would be needed for this design to deliver results. Once complete, this helps us to re-consider our design in the event it is not mapping to any customer requirement, or is having more negatives than positives. Or, if the hardware needed is much more demanding than what the customer is going to use.

The Power of Demonstrations
As they say, ‘the proof of the pudding is in eating’. And the proof of your software architecture is after you see it running live to your total satisfaction! In addition to delivering software in optimally frequent intervals, you will particularly find the concept of creating ‘min-deployment lab’ very useful. This lab mimics the real deployment environment that customer has signed up for. It has the same firewall, DMZ, domain, and security settings as the real environment would. This environment is first used by developers and testers to deploy the system and perform the testing before releasing the software. Later, the same deployment lab can be used by the customer’s teams for phase-end demonstrations. A small investment in such labs gives great ROI, as compared with the cost of fixing failed projects. Your development teams would be surprised to see your own system not behaving as intended or even crashing when really deployed in this mini-lab. This would help them solve some critical deployment level defects early in the game. If setting up a lab at the development location is not always feasible, then the project teams must look at using the customer staging and testing environments during the development cycles.

In today’s environment, with the advancements in development, deployment, and virtualization tools, setting up this lab has become easier than ever before. Teams that follow agile software development methodologies can conduct phase-end demonstrations of functional and non-functional requirements in this mini-lab to avoid unpleasant surprises in the end.

So here’s to real IT that works for the customer, and for you!

Implementing these methodological and effective approaches to software requirements gathering helps the architects collect, segregate, prioritize, analyze, and document all the relevant informational and process needs for the application under design. This understanding of software requirements gathering will help give you a competitive edge over others.

Calling a WCF service from Javascript

2009-07-05T00:24:00.000-07:00

In this sample I presume you can use Visual Studio 2008 and know a little about WCF.

1. Create an empty solution, and add a WCF service library to it
We'll call the solution JSONWCFTest, and the library JSONServices.

2. Add a data contract

using System.Collections.Generic;

using System.Runtime.Serialization;



namespace JSONServices

{

  [DataContract]

  public class SampleDataObject

  {

      public SampleDataObject(int NewId, string NewName)

      {

          Id = NewId;

         Name = NewName;

      }

      [DataMember]

      public int Id { get; set; }



      [DataMember]

      public string Name { get; set; }

  }

}

3. Add an implementing class
Implement the data contract like this

using System.Collections.Generic;



namespace JSONServices

{

  public class JSONService : IJSONService

  {

      public SampleDataObject GetSingleObject(int id, string name)

      {

          return new SampleDataObject(id, name);

      }



      public ICollection GetMultipleObjects(int number)

      {

          List list = new List();

          for (int i = 0; i < number; i++)          

              { 

                  list.Add(new SampleDataObject(i, "Name" + i));       

              }           

          return list;       

      }   

   }

}

4. Add an operation contract
Add an interface IJSONService with the following methods

using System.Collections.Generic;

using System.ServiceModel;



namespace JSONServices

{

  [ServiceContract(Namespace="http://DotNetByExample/JSONDemoService")]

  public interface IJSONService

  {

      [OperationContract]

      SampleDataObject GetSingleObject(int id, string name);



      [OperationContract]

      ICollection GetMultipleObjects(int number);

 }

}

So far, this is very basic WCF stuff. Nothing special here.

5. Add new web application
Add a new project of type "ASP.NET Web Application" to the solution. Call it JSONTestApp.

6. Add a SVC file to the web application
This part is a bit awkward. Choose "Text File", and name it "AjaxService.svc". Then open the file, and enter the following code

<%@ServiceHost    language="C#"    Debug="true"   

Service="JSONServices.JSONService"   

Factory="System.ServiceModel.Activation.WebScriptServiceHostFactory" %>

It may be tempting to add an "Ajax-enabled WCF service" to the project but this creates its own operation contract, and in this example I want to simulate the situation in which I re-use an already existing operation contract implemented in a separate service library.

7. Check the javascript interface
Basically, you are done now. Your service is hosted callable from javascript. You can check right-clicking on AjaxService.svc, and you will now see a web page that will say something like "This is a Windows© Communication Foundation service.
Metadata publishing for this service is currently disabled." and a lot things more. You can check the javascript interface by adding "/jsdebug" to the url displayed in your browser, in my case this is "http://localhost:1781/AjaxService.svc/jsdebug". This shows the dynamically generated javascript proxy that you can call in your client code:

Type.registerNamespace('dotnetbyexample.JSONDemoService');

dotnetbyexample.JSONDemoService.IJSONService=function() {

dotnetbyexample.JSONDemoService.IJSONService.initializeBase(this);

this._timeout = 0;

this._userContext = null;

this._succeeded = null;

this._failed = null;

}

dotnetbyexample.JSONDemoService.IJSONService.prototype={

_get_path:function() {

var p = this.get_path();

if (p) return p;

else return dotnetbyexample.JSONDemoService.IJSONService._staticInstance.get_path();}

,GetSingleObject:function(id,name,succeededCallback, failedCallback, userContext) {

/// <param name="id" type="Number">System.Int32</param>

/// <param name="name" type="String">System.String</param>

/// <param name="succeededCallback" type="Function" optional="true"

mayBeNull="true"></param>

/// <param name="failedCallback" type="Function" optional="true"

mayBeNull="true"></param>

/// <param name="userContext" optional="true" mayBeNull="true"></param>

return this._invoke(this._get_path(), 'GetSingleObject',false,{id:id,name:name},

succeededCallback,failedCallback,userContext); },

GetMultipleObjects:function(number,succeededCallback, failedCallback, userContext) {

/// <param name="number" type="Number">System.Int32</param>

/// <param name="succeededCallback" type="Function" optional="true"

 mayBeNull="true"></param>

/// <param name="failedCallback" type="Function" optional="true"

TomayBeNull="true"></param>

/// <param name="userContext" optional="true" mayBeNull="true"></param>

As you can see this contains a lot of plumbing - and this is only the top part - but I emphasized the parts that are interesting right now: the name of the object that you need to call from javascript (dotnetbyexample.JSONDemoService.IJSONService) and the methods, which are - surprise, suprise - have exactly the same name as their C# server-side counterparts. From here on, the procedure is pretty much the same as we were used to when calling asmx webservices from javascript:

8. Add an Web Form to the Web Application
Call it TestForm1.aspx

9. Add a script manager and a reference
Add a script manager to the form, right below the form tag, and make a reference to the AjaxService.svc file:

<form id="form1" runat="server">

<asp:scriptmanager runat="server">

<services>

  <asp:ServiceReference Path="AjaxService.svc" />

</services>

</asp:scriptmanager>

10. Add some user interface elements to call the service
Right below the script reference, add the following code:

<div>

   ID<asp:TextBox ID="tbId" runat="server">21</asp:TextBox>

   Name<asp:TextBox ID="tbName" runat="server">John Doe</asp:TextBox>

<br />

   <asp:Button ID="btnSelect" runat="server" Text="SingleSelect"

       UseSubmitBehavior="False"  OnClientClick="CallSingle(); return false;"/>

</div>

<div id="result1"></div>

11. Add Javascript code
Add some javascript code to call the WCF service and process the results. Place this inside the head-tag, below the title tag:

<script type ="text/javascript">

function CallSingle()

{

  dotnetbyexample.JSONDemoService.IJSONService.GetSingleObject(

        document.getElementById("tbId").value,

        document.getElementById("tbName").value,

        CallBackSingle );

}

function CallBackSingle( WebServiceResult )

{

resultDiv = document.getElementById("result1");

resultDiv.innerHTML = "You entered: id = " +

     WebServiceResult.Id + " name = " +

     WebServiceResult.Name;

}

</script>

Notice again that calling a WCF method from javascript works the same as when using asmx services: one extra parameter at the end of the list is required, which is the callback. This is a function that is called upon receiving the result from the server - the server method result is put into the single parameter of the callback.

12. Run the test page
Run Test1Form.aspx. You should be able to input and numerical id and a alphanumeric name, which are sent to the server, and returned back to you as and SampleObject.

13. Deploying WCF services in IIS
This all works fine when running it in Cassini, but when you want to host it in IIS, you will need to take care two things.

First, you will need to ensure that IIS and WCF are correctly installed and registered. If IIS does not seem to want to cough up your SVC files (you can check that by trying http://<your host here>/<your sitename here>/AjaxService.svc), try running the command ServiceModelReg.exe /i /x from %WINDIR%\Microsoft.NET\Framework\v3.0\Windows Communication Foundation. Restart IIS after running this command.

Second, if you created a default ASP.NET 2.0 website, you may run into this error message:

IIS specified authentication schemes 'IntegratedWindowsAuthentication, Anonymous',

but the binding only supports specification of exactly one authentication scheme.

Valid authentication schemes are Digest, Negotiate, NTLM, Basic, or Anonymous.

Change the IIS settings so that only a single authentication scheme is used.

To fix this, right-click the website in your IIS manager and choose "properties". Then click the "Directory" tab, click the "Edit" button in the "Anonymous access and authentication control" area. You will see that both Anonymous access and Integrated Windows Authentication are selected. Unselect one of them, then restart IIS. After that, the application should work smoothly.

Concluding remarks
Calling WCF services from javascript is even simpler than calling asmx services - you don't even have to mark a service as [ScriptService] anymore, you just put an .svc file into your web site with four lines of code, make a reference to an existing service library and you're done.

The sample described here does not use the IJSONService.GetMultipleObjects method, but you can download a the complete source code which includes a second test page that does. Notice that although GetMultipleObjects returns a ICollection, in javascript this is translated into a simple array. Thus, you can also use data and operation contract that use generic types, as long as the can simply be translated into an array.

The right way of accessing Master page properties from a child page

2009-07-05T00:12:00.000-07:00

Master pages are a superbe idea. But sometimes you need to access Master Page properties from the child page. Suppose, for instance, you have a button on the Master Page with a text that you want to be able to set:

<%@ Master Language="C#" AutoEventWireup="true" CodeBehind="MyDemoMaster.master.cs"
Inherits="MasterPageDemo.MyDemoMaster" %>

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

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
   <title>Untitled Page</title>
</head>
<body>
   <form id="form1" runat="server">
   <div>
       <asp:button id="btnWithText" runat="server" text="Button">
        <asp:contentplaceholder id="ContentPlaceHolder1" runat="server">
       </asp:ContentPlaceHolder>
   </div>
   </form>
</body>
</html>

In the Master Page, you can create a property like this:

public string ButtonText
{
  get { return this.btnWithText.Text;  }
  set { this.btnWithText.Text  = value; }
}

Unfortunately, if you try to find the property "Master.ButtonText" in the childpage, it won't be available since the "Master" property is of type System.Web.UI.Page, and that does not contain properties of your derived class "MyDemoMaster"

This, of course, can be solved by changing the Page_Load of the child page like this:

protected void Page_Load(object sender, EventArgs e)
{
 MyDemoMaster m = Master as MyDemoMaster;
 m.ButtonText = "My button text";
}

Congratulations. Your button shows the right text. And you have succeeded into locking your child page to a single master. Your web page will not run when you try to use another master page. Go back to programming class 101 and you don't get any cookies today ;-)

The right solution is: create an interface like this:

namespace MasterPageDemo
{
   public interface IButtonText
   {
       string ButtonText { get;set;}
   }
}

Open the code behind file of your Master Page and let it implement the interface:

public partial class MyDemoMaster : System.Web.UI.MasterPage, IButtonText
{
   protected void Page_Load(object sender, EventArgs e)
   {
   }

   public string ButtonText
   {
       get { return this.btnWithText.Text;  }
       set { this.btnWithText.Text  = value; }
   }
}

And then you make the Page_Load of the child page like this

protected void Page_Load(object sender, EventArgs e)
{
 IButtonText m = Master as IButtonText ;
 if( m != null ) m.ButtonText = "My button text";
}

Now the Master Page and Child Page are no longer coupled by name. Any Master Page implementing the IButtonText interface may be used as a Master Page for your child. Checking if it can be casted by testing m != null is a nice encore.

2009-06-23T00:34:00.000-07:00

1 Introduction

The purpose of this document is to provide a practical guide to using Microsoft’s .NET DataTables, DataSets and DataGrid. Most articles illustrate how to use the DataGrid when directly bound to tables within a database and even though this is an excellent way to use the DataGrid, it is also able to display and manage programmatically created and linked tables and datasets composed of these tables without being bound to a database. Microsoft’s implementation has provided a rich syntax for populating and accessing rows and their cells within tables, for managing collections of tables, columns, rows and table styles and for managing inserts, updates, deletes and events. Microsoft’s Visual Studio .NET development environment provides detailed explanations and code examples for the classes, which is excellent for obtaining a quick reference to a method or property, but not for understanding how they all fit together and are used in applications.

This article will present different ways to create and manage bound and unbound tables and datasets and to bind them to DataGrids for use by WebForms and WinForms. The different behaviors of the DataGrid depending upon whether it is in a WebForm or a WinForm will be presented. In addition, copying DataGrid content to the clipboard, importing and exporting in XML and printing will be presented. Techniques for linking DataGrid content to features within graphics objects to provide an interactive UI will be discussed in the last section.

The intent of this article is not to be a complete reference for all methods and members of the classes used for building Tables, Datasets and DataGrids, but to illustrate systematically how to build and manage them using their essential methods and properties. The article will also show equivalent ways for working with these entities to illustrate programming flexibility options. Once they are built the tables can be added to a database and/or the content easily extracted for updating existing database tables.

The structure and features of a table created using the DataTable class is at the heart of using the DataGrid; therefore, it will be presented first. Next the DataSet that manages collections of independent and linked tables will be presented followed by the DataGrid that displays and provides an interactive UI for its Tables and Datasets. All example code will be written in C# and the periodic table with its elements and isotopes will be used as a model and source of data.

2 Overview

Figure 1 is a summary view of the essential relationships between the DataGrid, DataGridTableStyles, DataSets and DataTables and their various methods and properties. This article will delve into the details of each of these components describing how to create them, to fill them with data and how they work together and thereby provide a clearer understanding of this relationship diagram.

Figure 1 DataGrid, DataSet and DataTable relationship diagram

3 Tables

The architecture and capability of Tables should be understood since it carries over to understanding how a DataSet and DataGrid function. In the process of binding a DataGrid to a database the underlying code creates and associates collections of tables that are filled with data from the database. Also, a DataSet created from a database may contain tables with more information than needs to be displayed, columns may need to be added that are based upon complex formulas using information in other columns and data from multiple databases may need to be combined into a single tabular view. These operations are done by extracting information from these data sources and by filling a programmatically designed table that is unbound.

Fundamentally a table contains Columns and Rows collections, which means standard methods for accessing and manipulating collections can be used. The Columns collection contains, for each column, a name, a data type specification and maybe an assigned default value. Each table row in the Rows collection contains one cell for each column. The table class has an extensive set of methods for editing and managing versions of column and row data and for event notifications when changes occur. Figure 2 illustrates the overall architecture of a table.

Figure 2 DataTable Decomposed

3.1 Table creation

A table memory object that will be able to contain/manage columns, rows and events can be easily created from the DataTable class as follows:

Collapse

// Create a table object by using the DataTable class:



DataTable dt = new DataTable();



// Name the table by assigning a data string containing 

// the name to the table’s

// TableName property:



dt.TableName = “Elements”;



// or use the DataTable(string TableName) constructor



DataTable dt = new DataTable(“Elements”);

3.2 Columns – Creating and Adding to Tables

A table contains a collection of column definitions that will be used to define how each cell within a row can be referenced and the type of data content. The following scenario shows how to define a column and add it to a table’s column collection.

a. Define a Table as described in the Tables section.

b. Create a column object to be added to the table by using the column class:

Collapse

DataColumn dc = new DataColumn();



// Set the properties for the column:



// string name for the column that is used as an index 

// for columns collection

// and a cell within a row

dc.ColumnName = “AtomicNbr”;



// string name that is used for a column label or header 

// for display purposes

// if not set, then the default value is dc.ColumnName

dc.Caption = “Atomic Number”;



// one of the standard system data types using the

// GetType() method.

dc.DataType = System.Type.GetType(“System.Int32);



// or one could use the typeof operator

dc.DataType = typeof(System.Int32);



// a default value that is assigned each time 

// a new row is created

dc.DefaultValue = 0;



// or use one of the other constructor’s such as

// DataColumn(string ColumnName, System.Type DataType)



DataColumn dc = new DataColumn(“AtomicNbr”,

 System.Type.GetType(“System.Int32”));

c. Add the new column to the table Columns collection. The order in which the columns are added determines their zero-based index.

Collapse

dt.Columns.Add(dc);

d. Repeat b and c for each column to be added to the table Columns collection.

Collapse

dc = new DataColumn(“Element”, System.Type.GetType(“System.String”));

dc.DefaultValue = string.Empty;

dc.Caption = “Element”;

dt.Columns.Add(dc);



dc = new DataColumn(“Symbol”, System.Type.GetType(“System.String”) );

dc.DefaultValue = string.Empty;

dc.Caption = “Symbol”;

dt.Columns.Add(dc);



dc = new DataColumn(“AtomicMass”, System.Type.GetType(“System.Decimal”) );

dc.DefaultValue = 0.0;

dc.Caption = “Atomic Mass”;

dt.Columns.Add(dc);

Examples of data types supported in the .NET environment.

Data Type	.NET System Types
`Boolean`	`System.Boolean`
`Byte`	`System.Byte`
`Byte[] (Array)`	`System.Byte[]`
`Char (Chararacter)`	`System.Char`
`DateTime`	`System.DateTime`
`Decimal`	`System.Decimal`
`Double`	`System.Double`
`Integer`	`System.Int16, System.Int32, System.Int64`
`Single`	`System.Single`
`String`	`System.String`
`Unsigned Integer`	`System.UInt16, System.UInt32, System.UInt64`
`TimeSpan`	`System.TimeSpan`

At this point a table called “Elements” has been created with four columns “AtomicNbr”, “Element”, “Symbol” and “AtomicMass” with their respective data types and default values. The following three DisplayColumnInfo() method code examples show this by using different techniques for accessing members and displaying data from their collections. In the first example, a for-loop is used to illustrate accessing table column collections through an integer index while in the second example a foreach loop illustrates accessing the same collections using a column class type. The third example uses strings containing the column names as an index. These accessing data examples illustrate the natural syntax approaches for working with collections.

1. for-loop

Collapse

private void DisplayColumnInfo(DataTable dt)

{lder ColInfo = new StringBuilder();

ColInfo.AppendFormat(“Column\tName\tDataType\n”);



// note that the total number of columns in the 

// collection is contained in the ‘Count’ property

for(int j=0; j{

 ColInfo.AppendFormat(“ [{0}]\t{1}\t{2}\ t{3}\n”, j,

   dt.Columns[j].ColumnName,

   dt.Columns[j].Caption, dt.Columns[j].DataType.ToString());

}



MessageBox.Show(ColInfo.ToString() , “Column Name”,

  MessageBoxButtons.OK,

MessageBoxIcon.Information);

}

2. foreach loop

Collapse

private void DisplayColumnInfo(DataTable dt)

{



 StringBuilder ColInfo = new StringBuilder();

 ColInfo.AppendFormat(“Column\tName\tDataType\n”);

 int j = -1;



 foreach (DataColumn dc in dt.Columns)

 {

  ColInfo.AppendFormat(“ [{0}]\t{1}\t{2}\t{3}\n”, ++j, dc.ColumnName,

  dc.Caption, dc.DataType.ToString() );

 }



 MessageBox.Show(ColInfo.ToString(),

   “Column Name”, MessageBoxButtons.OK,

 MessageBoxIcon.Information);

}

3. Using known column names as indexes – not column captions!

Collapse

private void DisplayColumnDataTypeInfo(DataTa}

3. Using known column names as indexes – not column captions!

Collapse

private void DisplayColumnDataTypeInfo(DataTable dt)

{

 StringBuilder ColInfo = new StringBuilder();

 ColInfo.AppendFormat(“Column\tName\tDataType\n”);



 ColInfo.AppendFormat(“ [{0}]\t{1}\t{2}\n”,1, “AtomicNbr”,

 dt.Columns[“AtomicNbr”].DataType.ToString());



 ColInfo.AppendFormat(“ [{0}]\t{1}\t{2}\n”,1, “Element”,

 dt.Columns[“Element”].DataType.ToString());



 ColInfo.AppendFormat(“ [{0}]\t{1}\t{2}\n”,1, “Symbol”,

 dt.Columns[“Symbol”].DataType.ToString());



 ColInfo.AppendFormat(“ [{0}]\t{1}\t{2}\n”,1, “AtomicMass”,

 dt.Columns[“AtomicMass”].DataType.ToString());



 MessageBox.Show(ColInfo.ToString() , “Column Name”,

 MessageBoxButtons.OK,

 MessageBoxIcon.Information);

}

3.3 Deleting/Removing Columns

Once a table has been defined columns can be deleted or removed as follows:

Collapse

// For example to delete a column “AtomicMass”

dt.Columns.Remove(“AtomicMass”);

// or using a zero-based index – “AtomicMass” is the

// 4th column with index 3

dt.Columns.RemoveAt(3);

// To make sure that a column can be removed,

// for example, first determine

// whether the column exists, belongs to the table,

// or is involved in a constraint

// or relation.

if (dt.Columns.Contains("AtomicMass"))

 if (dt.Columns.CanRemove(dt.Columns["AtomicMass"])

 {

  dt.Columns.Remove(“AtomicMass”);

 }

3.4 Modifying Column Properties

Modifying a column property is simply accessing the property and setting its new value. For example:

Collapse

dt.Columns[“AtomicNbr”].ColumnName = “AtomicNumber”;

dt.Columns[“AtomicMass”].DataType = typeof(System.float);

3.5 Clearing Column Collection

The entire table column collection can be cleared by simply using the Clear() method.

Collapse

dt.Columns.Clear();

3.6 Cloning a Table

Once a table has been defined it can be used to create an identical table with the same column collection or it can be used as a basis for a new table where columns will be deleted, added or modified. The original table’s Clone() method is used to create the new table with the same structure including schemas and constraints; however, it does not copy the content contained in the rows.

Collapse

DataTable dt1 = dt.Clone();

Now dt1 can be changed, for example:

Collapse

// delete a column

dt1.Columns.Remove(“AtomicMass”);

// add a new column to the table

dc = new DataColumn(“IsotopeNbr”,

System.Type.GetType(“System.Int32”));

dc.DefaultValue = 0;

dt1.Columns.Add(dc);

// modify the name and caption of an existing column

dt1.Columns[“AtomicNbr”].ColumnName = “AtomicNumber”;

dt1.Columns[“AtomicNbr”].Caption = “Atomic Number”;

3.7 Rows – creating and adding to a table.

This section will show how to add rows and assign values to rows in the table rows collection using four equivalent methods for accessing individual cells within a row. The choice of method really depends upon the type of task such as the source of the data being used to fill the rows or simply extracting data from the rows.

1. Define a Table with Columns as described in the Tables and Columns section

2. The following scenario is the fundamental procedure for creating a row, filling the cells in the row and then adding the row to the table. This section also illustrates equivalent ways to index a cell, which provides the developer with much flexibility.

Collapse

// First create a DataRow variable

DataRow dr;



// Next create a new row and assign it to the DataRow

// object dr using DataTable’s

// NewRow() method.

dr = dt.NewRow();

// dr now contains a cell for each column defined in the

// Columns collection

Four equivalent methods used to assign values to individual cells within a row.

Method 1

Collapse

// fill each cell using a zero-based cell integer column indexes

dr[0] = 1;

dr[1] = “Hydrogen”;

dr[2] = “H”;

dr[3] = 1.0078;

Method 2

Collapse

// fill each cell using the column name as the string column index

dr[“AtomicNbr”] = 1;

dr[“Element”] = “Hydrogen”;

dr[“Symbol”] = “H”;

dr[“AtomicMass”] = 1.0078;

Method 3

Collapse

// fill each cell using DataColumn dc -- this is more applicable

// when using a DataColumn foreach loop

// e.g. foreach (DataColumn dc in dt.Rows) …

DataColumn dc;

dc = dt.Columns[“AtomicNbr”];

dr[dc] = 1;



dc = dt.Columns[“Element”];

dr[dc] = “Hydrogen”;



dc = dt.Columns[“Symbol”];

dr[dc] = “H”;



dc = dt.Columns[“AtomicMass”];

dr[dc] = 1.0078;

Method 4

Collapse

// fill each cell using DataColumn dc and its ColumnName property

// which is identical to Method 3 but is

// included here for completeness

// Again, more applicable when using a foreach loop

DataColumn dc;

dc = dt.Columns[“AtomicNbr”];

dr[dc.ColumnName] = 1;



dc = dt.Columns[“Element”];

dr[dc.ColumnName] = “Hydrogen”;



dc = dt.Columns[“Symbol”];

dr[dc.ColumnName] = “H”;



dc = dt.Columns[“AtomicMass”];

dr[dc.ColumnName] = 1.0078;







// add the row to the table’s row collection

dt.Rows.Add(dr);

3. This scenario can be easily extended to a more general procedure to add n rows to the table. For example suppose a two dimensional object array ‘ElementData’ with n rows and dt.Columns.Count columns contains data to be added to the table. It could be loaded as follows:

Collapse

DataRow dr;



int j;

for (int i=0; i < n; i++)

{

 j = -1;

 dr = dt.NewRow();

 foreach (DataColumn dc in dt.Columns)

 {

  j++;

  // fill each cell, using the column dc as the index, from the

  // previously defined two dimensional object array à ElementData

  if (dc.DataType == typeof(System.String))

   dr[dc] = (System.String)ElementData[i][j];

  else

   if (dc.DataType == typeof(System.Int32))

    dr[dc] = (System.Int32)ElementData[i][j];

   else

    if (dc.DataType == typeof(System.Decimal))

     dr[dc] = (System.Decimal)ElementData[i][j];

 }

 dt.Rows.Add(dr);

}

3.8 Modifying data within an existing table row

There are a number of ways to modify data in a table with the following illustrating the basic mechanism. Other techniques will be presented in the following sections.

Collapse

// First create a DataRow variable

DataRow dr;

// Next assign the row in the Rows collection

// to be modified to dr, for example select row

with index = 0

dr = dt.Rows[0];

// Select the

// column within the row to be modified by specifying

// a column index and assign

the new value

dr[“AtomicNbr”] = 1.00781;

Equivalent alternative coding methods are as follows:

Collapse

dt.Rows[0][“AtomicNbr”] = 1.00781;

Collapse

dt.Rows[0][0] = 1.00781;

3.9 Fill Table using `LoadDataRow()` method

The LoadElementDataRow() code example method in this section illustrates loading data into a table using the DataTable’s LoadDataRow method that takes an object containing data for each cell within a row. The LoadDataRow method is bracketed by BeginLoadData() and EndLoadData() methods that turn off and on event notifications and other properties related to linked tables. Using these methods can prevent unnecessary processing by event handlers that would otherwise be triggered that are discussed in the Event Handler section. Also, the LoadDataRow method will modify an existing row if primary keys match or add the row to the Rows collection. Refer to the section on Row Versions that discusses the different versions of rows managed by the table’s class for sample code illustrating the different behaviors of the LoadDataRow method when a table has a primary key and when it does not.

Collapse

private DataRow LoadElementDataRow(DataTable dt,

  int AtomicNbr, string Element,

string Symbol, double AtomicMass)

{

 // Turns off event notifications,

 // index maintenance, and constraints

 // while loading data

 dt.BeginLoadData();

 // Add the row values to the rows collection and

 // return the DataRow. If the second

 // argument is set to true, then dt.AcceptChanges() is called

 //otherwise new rows are

 // marked as additions and changes to existing rows are marked as

 //modifications.

 DataRow dr = dt.LoadDataRow(new object[]

  {AtomicNbr, Element, Symbol, AtomicMass}

  , false);

 // Turns on event notifications, index maintenance, and constraints

 // that were turned off

 // with the BeginLoadData() method

 dt.EndLoadData();

 return dr; // returns the DataRow filled

 // with the new values

}

3.10Retrieving Table Content

The GetTableData() example method retrieves the column labels and row data from an input table and formats them into a string that can be used for printing, copying to the clipboard and exporting to a tab delimited text file.

Collapse

private string GetTableData(DataTable dt)

{



 StringBuilder TableData = new StringBuilder();

 // retrieve header row column labels

 TableData.AppendFormat(“Row”);

 foreach (DataColumn dc in dt.Columns)

 TableData.AppendFormat(“\t{0}”, dc.ColumnName);

 TableData.AppendFormat(“\n”);



 // retrieve rows

 int j = -1;

 foreach (DataRow dr in dt.Rows)

 {

   TableData.AppendFormat(“[{0}]”,++j);

   foreach (DataColumn dc in dt.Columns)

   {

    TableData.AppendFormat(“\t{0}”, dr[dc] );

   }

  TableData.AppendFormat(“\n”);

 }



 return TableData.ToString();



}

The output string for our element table with one row would look like the following when it is displayed in a grid format using an Excel spreadsheet or the DataGrid.

Row	AtomicNbr	Element	Symbol	AtomicMass
[0]	1	Hydrogen	H	1.0078

3.11Row Versions and Accepting/Rejecting Changes

3.11.1 Methods and Enumerations

This is an important section to understand because the Table class maintains different states and versions of rows that can be used to provide rollback, undo and transaction logging capability. That is, this state and version information provides very powerful programmatic control over table data and UI strategies.

Before discussing row states and versions there are Table and Row methods that need to be defined:

Table Method	Description
`AcceptChanges()`	Accepts all row changes to the table. Changes can be accepted to individual rows when the DataRow `AcceptChanges()` method is called.
`RejectChanges()`	Rejects all row changes to the table that have taken place since the last call to the Table or DataRow `AcceptChanges()`.
`GetChanges()`	Returns a table containing all rows that have been modified. This is particular useful when building transaction logs to satisfy government and corporate regulations, such as CFR21-11. Note: If the Table `AcceptChanges` is called prior to `GetChanges` then there will be no changes and the return value is null.

Rows Method	Description
`Add()`	Adds a row to the rows collection
`InsertAt()`	Inserts a row at a specific position in the rows collection
`RemoveAt()`	Removes a row at an index from the rows collection
`AcceptChanges()`	Accepts all changes to the row including changes to the individual cells including adding and deleting the row to and from the table respectively.
`RejectChanges()`	Rejects changes to the row restoring the original values
`BeginEdit()`	Begins a row editing session
`CancelEdit()`	Cancels a row editing session and restores all previous values
`EndEdit()`	Ends a row editing session

There are four different versions of Row Collections that are automatically maintained by the Table’s object that provides extensive programmatic control over edits, deletes and inserts.

DataRowVersion	Description
`Current`	This version contains the current set of all values contained in each table row. The current set and the default set are identical during modifying a row without calling `BeginEdit()` after `AcceptChanges()` is called.
`Default`	The Default rows collection contains all of the changes. Each time a new row is created the new row is initialized to the default column values. Each time a cell value within a row is modified, the modification will be reflected in this table.
`Proposed`	This version as its name implies contains only rows that have proposed changes where they are only present during a call to `BeginEdit()`. When `EndEdit()` is called the proposed changes are reflected in the Current `DataRow`, in the Original DataRow and proposed DataRow is deleted. When the `CancelEdit` is called, the proposed DataRow is deleted and the Default DataRow is changed back to the Current `DataRow` values.
`Original`	The Original Rows collection is updated each time `AcceptChanges()` is called. These values are used when `RejectChanges()` and `CancelEdit()` are called to return the values back to the state before any changes occurred since the last call to `AcceptChanges()`.

RowState	Description
`Added`	The row is marked as Added when a row is added or inserted to the Rows Collection and before an `AcceptChanges()` method is called.
`Deleted`	After `AcceptChanges()` is called the row is marked as Deleted when any of the following is performed: `dr.Delete()` `dt.Rows.RemoveAt(index)` `dt.Rows.Remove(dr)`
`Detached`	Before `AcceptChanges()` is called the row is marked as Detached when any of the following is performed: `dr.Delete()` `dt.Rows.RemoveAt(index)` `dt.Rows.Remove(dr)`
`Modified`	After `AcceptChanges()` is called any row cell value that is changed causes the row to be marked as Modified.
`Unchanged`	After `AcceptChanges()` is called the row or all rows are marked as Unchanged depending upon whether it is a DataRow `AcceptChanges()` call or Table `AcceptChanges()` call.

Collapse

DataTable dt = new DataTable("Elements");

DataColumn AtomicNbr = new DataColumn("AtomicNbr",

System.Type.GetType("System.Int32"));

AtomicNbr.DefaultValue=0;

dt.Columns.Add(AtomicNbr);

DataColumn Element = new DataColumn("Element",

System.Type.GetType("System.String"));

Element.DefaultValue= "Element";

dt.Columns.Add(Element);

DataRow dr;

3.11.2 Sample 1 – Row States

This section shows the different row states and the conditions for them.

Collapse

dr = dt.NewRow();

dr[Element]="Hydrogen";

dr[AtomicNbr]= 1;

// NewRow Before Add: RowState=Detached

dt.Rows.Add(dr);

// NewRow After Add: RowState=Added

dt.Rows[0].AcceptChanges();

//NewRow After AcceptChanges: RowState=Unchanged

dt.Rows.RemoveAt(0);

// note that the row is marked as Detached when

// RemoveAt() or Remove() is used

//NewRow After RemoveAt: RowState=Detached

// Add the row back, accept the changes and then delete the row

// note that the row state is now marked as deleted when Delete()

// if Delete() is called prior to the row being

// added then the row is marked as Detached.

dt.Rows.Add(dr);

dt.AcceptChanges();

dr.Delete();

// NewRow After Delete:

The following code examples will illustrate the above method functionality. After each section of code will be four tables, one each for each type of DataRowVersion, that will show whether the version contains a row and if so their respective values.

NOTE

Rows that do not exist (designated with a ‘No’ value under column ‘Has Versions’) for a particular RowState version are added or included for readability and clarity. That is, if all the rows in a version table were listed, these would not be in the Table Rows collection.

The presentation schema is from code Sample 2 to Sample N where each successive code Sample uses the results from the previous Sample. All changes that occur to the version tables for Sample code section are designated in bold red.

3.11.3 Sample 2 – Initial Loading of Table

Collapse

dr = dt.NewRow();

dr[Element]="Hydrogen";

dr[AtomicNbr]= 1;

dt.Rows.Add(dr);

dr = dt.NewRow();

dr[Element]="Helium";

dr[AtomicNbr]= 2;

dt.Rows.Add(dr);

dr = dt.NewRow();

dr[Element]="Lithium";

dr[AtomicNbr]= 3;

dt.Rows.Add(dr);

dr = dt.NewRow();

// this row contains default values

dt.Rows.Add(dr);

Row 0 has only an Original Version and it is marked as Deleted. The Current and Default versions are identical with the four new rows being marked as Added. The Proposed version table does not contain any values.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	Yes	Added	1	Hydrogen
[2]	Yes	Added	2	Helium
[3]	Yes	Added	3	Lithium
[4]	Yes	Added	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	Yes	Added	1	Hydrogen
[2]	Yes	Added	2	Helium
[3]	Yes	Added	3	Lithium
[4]	Yes	Added	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Deleted	0	Element
[1]	No
[2]	No
[3]	No
[4]	No

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No
[4]	No

3.11.4 Sample 3 – DataRow AcceptChanges

Collapse

dt.Rows[0].AcceptChanges();

dt.Rows[1].AcceptChanges();

After the Rows[0].AcceptChanges() was called, the row that was marked deleted, row 0 in the above version tables, has been deleted from all versions and all other rows have new indices. The next AcceptChanges() command references row 1 in the newly ordered Rows Collection. In this case, the Row State is marked as Unchanged in versions Current, Default and Original. In the Original version there is only one row and it corresponds to Row 1 that was accepted. The Proposed version table does not contain any values.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Added	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Added	3	Lithium
[3]	Yes	Added	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Added	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Added	3	Lithium
[3]	Yes	Added	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	Yes	Unchanged	2	Helium
[2]	No
[3]	No

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No

3.11.5 Sample 4 – Table AcceptChanges

Collapse

dt.AcceptChanges();

After the Table.AcceptChanges() is called, all remaining rows are marked Unchanged in the Current, Default and Original Version tables and the Original version table is identical to the Current and Default version tables. The Proposed version table does not contain any rows.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No

3.11.6 Sample 5 – DataRow BeginEdit

Collapse

dt.Rows[1].BeginEdit();

dt.Rows[1]["Element"]= "Helium";

dt.Rows[1]["AtomicNbr"]= 222;

The above code begins an editing session on row 1 and the new values are reflected in the Default version table and values now appear in the Proposed version table. All other table version entries remain unchanged.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	222	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	Yes	Unchanged	222	Helium
[2]	No
[3]	No

3.11.7 Sample 6 – DataRow CancelEdit

Collapse

dt.Rows[1].CancelEdit();

The CancelEdit() command returns the default values back to the Original state and clears out the Proposed values from row 1 in the Proposed version table.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No

3.11.8 Sample 7 – DataRow BeginEdit – Example 2

Collapse

dt.Rows[3].BeginEdit();

The BeginEdit() method initializes the Proposed row 3 with default values.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	Yes	Unchanged	0	Element

3.11.9 Sample 8 – DataRow Change values – Example 2

Collapse

dt.Rows[3]["Element"]="Carbon";

dt.Rows[3]["AtomicNbr"]= 12;

The Default and Proposed row 3 values have been changed to reflect Carbon and 12. All other rows in all versions remain unchanged.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	0	Element

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	Yes	Unchanged	12	Carbon

3.11.10 Sample 9 – DataRow EndEdit – Modified Rows

Collapse

dt.Rows[3].EndEdit();

dt.Rows[0]["Element"] = "Oxygen";

dt.Rows[0]["AtomicNbr"] = 8;

// Add a new row.

dr = dt.NewRow();

dt.Rows.Add(dr);

After EndEdit() is called, the Current and Default versions for row 3 are updated and marked as Modified. The Original version for row 3 still retains the original values before the changes and is marked as Modified.

The next two lines assign “Oxygen” and its atomic number to row 0 and these values are reflected in the Current and Default versions, which are also marked as Modified. The Original version for row 0 remains unchanged.

The next two lines adds a new row to the Current and Default version tables initialized with default values and marked as Added. Note that the new row does not appear in the Original version table.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	8	Oxygen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Modified	12	Carbon
[4]	Yes	Added	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	8	Oxygen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Modified	12	Carbon
[4]	Yes	Added	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Modified	0	Element
[4]	No

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No
[4]	No

3.11.11 Sample 10 – DataRow AcceptChanges of Modified Rows

Collapse

dt.Rows[3].AcceptChanges();

The DataRow AcceptChanges() for row 3 causes the corresponding row in the Current and Default version tables to be marked as Unchanged and the Original version table now contains the same row values.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	8	Oxygen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Added	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	8	Oxygen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Added	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	No

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No
[4]	No

3.11.12 Sample 11 – DataRow RejectChanges

Collapse

dt.Rows[0].RejectChanges();

Calling the DataRow RejectChanges() method for row 0 causes the corresponding row values for the Current and Default tables to revert to the Original version values and three tables, Current, Default and Original, have the Row State for row 0 marked as unchanged.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Added	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Added	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	No

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No
[4]	No

3.11.13 Sample 12 – LoadDataRow without table having primary key

Collapse

dt.BeginLoadData();

dt.LoadDataRow(new object[]{1,"Deuterium"}, false);

dt.EndLoadData();

If a table does not have a primary key then the LoadDataRow method will create a new row and fill it with values in the object array. Looking at rows 0 and 5 in the Current and Default version tables, they both have the same atomic number, but different element names. Also, Row 5 is marked as being Added.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Added	0	Element
[5]	Yes	Added	1	Deuterium

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Added	0	Element
[5]	Yes	Added	1	Deuterium

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Unchanged	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	No
[5]	No

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No
[4]	No
[5]	No

3.11.14 Sample 13 – LoadDataRow with table having primary key

Collapse

// must delete the row with a duplicate

// AtomicNbr in order to create

// a primary key.

dt.Rows.RemoveAt(5);

dt.AcceptChanges();

// Create a primary key and load the new object array data.

dt.PrimaryKey = new DataColumn[] {dt.Columns["AtomicNbr"]};

dt.BeginLoadData();

dt.LoadDataRow(new object[]{1,"Deuterium"}, false);

dt.EndLoadData();

If a table has a primary key then the LoadDataRow method will modify the data in the row if the primary keys match or else it will append the row to the table. Looking at row 0 in the Current and Default version tables, the element name has been changed from Hydrogen to Deuterium. In the three version tables Current, Default and Original row 0 is now marked as being Modified.

Current Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	1	Deuterium
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Unchanged	0	Element

Default Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	1	Deuterium
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Unchanged	0	Element

Original Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	Yes	Modified	1	Hydrogen
[1]	Yes	Unchanged	2	Helium
[2]	Yes	Unchanged	3	Lithium
[3]	Yes	Unchanged	12	Carbon
[4]	Yes	Unchanged	0	Element

Proposed Version

Row	Has Versions	Row State	AtomicNbr	Element
[0]	No
[1]	No
[2]	No
[3]	No
[4]	No

3.11.15 Sample Code for Obtaining Version and State Information

The above tables were generated using the following procedure.

Collapse

static void PrintRowVersions(DataTable dt)

{

 DataRowVersion[] rowVer = new DataRowVersion[4];

 rowVer[0] = DataRowVersion.Current;

 rowVer[1] = DataRowVersion.Default;

 rowVer[2] = DataRowVersion.Original;

 rowVer[3] = DataRowVersion.Proposed;

 StringBuilder TableData = new StringBuilder();

 for(int i=0; i {

   // Print the value of each column in each row.

   TableData.AppendFormat("{0} Version\n", rowVer[i].ToString());

   // retrieve header row column labels

   TableData.AppendFormat("Row\tHas Versions\tRow State");

   foreach (DataColumn dc in dt.Columns)

     TableData.AppendFormat("\t{0}", dc.ColumnName);

   TableData.AppendFormat("\n");

   int n=-1;

   foreach(DataRow row in dt.Rows )

   {

     n++;

     if (row.HasVersion(rowVer[i]) )

     {

       // Print the specified version of the row's value.

       TableData.AppendFormat("[{0}]\tYes\t{1}",

       n.ToString(), row.RowState.ToString());

       foreach (DataColumn dc in dt.Columns)

       {

          TableData.AppendFormat("\t{0}", row[dc,rowVer[i]]);

       }

       TableData.AppendFormat("\n");

    }

    else

    {

       TableData.AppendFormat("[{0}]\tNo\t", n.ToString());

       for(int j=0; j        TableData.AppendFormat("\t ");

       TableData.AppendFormat("\n");

    }

  }

  TableData.AppendFormat("\n");

 }

 // output string data to a text file using a StreamWriter

 // StreamWriter sw = new StreamWriter("c:\RowVersions.txt");

 sw.Write(TableData.ToString());

 // sw.Close();

}

3.12Handling DataTable Errors

A DataTable can be checked to determine if it contains any rows with errors by examining the Table’s HasErrors property value. The following code illustrates how to isolate the rows and their columns with errors.

Collapse

if (dt.HasErrors)

{ // Errors have occurred in rows in table dt

 foreach (DataRow dr in dt.Rows)

 {

  if(dr.HasErrors)

  {

   // Row has errors

   // GetColumnsInError() returns an array of

   // DataColumns that contain errors

   foreach(DataColumn dc in dr.GetColumnsInError())

   {

     // GetColumnError returns a description of the Column error

     MessageBox.Show(dr.GetColumnError(dc.Ordinal));

   }

  }

 }

}

3.13DataTable Events

The following code provides an example of adding a DataTable column changed event handler and the code within the handler illustrates some techniques for processing the new column values.

Collapse

dt.ColumnChanged += new DataColumnChangeEventHandler

 (this.SampleForm_ColumnChanged);

private void SampleForm_ColumnChanged(object sender,

 System.Data.DataColumnChangeEventArgs e)

{

if(e.Column.Ordinal  …)

{

  // could perform validation checks such as range values

  // or formatting or other types of 

  //processing on the changed column.

}

if(e.Row.HasErrors)

{

  // clear the error

  e.Row.SetColumnError(e.Column, string.Empty);

  // check to see if row has any more errors

  DataColumn [] dcErrors = e.Row.GetColumnsInError();

  // if there are no more errors then clear the row error flag.

  if(dcErrors.Length == 0)

  e.Row.ClearErrors();

}

}

How To Make Your Website More (McAfee) Secure

2009-06-15T00:06:00.000-07:00

Introduction

Recently one of my clients requested, after a critical attack on the server where an application was running, to make sure that the application is secured in all perspectives. We chose McAfee to ensure that the website is 100% hacker proof. After a thorough Application Scan, Network Scan, and PCI Scan, McAfee found out several vulnerabilities in the Website, and I thought some of them exist in most of the websites we make. So here is a brief list and solutions we have found out to make a website 100% McAfee Secured and PCI Compliant.

Before we delve into the technical details, I want to clarify what this article covers and what it does not, better not to create any false expectations. This article is solely based on my experience while solving the vulnerabilities, and I have presented them likewise. As several of the fixes require tweaks in registry, make sure to back the registry up, and change anything at your own risk.

Following are the most important vulnerabilities that were reported by McAfee:

Vulnerability 1

Vulnerability Name: Microsoft .NET Custom Errors Not Set

Description

This is when the custom error page is not set for an application. We generally use the web.config to specify the Error Page. But McAfee requires it to be done both ways.

Solution

In order to fix this vulnerability the error pages must be set from the IIS. The steps are as follows:

Go to IIS Manager
Right click on the project name that has to be McAfee Secured
Click Properties
In the Properties Box, click on the “Custom Errors” tab and the following window appears:
Highlight any one of the error types and click on edit properties and a small window appears where the custom error page can be specified.
Click on OK button in both this and its parent window.
If even one error page is specified for any one error, McAfee considers this a vulnerability no more.

Vulnerability 2

Vulnerability Name: Allow All Policy in crossdomain.xml

Description

If a website uses several flash videos and content and other websites use them in their websites, the crossdomain.xml comes into play. This XML file sets the policy about who can use the content in their websites in terms of domain name. It has a key called –

Collapse

According to McAfee, this poses a serious threat of hack attack to the website.

Solution

It is very confusing how McAfee scans the file, because even if the file is removed from the root (wwwroot), and a copy of the file still exists in any place of the whole server, McAfee still finds that and gives an alert. The best solution is to Edit each and every occurrence of that file in the whole server and remove all stars (*) and give specific domain names from which the videos will be accessed. If not required, it is best to completely delete the file.
So the edited file will look like:

Collapse

(* denotes anything that prepends the domain name e.g. messenger.yahoo.com in also all protocols: HTTP or HTTPS)

Vulnerability 3

Vulnerability Name: Using SSL v2 in Secure Communications

Description

The remote service appears to encrypt traffic using SSL protocol version 2.

Netscape Communications Corporation introduced SSL 2.0 with the launch of Netscape Navigator 1.0 in 1994 and it contains several well-known weaknesses. For example, SSLv2 doesn't provide any protection against man-in-the-middle attacks during the handshake, and uses the same cryptographic keys for message authentication and for encryption.

In Internet Explorer 7, the default HTTPS protocol settings are changed to disable the weaker SSLv2 protocol and to enable the stronger TLSv1 protocol. By default, Internet Explorer 7 users will only negotiate HTTPS connections using SSLv3 or TLSv1. Mozilla Firefox is expected to drop support for SSLv2 in its upcoming versions.

As almost all modern browsers support SSLv3, disabling support for the weaker SSL method should have minimal impact. The following browsers support SSLv3:

Internet Explorer 5.5 or higher (PC)
Internet Explorer 5.0 or higher (Mac)
Netscape 2.0 (Domestic) or higher (PC/Mac)
Firefox 0.8 or higher (PC/Mac/Linux)
Mozilla 1.7 or higher (PC/Mac/Linux)
Camino 0.8 or higher (Mac)
Safari 1.0 or higher (Mac)
Opera 1.7 or higher (PC/Mac)
Omniweb 3.0 or higher (Mac)
Konqueror 2.0 or higher (Linux)

According to https://www.pcisecuritystandards.org/pdfs/pcissc_assessors_nl_2008-11.pdf, an Assessor's update report, "...it is imperative that an ASV identify the use of SSL 2.0 to transmit cardholder data as a failure."

Solution

SSL related protocols can run on other service ports as well. Typical ports include: 465, 993, 995, 2078, 2083, 2087, 2096, 8443, etc. Each application will have its own configuration options to handle SSL protocols.
To solve this problem, one needs to open Registry Editor.

Click Start, click Run, type regedt32 or type regedit, and then click OK.

In Registry Editor, locate the following registry key:

Collapse

HKey_Local_Machine\System\CurrentControlSet\Control\SecurityProviders
    \SCHANNEL\Protocols\SSL 2.0\Server

On the Edit menu, click Add Value.
In the Data Type list, click DWORD.
In the Value Name box, type Enabled, and then click OK. (The value will be automatically set to 0 – Disabled )
Next Restart the system and the SSL V2 will be disabled for good.
Reference: http://support.microsoft.com/default.aspx?scid=kb;en-us;187498.

Vulnerability 4

Vulnerability Name: Weak Supported SSL Ciphers Suites

Description

The remote host supports the use of SSL ciphers that offer either weak encryption or no encryption at all. This vulnerability is valid for all SSL/TLS sessions that are passing sensitive information.
PCI defines strong cryptography, for secret key based systems, as anything above 80 bit encryption.

Solution

The solution to this is very simple but requires registry tweak again. Following are the steps:

Click Start, click Run, type regedt32 or type regedit, and then click OK.

In Registry Editor, locate the following registry key:

Collapse

HKey_Local_Machine\System\CurrentControlSet\Control\SecurityProviders
      \SCHANNEL\Ciphers

Under the Cipher key, there are several Ciphers.
Locate the ciphers which have encryption less than 128 bit.
Create DWORD values named Enabled and Value 0 for each of them, just as the previous case.
For convenience, I have marked them with red arrows in the picture above.
System Restart is NOT required for this.

Now the server is secured.
The above mentioned security issues are the major ones that most of the systems have. However other than this, there may be some easy and minor vulnerabilities like:

Using robots.txt in the pages. (Generally inserted by Web Marketing team to track user hit).
Directory Scanner: Common directories are revealed. This can be resolved by URL rewriting and setting “Directory Browsing” off.

Note: For the above vulnerabilities, minor registry tweaks will be necessary. So it is strongly recommended to back up the registry before doing anything. By any chance if something gets messed up, just delete the SCHANNEL key and restart the machine, the key will be auto-generated.

10 ASP.NET Performance and Scalability Secrets

2009-06-13T03:25:00.000-07:00

Introduction

ASP.NET 2.0 has many secrets, which when revealed can give you big performance and scalability boost. For instance, there are secret bottlenecks in Membership and Profile provider which can be solved easily to make authentication and authorization faster. Furthermore, ASP.NET HTTP pipeline can be tweaked to avoid executing unnecessary code that gets hit on each and every request. Not only that, ASP.NET Worker Process can be pushed to its limit to squeeze out every drop of performance out of it. Page fragment output caching on the browser (not on the server) can save significant amount of download time on repeated visits. On demand UI loading can give your site a fast and smooth feeling. Finally, Content Delivery Networks (CDN) and proper use of HTTP Cache headers can make your website screaming fast when implemented properly. In this article, you will learn these techniques that can give your ASP.NET application a big performance and scalability boost and prepare it to perform well under 10 times to 100 times more traffic.

In this article we will discuss the following techniques:

ASP.NET pipeline optimization
ASP.NET process configuration optimization
Things you must do for ASP.NET before going live
Content Delivery Network
Caching AJAX calls on browser
Making best use of Browser Cache
On demand progressive UI loading for fast smooth experience
Optimize ASP.NET 2.0 Profile provider
How to query ASP.NET 2.0 Membership tables without bringing down the site
Prevent Denial of Service (DOS) attack

The above techniques can be implemented on any ASP.NET website, especially those who use ASP.NET 2.0's Membership and Profile provider.

ASP.NET Pipeline Optimization

There are several ASP.NET default HttpModules which sit in the request pipeline and intercept each and every request. For example, SessionStateModule intercepts each request, parses the session cookie and then loads the proper session in the HttpContext. Not all of these modules are always necessary. For example, if you aren't using Membership and Profile provider, you don't need FormsAuthentication module. If you aren't using Windows Authentication for your users, you don't need WindowsAuthentication. These modules are just sitting in the pipeline, executing some unnecessary code for each and every request.

The default modules are defined in machine.config file (located in the $WINDOWS$\Microsoft.NET\Framework\$VERSION$\CONFIG directory).

Collapse

<httpModules>

<add name="OutputCache" type="System.Web.Caching.OutputCacheModule" />

<add name="Session" type="System.Web.SessionState.SessionStateModule" />

<add name="WindowsAuthentication"

     type="System.Web.Security.WindowsAuthenticationModule" />

<add name="FormsAuthentication"

     type="System.Web.Security.FormsAuthenticationModule" />

<add name="PassportAuthentication"

     type="System.Web.Security.PassportAuthenticationModule" />

<add name="UrlAuthorization" type="System.Web.Security.UrlAuthorizationModule" />

<add name="FileAuthorization" type="System.Web.Security.FileAuthorizationModule" />

<add name="ErrorHandlerModule" type="System.Web.Mobile.ErrorHandlerModule,

                          System.Web.Mobile, Version=1.0.5000.0,

                          Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

</httpModules>

You can remove these default modules from your Web application by adding <remove> nodes in your site's web.config. For example:

Collapse

<httpModules>

      

      <remove name="Session" />

      <remove name="WindowsAuthentication" />

      <remove name="PassportAuthentication" />

      <remove name="AnonymousIdentification" />

      <remove name="UrlAuthorization" />

      <remove name="FileAuthorization" />

</httpModules>

The above configuration is suitable for websites that use database based Forms Authentication and do not need any Session support. So, all these modules can safely be removed.

ASP.NET Process Configuration Optimization

ASP.NET Process Model configuration defines some process level properties like how many number of threads ASP.NET uses, how long it blocks a thread before timing out, how many requests to keep waiting for IO works to complete and so on. The default is in many cases too limiting. Nowadays hardware has become quite cheap and dual core with gigabyte RAM servers have become a very common choice. So, the process model configuration can be tweaked to make ASP.NET process consume more system resources and provide better scalability from each server.

A regular ASP.NET installation will create machine.config with the following configuration:

Collapse

<system.web>

  <processModel autoConfig="true" />

You need to tweak this auto configuration and use some specific values for different attributes in order to customize the way ASP.NET worker process works. For example:

Collapse

<processModel

enable="true"

timeout="Infinite"

idleTimeout="Infinite"

shutdownTimeout="00:00:05"

requestLimit="Infinite"

requestQueueLimit="5000"

restartQueueLimit="10"

memoryLimit="60"

webGarden="false"

cpuMask="0xffffffff"

userName="machine"

password="AutoGenerate"

logLevel="Errors"

clientConnectedCheck="00:00:05"

comAuthenticationLevel="Connect"

comImpersonationLevel="Impersonate"

responseDeadlockInterval="00:03:00"

responseRestartDeadlockInterval="00:03:00"

autoConfig="false"

maxWorkerThreads="100"

maxIoThreads="100"

minWorkerThreads="40"

minIoThreads="30"

serverErrorMessageFile=""

pingFrequency="Infinite"

pingTimeout="Infinite"

asyncOption="20"

maxAppDomains="2000"

/>

Here all the values are default values except for the following ones:

maxWorkerThreads - This is default to 20 per process. On a dual core computer, there'll be 40 threads allocated for ASP.NET. This means at a time ASP.NET can process 40 requests in parallel on a dual core server. I have increased it to 100 in order to give ASP.NET more threads per process. If you have an application which is not that CPU intensive and can easily take in more requests per second, then you can increase this value. Especially if your Web application uses a lot of Web service calls or downloads/uploads a lot of data which does not put pressure on the CPU. When ASP.NET runs out of worker threads, it stops processing more requests that come in. Requests get into a queue and keeps waiting until a worker thread is freed. This generally happens when site starts receiving much more hits than you originally planned. In that case, if you have CPU to spare, increase the worker threads count per process.
maxIOThreads - This is default to 20 per process. On a dual core computer, there'll be 40 threads allocated for ASP.NET for I/O operations. This means at a time ASP.NET can process 40 I/O requests in parallel on a dual core server. I/O requests can be file read/write, database operations, web service calls, HTTP requests generated from within the Web application and so on. So, you can set this to 100 if your server has enough system resource to do more of these I/O requests. Especially when your Web application downloads/uploads data, calls many external webservices in parallel.
minWorkerThreads - When a number of free ASP.NET worker threads fall below this number, ASP.NET starts putting incoming requests into a queue. So, you can set this value to a low number in order to increase the number of concurrent requests. However, do not set this to a very low number because Web application code might need to do some background processing and parallel processing for which it will need some free worker threads.
minIOThreads - Same as minWorkerThreads but this is for the I/O threads. However, you can set this to a lower value than minWorkerThreads because there's no issue of parallel processing in case of I/O threads.
memoryLimit - Specifies the maximum allowed memory size, as a percentage of total system memory, that the worker process can consume before ASP.NET launches a new process and reassigns existing requests. If you have only your Web application running in a dedicated box and there's no other process that needs RAM, you can set a high value like 80. However, if you have a leaky application that continuously leaks memory, then it's better to set it to a lower value so that the leaky process is recycled pretty soon before it becomes a memory hog and thus keep your site healthy. Especially when you are using COM components and leaking memory. However, this is a temporary solution, you of course need to fix the leak.

Besides the processModel, there's another very important section with the system.net where you can specify the maximum number of outbound requests that can be made to a single IP.

Collapse

<system.net>

<connectionManagement>

 <add address="*" maxconnection="100" />

</connectionManagement>

</system.net>

Default is 2, which is just too low. This means you cannot make more than 2 simultaneous connections to an IP from your Web application. Sites that fetch external content a lot suffer from congestion due to the default setting. Here I have set it to 100. If your Web applications make a lot of calls to a specific server, you can consider setting an even higher value.

You can learn more about these configuration settings from "Improving ASP.NET Performance".

Things You Must Do for ASP.NET Before Going Live

You should do some tweaking on your web.config if you are using ASP.NET 2.0 Membership Provider before you go live on your production server:

Add applicationname attribute in Profile Provider. If you do not add a specific name here, Profile provider will use a GUID. So, on your local machine you will have one GUID and on the production server you will have another GUID. If you copy your local DB to the production server, you won't be able to reuse the records available in your local DB and ASP.NET will create a new application on production. Here's where you need to add it:

Collapse
```
<profile enabled="true">

<providers>

<clear />

<add name="..." type="System.Web.Profile.SqlProfileProvider"

connectionStringName="..." applicationName="YourApplicationName"

description="..." />

</providers> 
```
Profile provider will automatically save the profile whenever a page request completes. So, this might result in an unnecessary UPDATE on your DB which has significant performance penalty. So, turn off automatic save and do it explicitly from your code using Profile.Save();

Collapse
```
<profile enabled="true" automaticSaveEnabled="false" >
```
Role Manager always queries the database in order to get the user roles. This has significant performance penalty. You can avoid this by letting the Role Manager cache role information on a cookie. But this will work for users who do not have a lot of roles assigned to them which exceeds the 2 KB limit of Cookie. But it's not a common scenario. So, you can safely store role info on a cookie and save one DB roundtrip on every request to *.aspx and *.asmx.

Collapse
```
<roleManager enabled="true" cacheRolesInCookie="true" >
```

The above three settings are must haves for high volume websites.

Content Delivery Network

Every request from a browser goes to your server traveling through the Internet backbones that span the world. The number of countries, continents, oceans a request has to go through to reach your server, the slower it is. For example, if you have your servers in USA and someone from Australia is browsing your site, each request is literary crossing the planet from one end to the other in order to reach your server and then come back again to the browser. If your site has large number of static files like images, CSS, JavaScript; sending request for each of them and downloading them across the world takes a significant amount of time. If you could setup a server in Australia and redirect users to your Australian server, then each request would take fraction of the time it takes to reach USA. Not only the network latency will be lower but also the data transfer rate will be faster and thus static content will download a lot faster. This will give significant performance improvement on the user�s end if your website is rich in static content. Moreover, ISPs provide far greater speed for country wide network compared to the Internet because each country generally has handful of connectivity to the Internet backbone that is shared by all ISPs within the country. As a result, users having 4 MBPS broadband connection will get the full 4 MBPS speed from servers that are within the same country. But they will get as low as 512 KBPS from servers which are outside the country. Thus having a server in the same country significantly improves site download speed and responsiveness.

Besides improving site load speed, CDN also offloads traffic from your Web servers. As it deals with static cacheable content, your webservers rarely get hits for those content. Thus hits going to your webservers drop significantly and webservers free up more resource to process dynamic requests. Your webservers also save a lot of IIS log space because IIS need not log requests for the static contents. If you have a lot of graphics, CSS and JavaScript on your website, you can save gigabytes of IIS logs every day.

Above figure shows average response time for www.pageflakes.com from Washington, DC, where the servers are in Dallas, Texas. The average response time is around 0.4 seconds. This response includes server side execution time as well. Generally it takes around 0.3 to 0.35 seconds to execute the page on the server. So, time spent on the network is around 0.05 seconds or 50ms. This is a really fast connectivity as there are only 4 to 6 hops to reach Dallas from Washington DC.

This figure shows average response time from Sydney, Australia. The average response time is 1.5 seconds which is significantly higher than that of Washington DC. It�s almost 4 times compared to USA. There's almost 1.2 seconds overhead on network only. Moreover, there are around 17 to 23 hops from Sydney to Dallas. So, the site downloads at least 4 times slower in Australia than it is from anywhere in USA.

A content delivery network (CDN) is a system of computers networked together across the Internet. The computers cooperate transparently to deliver content (especially large media content) to end users. CDN nodes (cluster of servers in a specific location) are deployed in multiple locations, often over multiple backbones. These nodes cooperate with each other to serve requests for content by end users. They also transparently move content behind the scenes to optimize the delivery process. CDN serves requests by intelligently choosing the nearest server. It looks for the fastest connectivity between your computer to a nearest node that has the content you are looking for. The number of nodes in different countries and the number of redundant backbone connectivity a CDN has measures its strength. Some of the most popular CDNs are Akamai, Limelight, EdgeCast. Akamai is used by large companies like Microsoft, Yahoo, AOL. It�s a comparatively expensive solution. However, Akamai has the best performance throughout the world because they have servers in almost every prominent city in the world. However, Akamai is very expensive and they only accept a customer who can spend a minimum of 5K on CDN per month. For smaller companies, Edgecast is a more affordable solution.

This figure shows CDN Nodes that are closest to the browser intercepts traffic and serves response. If it does not have the response in cache, it fetches it from origin server using a faster route and much more optimized connectivity than the browser�s ISP can provide. If the content is already cached, then it�s served directly from the node and no request goes to the origin server.

There are generally two types of CDNs. One is where you upload content to CDN's servers via FTP and you get a subdomain in their domain like dropthings.somecdn.net. You change all the URL of static content throughout your site to download content from the CDN domain instead of the relative URL to your own domain. So, a URL like /logo.gif will be renamed to http://dropthings.somecdn.net/logo.gif. This is easy to configure but has maintenance problems. You will have to keep CDN�s store synchronized with the files all the time. Deployment becomes complicated because you need to update both your website and the CDN store at the same time. Example of such a CDN (which is very cheap) is Cachefly.

A more convenient approach is to store static content on your own site but use domain aliasing. You can store your content in a subdomain that points to your own domain like static.dropthings.com. Then you use CNAME to map that subdomain to a CDN�s nameserver like cache.somecdn.net. When a browser tries to resolve static.dropthigns.com, the DNS lookup request goes to the CDN nameserver. The nameserver then returns IP of a CDN node which is closest to you and can give you the best download performance. The browser then sends requests for files to that CDN node. When CDN node sees the request, it checks whether it has the content already cached. If it is cached, it delivers the content directly from its local store. If not, it makes a request to your server and then looks at the cache header generated in response. Based on the cache header it decides how long to cache the response in its own cache. In the meantime, the browser does not wait for CDN node to get content and return to it. CDN does an interesting trick on the Internet backbone to actually route requests to the origin server so that the browser gets the response directly served from origin server while CDN is updating its cache. Sometimes CDN act as a proxy, intercepting each request and then fetching uncached content from the origin using a faster route and optimized connectivity to the origin server. Example of such CDN is Edgecast.

Caching AJAX Calls on Browser

Browsers can cache images, JavaScript, CSS files on a user's hard drive, and it can also cache XML HTTP calls if the call is a HTTP GET. The cache is based on the URL. If it's the same URL, and it's cached on the computer, then the response is loaded from the cache, not from the server when it is requested again. Basically, the browser can cache any HTTP GET call and return cached data based on the URL. If you make an XML HTTP call as HTTP GET and the server returns some special header which informs the browser to cache the response, on future calls, the response will be immediately returned from the cache and thus saves the delay of network roundtrip and download time.

At Pageflakes, we cache the user's state so that when the user visits again the following day, the user gets a cached page which loads instantly from the browser cache, not from the server. Thus the second time load becomes very fast. We also cache several small parts of the page which appears on user's actions. When the user performs the same action again, a cached result is loaded immediately from the local cache and thus saves the network roundtrip time. The user gets a fast loading site and a very responsive site. The perceived speed increases dramatically.

The idea is to make HTTP GET calls while making Atlas Web service calls and return some specific HTTP Response headers that tell the browser to cache the response for some specific duration. If you return the Expires header during the response, the browser will cache the XML HTTP response. There are two headers that you need to return with the response that instruct the browser to cache the response:

Collapse

HTTP/1.1 200 OK

Expires: Fri, 1 Jan 2030

Cache-Control: public

This instructs the browser to cache the response till Jan 2030. As long as you make the same XML HTTP call with the same parameters, you will get cached response from the computer and no call will go to the origin server. There are more advanced ways to get further control over response caching. For example, here is a header that instructs the browser to cache for 60 seconds but contact the server and get a fresh response after 60 seconds. It will also prevent proxies from returning cached response when the browser local cache expires after 60 seconds.

Collapse

HTTP/1.1 200 OK

Cache-Control: private, must-revalidate, proxy-revalidate, max-age=60

Let's try to produce such response headers from an ASP.NET Web service call:

Collapse

[WebMethod][ScriptMethod(UseHttpGet=true)]

public string CachedGet()

{

 TimeSpan cacheDuration = TimeSpan.FromMinutes(1);

 Context.Response.Cache.SetCacheability(HttpCacheability.Public);

 Context.Response.Cache.SetExpires(DateTime.Now.Add(cacheDuration));

 Context.Response.Cache.SetMaxAge(cacheDuration);

 Context.Response.Cache.AppendCacheExtension(

        "must-revalidate, proxy-revalidate");



 return DateTime.Now.ToString();

}

This will result in the following response headers:

The Expires header is set properly. But the problem is with the Cache-control. It is showing that max-age is set to 0 which will prevent the browser from doing any kind of caching. If you seriously want to prevent caching, you should emit such a cache-control header. Looks like exactly the opposite thing happened.

The output is as usual incorrect, and not cached:

There's a bug in ASP.NET 2.0 that you cannot change the max-age header. As max-age is set to 0, ASP.NET 2.0 sets the Cache-control to private because max-age = 0 means no cache is needed. So, there's no way you can make ASP.NET 2.0 return proper headers which cache the response. This is due to the ASP.NET AJAX Framework that intercepts calls to Webservices and incorrectly sets the max-age to 0 by default before executing a request.

Time for a hack. After decompiling the code of the HttpCachePolicy class (Context.Response.Cache object's class), I found the following code:

Somehow, this._maxAge is getting set to 0 and the check: "if (!this._isMaxAgeSet || (delta < this._maxAge))" is preventing it from getting set to a bigger value. Due to this problem, we need to bypass the SetMaxAge function and set the value of the _maxAge field directly, using Reflection.

Collapse

[WebMethod][ScriptMethod(UseHttpGet=true)]

public string CachedGet2()

{

  TimeSpan cacheDuration = TimeSpan.FromMinutes(1);



  FieldInfo maxAge = Context.Response.Cache.GetType().GetField("_maxAge",

      BindingFlags.Instance|BindingFlags.NonPublic);

  maxAge.SetValue(Context.Response.Cache, cacheDuration);



  Context.Response.Cache.SetCacheability(HttpCacheability.Public);

  Context.Response.Cache.SetExpires(DateTime.Now.Add(cacheDuration));

  Context.Response.Cache.AppendCacheExtension(

          "must-revalidate, proxy-revalidate");



  return DateTime.Now.ToString();

}

This will return the following headers:

Now max-age is set to 60 and thus the browser will cache the response for 60 seconds. If you make the same call again within 60 seconds, it will return the same response. Here's a test output which shows the date time returned from the server:

After 1 minute, the cache expires and the browser makes a call to the server again. The client side code is like this:

Collapse

function testCache()

{

 TestService.CachedGet(function(result)

 {

     debug.trace(result);

 });

}

There's another problem to solve. In web.config, you will see ASP.NET Ajax will add:

Collapse

<system.web>

<trust level="Medium"/>

This prevents us from setting _maxAge field of Response object because it requires Reflection. So, you will have to remove this trust level or put Full.

Collapse

<system.web>

<trust level="Full"/>

Making Best Use of Browser Cache

Use URLs Consistently

Browsers cache content based on the URL. When the URL changes, the browser fetches a new version from origin server. URL can be changed by changing the query string parameters. For example, /default.aspx is cached on the browser. If you request /default.aspx?123 it will fetch new content from the server. Response from the new URL can also be cached in the browser if you return proper caching headers. In that case, changing the query parameter to something else like /default.aspx?456 will return new content from the server. So, you need to make sure you use URL consistently everywhere when you want to get cached response. From homepage, if you have requested a file with URL /welcome.gif, make sure from another page you request the same file using the same URL. One common mistake is to sometimes omit the �www� subdomain from the URL. www.ebay.com/default.aspx is not same as ebay.com/default.aspx. Both will be cached separately.

Cache Static Content for Longer Period

Static files can be cached for longer periods like one month. If you are thinking that you should cache for couple of days so that when you change the file, users will pick it up sooner, you're mistaken. If you update a file which was cached by Expires header, new users will immediately get the new file while old users will see the old content until it expires on their browser. So, as long as you are using Expires header to cache static files, you should use as high a value as possible.

For example, if you have set Expires header to cache a file for three days, one user will get the file today and store it in cache for next three days. Another user will get the file tomorrow and cache it for three days after tomorrow. If you change the file on the day after tomorrow, the first user will see it on fourth day and the second user will see it on fifth day. So, different users will see different versions of the file. As a result, it does not help setting a lower value assuming all users will pick up the latest file soon. You will have to change the URL of the file in order to ensure everyone gets the exact same file immediately.

You can setup Expires header from static files from IIS Manager. You'll learn how to do it in a later section.

Use Cache Friendly Folder Structure

Store cached content under a common folder. For example, store all images of your site under the /static folder instead of storing images separately under different subfolders. This will help you use consistent URL throughout the site because from anywhere you can use /static/images/somefile.gif. Later on, we will learn it�s easier to move to a Content Delivery Network when you have static cacheable files under a common root folder.

Reuse Common Graphics Files

Sometimes we put common graphics files under several virtual directories so that we can write smaller paths. For example, say you have indicator.gif in root folder, some subfolders and under CSS folder. You did it because you need not worry about paths from different places and you could just use the file name as relative URL. This does not help in caching. Each copy of the file is cached in the browser separately. So, you should collect all graphics files in the whole solution and put them under the same root static folder after eliminating duplicates and use the same URL from all the pages and CSS files.

Change File Name When You Want to Expire Cache

When you want a static file to be changed, don't just update the file because it�s already cached in the user�s browser. You need to change the file name and update all references everywhere so that browser downloads the new file. You can also store the file names in database or configuration files and use data binding to generate the URL dynamically. This way you can change the URL from one place and have the whole site receive the change immediately.

Use a Version Number While Accessing Static Files

If you do not want to clutter your static folder with multiple copies of the same file, you can use query string to differentiate versions of same file. For example, a GIF can be accessed with a dummy query string like /static/images/indicator.gif?v=1. When you change the indicator.gif, you can overwrite the same file and then update all references to the file to /static/images/indicator.gif?v=2. This way you can keep changing the same file again and again and just update the references to access the graphics using the new version number.

Store Cacheable Files in a Different Domain

It�s always a good idea to put static contents in a different domain. First of all, the browser can open other two concurrent connections to download the static files. Another benefit is that you don't need to send the cookies to the static files. When you put the static files on the same domain as your Web application, browser sends all the ASP.NET cookies and all other cookies that your Web application is producing. This makes the request headers unnecessarily large and waste bandwidth. You don't need to send these cookies to access the static files. So, if you put the static files in a different domain, those cookies will not be sent. For example, put your static files in www.staticcontent.com domain while your website is running on www.dropthings.com. The other domain does not need to be a completely different Web site. It can just be an alias and share the same Web application path.

SSL is Not Cached, so Minimize SSL Use

Any content that is served over SSL is not cached. So, you need to put static content outside SSL. Moreover, you should try limiting SSL to only secure pages like Login page or Payment page. Rest of the site should be outside SSL over regular HTTP. SSL encrypts request and response and thus puts extra load on the server. Encrypted content is also larger than the original content and thus takes more bandwidth.

HTTP POST Requests are Never Cached

Cache only happens for HTTP GET requests. HTTP POST requests are never cached. So, any kind of AJAX call you want to make cacheable needs to be HTTP GET enabled.

Generate Content-Length Response Header

When you are dynamically serving content via Web service calls or HTTP handlers, make sure you emit Content-Length header. Browsers have several optimizations for downloading contents faster when it knows how many bytes to download from the response by looking at the Content-Length header. Browsers can use persisted connections more effectively when this header is present. This saves the browser from opening a new connection for each request. When there�s no Content-Length header, browser doesn't know how many bytes it�s going to receive from the server and thus keeps the connection open as long as it gets bytes delivered from the server until the connection closes. So, you miss the benefit of Persisted Connections that can greatly reduce download time of several small files like CS, JavaScripts, and images.

How to Configure Static Content Caching in IIS

In IIS Manager, Web site properties dialog box has �HTTP Headers� tab where you can define Expires header for all requests that IIS handles. There you can define whether to expire content immediately or expire after certain number of days or on a specific date. The second option (Expire after) uses sliding expiration, not absolute expiration. This is very useful because it works per request. Whenever someone requests a static file, IIS will calculate the expiration date based on the number of days/months from the Expire after.

For dynamic pages that are served by ASP.NET, a handler can modify the Expires header and override IIS default setting.

On Demand Progressive UI Loading for Fast Smooth Experience

AJAX websites are all about loading as many features as possible into the browser without having any postback. If you look at the Start Pages like Pageflakes, it's only one single page that gives you all the features of the whole application with zero postback. A quick and dirty approach for doing this is to deliver every possible HTML snippet inside hidden divs during page load and then make those divs visible when needed. But this makes first time loading way too slow and browser gives sluggish performance as too much stuff is there to process on the DOM. So, a better approach is to load the HTML snippet and necessary JavaScript on-demand. In my dropthings project, I have shown an example how this is done.

When you click on the "help" link, it loads the content of the help dynamically. This HTML is not delivered as part of the default.aspx that renders the first page. Thus the giant HTML and graphics related to the help section has no effect on site load performance. It is only loaded when user clicks the "help" link. Moreover, it gets cached on the browser and thus loads only once. When user clicks the "help" link again, it's served directly from the browser cache, instead of fetching from the origin server again.

The principle is making an XMLHTTP call to an *.aspx page, get the response HTML, put that response HTML inside a container DIV, make that DIV visible.

AJAX Framework has a Sys.Net.WebRequest class which you can use to make regular HTTP calls. You can define HTTP method, URI, headers and the body of the call. It�s kind of a low level function for making direct calls via XMLHTTP. Once you construct a Web request, you can execute it using Sys.Net.XMLHttpExecutor.

Collapse

function showHelp()

{

var request = new Sys.Net.WebRequest();

request.set_httpVerb("GET");

request.set_url('help.aspx');

request.add_completed( function( executor )

{

   if (executor.get_responseAvailable())

   {



      var helpDiv = $get('HelpDiv');

      var helpLink = $get('HelpLink');

      var helpLinkBounds = Sys.UI.DomElement.getBounds(helpLink);



      helpDiv.style.top = (helpLinkBounds.y + helpLinkBounds.height) + "px";

      var content = executor.get_responseData();

      helpDiv.innerHTML = content;

      helpDiv.style.display = "block";                    



   }

});



var executor = new Sys.Net.XMLHttpExecutor();

request.set_executor(executor);

executor.executeRequest();

}

The example shows how the help section is loaded by hitting help.aspx and injecting its response inside the HelpDiv. The response can be cached by the output cache directive set on help.aspx. So, next time when the user clicks on the link, the UI pops up immediately. The help.aspx file has no <html> block, only the content that is set inside the DIV.

Collapse

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Help.aspx.cs"

 Inherits="Help" %>

<%@ OutputCache Location="ServerAndClient" Duration="604800" VaryByParam="none" %>

<div class="helpContent">

<div id="lipsum">

<p>

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Duis lorem

eros, volutpat sit amet, venenatis vitae, condimentum at, dolor. Nunc

porttitor eleifend tellus. Praesent vitae neque ut mi rutrum cursus.

Using this approach, you can break the UI into smaller *.aspx files. Although these *.aspx files cannot have JavaScript or stylesheet blocks, they can contain large amount of HTML that you need to show on the UI on-demand. Thus you can keep initial download to absolute minimum just for loading the basic stuff. When the user explores new features on the site, load those areas incrementally.

Optimize ASP.NET 2.0 Profile Provider

Do you know there are two important stored procedures in ASP.NET 2.0 Profile Provider that you can optimize significantly? If you use them without doing the necessary optimization, your servers will sink taking your business down with you during heavy load. Here's a story:

During March, Pageflakes was shown on MIX 2006. We were having a glamorous time back then. We were right on Showcase of Atlas Web site as the first company. Number of visits per day were rising sky high. One day we noticed, the database server was no more. We restarted the server, brought it back, again it died within an hour. After doing a lot of postmortem analysis on the remains of the server's body parts, we found that it was having 100% CPU and super high IO usage. The hard drives were over heated and turned themselves off in order to save themselves. This was quite surprising to us because we thought we were very intelligent back then and we used to profile every single Web service function. So, we went through hundreds of megabytes of logs hoping to find which webservice function was taking the time. We suspected one. It was the first function that loads a user's page setup. We broke it up into smaller parts in order to see which part is taking most of the time.

Collapse

private GetPageflake(string source, string pageID, string userUniqueName)

{

if( Profile.IsAnonymous )

{

using (new TimedLog(Profile.UserName,"GetPageflake"))

{

You see, the entire function body is timed. If you want to learn how this timing works, I will explain it in a new article. We also timed smaller parts which we suspected were taking the most resource. But we could find not a single place in our code which was taking any significant time. Our codebase is always super optimized (after all, you know who is reviewing it, me).

Meanwhile, users were shouting, management was screaming, support staff was complaining on the phone. Developers were furiously sweating and blood vessels on their forehead were coming out. Nothing special, just a typical situation we have couple of times every month.

Now you must be shouting, "You could have used SQL Profiler, you idiot!" We were using SQL Server workgroup edition. It does not have SQL Profiler. So, we had to hack our way through to get it running on a server somehow. Don't ask how. After running the SQL Profiler, boy, were we surprised! The name of the honorable SP which was giving us so much pain was the great stored procedure dbo.aspnet_Profile_GetProfiles!

We used (and still use) Profile provider extensively.

Here's the SP:

Collapse

CREATE PROCEDURE [dbo].[aspnet_Profile_GetProfiles]

@ApplicationName nvarchar(256),

 @ProfileAuthOptions int,

 @PageIndex  int,

 @PageSize   int,

 @UserNameToMatch   nvarchar(256) = NULL,

 @InactiveSinceDate datetime = NULL

AS

BEGIN

 DECLARE @ApplicationId uniqueidentifier

 SELECT @ApplicationId = NULL

 SELECT @ApplicationId = ApplicationId

             FROM aspnet_Applications

                 WHERE LOWER(@ApplicationName)

                         = LoweredApplicationName



IF (@ApplicationId IS NULL)

     RETURN



-- Set the page bounds

 DECLARE @PageLowerBound int

 DECLARE @PageUpperBound int

 DECLARE @TotalRecords   int

SET @PageLowerBound = @PageSize * @PageIndex

SET @PageUpperBound = @PageSize - 1 + @PageLowerBound



 -- Create a temp table TO store the select results

 CREATE TABLE #PageIndexForUsers

 (

   IndexId int IDENTITY (0, 1) NOT NULL,

   UserId uniqueidentifier

 )



 -- Insert into our temp table

INSERT INTO #PageIndexForUsers (UserId)

 

   SELECT u.UserId

     FROM    dbo.aspnet_Users

         u, dbo.aspnet_Profile p

   WHERE   ApplicationId = @ApplicationId

         AND u.UserId = p.UserId    

             AND (@InactiveSinceDate

             IS NULL OR LastActivityDate

                     <= @InactiveSinceDate)                AND (

                 (@ProfileAuthOptions = 2)

             OR (@ProfileAuthOptions = 0

                     AND IsAnonymous = 1)

             OR (@ProfileAuthOptions = 1

                     AND IsAnonymous = 0)

                 )

             AND (@UserNameToMatch

             IS NULL OR LoweredUserName

                 LIKE LOWER(@UserNameToMatch))

     ORDER BY UserName



 SELECT u.UserName, u.IsAnonymous, u.LastActivityDate,

   p.LastUpdatedDate, DATALENGTH(p.PropertyNames)

   + DATALENGTH(p.PropertyValuesString)

   + DATALENGTH(p.PropertyValuesBinary)

 FROM    dbo.aspnet_Users

                 u, dbo.aspnet_Profile p, #PageIndexForUsers i

 WHERE

   u.UserId = p.UserId

   AND p.UserId = i.UserId

   AND i.IndexId >= @PageLowerBound

   AND i.IndexId <= @PageUpperBound     DROP TABLE #PageIndexForUsers



 END

END

First it looks up for ApplicationID.

Collapse

   DECLARE @ApplicationId  uniqueidentifier



 SELECT @ApplicationId = NULL



SELECT @ApplicationId = ApplicationId FROM aspnet_Applications

WHERE LOWER(@ApplicationName) = LoweredApplicationName



IF (@ApplicationId IS NULL)

   RETURN

Then it creates a temporary table (it should use table data type) in order to store profiles of users.

Collapse

    -- Create a temp table TO store the select results

 CREATE TABLE #PageIndexForUsers

 (

     IndexId int IDENTITY (0, 1) NOT NULL,

   UserId uniqueidentifier

 )

-- Insert into our temp table

 INSERT INTO #PageIndexForUsers (UserId)

If it gets called very frequently, there will be too high IO due to the temporary table creation. It also runs through two very big tables - aspnet_Users and aspnet_Profile. The SP is written in such a way that if one user has multiple profiles, it will return all profiles of the user. But normally we store one profile per user. So, there's no need for creating a temporary table. Moreover, there's no need for doing LIKE LOWER(@UserNameToMatch). We always called with a full user name which we can match directly using the equal operator.

So, we opened up the stored proc and did a open heart bypass surgery like this:

Collapse

IF @UserNameToMatch IS NOT NULL

BEGIN

     SELECT u.UserName, u.IsAnonymous, u.LastActivityDate, p.LastUpdatedDate,

   DATALENGTH(p.PropertyNames)

     + DATALENGTH(p.PropertyValuesString) + DATALENGTH(p.PropertyValuesBinary)

   FROM    dbo.aspnet_Users u

     INNER JOIN dbo.aspnet_Profile p ON u.UserId = p.UserId

   WHERE u.LoweredUserName = LOWER(@UserNameToMatch)



     SELECT @@ROWCOUNT

END



ELSE

 BEGIN -- Do the original bad things

It ran fine locally. Now it was time to run it on the server. This is an important SP which is used by the ASP.NET 2.0 Profile Provider, heart of ASP.NET Framework. If we do something wrong here, we might not be able to see the problem immediately, but may be after one month we will realize users profile is mixed up and there's no way to get it back. So, it was a pretty hard decision to run this on a live production server directly without doing enough testing. We did not have time to do enough testing anyway. We are already down. So, we all gathered, said our prayers and hit the "Execute" button on SQL Server Management Studio.

The SP ran fine. On the server we noticed from 100% CPU usage it came down to 30% CPU usage. IO usage also came down to 40%.

We went live again!

Here's another SP that gets called on every page load and webservice call on our site because we use Profile provider extensively.

Collapse

CREATE PROCEDURE [dbo].[aspnet_Profile_GetProperties]

 @ApplicationName   nvarchar(256),

 @UserName  nvarchar(256),

 @CurrentTimeUtc  datetime



AS

BEGIN

 DECLARE @ApplicationId uniqueidentifier

 SELECT @ApplicationId = NULL

 SELECT @ApplicationId = ApplicationId

             FROM dbo.aspnet_Applications

                     WHERE LOWER(@ApplicationName) = LoweredApplicationName



 IF (@ApplicationId IS NULL)

     RETURN



 DECLARE @UserId uniqueidentifier

 SELECT @UserId = NULL



 SELECT @UserId = UserId

 FROM   dbo.aspnet_Users

 WHERE ApplicationId = @ApplicationId

             AND LoweredUserName =

                     LOWER(@UserName)

 IF (@UserId IS NULL)

     RETURN



 SELECT TOP 1 PropertyNames, PropertyValuesString, PropertyValuesBinary

 FROM         dbo.aspnet_Profile

 WHERE        UserId = @UserId



 IF (@@ROWCOUNT > 0)

 BEGIN

     UPDATE dbo.aspnet_Users

     SET    LastActivityDate=@CurrentTimeUtc

     WHERE UserId = @UserId

 END



END

When you run the SP, see the statistics:

Collapse

Table 'aspnet_Applications'. Scan count 1, logical reads 2, physical reads 0,

                     read-ahead reads 0, lob logical reads 0, lob physical

                         reads 0, lob read-ahead reads 0.

(1 row(s) affected)

Table 'aspnet_Users'. Scan count 1, logical reads 4, physical reads 0,

                     read-ahead reads 0, lob logical reads 0, lob physical

                         reads 0, lob read-ahead reads 0.



(1 row(s) affected)

(1 row(s) affected)

Table 'aspnet_Profile'. Scan count 0, logical reads 3, physical reads 0,

                     read-ahead reads 0, lob logical reads 0, lob physical

                         reads 0, lob read-ahead reads 0.

(1 row(s) affected)

Table 'aspnet_Users'. Scan count 0, logical reads 27, physical reads 0,

                     read-ahead reads 0, lob logical reads 0, lob physical

                         reads 0, lob read-ahead reads 0.

(1 row(s) affected)

(1 row(s) affected)

This stored proc populates the Profile object with all the custom properties whenever Profile object is accessed for the first time within a request.

First it does a SELECT on aspnet_application to find out the application ID from application name. You can easily replace this with a hard coded application ID inside the SP and save some effort. Normally we run only one application on our production server. So, there's no need to lookup application ID on every single call. This is one quick optimization to do. However, from client statistics, you can see where's the real performance bottleneck:

Then look at the last block where aspnet_users table is updated with LastActivityDate. This is the most expensive one.

This is done in order to ensure Profile provider remembers when was the last time a user's profile was accessed. We do not need to do this on every single page load and Web service call where Profile object is accessed. Maybe we can do it when user first logs in and logs out. In our case, a lot of Web service is called while user is on the page. There's only one page anyway. So, we can easily remove this in order to save a costly update on the giant aspnet_users table on every single Web service call.

How to Query ASP.NET 2.0 Membership Tables Without Bringing Down the Site

Such queries will happily run on your development environment:

Collapse

Select * from aspnet_users where UserName = 'blabla'

Or you can get some user's profile without any problem using:

Collapse

Select * from aspnet_profile where userID = '�...'

Even you can nicely update a user's email in aspnet_membership table like this:

Collapse

Update aspnet_membership

SET Email = 'newemailaddress@somewhere.com'

Where Email = '�'

But when you have a giant database on your production server, running any of these will bring your server down. The reason is, although these queries look like very obvious ones that you will be using frequently, none of these are part of any index. So, all of the above results in "Table Scan" (worst case for any query) on millions of rows on respective tables.

Here's what happened to us. We used such fields like UserName, Email, UserID, IsAnonymous etc. on lots of marketing reports at Pageflakes. These are some reports which only marketing team use, no one else. Now, the site runs fine but several times a day marketing team and users used to call us and scream "Site is slow!", "Users are reporting extreme slow performance!", "Some pages are getting timed out!" etc. Usually when they call us, we tell them "Hold on, checking right now" and we check the site thoroughly. We use SQL profiler to see what's going wrong. But we cannot find any problem anywhere. Profiler shows queries running file. CPU load is within parameters. Site runs nice and smooth. We tell them on the phone, "We can't see any problem, what's wrong?"

So, why can't we see any slowness when we try to investigate the problem but the site becomes really slow several times throughout the day when we are not investigating?

Marketing team sometimes run analysis reports that use queries like the above several times per day. Whenever they run any of those queries, as the fields are not part of any index, it makes server IO go super high and CPU also goes super high - something like this:

We have SCSI drives which have 15000 RPM, very expensive, very fast. CPU is Dual core Dual Xeon 64bit. Both are very powerful hardware of their kind. Still these queries bring us down due to huge database size.

But this never happens when marketing team calls us and we keep them on the phone and try to find out what's wrong. Because when they are calling us and talking to us, they are not running any of the reports which bring the servers down. They are working somewhere else on the site, mostly trying to do the same things complaining users are doing.

Let's look at the indexes:

Table: aspnet_users

Clustered Index = ApplicationID, LoweredUserName
NonClustered Index = ApplicationID, LastActivityDate
Primary Key = UserID

Table: aspnet_membership

Clustered Index = ApplicationID, LoweredEmail
NonClustered = UserID

Table: aspnet_Profile

Clustered Index = UserID

Most of the indexes have ApplicationID in it. Unless you put ApplicationID='�' in the WHERE clause, it's not going to use any of the indexes. As a result, all the queries will suffer from Table Scan. Just put ApplicationID in the where clause (Find your ApplicationID from aspnet_Application table) and all the queries will become blazingly fast.

DO NOT use Email or UserName fields in WHERE clause. They are not part of the index instead LoweredUserName and LoweredEmail fields are in conjunction with ApplicationID field. All queries must have ApplicationID in the WHERE clause.

Our Admin site which contains several of such reports and each contains lots of such queries on aspnet_users, aspnet_membership and aspnet_Profile tables. As a result, whenever marketing team tried to generated reports, they took all the power of the CPU and HDD and the rest of the site became very slow and sometimes non-responsive.

Make sure you always cross check all your queries WHERE and JOIN clauses with index configurations. Otherwise you are doomed for sure when you go live.

Prevent Denial of Service (DOS) Attack

Web services are the most attractive target for hackers because even a pre-school hacker can bring down a server by repeatedly calling a Web service which does expensive work. Ajax Start Pages like Pageflakes are the best target for such DOS attack because if you just visit the homepage repeatedly without preserving cookie, every hit is producing a brand new user, new page setup, new widgets and what not. The first visit experience is the most expensive one. Nonetheless, it�s the easiest one to exploit and bring down the site. You can try this yourself. Just write a simple code like this:

Collapse

for( int i = 0; i < 100000; i ++ )

{

WebClient client = new WebClient();

client.DownloadString("http://www.pageflakes.com/default.aspx");

}

To your great surprise, you will notice that, after a couple of calls, you don't get a valid response. It�s not that you have succeeded in bringing down the server. It�s that your requests are being rejected. You are happy that you no longer get any service, thus you achieve Denial of Service (for yourself). We are happy to Deny You of Service (DYOS).

The trick I have in my sleeve is an inexpensive way to remember how many requests are coming from a particular IP. When the number of request exceeds the threshold, deny further request for some duration. The idea is to remember caller�s IP in ASP.NET Cache and maintain a count of request per IP. When the count exceeds a predefined limit, reject further request for some specific duration like 10 mins. After 10 mins, again allow requests from that IP.

I have a class named ActionValidator which maintains a count of specific actions like First Visit, Revisit, Asynchronous postbacks, Add New widget, Add New Page etc. It checks whether the count for such specific action for a specific IP exceeds the threshold value or not.

Collapse

public static class ActionValidator

{

  private const int DURATION = 10; // 10 min period



  public enum ActionTypeEnum

  {

      FirstVisit = 100, // The most expensive one, choose the value wisely. 

      ReVisit = 1000,  // Welcome to revisit as many times as user likes

      Postback = 5000,    // Not must of a problem for us

      AddNewWidget = 100,

      AddNewPage = 100,

  }

The enumeration contains the type of actions to check for and their threshold value for a specific duration � 10 mins.

A static method named IsValid does the check. It returns true if the request limit is not passed, false if the request needs to be denied. Once you get false, you can call Request.End() and prevent ASP.NET from proceeding further. You can also switch to a page which shows �Congratulations! You have succeeded in Denial of Service Attack.�

Collapse

public static bool IsValid( ActionTypeEnum actionType )

{

HttpContext context = HttpContext.Current;

if( context.Request.Browser.Crawler ) return false;



string key = actionType.ToString() + context.Request.UserHostAddress;

var hit = (HitInfo)(context.Cache[key] ?? new HitInfo());



if( hit.Hits > (int)actionType ) return false;

else hit.Hits ++;



if( hit.Hits == 1 )

   context.Cache.Add(key, hit, null, DateTime.Now.AddMinutes(DURATION),

      System.Web.Caching.Cache.NoSlidingExpiration,

      System.Web.Caching.CacheItemPriority.Normal, null);

return true;

}

The cache key is built with a combination of action type and client IP address. First it checks if there�s any entry for the action and the client IP in cache or not. If not, start the count and remember the count for the IP in cache for the specific duration. The absolute expiration on cache item ensures that after the duration the cache item will be cleared and the count will restart. When there�s already an entry in the cache, get the last hit count, and check if the limit is exceeded or not. If not exceeded, increase the counter. There is no need to store the updated value in the cache again by doing: Cache[url]=hit; because the hit object is by reference and changing it means it gets changed in the cache as well. In fact, if you do put it again in the cache, the cache expiration counter will restart and fail the logic of restarting count after specific duration.

The usage is very simple, on the default.aspx:

Collapse

protected override void OnInit(EventArgs e)

{

base.OnInit(e);



// Check if revisit is valid or not

if( !base.IsPostBack )

{

   // Block cookie less visit attempts

   if( Profile.IsFirstVisit )

   {

      if( !ActionValidator.IsValid(ActionValidator.ActionTypeEnum.FirstVisit))

         Response.End();

   }

   else

   {

      if( !ActionValidator.IsValid(ActionValidator.ActionTypeEnum.ReVisit) )

         Response.End();

   }

}

else

{

   // Limit number of postbacks

   if( !ActionValidator.IsValid(ActionValidator.ActionTypeEnum.Postback) )

         Response.End();

}

}

Here I am checking specific scenario like first Visit, re-visit, postbacks etc.

Of course you can put in some Cisco firewall and prevent DOS attack. You will get a guarantee from your hosting provider that their entire network is immune to DOS and DDOS (Distributed DOS) attacks. What they guarantee is network level attack like TCP SYN attacks or malformed packet floods etc. There is no way they can analyze the packet and find out a particular IP is trying to load the site too many times without supporting cookie or trying to add too many widgets. These are called application level DOS attack which hardware cannot prevent. It must be implemented in your own code.

There are very few websites out there which take such precaution for application level DOS attacks. Thus it�s quite easy to make servers go mad by writing a simple loop and hitting expensive pages or Web services continuously from your home broadband connection. I hope this small but effective class will help you prevent DOS attack in your own Web applications.

WCF Contracts Defined

2009-06-03T03:08:00.000-07:00

A WCF service publishes the operations that it supports by using a service contract. This contract defines the operations that the service provides, without specifying how the operations should be implemented.

Operations are defined by adding methods to a Service Contract interface that is annotated with the OperationContract attribute. Only methods that are qualified by the OperationContract attribute are service operations, and can be exposed to clients.

[ServiceContract]
public interface IOrderService {
[OperationContract]
void CreateOrder(int orderNumber);
[OperationContract]
void AddItemToOrder(int orderNumber, Item itm);
[OperationContract]
Order GetOrderDetails(int orderNumber);
}

A WCF service is implemented by creating a class that implements the service interface.

public class OrderService : IOrderService {
void CreateOrder(int orderNumber) {
// implementation details
}
void AddItemToOrder(int orderNumber, Item itm) {
// implementation details
}
Order GetOrderDetails(int orderNumber) {
// implementation details
}
}

Data contracts define how complex types are serialized when they are used in WCF service operations. They defined by applying the DataContract attribute to a class, and then adding DataMember attributes to fields and properties to show which members are to be exposed to clients.

[DataContract]
public class Order {
[DataMember]
public int OrderNumber;
[DataMember]
public String ClientName;
...
}

Message contracts describe the entire SOAP message format. They can use data contracts and serializable types to emit schema for complex types, and they also make it possible to control the SOAP message headers and body explicitly, by using a single type. Message contracts provide a simple method to add custom SOAP headers to incoming and outgoing messages.

[MessageContract]
public class MyRequest {
[MessageHeader]
public string field1;
[MessageBody]
public string field2;
}

A WCF service reports errors by using Fault objects. Fault contracts document the errors that WCF code is likely to produce, and WCF maps Fault objects to SOAP faults. Note that the type specified in the FaultContract does not have to be an exception.

[OperationContract]
[FaultContract(typeof(DivideByZeroException))]
void SomeMethod();

A Fault is generated by throwing a FaultException:

throw new FaultException(someException);

Abstract Class and An Interface

2009-06-01T11:06:00.000-07:00

Background

An Abstract class without any implementation just looks like an Interface; however there are lot of differences than similarities between an Abstract class and an Interface. Let's explain both concepts and compare their similarities and differences.

What is an Abstract Class?

An abstract class is a special kind of class that cannot be instantiated. So the question is why we need a class that cannot be instantiated? An abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated. The advantage is that it enforces certain hierarchies for all the subclasses. In simple words, it is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.

What is an Interface?

An interface is not a class. It is an entity that is defined by the word Interface. An interface has no implementation; it only has the signature or in other words, just the definition of the methods without the body. As one of the similarities to Abstract class, it is a contract that is used to define hierarchies for all subclasses or it defines specific set of methods and their arguments. The main difference between them is that a class can implement more than one interface but can only inherit from one abstract class. Since C# doesn�t support multiple inheritance, interfaces are used to implement multiple inheritance.

Both Together

When we create an interface, we are basically creating a set of methods without any implementation that must be overridden by the implemented classes. The advantage is that it provides a way for a class to be a part of two classes: one from inheritance hierarchy and one from the interface.

When we create an abstract class, we are creating a base class that might have one or more completed methods but at least one or more methods are left uncompleted and declared abstract. If all the methods of an abstract class are uncompleted then it is same as an interface. The purpose of an abstract class is to provide a base class definition for how a set of derived classes will work and then allow the programmers to fill the implementation in the derived classes.

There are some similarities and differences between an interface and an abstract class that I have arranged in a table for easier comparison:

Feature	Interface	Abstract class
Multiple inheritance	A class may inherit several interfaces.	A class may inherit only one abstract class.
Default implementation	An interface cannot provide any code, just the signature.	An abstract class can provide complete, default code and/or just the details that have to be overridden.
Access Modfiers	An interface cannot have access modifiers for the subs, functions, properties etc everything is assumed as public	An abstract class can contain access modifiers for the subs, functions, properties
Core VS Peripheral	Interfaces are used to define the peripheral abilities of a class. In other words both Human and Vehicle can inherit from a IMovable interface.	An abstract class defines the core identity of a class and there it is used for objects of the same type.
Homogeneity	If various implementations only share method signatures then it is better to use Interfaces.	If various implementations are of the same kind and use common behaviour or status then abstract class is better to use.
Speed	Requires more time to find the actual method in the corresponding classes.	Fast
Adding functionality (Versioning)	If we add a new method to an Interface then we have to track down all the implementations of the interface and define implementation for the new method.	If we add a new method to an abstract class then we have the option of providing default implementation and therefore all the existing code might work properly.
Fields and Constants	No fields can be defined in interfaces	An abstract class can have fields and constrants defined

DataBase Naming Conventions

2009-05-27T07:25:00.000-07:00

Database Naming Conventions Version

The main goal of adopting a naming convention for database objects is so that you and others can easily identify the type and purpose of all objects contained in the database. The information presented here serves as a guide for you to follow when naming your database objects. When reading these rules and guidelines remember that consistent naming can be the most important rule to follow. Keep in mind that following the guidelines as outlined in this document can still produce long and cryptic names, ultimately, your unique situation will dictate the reasonability of your naming convention. The goal of this particular naming convention is to produce practical, legible, concise, unambiguous and consistent names for your database objects.

While most databases contain more types of objects than those discussed here (User Defined Types, Functions, Queries, etc.), the 7 types of objects mentioned here are common among all major database systems. Think of this as a generic DBMS-neutral guide for naming your objects.

The following types of database objects are discussed here:

Tables
Columns (incl. Primary, Foreign and Composite Keys)
Indexes
Constraints
Views
Stored Procedures
Triggers

ALL DATABASE OBJECTS

Limit the name to 30 characters (shorter is better)
Use only letters or underscores (try to avoid numbers)
Try to use underscore characters as little as possible. PascalCase notation achieves the same word separation without them.

Use a letter as the first character of the name. (don't start names with underscores)

Avoid abbreviations (can lead to misinterpretation of names)

Avoid acronyms (some acronyms have more than one meaning eg. "ASP")

Makes the name readable (they shouldn't sound funny when read aloud)

Avoid using spaces in names even if the system allows it.

1. TABLES
When naming your database tables, give consideration to other steps in the development process. Keep in mind you will most likely have to utilize the names you give your tables several times as part of other objects, for example, procedures, triggers or views may all contain references to the table name. You want to keep the name as simple and short as possible. Some systems enforce character limits on object names also. For example, in Oracle you are limited to about 30 characters per object.

Rule 1a (Plural Names) - Table names should be plural, for example, "Customers" instead of "Customer". This rule is applicable because tables are logical collections of one or more entities as records - just like collection classes are logical collections of one or more objects. If you were to first draw an abstract data model like a NIAM/ORM model, you might have singular entity names like "Customer" or "User" but, they should be changed to the plural form when building the actual tables. For table names with multiple words, only the last word should be plural, for example, "UserRoles" and "UserRoleSettings".

Rule 1b (Prefixes) - Used correctly, table prefixes can help you organize your tables into related groups or distinguish them from other unrelated tables. Used poorly, they can cause you to have to type a lot of unnecessary characters. We'll discuss what not to do first. Do not give your table names prefixes like "tbl" or "TBL_" as these are just redundant and unnecessary. It will be obvious which names are the table names in SQL statements because they will always be proceeded by the FROM clause of the SELECT statement. Not all prefixes are bad. In some cases, your tables might be sharing a schema/database with other tables that are not related in any way. In this case, it is sometimes a good idea to prefix your table names with some characters that group your tables together. For example, for a healthcare application you might give your tables an "Hc" prefix so that all of the tables for that application would appear in alphabetized lists together. Note that even for the prefix, use Pascal Case. This is discussed in Rule 1c. Do not use underscores in your prefixes, which is discussed in more depth in Rule 1d. The last kind of prefix that is acceptable is one that allows you to group logical units of tables. A plausible example could entail a large application (30 to 40+ tables) that handled both Payroll and Benefits data. You could prefix the tables dealing with payroll with a "Pay" or "Prl" prefix and give the tables dealing with benefits data a "Ben" or "Bfts" prefix. The goal of both this prefix and the aforementioned shared schema/database prefix is to allow you to group specific tables together alphabetically in lists and distinguish them from unrelated tables. Lastly, the shared schema/database prefix is a higher grouping level and comes first in the name, for example, "HcPayClients" not "PayHcClients".

Rule 1c (Notation) - For all parts of the table name, including prefixes, use Pascal Case. Using this notation will distinguish your table names from SQL keywords (all capital letters). For example, "SELECT CustomerId_Pk, CustomerName FROM MyAppGroupTable WHERE CustomerName = '%S'" shows the notation for the table name distinguishing it from the SQL keywords used in the query. PascalCase also reduces the need for underscores to visually separate words in names.

Rule 1d (Special Characters) - For table names, underscores should not be used. The underscore character has a place in other object names but, not for tables. Using Pascal Case for your table name allows for the upper-case letter to denote the first letter of a new word or name. Thus there is no need to do so with an underscore character. Do not use numbers in your table names either. This usually points to a poorly designed data model or irregularly partitioned tables. Do not use spaces in your table names either. While most database systems can handle names that include spaces, some systems require you to add more characters around the name when referencing it (like [table name] for example) which goes against the rule of keeping things as short and simple as possible. If you are developing in a non-english language, do not use any of that language's special characters.

Rule 1e (Abbreviations) - Avoid using abbreviations if possible. Use "Accounts" instead of "Accts" and "Hours" instead of "Hrs". Not everyone will always agree with you on what your abbrevations stand for - and - this makes it simple to read and understand for both developers and non-developers. This rule can be relaxed for junction table names (See Rule 1f). Do not use acronyms.

Rule 1f (Junction a.k.a Intersection Tables) - Junction tables, which handle many to many relationships, should be named by concatenating the names of the tables that have a one to many relationship with the junction table. For example, you might have "Doctors" and "Patients" tables. Since doctors can have many patients and patients can have many doctors (specialists) you need a table to hold the data for those relationships in a junction table. This table should be named DoctorsPatients". Since this convention can result in lengthy table names, abbreviations sometimes may be used at your discretion.

2. COLUMNS - (incl. PRIMARY, FOREIGN, AND COMPOSITE KEYS)
When naming your columns, keep in mind that they are members of the table, so they do not need the any mention of the table name in the name. The primary key field is typically the only exception to this rule where including the table name is justified so that you can have a more descriptive field name than just "Id". "CustomerId" is acceptable but not required. Just like with naming tables, avoid using abbreviations, acronyms or special characters. All column names should use Pascal Case to distinguish them from SQL keywords (all upper case).

Rule 2a (Identity Primary Key Fields) - For fields that are the primary key for a table and uniquely identify each record in the table, the name should simply be “Id“ since, that's what it is - an identification field. This name also maps more closely to a property name like “Id“ in your class libraries. Another benefit of this name is that for joins you will see something like
"Customers JOIN Orders ON Customer.Id = Orders.CustomerId“
which allows you to avoid the word “Customer“ again after the Customer table.

Rule 2b (Foreign Key Fields) - Foreign key fields should have the exact same name as they do in the parent table where the field is the primary key - with one exception - the table name should be specified. For example, in the Customers table the primary key field might be "Id". In an Orders table where the customer id is kept, it would be "CustomerId". There is one exception to this rule, which is when you have more than one foreign key field per table referencing the same primary key field in another table. In this situation, it might be helpful to add a descriptor before the field name. An example of this is if you had an Address table. You might have another table with foreign key fields like HomeAddressId, WorkAddressId, MailingAddressId, or ShippingAddressId.

Rule 2c (Composite Keys) - If you have tables with composite keys (more than one field makes up the unique value) then instead of just “Id“ you should use a descriptor before the “Id“ characters. Two fields like “ModuleId“ and “CodeId“ might make up the composite key, for example. If you don't see an “Id“ column in the table - you'll know that a composite key is used to uniquely identify records.

Rule 2d (Prefixes) - Do not prefix your fields with "fld_" or "Col_" as it should be obvious in SQL statements which items are columns (before or after the FROM clause). Including a two or three character data type prefix for the field is optional and not recommended, for example, "IntCustomerId" for a numeric type or "VcName" for a varchar type. However, these data type abbreviations are DBMS specific and are outside the scope of this document.

Rule 2e (Data Type Specific Naming) - Boolean fields should be given names like "IsDeleted", "HasPermission", or "IsValid" so that the meaning of the data in the field is not ambiguous. If the field holds date and/or time information, the word "Date" or "Time" should appear somewhere in the field name. It is sometimes appropriate to add the unit of time to the field name also, especially if the field holds data like whole numbers ("3" or "20"). Those fields should be named like "RuntimeHours" or "ScheduledMinutes".

3. INDEXES
Since indexes are always related to a table or view, it makes the most sense to use the name of the table or view, as well as the column(s) they index, in the index name, along with some characters that specify the type of index it is. This naming convention also allows you, if looking at a list of indexes, to see the indexes ordered by table, then column, then index type.

Rule 3a (Naming Convention) - The naming convention for indexes follows this structure:

{TableName}{ColumnsIndexed}{U/N}{C/N}

where "U/N" is for unique or non-unique and "C/N" is for clustered or non-clustered. This naming convention is unique among database objects, so adding characters to denote it being an index, like "idx" is not necessary. The naming convention alone is self-documenting and indentifies it as an index. For indexes that span multiple columns, concatenate the column names. "ProductsIdUC" indicates a unique, clustered index on the Id column of the Products table. OrderDetailsOrderIdCustomerIdNN" indicates a non-unique, non-clustered index on the OrderId and CustomerId columns in the OrderDetails table. Since this name is rather lengthy with both "OrderId" and "CustomerId" spelled out, they could be shortened to OrdId and CustId. However, notice that by using Pascal Case, thus not needing to use underscores, it is possible to keep the name of a complex index to about 30 characters.

Rule 3b (Prefixes and Suffixes) - Avoid putting a prefix like "idx" or "IDX_" before your indexes. This is not necessary due to the naming convention discussed in Rule 3a. A suffix of "_idx" or "IDX" is not necessary either for the same reason.

4. CONSTRAINTS
Constraints are at the field/column level so the name of the field the constraint is on should be used in the name. The type of constraint (Check, Referential Integrity a.k.a Foreign Key, Primary Key, or Unique) should be noted also. Constraints are also unique to a particular table and field combination, so you should include the table name also to ensure unique constaint names across your set of database tables.

Rule 4a (Naming Convention) - The naming convention syntax for constraints looks like this:

{constraint type}{table name}_{field name}

Examples:
1. PkProducts_Id - primary key constraint on the Id field of the Products table
2. FkOrders_ProductId - foreign key constraint on the ProductId field in the Orders table
3. CkCustomers_AccountRepId - check constraint on the AccountRepId field in the Customers table

The reason underscores are used here with Pascal Case notation is so that the table name and field name are clearly separated. Without the underscore, it would become easy to get confused about where the table name stops and the field name starts.

Rule 4b(Prefixes) A two letter prefix gets applied to the constraint name depending on the type
Primary Key: Pk
Foreign Key: Fk
Check: Ck
Unique: Un

5. VIEWS
Views follow many of the same rules that apply to naming tables. There are only two differences (Rules 5a and 5b). If your view combines entities with a join condition or where clause, be sure to combine the names of the entities that are joined in the name of your view. This is discussed in more depth in Rule 5b.

Rule 5a (Prefixes) - While it is pointless to prefix tables, it can be helpful for views. Prefixing your views with "Vw" or "View" is a helpful reminder that you're dealing with a view, and not a table. Whatever type of prefix you choose to apply, use at least 2 letters and not just "V" because a prefix should use more more than one letter or its meaning can be ambiguous.

Rule 5b (View Types) - Some views are simply tabular representations of one or more tables with a filter applied or because of security procedures (users given permissions on views instead of the underlying table(s) in some cases). Some views are used to generate report data with more specific values in the WHERE clause. Naming your views should be different depending on the type or purpose of the view. For simple views that just join one or more tables with no selection criteria, combine the names of the tables joined. For example, joining the "Customers" and "StatesAndProvinces" table to create a view of Customers and their respective geographical data should be given a name like "VwCustomersStatesAndProvinces". For a view that is more like a report, a name like "VwDivisionSalesFor2004" might make more sense.

6. STORED PROCEDURES
Unlike a lot of the other database objects discussed here, stored procedures are not logically tied to any table or column. Typically though, stored procedures perform one of the CRUD (Create, Read, Update, and Delete) operations on a table, or another action of some kind. Since stored procedures always perform some type of operation, it makes sense to use a name that describes the operation they perform. Use a verb to describe the type of operation, followed by the table(s) the operations occur on.

Rule 6a (Prefixes or Suffixes) - The way you name your stored procedures depends on how you want to group them within a listing. If you'd like to group them by the type of CRUD operation they perform, then prefix the name with "Create", "Get", "Update" or "Delete". Using this kind of prefix will, for example, group all of your "Create" procedures together since they will all start with the Create prefix, like "CreateProductInfo" or "CreateOrder". If instead, you would like to have your procedures ordered by the table they perform a CRUD operation on, adding "Create, Get, Update, or Delete" as a suffix will do that for you. For example, "ProductInfoCreate" or "OrdersCreate". If your procedure returns a scalar value, or performs an operation like validation, you should not use a CRUD prefix or suffix. Instead use the verb and noun combination. For example, "ValidateLogin"

Rule 6b (Grouping Prefixes) - If you have many stored procedures, you might want to consider using a grouping prefix that can be used to identify which parts of an application the stored procedure is used by. For example, a "Prl" prefix for Payroll related procedures or a "Hr" prefix for Human Resources related procedures can be helpful. This prefix would come before a CRUD prefix (See Rul 6a).

Rule 6c (Bad Prefixes) - Do not prefix your stored procedures with something that will cause the system to think it is a system procedure. For example, in SQL Server, if you start a procedure with "sp_", "xp_" or "dt_" it will cause SQL Server to check the master database for this procedure first, causing a performance hit. Spend a little time researching if any of the prefixes you are thinking of using are known by the system and avoid using them if they are.

7. TRIGGERS
Triggers have many things in common with stored procedures. However, triggers are different than stored procedures in two important ways. First, triggers don't exist on their own. They are dependant upon a table. So it is wise to include the name of this table in the trigger name. Second, triggers can only execute when either an Insert, Update, or Delete happens on one or more of the records in the table. So it also makes sense to include the type of action that will cause the trigger to execute.

Rule 7a (Prefixes and Suffixes) - To distinguish triggers from other database objects, it is helpful to add "Trg" as a prefix or suffix. For example any of these combinations work: Trg_ProductsIns, ProductsInsTrg, Products_InsTrg, or InsProducts_Trg. As long as you include the table name, the operation that executes the trigger (Ins, Upd, or Del) and the "Trg" letters, it should be obvious to someone working with the database what kind of object it is. As with all conventions you use, pick one and remain consistent.

Rule 7b (Multiple Operations) - If a trigger handles more than one operation (both INSERT and UPDATE for example) then include both operation abbreviations in your name. For example, "Products_InsUpdTrg" or "TrgProducts_UpdDel"

Rule 7c (Multiple Triggers) - Some systems allow multiple triggers per operation per table. In this case, you should make sure the names of these triggers are easy to distinguish between. For example "Users_ValidateEmailAddress_InsTrg" and "Users_MakeActionEntries_InsTrg".

C#.Winform Interview questions

2009-05-22T14:16:00.000-07:00

What base class do all Web Forms inherit from?
System.Windows.Forms.Form

What is the difference between Debug.Write and Trace.Write? When should each be used?
The Debug.Write call won’t be compiled when the DEBUGsymbol is not defined (when doing a release build). Trace.Write calls will be compiled. Debug.Write is for information you want only in debug builds, Trace.Write is for when you want it in release build as well.

Difference between Anchor and Dock Properties?
Dock Property->Gets or sets which edge of the parent container a control is docked to. A control can be docked to one edge of its parent container or can be docked to all edges and fill the parent container. For example, if you set this property to DockStyle.Left, the left edge of the
control will be docked to the left edge of its parent control. Additionally, the docked edge of the control is resized to match that of its container
control.
Anchor Property->Gets or sets which edges of the control are anchored to the edges of its container. A control can be anchored to one or more edges of its parent container. Anchoring a control to its parent ensures that the anchored edges remain in the same position relative to the edges of the parent container when the parent container is resized.

When would you use ErrorProvider control?
ErrorProvider control is used in Windows Forms application. It is like Validation Control for ASP.NET pages. ErrorProvider control is used to provide validations in Windows forms and display user friendly messages to the user if the validation fails.
E.g
If we went to validate the textBox1 should be empty, then we can validate as below
1). You need to place the errorprovide control on the form
private void textBox1_Validating (object sender, System.ComponentModel.CancelEventArgs e)
{
ValidateName();
}
Private bool ValidateName()
{
bool bStatus = true;
if (textBox1.Text == “”)
{
errorProvider1.SetError (textBox1,”Please enter your Name”);
bStatus = false;
}
else
errorProvider1.SetError (textBox1,”");
return bStatus;
}
it check the textBox1 is empty . If it is empty, then a message Please enter your name is displayed.

Can you write a class without specifying namespace? Which namespace does it belong to by default?
Yes, you can, and then the class belongs to global namespace which has no name. For commercial products, naturally, you wouldn’t want global namespace.

You are designing a GUI application with windows and several widgets on it. The user then resizes the app window and sees a lot of grey space, while the widgets stay in place. What’s the problem?
One should use anchoring for correct resizing. Otherwise the default property of a widget on a form is top-left, so it stays at the same location when resized.

How can you save the desired properties of Windows Forms application?
.config files in .NET are supported through the API to allow storing and retrieving information. They are nothing more than simple XML files, sort of like what .ini files were before for Win32 apps.

So how do you retrieve the customized properties of a .NET application from XML .config file?
Initialize an instance of AppSettingsReader class. Call the GetValue method of AppSettingsReader class, passing in the name of the property and the type expected. Assign the result to the appropriate variable.

Can you automate this process?
In Visual Studio yes, use Dynamic Properties for automatic .config creation, storage and retrieval.

My progress bar freezes up and dialog window shows blank, when an intensive background process takes over.
Yes, you should’ve multi-threaded your GUI, with taskbar and main form being one thread, and the background process being the other.

What’s the safest way to deploy a Windows Forms app?
Web deployment: the user always downloads the latest version of the code, the program runs within security sandbox, properly written app will not require additional security privileges.

Why is it not a good idea to insert code into InitializeComponent method when working with Visual Studio?
The designers will likely through it away, most of the code inside InitializeComponent is auto-generated.

What’s the difference between WindowsDefaultLocation and WindowsDefaultBounds?

WindowsDefaultLocation tells the form to start up at a location selected by OS, but with internally specified size. WindowsDefaultBounds delegates both size and starting position choices to the OS.

What’s the difference between Move and LocationChanged? Resize and SizeChanged?

Both methods do the same, Move and Resize are the names adopted from VB to ease migration to C#.

How would you create a non-rectangular window, let’s say an ellipse?
Create a rectangular form, set the TransparencyKey property to the same value as BackColor, which will effectively make the background of the form transparent. Then set the FormBorderStyle to FormBorderStyle.None, which will remove the contour and contents of the form.

How do you create a separator in the Menu Designer?
A hyphen ‘-’ would do it. Also, an ampersand ‘&\’ would underline the next letter.

How’s anchoring different from docking?
Anchoring treats the component as having the absolute size and adjusts its location relative to the parent form. Docking treats the component location as absolute and disregards the component size. So if a status bar must always be at the bottom no matter what, use docking. If a button should be on the top right, but change its position with the form being resized, use anchoring.

How do you trigger the Paint event in System.Drawing?
Invalidate the current form; the OS will take care of repainting. The Update method forces the repaint.

With these events, why wouldn’t Microsoft combine Invalidate and Paint, so that you wouldn’t have to tell it to repaint, and then to force it to repaint?
Painting is the slowest thing the OS does, so usually telling it to repaint, but not forcing it allows for the process to take place in the background.

How can you assign an RGB color to a System.Drawing.Color object?
Call the static method FromArgb of this class and pass it the RGB values.

What class does Icon derive from?
Isn’t it just a Bitmap with a wrapper name around it? No, Icon lives in System.Drawing namespace. It’s not a Bitmap by default, and is treated separately by .NET. However, you can use ToBitmap method to get a valid Bitmap object from a valid Icon object.

Before in my VB app I would just load the icons from DLL. How can I load the icons provided by .NET dynamically?
By using System.Drawing.SystemIcons class, for example System.Drawing.SystemIcons.Warning produces an Icon with a warning sign in it.

When displaying fonts, what’s the difference between pixels, points and ems?
A pixel is the lowest-resolution dot the computer monitor supports. Its size depends on user’s settings and monitor size. A point is always 1/72 of an inch. An em is the number of pixels that it takes to display the letter M.

ASP.Net 2.0 Interview questions.

2009-04-23T01:24:00.001-07:00

How to use Masterpages and Contentpages in ASP.NET 2.0? What is a Masterpage? What is a ContentPage? How to setup master-content pages in ASP.NET 2.0?

A Master Page is the mother of the page and the content page is the baby! There may be many babies of the mother. A master page may have plenty of content pages within it. There also may be a master page within a master page, which is called a nested master page. Nested Master Pages

So whats a master page in ASP.NET 2.0? A Master Page is a page that contains markup and controls that are shared across multiple pages in your site. For example, if required that all pages should have the same header and footer banners or the common navigation menu, the Master page can be written once, and all the content pages can access the common master page. The content pages inherit the tags inside the master page.

Next question is how to define a master page. The answer is...

To define a Master Page, it may be written like a normal page. Master Pages can contain markup, controls, or code, or any combination of these tags. The Content pages are rendered in a master page control called as ContentPlaceHolder control. A ContentPlaceHolder defines a region of the master page rendering that can be exchanged with content from a page associated to the master. A ContentPlaceHolder can also contain default content, when in case the derive page does not need to override this content. Below is the markup of how to use a Contentplaceholder.

< asp:contentplaceholder id="ContentPlaceHolderInterviewQuestions" runat="server">

< asp:contentplaceholder id="ContentPlaceHolderInterviewQuestions" runat="server">

< h3>Welcome to the .NET Interview Questions website!

< /asp:contentplaceholder>

A master page has the extension .master, unlike a normal web form that has the extenstion .aspx. A page may derive from a Master Page by defining a MasterPageFile attribute on its Page directive. Below is the markup of a content page.

<%@ Page MasterPageFile="Masterpage.master" %>
< asp:content id="Content1" contentplaceholderid="ContentPlaceHolderInterviewQuestions" runat="server">
Here goes contents of ContentPlaceHolderInterviewQuestions < /asp:content>
< /asp:contentplaceholder>

So how does Content page access a master page? It is also possible for a Content Page to programmatically access a Master Page. A ContentPage may create a strongly-typed reference to the Master Page using the <%@ MasterType %> directive, which specifies the virtual path to the masterpage as below...

<%@ MasterType VirtualPath="Masterpage.master" %>

The Content Page may then reference the Master Page using the Master property of the Page class:

Master.FooterText = "Some text on the footer of .NET Interview Questions page";
Label lb1 = Master.FindControl("label2");

As with the example above, FooterText is a public property exposed on the Master Page, whereas label2 is a server side control on the Master Page.

Note that the FindControl method is a very useful and a very important method, that may be used for finding a control in a content page from a master page and vice versa.

C# Questions

2009-04-21T04:04:00.000-07:00

C#.NET

Question:-Can it is possible that pointer are also in C#?
Answer:Can you believe C# supports pointers but in a limited extent. We all know pointer is variable that only holds the memory address of another type. But pointer are little different in C# these declared to hold the memory address of value types and arrays also pointer types are not tracked by the default garbage collection mechanism. Pointers are not allowed to point to a reference type or even to a structure type which contains a reference type. Pointers only point to unmanaged types which includes all basic data types, enum types, other pointer types and structs which contain only unmanaged types.

Question:-What's New features are added to C#3.0 over C#2.0 ?
Answer:These are the major new enhancements expected in C# 3.0:-
* Implicitly typed local variables
* Anonymous types
* Extension methods
* Object and collection initializers
* Lambda expressions
* Query expressions
* Expression Trees

Question:-How we Implicitly Typed Local Variables in C# 3.0 ?
Answer:In C# 3.0 we have new keyword called "var".Var helps us to declare a new variable, which is implicitly inferred from the expression whic is used to initialize the variable here is the syntax:-
var i = 1;
In last line we initializes a variable i to value 1 and gives its type integer.We strongly type "i" to an integer.It is not an object or a VB6 variant,and it is not carry the overhead of an object or a variant.The var keyword allows you to refer to instances of anonymous types (described in the next section) and yet the instances are statically typed. So, when you create instances of a class that contain an arbitrary set of data, you don't need to predefine a class to both hold that structure and be able to hold that data in a statically typed variable.

Question:-What do you mean by Anonymous Types in C# 3.0 ?
Answer:In C# 3.0 we have options to create an instance of a class without writing code for the class beforehand.And code is so simple :-
new {book="dotnet", writer="pervej", ageofwriter=24}
In behind C# 3.0 compiler would create a class that looks as follows:
class __anonymous
{
private string _book="dotnet";
private string _writer="pervej";
private int _ageofwriter=24;
public string book {get { return _book; } set { _book = value; }}
public string writer {get { return _writer; } set { _writer = value; }}
public int ageofwriter {get { return _ageofwriter; } set { _ageofwriter = value; }}
}
in c# 3.0 we declare the same sequence of names and types , the C# compiler be smart enough to create a single anonymous type for both instances for use they are exchanged because the types are really the same.
we have class, but still need something to take an instance of the above class. here the "var" keyword comes in handy it helps to hold a statically typed instance of the above instance of the anonymous type. Here is simple syntax of an anonymous type:
var interviewquestion = new {book="dotnet", writer="pervej", ageofwriter=24}

Question:-What the relation between Static method in Interface ?
Answer:Static methods are common in class. In object oriented , an interface is not technically a class, it is a type, but not a class so interfaces do not extend Object. Because interfaces are not classes, they cannot have static methods, because there is no actual class to attach to.We may call InterfaceName.class to get the Class Object corresponding to the interface, but the Class class specifically states that it represents classes and interfaces in a object oriented application. However, the interface itself is not treated as a class, and hence you cannot attach a static method.

Question:-How to get last month date from code in C# ?
Answer:DateTime LastMonthDate=DateTime.Now.AddMonths(-1);

Question:-What is Generic class how it helps programmer ?
Answer:Generic is new feature included in .NET it is essential in C# .Because today the projects are more complicated as past so programmer badly need touse better reuse and customize their existing component-based software. So get this high level of code reuse in other languages, programmers have a option that option is Generics .By Using Generics, we can create class templates that support any type.

Question:-What is the use of USING in c# ?
Answer:As we all knows that one of beauty of C# is that it will releases memory automatically and in .NET CLR do this work calling garbage collector realse object that are not needed. USING is also play some role in releasing memory its programmer to specify which object should release that using resources.When object is provided to Using statement it must provided a iDisposable interface.This interface contains Dispose method.

Question:-What is Partial class ?
Answer:Partial class can also be split into two or more classes. We can also say that a class be physically separated into other parts of the class but within the same namespace and also one more important thing the parts must use the partial keyword.And other classes should also have the same access modifier.When compile is done, all the partial classes will be treated as a single class. Let us list some advantages of having partial classes.
• Allows a clean separation of business logic layer and the user interface.
• The UI code can be hidden from the developer.
• Makes the debugging easier..

Question: what are the Hiding method in c# can it is possible to hide method without using Virtual Function?
Answer: It is possible to hide the base class method with the derived class without using Virtual in base class and Override keyword in subclass.there are some condition where we have to redefine any method in derived class same name in base class now question arise how can we hide the method anwer is simple and logical we use the modifier NEW which tell the compiler that derived class method "hides the base class method. There are some example:
Class baseclass
{
Public void display()
{
console.writeline("base method");
}
}
class derived : baseclass
{
public new void display()
{
console.writeline("dervied mthod");
}
}
class test
{
public static void main()
{
derived d=new derivedclass();
d.display();
}
}

Question:-explain some of method of System.Array class ?
Answer:-
Clear():-Set ranges of value to empty.
CopyTo():-Copies element source to desinations.
GetLength()-:Display number of element in given array.
GetValue():-Value of given index in array.
Length():-To get length of array.
SetValue():-Sets the value of given index in the array.
Reverse() :-Reverse the element of Array.
Sort():-Sort the element in array.

Question: what do u mean by Array in C# ?
Answer: Array is a group of same type of datatype variable that shared a common name .The ability to use a single name to represent a collections of item is an array.There are manily three types of array.
*One-Dimensinal Array
*Two-Dimensinal Array
*Multi-Dimensinal Array
There are three steps include to create a Array
(1) Declare an array
(2)Creating memory location
(3)Putting values into the memory location
Declare the Array:-int[] counter;(declare int array)
Creating of Array:-arrayname=new type[size];
putting values in array:-number=new int[5];
number[0]=35;

Question: What is difference between the System.Array.CopyTo() & System.Array.Clone()?
Answer: The Clone() method returns a new array object containing all the elements in the original array. The CopyTo() method copies the elements into another existing array. Both perform a shallow copy. A shallow copy means the contents (each element) contains references to the same object as the elements in the original array. A deep copy (which neither of these methods performs) would create a new instance of each element's object, resulting in a different, yet identacle object.

Question: Is there an equivalent of exit() for quitting a C# .NET application ?
Answer: Yes, you can use System.Environment.Exit(int exitCode) to exit the application or Application.Exit() if it’s a Windows Forms app.

Question: Is there a way to force garbage collection ?
Answer: Yes. Set all references to null and then call System.GC.Collect(). If you need to have some objects destructed, and System.GC.Collect() doesn’t seem to be doing it for you, you can force finalizers to be run by setting all the references to the object to null and then calling System.GC.RunFinalizers().

Question: Is there regular expression (regex) support available to C# developers ?
Answer: Yes, The .NET class libraries provide support for regular expressions. Look at the System.Text.RegularExpressions namespace.

Question: Define diffrent format for date time ?
Answer: DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
String.Format("{0:y yy yyy yyyy}", dt); // "8 08 008 2008" year
String.Format("{0:M MM MMM MMMM}", dt); // "3 03 Mar March" month
String.Format("{0:d dd ddd dddd}", dt); // "9 09 Sun Sunday" day
String.Format("{0:h hh H HH}", dt); // "4 04 16 16" hour 12/24
String.Format("{0:m mm}", dt); // "5 05" minute
String.Format("{0:s ss}", dt); // "7 07" second
String.Format("{0:f ff fff ffff}", dt); // "1 12 123 1230" sec.fraction
String.Format("{0:F FF FFF FFFF}", dt); // "1 12 123 123" without zeroes
String.Format("{0:t tt}", dt); // "P PM" A.M. or P.M.
String.Format("{0:z zz zzz}", dt); // "-6 -06 -06:00" time zone
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - english (en-US)
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9.3.2008 16:05:07" - german (de-DE)

Question: What is the difference between a struct and a class in C# ?
Answer: From language spec: The list of similarities between classes and structs is as follows. Longstructs can implement interfaces and can have the same kinds of members as classes. Structs differ from classes in several important ways; however, structs are value types rather than reference types, and inheritance is not supported for structs. Struct values are stored on the stack or in-line. Careful programmers can sometimes enhance performance through judicious use of structs. For example, the use of a struct rather than a class for a Point can make a large difference in the number of memory allocations performed at runtime. The program below creates and initializes an array of 100 points. With Point implemented as a class, 101 separate objects are instantiated-one for the array and one each for the 100 elements.

Question: Why do I get a syntax error when trying to declare a variable called checked ?
Answer: The word checked is a keyword in C#.

Question: Are private class-level variables inherited ?
Answer: Yes, but they are not accessible, so looking at it you can honestly say that they are not inherited. But they are.

Question: What is the difference between the C#.NET and VB.NET ?
Answer:

VB.NET
- It didn't have the XML Documentation.
- It didn't have the Operator Overloading.
- It didn't have the Pointer Type variables.

C#.NET
- It has XML Documentation, Operator Overloading and supports Pointer Variables using unsafe keyword.

Question: Is it possible to inline assembly or IL in C# code ?
Answer: No.

Question: What is the syntax for calling an overloaded constructor within a constructor (this() and constructorname() does not compile) ?
Answer: The syntax for calling another constructor is as follows: class B { B(int i) { } } class C : B { C() : base(5) // call base constructor B(5) { } C(int i) : this() // call C() { } public static void Main() {} }.

Question: Provide C# Keywords ?
Answer: These are some most important keyword of c# :
abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else
enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock
long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof
stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual volatile void
while

Question: What optimizations does the C# compiler perform when you use the /optimize+ compiler option ?
Answer: The following is a response from a developer on the C# compiler team: We get rid of unused locals (i.e., locals that are never read, even if assigned). We get rid of unreachable code. We get rid of try-catch with an empty try. We get rid of try-finally with an empty try. We get rid of try-finally with an empty finally. We optimize branches over branches: gotoif A, lab1 goto lab2: lab1: turns into: gotoif !A, lab2 lab1: We optimize branches to ret, branches to next instruction, and branches to branches.

SQL Server Questions

2009-04-21T02:01:00.001-07:00

How do you implement one-to-one, one-to-many and many-to-many relationships while designing tables?
One-to-One relationship can be implemented as a single table and rarely as two tables with primary and foreign key relationships.
One-to-Many relationships are implemented by splitting the data into two tables with primary key and foreign key relationships.
Many-to-Many relationships are implemented using a junction table with the keys from both the tables forming the composite primary key of the junction table.

What's the difference between a primary key and a unique key?
Both primary key and unique enforce uniqueness of the column on which they are defined. But by default primary key creates a clustered index on the column, where are unique creates a nonclustered index by default. Another major difference is that, primary key doesn't allow NULLs, but unique key allows one NULL only.

What are user defined datatypes and when you should go for them?
User defined datatypes let you extend the base SQL Server datatypes by providing a descriptive name, and format to the database. Take for example, in your database, there is a column called Flight_Num which appears in many tables. In all these tables it should be varchar(8). In this case you could create a user defined datatype called Flight_num_type of varchar(8) and use it across all your tables.

See sp_addtype, sp_droptype in books online.

What is bit datatype and what's the information that can be stored inside a bit column?
Bit datatype is used to store boolean information like 1 or 0 (true or false). Untill SQL Server 6.5 bit datatype could hold either a 1 or 0 and there was no support for NULL. But from SQL Server 7.0 onwards, bit datatype can represent a third state, which is NULL.

Define candidate key, alternate key, composite key.
A candidate key is one that can identify each row of a table uniquely. Generally a candidate key becomes the primary key of the table. If the table has more than one candidate key, one of them will become the primary key, and the rest are called alternate keys.

A key formed by combining at least two or more columns is called composite key.

What are defaults? Is there a column to which a default can't be bound?

A default is a value that will be used by a column, if no value is supplied to that column while inserting data. IDENTITY columns and timestamp columns can't have defaults bound to them. See CREATE DEFUALT in books online.

What is a transaction and what are ACID properties?

A transaction is a logical unit of work in which, all the steps must be performed or none. ACID stands for Atomicity, Consistency, Isolation, Durability. These are the properties of a transaction. For more information and explanation of these properties, see SQL Server books online or any RDBMS fundamentals text book.

Explain different isolation levels

An isolation level determines the degree of isolation of data between concurrent transactions. The default SQL Server isolation level is Read Committed. Here are the other isolation levels (in the ascending order of isolation): Read Uncommitted, Read Committed, Repeatable Read, Serializable. See SQL Server books online for an explanation of the isolation levels. Be sure to read about SET TRANSACTION ISOLATION LEVEL, which lets you customize the isolation level at the connection level.

CREATE INDEX myIndex ON myTable(myColumn)
What type of Index will get created after executing the above statement?

Non-clustered index. Important thing to note: By default a clustered index gets created on the primary key, unless specified otherwise.

What's the maximum size of a row?

8060 bytes. Don't be surprised with questions like 'what is the maximum number of columns per table'. Check out SQL Server books online for the page titled: "Maximum Capacity Specifications"

What's the difference between DELETE TABLE and TRUNCATE TABLE commands?

DELETE TABLE is a logged operation, so the deletion of each row gets logged in the transaction log, which makes it slow. TRUNCATE TABLE also deletes all the rows in a table, but it won't log the deletion of each row, instead it logs the deallocation of the data pages of the table, which makes it faster. Of course, TRUNCATE TABLE can be rolled back.
TRUNCATE
TRUNCATE is faster and uses fewer system and transaction log resources than DELETE.
TRUNCATE removes the data by deallocating the data pages used to store the table’s data, and only the page deallocations are recorded in the transaction log.
TRUNCATE removes all rows from a table, but the table structure and its columns, constraints, indexes and so on remain. The counter used by an identity for new rows is reset to the seed for the column.
You cannot use TRUNCATE TABLE on a table referenced by a FOREIGN KEY constraint.
Because TRUNCATE TABLE is not logged, it cannot activate a trigger.
TRUNCATE can not be Rolled back using logs.
TRUNCATE is DDL Command.
TRUNCATE Resets identity of the table.

DELETE
DELETE removes rows one at a time and records an entry in the transaction log for each deleted row.
If you want to retain the identity counter, use DELETE instead. If you want to remove table definition and its data, use the DROP TABLE statement.
DELETE Can be used with or without a WHERE clause
DELETE Activates Triggers.
DELETE Can be Rolled back using logs.
DELETE is DML Command.
DELETE does not reset identity of the table.

What are constraints? Explain different types of constraints.

Constraints enable the RDBMS enforce the integrity of the database automatically, without needing you to create triggers, rule or defaults.

Types of constraints: NOT NULL, CHECK, UNIQUE, PRIMARY KEY, FOREIGN KEY

For an explanation of these constraints see books online for the pages titled: "Constraints" and "CREATE TABLE", "ALTER TABLE"

Whar is an index? What are the types of indexes? How many clustered indexes can be created on a table? I create a separate index on each column of a table. what are the advantages and disadvantages of this approach?

Indexes in SQL Server are similar to the indexes in books. They help SQL Server retrieve the data quicker.

Indexes are of two types. Clustered indexes and non-clustered indexes. When you craete a clustered index on a table, all the rows in the table are stored in the order of the clustered index key. So, there can be only one clustered index per table. Non-clustered indexes have their own storage separate from the table data storage. Non-clustered indexes are stored as B-tree structures (so do clustered indexes), with the leaf level nodes having the index key and it's row locater. The row located could be the RID or the Clustered index key, depending up on the absence or presence of clustered index on the table.

If you create an index on each column of a table, it improves the query performance, as the query optimizer can choose from all the existing indexes to come up with an efficient execution plan. At the same t ime, data modification operations (such as INSERT, UPDATE, DELETE) will become slow, as every time data changes in the table, all the indexes need to be updated. Another disadvantage is that, indexes need disk space, the more indexes you have, more disk space is used.

What are the steps you will take to improve performance of a poor performing query?

This is a very open ended question and there could be a lot of reasons behind the poor performance of a query. But some general issues that you could talk about would be: No indexes, table scans, missing or out of date statistics, blocking, excess recompilations of stored procedures, procedures and triggers without SET NOCOUNT ON, poorly written query with unnecessarily complicated joins, too much normalization, excess usage of cursors and temporary tables.

Some of the tools/ways that help you troubleshooting performance problems are: SET SHOWPLAN_ALL ON, SET SHOWPLAN_TEXT ON, SET STATISTICS IO ON, SQL Server Profiler, Windows NT /2000 Performance monitor, Graphical execution plan in Query Analyzer.

Download the white paper on performance tuning SQL Server from Microsoft web site. Don't forget to check out sql-server-performance.com

What are cursors? Explain different types of cursors. What are the disadvantages of cursors? How can you avoid cursors?

Cursors allow row-by-row prcessing of the resultsets.

Types of cursors: Static, Dynamic, Forward-only, Keyset-driven. See books online for more information.

Disadvantages of cursors: Each time you fetch a row from the cursor, it results in a network roundtrip, where as a normal SELECT query makes only one rowundtrip, however large the resultset is. Cursors are also costly because they require more resources and temporary storage (results in more IO operations). Furthere, there are restrictions on the SELECT statements that can be used with some types of cursors.

Most of the times, set based operations can be used instead of cursors. Here is an example:

If you have to give a flat hike to your employees using the following criteria:

Salary between 30000 and 40000 -- 5000 hike
Salary between 40000 and 55000 -- 7000 hike
Salary between 55000 and 65000 -- 9000 hike

In this situation many developers tend to use a cursor, determine each employee's salary and update his salary according to the above formula. But the same can be achieved by multiple update statements or can be combined in a single UPDATE statement as shown below:

UPDATE tbl_emp SET salary =
CASE WHEN salary BETWEEN 30000 AND 40000 THEN salary + 5000
WHEN salary BETWEEN 40000 AND 55000 THEN salary + 7000
WHEN salary BETWEEN 55000 AND 65000 THEN salary + 10000
END

Another situation in which developers tend to use cursors: You need to call a stored procedure when a column in a particular row meets certain condition. You don't have to use cursors for this. This can be achieved using WHILE loop, as long as there is a unique key to identify each row. For examples of using WHILE loop for row by row processing,

Write down the general syntax for a SELECT statements covering all the options.

Here's the basic syntax: (Also checkout SELECT in books online for advanced syntax).

SELECT select_list
[INTO new_table_]
FROM table_source
[WHERE search_condition]
[GROUP BY group_by_expression]
[HAVING search_condition]
[ORDER BY order_expression [ASC | DESC] ]

What is a join and explain different types of joins.

Joins are used in queries to explain how different tables are related. Joins also let you select data from a table depending upon data from another table.

Types of joins: INNER JOINs, OUTER JOINs, CROSS JOINs. OUTER JOINs are further classified as LEFT OUTER JOINS, RIGHT OUTER JOINS and FULL OUTER JOINS.

For more information see pages from books online titled: "Join Fundamentals" and "Using Joins".

What are triggers? How many triggers you can have on a table? How to invoke a trigger on demand?

Triggers are special kind of stored procedures that get executed automatically when an INSERT, UPDATE or DELETE operation takes place on a table.

In SQL Server 6.5 you could define only 3 triggers per table, one for INSERT, one for UPDATE and one for DELETE. From SQL Server 7.0 onwards, this restriction is gone, and you could create multiple triggers per each action. But in 7.0 there's no way to control the order in which the triggers fire. In SQL Server 2000 you could specify which trigger fires first or fires last using sp_settriggerorder

Triggers can't be invoked on demand. They get triggered only when an associated action (INSERT, UPDATE, DELETE) happens on the table on which they are defined.

Triggers are generally used to implement business rules, auditing. Triggers can also be used to extend the referential integrity checks, but wherever possible, use constraints for this purpose, instead of triggers, as constraints are much faster.

Till SQL Server 7.0, triggers fire only after the data modification operation happens. So in a way, they are called post triggers. But in SQL Server 2000 you could create pre triggers also. Search SQL Server 2000 books online for INSTEAD OF triggers.

Also check out books online for 'inserted table', 'deleted table' and COLUMNS_UPDATED()

What is a self join? Explain it with an example.

Self join is just like any other join, except that two instances of the same table will be joined in the query. Here is an example: Employees table which contains rows for normal employees as well as managers. So, to find out the managers of all the employees, you need a self join.

CREATE TABLE emp
(
empid int,
mgrid int,
empname char(10)
)

INSERT emp SELECT 1,2,'Vyas'
INSERT emp SELECT 2,3,'Mohan'
INSERT emp SELECT 3,NULL,'Shobha'
INSERT emp SELECT 4,2,'Shridhar'
INSERT emp SELECT 5,2,'Sourabh'

SELECT t1.empname [Employee], t2.empname [Manager]
FROM emp t1, emp t2
WHERE t1.mgrid = t2.empid

Here's an advanced query using a LEFT OUTER JOIN that even returns the employees without managers (super bosses)

SELECT t1.empname [Employee], COALESCE(t2.empname, 'No manager') [Manager]
FROM emp t1
LEFT OUTER JOIN
emp t2
ON
t1.mgrid = t2.empid

T-SQL Code to find out Nth highest number in a column

Ever wondered how to find out the second highest salary from the employees table? Or how to find out the third oldest employee in the company? Here is a stored procedure which accepts the table name, column name, and nth number and displays the nth highest number from the given column.

CREATE PROC nth 
(
 @table_name sysname,
 @column_name sysname,
 @nth int
)
AS
BEGIN

--Purpose: To find out the nth highest number in a column. Eg: Second highest salary from the salaries table
--Input parameters: Table name, Column name, and the nth position



SET @table_name = RTRIM(@table_name)
SET @column_name = RTRIM(@column_name)

DECLARE @exec_str CHAR(400)
IF (SELECT OBJECT_ID(@table_name,'U')) IS NULL
BEGIN
 RAISERROR('Invalid table name',18,1)
 RETURN -1
END

IF NOT EXISTS(SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @table_name AND COLUMN_NAME = @column_name)
BEGIN
 RAISERROR('Invalid column name',18,1)
 RETURN -1
END

IF @nth <= 0
BEGIN
 RAISERROR('nth highest number should be greater than Zero',18,1)
 RETURN -1
END

SET @exec_str = 'SELECT MAX(' + @column_name + ') from ' + @table_name + ' WHERE ' + @column_name +
 ' NOT IN ( SELECT TOP ' + LTRIM(STR(@nth - 1)) + ' ' + @column_name + ' FROM ' + @table_name +
' ORDER BY ' + @column_name + ' DESC )'
EXEC (@exec_str)

END

What is the difference between a HAVING CLAUSE and a WHERE CLAUSE?

Specifies a search condition for a group or an aggregate. HAVING can be used only with the SELECT statement. HAVING is typically used in a GROUP BY clause. When GROUP BY is not used, HAVING behaves like a WHERE clause. Having Clause is basically used only with the GROUP BY function in a query. WHERE Clause is applied to each row before they are part of the GROUP BY function in a query. HAVING criteria is applied after the the grouping of rows has occurred.

What is sub-query? Explain properties of sub-query.

Sub-queries are often referred to as sub-selects, as they allow a SELECT statement to be executed arbitrarily within the body of another SQL statement. A sub-query is executed by enclosing it in a set of parentheses. Sub-queries are generally used to return a single row as an atomic value, though they may be used to compare values against multiple rows with the IN keyword.

A subquery is a SELECT statement that is nested within another T-SQL statement. A subquery SELECT statement if executed independently of the T-SQL statement, in which it is nested, will return a result set. Meaning a subquery SELECT statement can standalone and is not depended on the statement in which it is nested. A subquery SELECT statement can return any number of values, and can be found in, the column list of a SELECT statement, a FROM, GROUP BY, HAVING, and/or ORDER BY clauses of a T-SQL statement. A Subquery can also be used as a parameter to a function call. Basically a subquery can be used anywhere an expression can be used.

Properties of Sub-Query
A subquery must be enclosed in the parenthesis.
A subquery must be put in the right hand of the comparison operator, and
A subquery cannot contain a ORDER-BY clause.
A query can contain more than one sub-queries.

What are types of sub-queries?

Single-row subquery, where the subquery returns only one row.
Multiple-row subquery, where the subquery returns multiple rows,.and
Multiple column subquery, where the subquery returns multiple columns.

What is User Defined Functions?
User-Defined Functions allow to define its own T-SQL functions that can accept 0 or more parameters and return a single scalar data value or a table data type.

What kind of User-Defined Functions can be created?
There are three types of User-Defined functions in SQL Server 2000 and they are Scalar, Inline Table-Valued and Multi-statement Table-valued.

Scalar User-Defined Function
A Scalar user-defined function returns one of the scalar data types. Text, ntext, image and timestamp data types are not supported. These are the type of user-defined functions that most developers are used to in other programming languages. You pass in 0 to many parameters and you get a return value.

Inline Table-Value User-Defined Function
An Inline Table-Value user-defined function returns a table data type and is an exceptional alternative to a view as the user-defined function can pass parameters into a T-SQL select command and in essence provide us with a parameterized, non-updateable view of the underlying tables.

Multi-statement Table-Value User-Defined Function
A Multi-Statement Table-Value user-defined function returns a table and is also an exceptional alternative to a view as the function can support multiple T-SQL statements to build the final result where the view is limited to a single SELECT statement. Also, the ability to pass parameters into a T-SQL select command or a group of them gives us the capability to in essence create a parameterized, non-updateable view of the data in the underlying tables. Within the create function command you must define the table structure that is being returned. After creating this type of user-defined function, It can be used in the FROM clause of a T-SQL command unlike the behavior found when using a stored procedure which can also return record sets.

3.Data Races & Locks

2009-04-20T22:52:00.000-07:00

Data races

Well, that's shown you how to create a new thread and start it. For a very few cases, it really is as simple as that - just occasionally, you end up with a thread which doesn't need access to any data other than its own (the counters in this case). Far more commonly, however, you need threads to access the same data, sooner or later - and that's where the problems start. Let's take a very simple program to start with:

using System;

using System.Threading;



public class Test

{

  static int count=0;



  static void Main()

  {

      ThreadStart job = new ThreadStart(ThreadJob);

      Thread thread = new Thread(job);

      thread.Start();

    

      for (int i=0; i < class="String">"Final count: {0}", count);

  }



  static void ThreadJob()

  {

      for (int i=0; i <>

This is very straightforward - each of the threads just increments the count variable, and then the main thread displays the final value of count at the end. The only really new thing here is the call in the main thread to Thread.Join, which basically pauses the main thread until the other thread has completed.

So, the result should always be Final count: 10, right? Well, no. In fact, chances are that that will be the result if you run the above code - but it isn't guaranteed to be. There are two reasons for this - one fairly simple, and one much subtler. We'll leave the subtle one for the moment, and just consider the simple one.

The statement count++; actually does three things: it reads the current value of count, increments that number, and then writes the new value back to the count variable. Now, if one thread gets as far as reading the current value, then the other thread takes over, does the whole increment operation, and then the first thread gets control again, its idea of the value of count is out of date - so it will increment the old value, and write that newly incremented (but wrong) value back into the variable.

The easiest way of showing this is by separating the three operations and introducing some Sleep calls into the code, just to make it more likely that the threads will clash heads, as it were. Note that introducing Sleep calls should never change the correctness of a program, in terms of threading - any thread can go to sleep at any time, basically. In other words, you can never rely on two operations both happening without another thread doing stuff in between. I've also put some diagnostics in to make it clearer what's happening. The "main" thread's activities appear on the left, while the "other" thread's activities are on the right. Here's the code:

using System;

using System.Threading;



public class Test

{

  static int count=0;



  static void Main()

  {

      ThreadStart job = new ThreadStart(ThreadJob);

      Thread thread = new Thread(job);

      thread.Start();

    

      for (int i=0; i < class="ValueType">int tmp = count;

          Console.WriteLine ("Read count={0}", tmp);

          Thread.Sleep(50);

          tmp++;

          Console.WriteLine ("Incremented tmp to {0}", tmp);

          Thread.Sleep(20);

          count = tmp;

          Console.WriteLine ("Written count={0}", tmp);

          Thread.Sleep(30);

      }

    

      thread.Join();

      Console.WriteLine ("Final count: {0}", count);

  }



  static void ThreadJob()

  {

      for (int i=0; i < class="ValueType">int tmp = count;

          Console.WriteLine ("\t\t\t\tRead count={0}", tmp);

          Thread.Sleep(20);

          tmp++;

          Console.WriteLine ("\t\t\t\tIncremented tmp to {0}", tmp);

          Thread.Sleep(10);

          count = tmp;

          Console.WriteLine ("\t\t\t\tWritten count={0}", tmp);

          Thread.Sleep(40);

      }

  }

}

... and here's one set of results I saw ...

Read count=0

                              Read count=0

                              Incremented tmp to 1

                              Written count=1

Incremented tmp to 1

Written count=1

                              Read count=1

                              Incremented tmp to 2

Read count=1

                              Written count=2

                              Read count=2

Incremented tmp to 2

                              Incremented tmp to 3

Written count=2

                              Written count=3

Read count=3

                              Read count=3

Incremented tmp to 4

                              Incremented tmp to 4

                              Written count=4

Written count=4

                              Read count=4

Read count=4

                              Incremented tmp to 5

                              Written count=5

Incremented tmp to 5

Written count=5

Read count=5

Incremented tmp to 6

Written count=6

Final count: 6

Just looking at the first few lines shows exactly the nasty behaviour described before the code: the main thread has read the value 0, the other thread has incremented count to 1, and then the main thread has incremented its "stale" value from 0 to 1, and written that value to the variable. The same thing happens a few more times, and the end result is that count is 6, instead of 10.

Exclusive access - Monitor. Enter Exit and the lock statement

What we need to fix the problem above is to make sure that while one thread is in a read/increment/write operation, no other threads can try to do the same thing. This is where monitors come in. Every object in .NET has a (theoretical) monitor associated with it. A thread can enter (or acquire) a monitor only if no other thread has currently "got" it. Once a thread has acquired a monitor, it can acquire it more times, or exit (or release) it. The monitor is only available to other threads again once it has been exited as many times as it was entered. If a thread tries to acquire a monitor which is owned by another thread, it will block until it is able to acquire it. (There may be more than one thread trying to acquire the monitor, in which case when the current owner thread releases it for the last time, only one of the threads will acquire it - the other one will have to wait for the new owner to release it too.)

In our example, we want exclusive access to the count variable while we're performing the increment operation. First we need to decide on an object to use for locking. I'll discuss this choice in more detail later, but for the moment we'll introduce a new variable just for the purposes of locking: countLock. This is initialised to be a reference a new object, and thereafter is never changed. It's important that it's not changed - otherwise one thread would be locking on one object's monitor, and another object might be locking on a different object's monitor, so they could interfere with each other just like they did before.

We then simply need to put each increment operation in a Monitor.Enter and Monitor.Exit pair:

 

using System;

using System.Threading;



public class Test

{

  static int count=0;

  static readonly object countLock = new object();



  static void Main()

  {

      ThreadStart job = new ThreadStart(ThreadJob);

      Thread thread = new Thread(job);

      thread.Start();

    

      for (int i=0; i < class="ValueType">int tmp = count;

          Console.WriteLine ("Read count={0}", tmp);

          Thread.Sleep(50);

          tmp++;

          Console.WriteLine ("Incremented tmp to {0}", tmp);

          Thread.Sleep(20);

          count = tmp;

          Console.WriteLine ("Written count={0}", tmp);

          Monitor.Exit(countLock);

          Thread.Sleep(30);

      }

    

      thread.Join();

      Console.WriteLine ("Final count: {0}", count);

  }



  static void ThreadJob()

  {

      for (int i=0; i < class="ValueType">int tmp = count;

          Console.WriteLine ("\t\t\t\tRead count={0}", tmp);

          Thread.Sleep(20);

          tmp++;

          Console.WriteLine ("\t\t\t\tIncremented tmp to {0}", tmp);

          Thread.Sleep(10);

          count = tmp;

          Console.WriteLine ("\t\t\t\tWritten count={0}", tmp);

          Monitor.Exit(countLock);

          Thread.Sleep(40);

      }

  }

}

The results look a lot better this time:

Read count=0

Incremented tmp to 1

Written count=1

                              Read count=1

                              Incremented tmp to 2

                              Written count=2

Read count=2

Incremented tmp to 3

Written count=3

                              Read count=3

                              Incremented tmp to 4

                              Written count=4

Read count=4

Incremented tmp to 5

Written count=5

                              Read count=5

                              Incremented tmp to 6

                              Written count=6

Read count=6

Incremented tmp to 7

Written count=7

                              Read count=7

                              Incremented tmp to 8

                              Written count=8

Read count=8

Incremented tmp to 9

Written count=9

                              Read count=9

                              Incremented tmp to 10

                              Written count=10

Final count: 10

The fact that the increments were strictly alternating here is just due to the sleeps - in a more normal system there could be two increments in one thread, then three in another, etc. The important thing is that they would always be thread-safe: each increment would be isolated from each other increment, with only one being processed at a time.

There's a chance - a tiny chance, but a chance nonetheless - that the code above would hang, however. If part of the increment operation (one of the calls to Console.WriteLine, for instance) threw an exception, the thread would still own the monitor, so the other thread would never be able to acquire it and move on. The obvious solution to this (if you're used to exception handling, at least) is to put the call to Monitor.Exit in a finally block, with everything after the call to Monitor.Enter in a try block. Just like the using statement which puts a call to Dispose in a finally block automatically, C# provides the lock statement to call Monitor.Enter and Monitor.Exit with a try/finally block automatically. This makes it much easier to get synchronization right, as you don't end up having to check for "balanced" calls to Enter and Exit everywhere. It also makes sure that you don't try to release a monitor you don't own: in the code we had above, if we changed the value of countLock to be a reference to a different object within the increment operation, we'd have failed to release the monitor we owned, and tried to release a monitor we didn't own - which would (in theory) have caused a SynchronizationLockException. (In fact, the exception wouldn't have been thrown because there's a bug in the framework in version 1.0/1.1, but that's another story.) The lock statement automatically takes a copy of the reference you specify, and calls both Enter and Exit with it. (In the example above, and everywhere else in this article, variables used to hold locks are declared as read-only. I have yet to come across a good reason to change what a particular piece of code locks on.)

So, we can rewrite our previous code into the somewhat clearer and more robust code below:


using System;

using System.Threading;



public class Test

{

  static int count=0;

  static readonly object countLock = new object();



  static void Main()

  {

      ThreadStart job = new ThreadStart(ThreadJob);

      Thread thread = new Thread(job);

      thread.Start();

    

      for (int i=0; i < class="Statement">lock (countLock)

          {

              int tmp = count;

              Console.WriteLine ("Read count={0}", tmp);

              Thread.Sleep(50);

              tmp++;

              Console.WriteLine ("Incremented tmp to {0}", tmp);

              Thread.Sleep(20);

              count = tmp;

              Console.WriteLine ("Written count={0}", tmp);

          }

          Thread.Sleep(30);

      }

    

      thread.Join();

      Console.WriteLine ("Final count: {0}", count);

  }



  static void ThreadJob()

  {

      for (int i=0; i < class="Statement">lock (countLock)

          {

              int tmp = count;

              Console.WriteLine ("\t\t\t\tRead count={0}", tmp);

              Thread.Sleep(20);

              tmp++;

              Console.WriteLine ("\t\t\t\tIncremented tmp to {0}", tmp);

              Thread.Sleep(10);

              count = tmp;

              Console.WriteLine ("\t\t\t\tWritten count={0}", tmp);

          }

          Thread.Sleep(40);

      }

  }

}

2. Passing Parameters to Threads

2009-04-20T22:51:00.001-07:00

Passing Parameters to Threads

Often when you start a thread, you want to give it some parameters - usually some data it has to process, a queue to wait on, etc. The ThreadStart delegate doesn't take any parameters, so the information has to be stored somewhere else if you are going to create a new thread yourself. Typically, this means creating a new instance of a class, and using that instance to store the information. Often the class itself can contain the delegate used for starting the thread. For example, we might have a program which needs to fetch the contents of various URLs, and wants to do it in the background. You could write code like this:

public class UrlFetcher
{
   string url

   public UrlFetcher (string url)
   {
       this.url = url;
   }

   public void Fetch()
   {
       // use url here
   }
}

[... in a different class ...]
            
UrlFetcher fetcher = new UrlFetcher (myUrl);
new Thread (new ThreadStart (fetcher.Fetch)).Start();

In some cases, you actually just wish to call a method in some class (possibly the currently executing class) with a specific parameter. In that case, you may wish to use a nested class whose purpose is just to make this call - the state is stored in the class, and the delegate used to start the thread just calls the "real" method with the appropriate parameter. (Note that the object on which to call the method in the first place will also be required as state unless the method is static.)

Using the thread pool instead

One alternative to starting the thread using a ThreadStart delegate is to use the thread pool, either using ThreadPool.QueueUserWorkItem or by calling a delegate asynchronously. Both of these are covered later on in a more detailed discussion of the thread pool, which also contains examples. Note that calling a delegate asynchronously allows you to specify multiple parameters, and those parameters are strongly typed.

.NET 2.0 solution 1: anonymous methods (with and without the thread pool)

One of the enhancements to C# in version 2.0 is anonymous methods. These allow you to specify blocks of code as methods within other methods, and use those methods as delegates. You can access variables (including local variables and parameters of the "outside" method) within the anonymous method. For example, using an anonymous method to fetch a URL using a normal ThreadStart delegate (and using inference of delegate type too):

ThreadStart starter = delegate { Fetch (myUrl); };
new Thread(starter).Start();

(This could have all been expressed within a single step, creating both the thread and the delegate in the same line of code, but I believe the above is more readable.) Here's similar code to use a WaitCallback and queue the job in ThreadPool:

WaitCallback callback = delegate (object state) { Fetch ((string)state); };
ThreadPool.QueueUserWorkItem (callback, myUrl);

Note the way that the state is declared.

.NET 2.0 solution 2: `ParameterizedThreadStart`

In .NET 2.0, there is a new delegate, ParameterizedThreadStart, which takes a parameter of type object. You can create a thread using an instance of this delegate instead of just ThreadStart, and a new overload to Thread.Start allows you to specify the value to be passed to the new thread. This is simple, but only accepts a single parameter and isn't type-safe (just like the options when using thread pool threads). The earlier code could then be rewritten as:

[In some method or other]
Thread t = new Thread (new ParameterizedThreadStart(FetchUrl));
t.Start (myUrl);

[And the actual method...]
static void FetchUrl(object url)
{
   // use url here, probably casting it to a known type before use
}

Amit Narula's Blog

Requirement Gathering Tips for designing successfull software architecture

Calling a WCF service from Javascript

The right way of accessing Master page properties from a child page

Method 1

Method 2

Method 3

Method 4

Current Version

Default Version

Original Version

Proposed Version

How To Make Your Website More (McAfee) Secure

Introduction

Vulnerability 1

Vulnerability Name: Microsoft .NET Custom Errors Not Set

Description

Solution

Vulnerability 2

Vulnerability Name: Allow All Policy in crossdomain.xml

Description

Solution

Vulnerability 3

Vulnerability Name: Using SSL v2 in Secure Communications

Description

Solution

Vulnerability 4

Vulnerability Name: Weak Supported SSL Ciphers Suites

Description

Solution

10 ASP.NET Performance and Scalability Secrets

Introduction

ASP.NET Pipeline Optimization

ASP.NET Process Configuration Optimization

Things You Must Do for ASP.NET Before Going Live

Content Delivery Network

Caching AJAX Calls on Browser

Making Best Use of Browser Cache

Use URLs Consistently

Cache Static Content for Longer Period

Use Cache Friendly Folder Structure

Reuse Common Graphics Files

Change File Name When You Want to Expire Cache

Use a Version Number While Accessing Static Files

Store Cacheable Files in a Different Domain

SSL is Not Cached, so Minimize SSL Use

HTTP POST Requests are Never Cached

Generate Content-Length Response Header

How to Configure Static Content Caching in IIS

On Demand Progressive UI Loading for Fast Smooth Experience

Optimize ASP.NET 2.0 Profile Provider

How to Query ASP.NET 2.0 Membership Tables Without Bringing Down the Site

Prevent Denial of Service (DOS) Attack

WCF Contracts Defined

Abstract Class and An Interface

Background

What is an Abstract Class?

What is an Interface?

Both Together

DataBase Naming Conventions

C#.Winform Interview questions

ASP.Net 2.0 Interview questions.

C# Questions

SQL Server Questions

3.Data Races & Locks

2. Passing Parameters to Threads

Passing Parameters to Threads

Using the thread pool instead

.NET 2.0 solution 1: anonymous methods (with and without the thread pool)

.NET 2.0 solution 2: ParameterizedThreadStart

.NET 2.0 solution 2: `ParameterizedThreadStart`