Nitty-gritty of .net

Client-Side vs. Server-Side Validation

noreply@blogger.com (Priyanks) — Sun, 25 Jan 2009 02:20:00 +0000

If the browser supports DHTML, ASP.NET validation controls can perform validation by using client script . The advantage of using client script is that a feedback can be provided without a response from the server . The validation controls automatically detect whether the browser supports DHTML and perform the validation accordingly.

The error display mechanism for client side is same as server-side validation. Validation is performed on the server even if it was already performed on the client. This enables you to determine the validation status in the server code and ensure security against users bypassing client-side validation.

If validation is performed on the client, validation controls include some additional features:

If you are summarizing validation error messages, you can display them in a message box that appears when the user submits the page.
Validation controls present the same object model on the client as on the server. For example, you can test validation by reading a validation control's IsValid property the same way, on both the client and the server. However, there are differences in the validation information exposed at the page level. On the server, the page supports properties; on the client, it contains global variables.

Client : Page_IsValid
Server : IsValid
Client : Page_Validators (array). Contains references to all validation controls on te page. Server: Validators (collection). Contains references to all validation controls.
Client : Page_ValidationActive. A Boolean value that indicates whether validation should take place. Set this variable to false to turn off client-side validation programmatically.
Server : Not applicable

Note : If client-side validation is enabled, the page includes references to script libraries that are used to perform the client-side validation.When you use a RegularExpressionValidator control, the expressions can be checked on the client if an ECMAScript-compatible language, such as Microsoft JScript is available. Client-side regular expressions differ in small details from the regular expression checking done on the server by using the Regex class.The page includes a client-side method to intercept and handle the Click event before the page is submitted.

Source of Reference : MSDN

Validation controls

noreply@blogger.com (Priyanks) — Sun, 25 Jan 2009 02:02:00 +0000

Validation controls contain 5 controls that make comparisons and 1 control that summarizes any errors that appear. All validation controls need to be placed within a Form or a Panel control, or inside a control's template on a mobile Web page. A validation control can be dragged onto a mobile user control page.

RequiredFieldValidator : Used to validate user entered data into a SelectionList or TextBox control. With a SelectionList control, the user needs to select an item in the list. With a TextBox control, the user needs to enter a value.
CompareValidator: Used to compare the data value entered by the user to a value in another control. Set the ControlToCompare property to the string in the id property of the SelectionList or TextBox control that contains the comparison value and the ValueToCompare property to the comparison value .
RangeValidator : Used to validate whether user input falls within a specified range. Use the MinimumValue and MaximumValue properties.
RegularExpressionValidator : to test whether the user input in a TextBox or SelectionList control matches a regular expression. The regular expression pattern is specified in its ValidationExpression property. You can specify regular expressions or select from a list of predefined expressions.
CustomValidator : Use this to create a control that performs customized validation. It also validates input from the TextBox or SelectionList control. Set its ControlToValidate property to the ID of the control, to validate. When a form that contains a CustomValidator control is posted to the server, the CustomValidator control raises a ServerValidate event. In this event, you can write the custom validation code you want. Eventually, you can set the IsValid property of the validation eventArgs to true or false, depending on the outcome of the validation.
ValidationSummary: Use to to present the user with a list of validation errors that occurred when a form was posted on the server. The mobile version of the ValidationSummary control displays a back-link for the user to return to the form and correct the data entered.

Each validation control can display an error message at the position of the validation control on the form. Validation errors can be collected in a validation summary control and can be displayed at a single place, such as at the top of the page.

Set the Display property to None, Static , or Dynamic , to check whether the validation control displays error messages. You can select Dynamic to display the results of the validation, and None, if you do not want to display the results. In the current version of the ASP.NET mobile controls, Dynamic and Static have similar meaning.

You can use the mobile version of the ValidationSummary control to display a list of validation errors that occurred when a form was submitted. This control lists all the error messages generated by the other validation controls on the form. The ValidationSummary control obtains the error message strings from the ErrorMessage properties of the validation controls.

Server Controls

noreply@blogger.com (Priyanks) — Sat, 24 Jan 2009 08:01:00 +0000

On receiving a request, ASP.Net examines the request, by using a User Agent retrieved from the header of HTTP Request, to find out the brower type and version for outputting the HTML specific to that browser.

When you are using server controls, you do not need to specify the HTML that is to be the output from the server-side code. You can specify the functionality you want to see in the browser, and ASP.NET decides the output to be sent to the browser.

Label

TextBox : It can be mapped to the following HTML elements used in your forms:

Standard TextBox
Multiline TextBox
Password Field

Button: Use the button to submit forms. You can also manage the items on your forms by using the Button control’s OnClick event.

DropDownList: With this, you can place an HTML select box on your Web page and set it against the select box. You can use this control when you want the user to select a single item from a list of multiple items. The select box generated by the DropDownList control displays a single item and allows the user to select one item from the list.

ListBox: displays a collection of items. The ListBox control displays more of the collection to the user and allows the user to make multiple selections from the collection.

CheckBox or CheckBoxList: By using check boxes on a Web Form, users can either select from a collection of items or specify the value of an item to be yes/no, on/off, or true/false. You can use multiple CheckBox controls on your ASP.NET pages, treating each check box as its own element with associated events. The CheckBoxList control allows you to put multiple check boxes on the form and create specific events for the entire group.

RadioButton or RadioButtonList: Radio buttons are form elements that require at least two options. The RadioButtonList server control allows you to display a collection of radio buttons on a Web page. The RadioButtonList control allows you to iterate through to see what the user selected, to make counts, or to perform other actions.

Source of Reference : MSDN

HTTP Handler in detail

noreply@blogger.com (Priyanks) — Tue, 20 Jan 2009 10:45:00 +0000

The process that runs in response to a request made to an ASP.NET Web application is the HTTP handler ( or endpoint). When users request an .aspx, .asmx, or .ashx file, the page processes the request through the page handler.

Uses:

It can be created to render custom utput to the browser.
It add new functionalities to the Web server.
It can be created to generate RSS-formatted XML. You can then bind a file name extension such as .rss to the custom handler. When users send a request to your site in a format that ends in .rss, the Web application sends the request to the HTTP handler to process the request.
Image server. HTTP handlers can be used to resize the images in a Web application. When you want a Web application to resize the images, you can write a custom handler to resize the images, and then send them to the user as the handler's response.

ASP.NET maps HTTP requests to HTTP handlers, based on a file name extension. Each HTTP handler can process individual HTTP URLs or groups of URL extensions in an application. ASP.NET includes the following built-in HTTP handlers:
ASP.NET page handler (*.aspx) : default HTTP handler for all ASP.NET pages.
Web service handler (*.asmx): default HTTP handler for Web service pages created as .asmx files in ASP.NET.
Generic Web handler (*.ashx): default HTTP handler for all Web handlers that do not have a user interface (UI) and that include the @WebHandler directive.
Trace handler (trace.axd): displays current page trace information.

A Http Handler for performing synchronous processing of requests:

public class HelloWorldHandler : IHttpHandler
{
public HelloWorldHandler()
{
}

//The ProcessRequest method is responsible for processing individual
//HTTP requests. You can write the code that produces the
//output for the handler by using the ProcessRequest method.
public void ProcessRequest(HttpContext context)
{
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
// This handler is called whenever a file ending in .sample is
//requested. A file with that extension does not need to exist.
Response.Write(".HTML.");
Response.Write(".body.");
Response.Write(" .h1.Hello from a synchronous custom HTTP handler./h1");
Response.Write("./body.");
Response.Write("./html.");
}

// This property specifies whether the IHttpHandlerFactory object can put the handler in a pool and reuse it. If the handler cannot be pooled, the factory should create a new instance of the handler

public bool IsReusable
{
// To enable pooling, return true here. This keeps the handler in memory.
get { return false; }
}
}

To register the handler :

.configuration.
.system.web.
.httpHandlers.
.add verb="*" path="*.sample" type="HelloWorldHandler"/.
.httpHandlers.
.system.web.
.configuration.

Note : "*" means all of the http verbs, eg. GET,POST

To register the handler in IIS 7.0 running in Integrated mode

.configuration.
.system.webServer.
.handlers.
.add verb="*" path="*.sample" name="HelloWorldHandler" type="HelloWorldHandler".
./handlers.
./system.webServer.
./configuration.

Note : When a HTTP Handler class is created, the handler can respond to any file name extension that is not already mapped in IIS and in ASP.NET. For ASP.NET to know which handler to use for your custom file name extension, you must map the extension in IIS to ASP.NET. Then, in the application, you must map the extension to the custom handler.
By default, ASP.NET maps the file name extension, .ashx, to an HTTP handler. If you create an HTTP handler class that has the file name extension, .ashx, the handler is automatically registered with IIS and ASP.NET. The advantage of not using the .ashx file name extension is that the handler is then reusable for different extension mappings. If you want to create a custom file name extension for a handler, you must explicitly register the extension with IIS and ASP.NET. After you create the custom HTTP handler class, you must register it in the application's web.config file

source of reference : MSDN

HTTP Modules in detail

noreply@blogger.com (Priyanks) — Thu, 15 Jan 2009 11:54:00 +0000

HTTP modules, part of ASP.Net request pipeline, are called on every request made to an application and can access life cycle events through out the request. They are like ISAPI filters as they are invoked for all requests. Once the request passes through all of the HTTP modules, it is eventually served by an HTTP handler. The HTTP handler performs some processing on it, and the result again passes through the HTTP modules in the pipeline.

Features like form authentication, caching, sessionstate, client script services are implemented using modules. As part of a request, the module is called to perform tasks that a single page request cannot perform. They use application events, raise events that can be handled in the Global.asax file.

To receive notifications from the request pipeline, you need to register HTTP modules in the application's web.config file. When ASP.NET creates an instance of the HttpApplication class that represents your application, instances of any modules that have been registered are created.

When you create a module, its Init method is called, and then the module initializes itself.
In the module's Init method, you can subscribe to various application events such as BeginRequest or EndRequest by binding the events to methods in the module. When application events are raised, you need to call the appropriate method in your module to perform the required logic, such as checking authentication or logging request information. During event handling, the module can access the Context property of the current request to redirect the request to an alternative page, modify the request, or perform any other request manipulation. Otherwise, when the module's event handler has finished running, ASP.NET calls the next process in the pipeline.

public class MyFirstModule : IHttpModule
{
public MyFirstModule ()
{
}

public String ModuleName
{
get { return "MyModule"; }
}
}

To register in web.config

.configuration.
.system.web.
.httpModules.
.add name="MyFirstModule" type="MyFirstModule"/.
.httpModules.
./system.web.
./configuration.

Note: Replace the "." with opening and closing tags.

To write a handler for the Init method.
// In the Init function, register for HttpApplication events by adding
your handlers.
public void Init(HttpApplication application)
{
application.BeginRequest += (new EventHandler(this.Application_BeginRequest));
application.EndRequest += (new EventHandler(this.Application_EndRequest));
}

Note : During the processing of an http request, only one HTTP handler will be called, whereas more than one HTTP modules can be called
Source of Reference: MSDN

Intrinsic Server Objects

noreply@blogger.com (Priyanks) — Tue, 13 Jan 2009 11:27:00 +0000

Response - An instance of HttpResponse class, this object provides access to the output stream for the current page. Used for writing text into the page or for creating cookies.

Request - An instance of HttpRequest, this object provides access to the current page request, including request headers, cookies, client certificates, and a query string.

Context - An instance of HttpContext, this object provides access to the entire current context, which includes the Request object. You can use the HttpContext class to share information between Web pages.

Server- An instance of HttpServerUtility, it provides utility methods that you can use to transfer control between pages, get information about the most recent error, and encode and decode HTML text.

Application - An instance of HttpApplicationState , it provides access to application-wide methods and events for all sessions.

Soure of Reference- MSDN

Processing of PageRequests

noreply@blogger.com (Priyanks) — Tue, 13 Jan 2009 10:42:00 +0000

When the first request comes, the top-level items even the application code ,if required, residing in App_code folder is compiled and an instance of Application Manager ,i.e Application domain is created . By virtue of this application domain , the isolation is provided between global variables of different applications. Asp.Net also creates an instance of Hosting environment class in the application domain. After this the application objects such as HttpContext, HttpRequest, and HttpResponse are created and initialized.

The HttpContext class contains objects that are particular to the current application request,i.e. HttpRequest and HttpResponse.

The HttpRequest object contains information about the current request, i.e. cookies and browser information.

The HttpResponse object contains the response that is sent to the client, which includes all the rendered output and cookies.

The request is then processed by the HttpApplication pipeline and after the processing the ASP.NET page life cycle is run.

Page life cycle events

noreply@blogger.com (Priyanks) — Sun, 11 Jan 2009 09:25:00 +0000

At every stage of its lifecycle, the page raises following events:

Stage PageInitialization - Events raised PreInit,Init,InitComplete

PreInit - handles following tasks:

The IsPostBack property is checked to determine if the page is being processed for the first time .
Dynamic controls are created
A master page is dynamically.
Theme property is set dynamically.
Profile property values are read or set.

Note : The values of the controls are not restored from viewstate yet if it's a postback. so if any control property is set during this event, its value might be overwritted in the next event.

Init -

Control properties are read or initialized.
It's triggered after the controls are initialized and skin settings are applied.

Initcomplete -

Those tasks that need the initialization to be complete are processed.
Page object triggers it

Stage LOAD - Events raised Preload, Load

PreLoad -

Once this event is triggered by Page, the view state of the page and all controls are loaded and any postback data included in the Request instance is processed.

Load -

Properties of the controls are set using OnLoad event.
Database connections are established.
The OnLoad event method of the page and its child control are called recursively until they all are loaded.

Control events -

Control specific events are handled at this stage. e.g. TextChanged event’s for a textbox.
In a postback request, if the page contains validator controls, you should check the IsValid property of the page and of the individual validation controls before performing any processing.

LoadComplete -

For accessing controls that have been properly loaded.

PreRender

To make any final changes to the controls before they are rendered.
Before this event , the Page object calls EnsureChildControls for each control and for the page. Each data bound control, whose DataSourceID property is set, calls its DataBind method.

SaveStateComplete-

Used for tasksthat require view state to be saved, yet not making any changes to the controls themselves.
ViewState for the page and its controls are saved before this event occurs and thus any chhanges to the page or controls at this point will be ignored.

Render

The page object calls this method on all of the controls, so all the controls are written and sent to the browser.

Note: If a custom control incorporates only standard NET Web server controls and no custom markup, you do not need to override the Render method which you do normally for any custom control.

Unload -

A final cleanup for specific controls such as closing the control-specific database connections and open files, finishing up logging is performed here.
The Unload event occurs for each control, and then for the page.

Note : No further changes to the response stream can be made now. All the controls UnLoad method are fired, followed by the pages UnLoad event (bottom-up). This stage is used for closing database connections, closing open files, etc.

The Init, Unload event for each child control occur before its parent container corresponding event are raised. However the Load event for a container occurs before the Load events for its child controls (top-down).

Source of Reference: MSDN

Asp.net Lifecycle stages

noreply@blogger.com (Priyanks) — Sun, 11 Jan 2009 08:15:00 +0000

It's been quiet some time since I started building asp.net websites. Today I just thought of revising my concepts as I am planning to take Microsoft .NET Framework 3.5, ASP.NET Application Development exam soon. I am starting with the most basic concept which is the lifecycle stages of a asp.net page. I am referring to MSDN site mainly for my revision.

Isolation levels in SQL Server 2005

noreply@blogger.com (Priyanks) — Thu, 18 Sep 2008 11:43:00 +0000

Read Uncommitted:

Least restrictive isolation level.
Transactions only ensure that they do not read physically corrupt data.
Dirty reads, Nonrepeatable reads, Phantom reads are possible.

Read Committed with snapshot:
New to SQL Server 2005
When a transaction references rows that have been updated by another transaction, read operations retrieve the version of the row that existed when the snapshot transaction started.
Dirty reads are prevented.
Nonrepeatable reads, Phantom reads are possible.

Read Committed with locking:
Default isolation level used by SQL Server 2005.
Read operations cannot access data that other transactions are currently modifying.
Dirty reads are prevented.
Nonrepeatable reads, Phantom reads are possible.

Repeatable Read:
The first transaction locks all the rows that its reading so that other transactions cannot update the data.
Dirty reads, Nonrepeatable reads are prevented.
Phantom reads are possible.

Snapshot:
New to SQL Server 2005
Read operations retrieve the version of the row that existed when the snapshot transaction started as it does not acquire locks.
Dirty reads, Nonrepeatable, Phantom reads are prevented.

Serializable:

Most restrictive isolation level.
Transactions are completely isolated from each other. This is implemented by Database engines frequently by locking large numbers of rows or entire tables.
Dirty reads, Nonrepeatable, Phantom reads are prevented.

How to use transaction in .Net

noreply@blogger.com (Priyanks) — Sat, 06 Sep 2008 09:05:00 +0000

The following code gives an example of using local transaction in ado.net

using System.Transactions;

bool success = false;
SqlConnection conn = null;
SqlTransaction transaction = null;
try
{
conn= new SqlConnection(ConfigurationManager.ConnectionStrings["AdventureWorks"].ConnectionString;);
conn.Open();
transaction = conn.BeginTransaction(System.Data.IsolationLevel.Serializable);
//Serializable isolation prevents dirty reads, phantom reads, non-repeatable reads by locking large numbers of rows or entire tables.

using (SqlCommand commanda = new SqlCommand(somesql1, conn, transaction))
{
int rowsUpdateda = commanda.ExecuteNonQuery();
if (rowsUpdateda > 0)
{
using (SqlCommand commandb = new SqlCommand(somesql2,conn, transaction))
{
int rowsUpdatedb = commandb.ExecuteNonQuery();
if (rowsUpdatedb > 0)
{
success = true;
}
}
}
}
}
finally
{
if (success)
transaction.Commit();
else
transaction.Rollback();
if (conn!= null)
connection.Close();
}

To use distributed transaction:

//A TransactionOptions object is created to specify the isolation level or timeout for the transaction
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = new TimeSpan(0, 2, 0);

//A Transaction scope defines a block of code that participates in a local or distributed transaction
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
using (SqlConnection conna= new SqlConnection(connstring))
{
using (SqlCommand commanda = new SqlCommand(sqla, conna))
{
int rowsUpdateda = commanda.ExecuteNonQuery();
if (rowsUpdateda > 0)
{
using (SqlConnection connb= new SqlConnection(connb))
{
using (SqlCommand commandb = new SqlCommand(sqlb,connb))
{
int rowsUpdatedb = commandb.ExecuteNonQuery();
if (rowsUpdatedb > 0)
{
transactionScope.Complete(); }
}
commandb.Dispose ;// Dispose the second command object.
}
connb.Close;
// Dispose (close) the second connection.
}
} commandb.Dispose; // Dispose the first command object.
} connb.Close ;
// Dispose (close) the first connection.
} TransactionScope.Dispose; // Dispose TransactionScope object, to commit or rollback

Google's Browser Chrome beta version is out

noreply@blogger.com (Priyanks) — Wed, 03 Sep 2008 12:50:00 +0000

Google has finally released it much awaited web browser Chrome beta version. I hope it doesn't crash like IE and is more stable.

It's highlighted features are :
1.Multiprocess based. Each tab has its own process, if one of the tab crashes it will not close the entire window like IE.
2. With it's task manager you can find out which website is using the most memory.
3.Plug-ins appear as a separate process in the task manager
4.Webkit is the open source rendering engine behind Chrome
5.Address bar offers suggestions for both search and top pages

For trying it out refer to http://www.google.com/chrome/index.html?hl=en&brand=CHMG&utm_source=en-hpp&utm_medium=hpp&utm_campaign=en

I am liking it.

To store connection string in application configuration file

noreply@blogger.com (Priyanks) — Wed, 03 Sep 2008 12:36:00 +0000

Open up web.config file and inside the root element add the element.

connectionString="Data Source=(local); Initial Catalog=AdventureWorks; Integrated Security=SSPI; Persist Security Info=False" />

Connecting to different Data sources using ADO.Net

noreply@blogger.com (Priyanks) — Wed, 03 Sep 2008 12:20:00 +0000

Connect to a SQLServer datasource

using System.Data.SqlClient

string connectionString = "Data Source=(local); Initial Catalog=Adventureworks; " + "Integrated Security=SSPI; Persist Security Info=False";

SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

using (connection)
{
// use connection.
}

Connect to an OLE DB Data Source
using System.Data.OleDb

string connectionString = "Provider=SQLOLEDB; Data Source=(local); Initial Catalog=Northwind; " + "Integrated Security=SSPI; Persist Security Info=False";

OleDbConnection connection = new OleDbConnection(connectionString);
connection.Open();

using (connection)
{
// use connection.

}

Connect to ODBC data source
using System.Data.Odbc

string connectionString = "Driver={Microsoft Access Driver (*.mdb)}; DBQ=c:\\nwind.mdb; " + "Trusted_Connection=yes";

OdbcConnection connection = new OdbcConnection(connectionString);
connection.Open();

using (connection)
{
//use connection

}

Connect to Oracle data source
using System.Data.OracleClient

string connectionString = " Data Source=MyOracleServer;Integrated Security=yes";

OracleConnection connection = new OracleConnection(connectionString);
connection.Open();

using (connection)
{
//use connection

.}

Note : If you don't want the data source to return security-sensitive information, i.e password, when the connection is open or has ever been in an open state, set persist Security Info to be false(default value).

.Net Framework 2.0 update not found. The win32manifest will not be embedded

noreply@blogger.com (Priyanks) — Wed, 03 Sep 2008 10:23:00 +0000

Are you getting the following error after installing VS2008 on a vista machine:
.Net Framework 2.0 update not found. The win32manifest will not be embedded while opening a VB.Net Project or
Required file 'alink.dll with IAlink3' could not found while opening a C# project.

To fix the issue you need to install
NetFX2.0-KB110806-v60000-x86.msu from the installation disk of VS2008 . After that repair VS2008 and reboot your pc.

Named Pipes Provider, error: 40 - Could not open a connection to SQL Server

noreply@blogger.com (Priyanks) — Fri, 01 Aug 2008 05:16:00 +0000

Are you getting the following message when you try connecting to SQLSever 2005 on some other machine ?

TITLE: Microsoft SQL Server Management Studio------------------------------
An error has occurred while establishing a connection to the server. When connecting to SQL Server 2005, this failure may be caused by the fact that under the default settings SQL Server does not allow remote connections. (provider: Named Pipes Provider, error: 40 - Could not open a connection to SQL Server) (Microsoft SQL Server, Error: 1396)

This mainly happens if you haven't allowed remote connections on the sqlserver.

Go to MicrosoftSQLServer2005> ConfigurationTools>SQL Server Surface AreaConfiguration tool
Click on Surface Area Configuration for services and Connections
Select MSSQLServer
Select Remote Connections option
If you are using SQL Server Developed Edition, by default Local Connections only is selected.
Select Local and remote connections and select the first option Using TCP/IP only if you are not using Named pipes.
Restart MSSQLServer services.
At times, it's better to reboot the system to make the change effective.

Deleting duplicate records from a table

noreply@blogger.com (Priyanks) — Fri, 11 Jul 2008 04:49:00 +0000

One of my recent task has required me to get rid of multiple duplicate records from a table. While doing that I came across a useful feature introduced in SQL Server 2005 which I would like to share with everyone.
Example : A CustomerOrder table has duplicate records of the same customerid and orderid. If you got records for 1 customer, you can directly run the sql query as follows:

with temp as (SELECT ROW_NUMBER ( ) OVER ( PARTITION BY CUSTOMERID, ORDERID ORDER BY ID ) AS RNUM FROM CUSTOMERORDER )
delete from temp where rnum > 1

If there are more than 1 customer, it's better to write a storedprocedure as follows:

CREATE PROCEDURE DeleteDuplicateRecords
-- Add the parameters for the stored procedure here
AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;

-- Create a temporary table to store all those customer which have duplicate records

create table #temp(customerid,orderid,totalcount)

insert into #temp(customerid,orderid,totalcount)
select customerid,orderid,count(*)
from CustomerOrder
group by customerid, orderid
having count(*) > 1
order by count(*) desc

declare @cid int,
@orderid int

declare delete_cursor cursor for
select customerid,orderid from #temp

open delete_cursor
fetch next
from delete_cursor
into @cid, @orderid
while (@@fetch_status = 0 )
begin

with temp as (SELECT ROW_NUMBER ( ) OVER ( PARTITION BY CUSTOMERID, ORDERID ORDER BY ID ) AS RNUM FROM CUSTOMERORDER WHERE CustomerId = @cid and OrderId = @orderid )
delete from temp where rnum > 1

fetch next
from delete_cursor
into @cid,@orderid
end

close delete_cursor
deallocate delete_cursor
END
GO

ROWNUMBER() Returns the sequential number of a row within a partition of a result set, starting at 1 for the first row in each partition.
http://msdn.microsoft.com/en-us/library/ms186734.aspx

Thread

noreply@blogger.com (Priyanks) — Mon, 28 Apr 2008 12:12:00 +0000

The process of creating a thread is called spawning a new thread, the process of destroying an existing thread is called killing or terminating a thread, and the process of pausing a thread is called putting the thread to sleep.

A short-lived thread is a thread that is created to perform a single task and is then terminated. It is common to create short-lived threads to perform operating system tasks such as copying or moving files. In such situations, you can use the ThreadPool class in the .NET Framework. This class can also be used when it is not necessary to have full control over each individual thread.

The ThreadPool class manages a set of readily available threads to be used by a process. Each process has only one thread pool that the process uses to execute different methods. Resource allocation does not need to occur every time a thread is started because the thread is already created in the pool. This increases application performance. However, there are situations in which the thread pool should be avoided because there is no direct control over the thread. You should not use a thread pool when:
You require a foreground thread.
You require a thread to have a particular priority.
You have tasks that can block threads for long periods of time. The thread pool has a maximum number of threads, so a large number of threads from the thread pool being blocked might prevent tasks from starting.
You need to place threads into a single-threaded apartment. All thread pool threads are in the multithreaded apartment.
You need to have a stable identity associated with the thread, or you need to dedicate a thread to a task.
Based on these situations, you need to use a thread pool whenever the application requires threads to execute short-lived tasks in a fast-paced scenario. For example, if you want to test read/write operations to a database simulating a multiuser environment, you can create a set of methods that access the database by executing common queries, and use multiple threads from the thread pool to execute the methods multiple times, simultaneously.

There is a limit of 25 threads in a thread pool; therefore, even if you start 50 threads, only 25 threads will be executed at a given time. As soon as a thread finishes, another thread that was waiting for an idle thread in the pool can start.

The process of managing access to resources being shared by multiple threads is called synchronization.Synchronization comprises of locking mechanisms, signaling, and some interlocked operations.

the most common ones include exclusive and shared locks. The .NET Framework provides several classes that you can use to lock resources. However, the simplest method to lock a shared resource is to use the SyncLock statement in Visual Basic or the lock statement in C#.
When a thread notifies another thread about the lock status of a resource, it is called signaling. synchronization includes some interlocked operations that you can use to perform simple operations on a shared memory location or a variable.

.NET Framework provides several classes to manage the locking of shared resources. These classes include Monitor, WaitHandle, Mutex, Semaphore, and ReaderWriterLock.

The Monitor class is a static class used by a thread to acquire an exclusive lock on an object so that other threads are not able to use that object while it is being monitored. The use of the Monitor class is similar to that of the SyncLock or lock blocks in Visual Basic and C# respectively. To start synchronization, the thread must call the Enter method of the Monitor class and pass the object to be locked as a parameter. To end synchronization, the thread must call the Exit method and pass the same parameter. The code is synchronized between the calls. Although the functionality of the Monitor class is exactly the same as that of the SyncLock and lock blocks, this class provides better control of the synchronization code through a set of methods.

The Mutex class derives from the WaitHandle class and provides the same functionality achieved through the Monitor class, but it can synchronize threads in different application domains. There are two types of mutexes that can be created, local and system mutexes. A local mutex can only be used within the process where it was created, while a system (or named) mutex can be used by any process in the operating system. Once a mutex is created, it can only be released from the thread in which it was created.

You can use the Semaphore class to synchronize access to resources by a pool of threads, instead of a single thread at once. When using the Semaphore class, you can specify the maximum number of threads that can access the resources simultaneously. Other threads must wait in queue until the executing threads release the semaphore. You can achieve this functionality by maintaining a count of new threads that can access the resource, decrementing this count every time a thread enters the semaphore, and incrementing it every time a thread leaves the semaphore. Whenever the counter is greater than zero, new threads can enter the semaphore. Once the counter is zero, incoming threads will be queued until the counter increases. Just like Mutex, Semaphore can be local or global (named).
You can use the Semaphore class when you want to restrict the number of threads executing a piece of code.

You can use the ReaderWriterLock class to synchronize access to resources by using a pool of threads with read access or a single thread with write access. You can use different methods in the ReaderWriterLock class to lock resources for either read or write access. When a thread submits a read lock request, the ReaderWriterLock class works similar to the Semaphore class, allowing access to resources by multiple threads. Once a writer lock is requested, all new reader requests are queued. After the existing locks are released, the writer lock is honored. A lock can be represented by a variable of type LockCookie for multiple requests, such as when upgrading a reader lock to a writer lock and vice versa. However, a thread cannot have both reader and writer locks at the same time; it must change the lock type by using predefined methods.
You can use the ReaderWriterLock class in situations where changes to resources are infrequent and multiple threads are able to share the resource.

When working with the Monitor class, you can implement signaling by using the Pulse method. However, you can also use other classes such as Mutex, Semaphore, EventWaitHandle, and RegisteredWaitHandle for signaling.

Signaling may be necessary when the same object is being used to execute different actions by different threads, and the synchronization of these different threads is needed. For instance, consider a bank account object being used simultaneously to both withdraw and deposit money in an account. The deposit method reads the balance, followed by the withdraw method. The withdraw method then changes the balance based on the amount withdrawn. Since the deposit method had already read the balance, it adds the amount to be deposited to the old balance, and therefore, saves the new balance incorrectly. This error could be prevented if the two threads were using signaling.

All classes that derive from the WaitHandle class can use signaling, such as the Mutex, Semaphore, and EventWaitHandle classes.

You can use the EventWaitHandle class to exchange signals among different threads and processes. EventWaitHandle can be local (to the process) or global (named). The EventWaitHandle class has two child classes, AutoResetEvent and ManualResetEvent. These two classes are very similar; you can use both to signal to a thread whether it can execute or not after waiting for a signal.
You can think of the signal as a green (go) or red (stop) light letting the thread know whether to wait or move on. Once a thread makes a call to wait on a signal, it stops until a green light is received. The signal remains green until a thread turns it red again. This describes the Set (turn green) and Reset (turn red) methods available in the ManualResetEvent class. The AutoResetEvent class works in a similar way; however, the light turns red automatically after turning green and letting one, and only one, thread continue.

You can use the AutoResetEvent class in the same way as the EventWaitHandle class when working with an object in the AutoReset mode. The only difference is that the event created is a local event, with thread affinity. You can use this class when the signal does not need to cross application domains and the AutoResetEvent class automatically resets itself between signaled and non-signaled states. The only constructor for this class takes a parameter of type Boolean indicating if the initial state of the event is signaled.

You can use the ManualResetEvent class in the same way as the EventWaitHandle class when working with an object in the ManualReset mode. The only difference is that the event created is a local event, with thread affinity. You should use this class when the signal does not need to cross application domains. The ManualResetEvent class remains signaled until you manually switch it to a non-signaled state and vice versa.
The only constructor for the ManualResetEvent class takes a parameter of type Boolean indicating if the initial state of the event is signaled. You can use the OpenExisting method of the ManualResetEvent class to open a named event that already exists.

When attempting to access a shared resource by using a thread from a thread pool, your application may have to wait in queue until the resource is free. Your application can reserve a place in queue in a method analogous to you taking a numeric ticket to stand in queue while at a public office. The ThreadPool class includes a method named RegisterWaitForSingleObject that returns a WaitHandle class. WaitHandle represents your application’s reserved spot in the queue and your object is signaled when the resource in question is free.
The RegisteredWaitHandle class represents the WaitHandle returned by the RegisterWaitForSingeObject method. If you decide that you would like your application to surrender its place in line and no longer wait for a resource, you may call the Unregister method.

The Interlocked class is a static (Shared) class that you can use to synchronize shared thread access to a variable. Variables that are interlocked have an exclusive lock placed on them so that no other threads can interrupt operations. The operations that can be performed on an interlocked variable are limited to very simple operations such as simple mathematic calculations. One benefit of using the Interlocked class is that it performs operations at a very low level, directly with the operating system and is, therefore, very fast.

In asynchronous programming, calls to various methods are made in a parallel manner where a method call does not wait for the other method to complete before application execution continues.

Implementing service processes, threading, and application domains in a .NET Framework application (11 %)

noreply@blogger.com (Priyanks) — Sun, 27 Apr 2008 11:15:00 +0000

Implement, install, and control a service. (Refer System.ServiceProcess namespace)
•Inherit from ServiceBase class
•ServiceController class and ServiceControllerPermission class
•ServiceInstaller and ServiceProcessInstaller class
•SessionChangeDescription structure and SessionChangeReason enumeration

F.Delegates

noreply@blogger.com (Priyanks) — Sun, 27 Apr 2008 04:31:00 +0000

Delegates

Reference types
Type safe , instances of objects with their own properties and methods.
Declare a delegate type,define a variable of a delegate type,create an instance of a delegate.
Used to indirectly call one or more methods at run time,pass a delegate by ref as a parameter of a method
Method is not specified when declaring the delegate type or a variable based on the delegate type
Invoking Method is specified when an instance of delegate is created and dynamically associate one or more instances with the variable at runtime.

Uses:

In creation of events. e.g. all events in 2.0 based on delegate types
creation of asynchronous method calls.e.g. callbacks in 2.0 based on delegate types
If you have two objects that have similar methods with identical method signatures, you can use the same delegate to invoke them even if two objects are not related,methods have different names.
You can use generics in delegate signatures. By using generics, you can instantiate a strongly typed delegate that can be used at run time with full type safety without specifying a particular type in the signature of your delegate type declaration.This helps you create an event in a generic class and specify the return type and parameter types when you create an instance of the delegate.
Invoke static or instance methods
In C#,you can have anonymous methods

Types:

A singlecast delegate references only a single method.
A multicast delegate references many methods . All delegates are implicitly multicast delegates. By adding multiple method references to a delegate’s invocation list, you can invoke all the methods with one call to the delegate.This process is referred to as multicasting. You can invoke each method in the invocation list individually. This is useful if you want to determine the return value or output parameters of each method call or if you do not want to call certain methods in certain circumstances.

C# exeception rules to delegate

Covariance : occurs when the return type of the method referenced by the delegate inherits from the return type of the delegate itself. Because the method’s return type inherits from the delegate’s return type, the signatures are still considered a match.

Contravariance :Contravariance permits the declaration of a delegate with parameters that inherit from the types used in the parameters of the method that will be invoked. However, for contravariance to work, the order and number of parameters in the signatures of the delegate as well as the method must still match.

D. Specialized collection

noreply@blogger.com (Priyanks) — Sat, 26 Apr 2008 11:40:00 +0000

System.Collections.Specialized
Specialized collections:Predefined collections that serve a special or highly specific purpose

Specialized String Collection :
StringCollection class: same behavior as the generic List class when elements are specified as string.
Strongly typed version of ArrayList
Accepts Null reference as a valid value.
Allow duplicate Element
Zero based index
String comparision is case sensitive

StringDictionary class: exact same behavior as the generic Dictionary class, when the key is specified as a string and the value is specified as a string.
Can accept a null value but the key cannot be a null reference
Case insensitive

StringEnumerator class provides enumeration for the string collection.
CollectionsUtil class allows to create a case insensitive Hashtable or a case insensitive SortedList.
Hashtable name=CollectionsUtil.CreateCaseInsensitiveHashtable();

Specialized Dictionary collection:
HybridDictionary class internally switches to either a ListDictionary or a Hashtable to store data, depending on the number of elements.
ListDictionary provides a better performance for less than 10 elements
Not suitable in conditions when performance is important.

Hashtable provides a better performance for more than 10 elements.
OrderedDictionary can store elements sorted by key and sorted by index. This class is very efficient if the number of elements is 10 or less than 10.

Specialized Named Collection:
The named collection classes provide the abstract base class for a collection of associated string keys and object values that you can access either by the key or by the index.
It allows multiple string values to be associated with a single string key.
It provides a class that you can derive from to create your own key/value collections, with their own specialized behavior
Default initial capacity for a NameValueCollection is zero.
Dynamically resizes.
In NameValueCollection, a null reference is allowed for either a key or a value.

Specialized Bit collection:
A BitVector32 provides a simple structure that stores Boolean values and small integers.
It stores Boolean values in a 32-bit structure hence more efficient than bit structure.

A BitVector32.Section is a window into the BitVector32 and is composed of the smallest number of consecutive bits that can contain the maximum value specified in CreateSection. For example, a section with a maximum value of 1 is composed of only one bit, whereas a section with a maximum value of 5 is composed of three bits
The BitVector32.Section allows you to store small integers within a BitVector32 class.

Generic Collection

noreply@blogger.com (Priyanks) — Sat, 26 Apr 2008 11:21:00 +0000

List : Equivalent to Arraylist of NonGeneric collection
Unlike Arraylist, can store value type as well
You need to specify datatype.
Uses List.Enumertor for iteration.
e.g. Listnames = new List ();
dim names as List = new List(of String)

Generic Stack : Equivalent to Non generic Stack but you specify a datatype
Use Push to add
Use Pop to remove element

Generic Queue:
Enqueue to add element
Dequeue to remove element

LinkedList : Createss and manage a strongly typed doubly linked list.
Every node contains reference to the previous and next nodes in the list.

Collection and Collection Interfaces

noreply@blogger.com (Priyanks) — Sat, 26 Apr 2008 06:50:00 +0000

INTERFACES
IComparable : Used to compare two objects and determine which object is greater.
The CompareTo method returns 1, 0, or -1 if the value of the current object is greater than, equal to, or less than the object passed as a parameter to this method.

ICollection: defines the size, enumerators, and synchronization methods for all non-generic and generic collections.
Non-Generic : AddAt, AddItem, GetEnumerator, Item methods,IsReadOnly and Count properties
Generic : Add, Clear, Contains, CopyTo, Remove,Count methods.

IList :Used to index a collection..
Generic & Non-Generic : Insert, IndexOf, and RemoveAt methods.
Non-Generic: Add, Clear, Contains, IndexOf, Insert, Remove, and RemoveAt methods.

IComparer: The non-generic IComparer interface provides the Compare method same as Compare method of IComparable.
In the generic version ,both parameters are passed as a specific data type.

IEqualityComparer:Used to check if two collections are equivalent.
Non-Generic: Equals(determines if two system.Object are equivalent or not) and GetHashCode(returns same hashcode if two collections are equivalent.
The generic version accepts parameters of a specific data type.

IDictionary:The non-generic IDictionary provides the collection key/value pair behavior.
The generic version allows the key and the value to be declared as specific data type.

IEnumerable: It provides the GetEnumerator method to enumerate the collection and returns the IEnumerator data type.

IEnumerator: Non genric version supports a simple iteration in a non-generic collection. This interface is the base interface of all non-generic enumerators. e.g.For each in vb.net and foreach in C#
Non-Generic: MoveNext , Reset methods ,current property(returns a data type of system.object)
The generic version provides the strongly typed Current property.

ArrayList : Can be resized.
Implements IList

Stack : based on LIFO

Queue :Based on FIFO

Iterator : used in C#

Comparer :
Default method that provides a comparison based on the current culture
DefaultInvariant that provides a culture-independent comparison

HashTable : represents a collection of name/value pairs
The key is stored as an object and its hash code is used to identify the value which makes data retrieval very fast.
Allows you to dynamically add and remove elements without re-indexing.
Doesnt have a generic version
Implements IEnumerator
Disadvantage : doesnt allow sorting

SortedList:represents a collection of name/value pairs that are accessible either by key or by index, but are sorted only by keys.
The SortedList class maintains two arrays to store the elements of the list, one array for the keys and another for the associated values.
The elements are sorted by keys.
Does not allow duplication of keys.
Indexing adjusts when you add or remove a element .
Slower than hashtable becoz of sorting process. However,compared to hashtable more flexible as flexibility it can be accessed by key or index.

BitArray: implements a bit structure, which represents a collection of binary bits, 1s and 0s.
The size of a bit structure in memory depends on the number of elements in the collection.
Elements are accessed using an integer index.
Zero-based indexes.
To add element use Length property

My Notes on A

noreply@blogger.com (Priyanks) — Wed, 23 Apr 2008 06:50:00 +0000

When to use structure :

If the type will perform better as a value type rather than reference, use a structure instead of class.
Instance size less than 16bytes
Represents a single value
Will not be changed after creation
Will not be cast to a Reference type

Advantages of using Generics:

Processing is fast as boxing and unboxing are not required
Catch errors at compile time by ensuring typesafety
You can use constraints on the types: Interface,Base Class,Constructor,Reference or ValueType

IConvertible: Converts an object to CLR datatypes

ICloneable: defines the Clone method that you can implement to do a deep cloning of an object and it's references to other objects

IFormattable: defines the ToString method that you can implement to format the value of the current instance by using the specified format.

IDisposable: defines the dispose method that you can implement to release the resources with the help of a supporting custom-defined ReleaseResource method and remove the current object from the finalization queue. This relieves the garbage collector from calling the finalizer of an object after the object is disposed

New in 2.0

Nullable
Operator
Generic types .eg.EventHandler

IEquatable: applicable to Generic class used Equal method
TypeForwarding

Conversion operator ( Vb.Net:Widening,Narrowing C#:implicit,explicit)

1. Developing applications that use system types and collections (15 percent)

noreply@blogger.com (Priyanks) — Wed, 23 Apr 2008 05:37:00 +0000

A .Manage data in a .NET Framework application by using the .NET Framework 2.0 system types. (Refer System namespace)

•Value types ( VB.Net )
•Nullable type (VB.Net)
•Reference types
•Attributes
•Generic types (VB.Net)
•Exception classes (VB.Net)
•Boxing and UnBoxing (VB.Net)
•TypeForwardedToAttribute Class

B.Manage a group of associated data in a .NET Framework application by using collections. (Refer System.Collections namespace)
•ArrayList class
•Collection interfaces
•ICollection interface and IList interface
•IComparer interface and IEqualityComparer interface
•IDictionary interface and IDictionaryEnumerator interface
•IEnumerable interface and IEnumerator interface
•Iterators
•Hashtable class
•CollectionBase class and ReadOnlyCollectionBase class
•DictionaryBase class and DictionaryEntry class
•Comparer class
•Queue class
•SortedList class
•BitArray class
•Stack class

C.Improve type safety and application performance in a .NET Framework application by using generic collections. (Refer System.Collections.Generic namespace)
•Collection.Generic interfaces
•Generic IComparable interface (Refer System Namespace)
•Generic ICollection interface and Generic IList interface
•Generic IComparer interface and Generic IEqualityComparer interface
•Generic IDictionary interface
•Generic IEnumerable interface and Generic IEnumerator interface
IHashCodeProvider interface (obsolete now)

•Generic Dictionary
•Generic Dictionary class and Generic Dictionary.Enumerator structure
•Generic Dictionary.KeyCollection class and Dictionary.KeyCollection.Enumerator structure
•GenericDictionary.ValueCollectionclass and Dictionary.ValueCollection.Enumerator structure

•Generic Comparer class and Generic EqualityComparer class
•Generic KeyValuePair structure
•Generic List class, Generic List.Enumerator structure, and Generic SortedList class
•Generic Queue class and Generic Queue.Enumerator structure
•Generic SortedDictionary class
•Generic LinkedList
•Generic LinkedList class
•Generic LinkedList.Enumerator structure
•Generic LinkedListNode class

•Generic Stack class and Generic Stack.Enumerator structure

D.Manage data in a .NET Framework application by using specialized collections. (Refer System.Collections.Specialized namespace)
•Specialized String classes
•StringCollection class
•StringDictionary class
•StringEnumerator class

•Specialized Dictionary
•HybridDictionary class
•IOrderedDictionary interface and OrderedDictionary class
•ListDictionary class

•Named collections
•NameObjectCollectionBase class
•NameObjectCollectionBase.KeysCollection class
•NameValueCollection class

•CollectionsUtil
•BitVector32 structure and BitVector32.Section structure

E.Implement .NET Framework interfaces to cause components to comply with standard contracts. (Refer System namespace)
•IComparable interface
•IDisposable interface
•IConvertible interface
•ICloneable interface
•IEquatable interface
•IFormattable interface

F.Control interactions between .NET Framework application components by using events and delegates. (Refer System namespace)
•Delegate class
•EventArgs class
•EventHandler delegates