Keep it Simple

Build Secure Web Services With SOAP Headers and Extensions

2009-12-16T20:34:00.033+05:30

Legions of Web developers have built Web services using the Microsoft .NET Framework and have learned how easy it is to get a basic Web service up and running. Just create an ASMX file, add a class, decorate its methods with the [WebMethod] attribute, and presto! Instant Web service.

The Framework does the hard part, mapping Web methods to class methods, leaving you to concentrate on the business logic that makes your Web service unique. Building Web services with the .NET Framework is easy—easy, that is, unless the Web services are secure. There is no standard, agreed-upon method for exposing Web services over the Internet in such a way that only authorized users can call them. WS-Security will one day change that, but for now, you're on your own. One Microsoft sample published last year demonstrates how to secure Web services by passing user IDs in method calls. While functional, that approach is less than optimal because it mixes real data with authentication data and, to first order, requires each and every Web method to perform an authorization check before rendering a service. A better solution is one that passes authentication information out-of-band (that is, outside the Web methods' parameter lists) and that "front-ends" each method call with an authentication module that operates independently of the Web methods themselves.

SOAP headers are the perfect vehicle for passing authentication data out-of-band. SOAP extensions are equally ideal for examining SOAP headers and rejecting calls that lack the required authentication data. Combine the two and you can write secure Web services that cleanly separate business logic from security logic. In this column, I'll present one technique for building secure Web services using SOAP headers and SOAP extensions. Until WS-Security gains the support of the .NET Framework, it's one way to build Web services whose security infrastructure is both centralized and protocol-independent.

The Quotes Web Service

Let's start with the Web service in Figure 1. Called "Quote Service," it publishes a single Web method named GetQuote that takes a stock symbol (for example, "MSFT") as input and returns the current stock price.

Figure I

using System;
using System.Web.Services;
using System.Web.Services.Protocols;

[WebService (Name="Quote Service", Description="Provides instant stock quotes to registered users")]
public class QuoteService
{
[WebMethod (Description="Returns the current stock price")]
public int GetQuote (string symbol)
{
if (symbol.ToLower () == "msft")
return 55;
else if (symbol.ToLower () == "intc")
return 32;
else
throw new SoapException ("Unrecognized symbol", SoapException.ClientFaultCode);
}
}

Now you can call this web service from your application inorder to test. I guess you know how to test a web service. I did a small test with the Console Application as below. The application should respond by reporting a current stock price of 55.

Figure II:

using System;

class Client
{
static void Main (string[] args)
{
if (args.Length == 0)
{
Console.WriteLine ("Please supply a stock symbol");
return;
}
QuoteService qs = new QuoteService ();
int price = qs.GetQuote (args[0]);
Console.WriteLine ("The current price of " + args[0] + " is " + price);
}
}

Now the GetQuote method is simple enough that anyone can call it. And that's just the problem. Anyone can call it. Assuming you'd want to charge for such a service, you wouldn't want for it to be available to everyone. Rather, you'd want to identify the caller on each call to GetQuote and throw a SOAPException if the caller is not authorized.

Figure III lists a revised version of Quote Service that uses a custom SOAP header to transmit user names and passwords. A SOAP header is a vehicle for passing additional information in a SOAP message. The general format of a SOAP message is:

[soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"]
[soap:Header]
...
[/soap:Header]
[soap:Body]
...
[/soap:Body]
[/soap:Envelope]

SOAP headers are optional. Here's a SOAP message that lacks a header:

[soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"]
[soap:Body]
[GetQuote xmlns="http://tempuri.org/"]
[symbol]msft[/symbol]
[/GetQuote]
[/soap:Body]

And here's the same message with a header containing a user name and password:

[soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"]

[soap:Header]
[AuthHeader xmlns="http://tempuri.org/"]
[UserName]techie[/UserName]
[Password]imbest[/Password]
[/AuthHeader]
[/soap:Header]
[soap:Body]
[GetQuote xmlns="http://tempuri.org/"]
[symbol]msft[/symbol]
[/GetQuote]
[/soap:Body]
[/soap:Envelope]

The .NET Framework lets you define custom SOAP headers by deriving from SoapHeader, which belongs to the System.Web.Services.Protocols namespace. The following statements in Quotes.asmx define a custom header named AuthHeader:

public class AuthHeader : SoapHeader

{

public string UserName;

public string Password;

}

The statement

public AuthHeader Credentials;

declares an instance of AuthHeader named Credentials in QuoteService, and the statement

[SoapHeader ("Credentials", Required=true)]

makes AuthHeader a required header for calls to GetQuote and transparently maps user names and passwords found in AuthHeaders to the corresponding fields in Credentials.

Calls lacking AuthHeaders won't even reach GetQuote. Calls that do reach it can be authenticated by reading Credentials' UserName and Password fields. GetQuote checks the user name and password and fails the call if either is invalid:

if (Credentials.UserName.ToLower () != "techie" && Credentials.Password.ToLower () != "imbest")

throw new SoapException ("Unauthorized", SoapException.ClientFaultCode);

In the real world, of course, you'd check the caller's credentials against a database rather than hard-code a user name and password. I took the easy way out here to keep the code as simple and understandable as possible.

Figure III

<%@ WebService Language="C#" Class="QuoteService" %>

<%@ WebService Language="C#" Class="QuoteService" %>
using System;
using System.Web.Services;
using System.Web.Services.Protocols;

[WebService(Name="Quote Service",Description="Provides instant stock quotes to registered users")]

public class QuoteService
{
public AuthHeader Credentials;

[SoapHeader ("Credentials", Required=true)]
[WebMethod (Description="Returns the current stock price")]
public int GetQuote (string symbol)
{
// Fail the call if the caller is not authorized

if (Credentials.UserName.ToLower () != "techie" && Credentials.Password.ToLower () != "imbest")

throw new SoapException ("Unauthorized",SoapException.ClientFaultCode);

// Process the request
if (symbol.ToLower () == "msft")
return 55;
else if (symbol.ToLower () == "intc")
return 32;
else

throw new SoapException ("Unrecognized symbol",SoapException.ClientFaultCode);

}
}

public class AuthHeader : SoapHeader
{
public string UserName;
public string Password;
}

To call this version of Quotes.asmx version of GetQuote, a client must include a SOAP header containing the user name "techie" and the password "imbest" as below.

using System;
class Client
{
static void Main (string[] args)
{
if (args.Length == 0) {
Console.WriteLine ("Please supply a stock symbol");
return;
}
QuoteService qs = new QuoteService ();

AuthHeader Credentials = new AuthHeader ();
Credentials.UserName = "techie";
Credentials.Password = "imbest";
qs.AuthHeaderValue = Credentials;

int price = qs.GetQuote (args[0]);
Console.WriteLine ("The current price of " + args[0] + " is " + price);
}
}

Voila !! Our web service is secured.

Asp.Net 2.0's New SQL Server-Based Cache Invalidation Mechanism

2009-04-23T11:12:00.034+05:30

With the advent of SQL Server 2005, your application can request SQL Server to notify it when critical data in a database has changed. Up to that point, an application can safely continue to retrieve data from the cache. This provides a much more granular level of control and takes any guesswork out of the question of how often the cache should be refreshed. This is possible via a new feature called Query Notification, used in conjunction with .NET 2.0.

There are various types of caching available in .Net. Then what's special in Sqlserver query notification. Basically one of the pitfalls with ASP.NET is that it is app domain specific. So if you have a web farm environment, each web server has its own copy of the cache, and this means there is a potential for data being out of sync. With SQL cache dependency you can cache the data on the web server but have SQL Server notify you when the data changes.

An overview of Query Notification

A multi-user web application should be able to provide the latest critical data to its users. To be sure of meeting this need, your application may have to retrieve the results from a database every time the user issues the query. However, this unnecessarily increases network round-trips, and is an inefficient use of resources. To reduce the number of round-trips, developers have traditionally relied on caching mechanisms. Once a query is run, the data is subsequently retrieved from the application's local cache. However, the lifetime value of this cache is generally defined so that the application can periodically update the cache with new values from the database, irrespective of whether the data in the back end has changed or not. This is much better, but it is still not precise.

With query notification enabled then when you run a query against the back-end database, you not only retrieve the data into the cache, but also tell SQL Server to register a subscription for notification if the underlying data changes in a way that will affect the result of the query.

When the notification is received, the event handler in your application invalidates the cache and the next time the application runs the query, it will fetch the data from the back-end server.

All this is done without the need to write any complex application code.

Before you can establish cache dependency with SQL Server 2005, you need to perform the following steps:

Configure SQL Server to support SQL Cache invalidation. This is a one-time setup of the tables or databases in the SQL Server database that you want to monitor.
Add the necessary configuration information to the web.config file.

Configuration of SQL Server to Support SQL Cache Invalidation

You can perform the configuration of SQL Server 2000 to support SQL Cache invalidation in two ways:

Using the aspnet_regsql utility
Using the EnableTableForNotifications method of the SqlCacheDependencyAdmin class

For this article, consider the first method. Basically, the aspnet_regsql utility creates an extra table named AspNet_SqlCacheTablesForChangeNotification that is used to keep track of the changes to all the monitored tables in the database. It also creates a number of triggers and stored procedures to enable this capability. To run the aspnet_regsql utility, open up the Visual Studio command prompt and enter the command shown below.

Command : aspnet_regsql -S localhost -U sa -P atanu -d TestDB -ed

Click the image to enlarge

The command enables the TestDB (My database..you can use your own) database to support SQL cache invalidation:

S—Name of the Server
U—User ID to use to connect to the SQL Server
P—Password to use to connect to the SQL Server
d—The name of the database
ed—Enables the database for SQL Server-triggered cache invalidation

Once this is done at the database level, you need to enable cache invalidation at the individual table level.

Command :aspnet_regsql -S localhost -U sa -P atanu -t Products -d TestDB -et

Click the image to enlarge

In the above command:

t—Specifies the name of the table
et—Enables the table for SQL Server-triggered cache invalidation

The preceding screenshot shows how to enable SQL cache invalidation for the Products table in the TestDB database. Once you configure the Products table to send notifications, any time data in the table changes, it notifies ASP.NET to invalidate the corresponding item in the cache.

Web Configuration Settings for SQL Cache Invalidation

The next step, before you can use SQL cache invalidation in your ASP.NET application, is to update the Web configuration file. You need to instruct the ASP.NET framework to poll the databases that you have enabled for SQL cache invalidation. The following Web configuration file contains the necessary configuration information to poll the TestDB database at periodic intervals:

Click the image to enlarge

The preceding Web configuration file contains two sections, [connectionStrings] and [caching]. The connectionStrings section creates a database connection string to the TestDB database named "TestDbConnection". The caching section configures the SQL cache invalidation polling. Within the databases subsection, you list one or more databases that you want to poll for changes. The add section inside the databases section indicates that the database represented by "TestDB" is polled once a minute (every 60,000 milliseconds). You can specify different polling intervals for different databases. Remember, the server must do a little bit of work every time the database is polled for changes. If you don't expect the data in the database to change very often, you should increase the polling interval.

Enabling query notification in ASP.NET using SQLCacheDependency

Now that you have performed the required configurations, you are ready to take advantage of the SQL cache invalidation feature in your ASP.NET Web page. Add a new Web form named Default.aspx to your Web site. The following is the code for the Default.aspx where we are going to bind a Grid with the data of the Products table.

using System.Data.SqlClient;
using System.Web.Caching;

protected void Page_Load(object sender, EventArgs e)
{
GridView1.DataSource = bindCachedData();
GridView1.DataBind();
}

private DataSet bindCachedData()
{

DataSet dsProducts;
dsProducts = (DataSet)Cache.Get("Products");

if (dsProducts == null)
{
SqlConnection sqlcon = new SqlConnection(ConfigurationManager.ConnectionStrings["TestDbConnection"]
.ConnectionString);
SqlDataAdapter adapter = new SqlDataAdapter("Select * from Products", sqlcon);
dsProducts = new DataSet();
adapter.Fill(dsProducts);

SqlCacheDependency dependency = new SqlCacheDependency("TestDbConnection", "Products");
Cache.Insert("Products", dsProducts, dependency);
}

return dsProducts;
}

In the above code, you start by creating an instance of the SqlConnection object passing in the connection string that is retrieved from the web.config file. Then you create an instance of the SqlDataAdapter object and pass in the SQL statement to be executed and the previously created SqlConnection object as its arguments. Then you execute the SQL query using the Fill method of the SqlDataAdapter object. After that you create an instance of the SqlCacheDependency object and supply the database name (that corresponds to the database name specified in the web.config file) and the table name as its arguments. Then you insert the categories dataset to the cache using the Insert method of the Cache object. At the time of inserting, you should also specify the SqlCacheDependency object so that the dataset can be invalidated when the data in the Product table changes. Finally, you bind the dataset to the GridView control.

The first time this application loads, there will be nothing in the application cache and dsProducts will be null. As a result, the query will be called. When this happens, the function will register a notification subscription with SQL Server. It will also load up the cache with the output of our query. When the user runs this query again the data will be retrieved from the cache. You can confirm this by running the app in debug mode.

To test if the SQL Server based cache invalidation mechanism works, modify the data in the Products table and then if you navigate to the page using the browser, you will get the changed data as retrieved from the database.

Garbage Collection in .NET - How it really works

2009-04-19T11:01:00.015+05:30

Garbage collection is a process of releasing the memory used by the objects, which are no longer referenced. This is done in different ways and different manners in various platforms and languages. We will see how garbage collection is being done in .NET.

Garbage Collection basis

Almost every program uses resources such as database connection, file system objects etc. In order to make use of these things some resources should be available to us.
First we allocate a block of memory in the managed memory by using the new keyword.
Use the constructor of the class to set the initial state of the object.
Use the resources by accessing the type's members
At last CLEAR THE MEMORY

But how many times have programmers forgotten to release the memory. Or how many times the programmers try to access the memory which was cleaned.

These two are the serious bugs, which will lead us to memory leak and commonly occurring. In order to overcome these things the concept of automatic memory management has come. Automatic memory management or Automatic garbage collection is a process by which the system will automatically take care of the memory used by unwanted objects (we call them as garbage) to be released. Hurrah... Thanks to Microsoft's Automatic Garbage collection mechanism.

Automatic Garbage Collection in .NET

When Microsoft planned to go for a new generation platform called .NET with the new generation language called C#, their first intention is to make a language which is developer friendly to learn and use it with having rich set of APIs to support end users as well. So they put a great thought in Garbage Collection and come out with this model of automatic garbage collection in .NET.

They implemented garbage collector as a separate thread. This thread will be running always at the back end. Some of us may think, running a separate thread will make extra overhead. Yes. It is right. That is why the garbage collector thread is given the lowest priority. But when system finds there is no space in the managed heap (managed heap is nothing but a bunch of memory allocated for the program at run time), then garbage collector thread will be given REALTIME priority (REALTIME priority is the highest priority in Windows) and collect all the un wanted objects.

How does Garbage collector locate garbage

When an program is loaded in the memory there will be a bunch of memory allocated for that particular program alone and loaded with the memory. This bunch of memory is called Managed Heap in .NET world. This amount of memory will only be used when an object is to be loaded in to the memory for that particular program.

This memory is separated in to three parts :

Generation Zero
Generation One
Generation Two

Ideally Generation zero will be in smaller size, Generation one will be in medium size and Generation two will be larger.

When we try to create an object by using NEW keyword the system will,

Calculate the number of bytes required for the object or type to be loaded in to the managed heap.
The CLR then checks that the bytes required to allocate the object are available in the reserved region (committing storage if necessary). IF the object fits, it is allocated at the address pointed to by NextObjPtr.
These processes will happen at the Generation zero level.

When Generation Zero is full and it does not have enough space to occupy other objects but still the program wants to allocate some more memory for some other objects, then the garbage collector will be given the REALTIME priority and will come in to picture.

Now the garbage collector will come and check all the objects in the Generation Zero level. If an object's scope and lifetime goes off then the system will automatically mark it for garbage collection.

Note:

Here in the process the object is just marked and not collected. Garbage collector will only collect the object and free the memory.

Garbage collector will come and start examining all the objects in the level Generation Zero right from the beginning. If it finds any object marked for garbage collection, it will simply remove those objects from the memory.

Here comes the important part. Now let us refer the figure below. There are three objects in the managed heap. If A and C are not marked but B has lost it scope and lifetime. So B should be marked for garbage collection. So object B will be collected and the managed heap will look like this.
But do remember that the system will come and allocate the new objects only at the last. It does not see in between. So it is the job of garbage collector to compact the memory structure after collecting the objects. It does that also. So the memory would be looking like as shown below now.
But garbage collector does not come to end after doing this. It will look which are all the objects survive after the sweep (collection). Those objects will be moved to Generation One and now the Generation Zero is empty for filling new objects.

If Generation One does not have space for objects from Generation Zero, then the process happened in Generation Zero will happen in Generation one as well. This is the same case with Generation Two also.

You may have a doubt, all the generations are filled with the referred objects and still system or our program wants to allocate some objects, then what will happen? If so, then the MemoryOutofRangeException will be thrown.

Dispose

Instead of declaring a Finalizer, exposing a Dispose method is considered as good.

public void Dispose()
{
// all clean up source code here..
GC.SuppressFinalize(this);
}

If we clean up a object, using Dispose or Close method, we should indicate to the runtime that the object is no longer needed finalization, by calling GC.SuppressFinalize() as shown above.

If we are creating and using objects that have Dispose or Close methods, we should call these methods when we’ve finished using these objects. It is advisable to place these calls in a finally clause, which guarantees that the objects are properly handled even if an exception is thrown.

Exploring the Factory Design Pattern

2009-04-15T19:55:00.007+05:30

Software changes. This is a rather obvious statement, but it is a fact that must be ever present in the minds of developers and architects. Although we tend to think of software development as chiefly an engineering exercise, the analogy breaks down very quickly. When was the last time someone asked the designers of the Empire State building to add ten new floors at the bottom, put a pool on the top, and have all of this done before Monday morning?

This is a daunting challenge. We must design systems that are capable of changing at a moment's notice. Be it requirements, technology, or personnel, there will be change and we must be prepared. If we forget this, we do so at our own peril.

Although this can be a frightening proposition, there are a great many tools at our disposal to ensure that systems are designed to change rapidly while reducing the negative impact these alterations can bring. One such tool is design patterns. Design patterns represent a wealth of collective knowledge and experience. The proper use of these patterns will help to ensure that systems are malleable, enabling rapid change.

Over the course of this article, I will try examine in short one of the most commonly used patterns, the Factory pattern.

Factory Pattern

An important facet of system design is the manner in which objects are created. Although far more time is often spent considering the object model and instance interaction, if this simple design aspect is ignored it will adversely impact the entire system. Thus, it is not only important what an object does or what it models, but also in what manner it was created.

Since most object-oriented languages and runtimes provide object instantiation (e.g. new, newobj, etc.) and initialization (e.g. constructors) mechanisms, there may be a tendency to simply use these facilities directly without forethought to future consequences. The overuse of this functionality often introduces a great deal of the inflexibility in the system, as the direct use of a language/run-time object instantiation function creates an explicit association between the creator and created classes. While associations are a necessary type of relationship in an object-oriented system, the coupling introduced between classes is extremely difficult to overcome should requirements change (as they always do).

One of the most widely used creational patterns is the Factory. This pattern is aptly named, as it calls for the use of a specialized object solely to create other objects, much like a real-world factory. In the following sections, we will examine the basic knowledge of this pattern which will help you to adopt this design pattern quickly.

Logical Model

As with other design patterns, there are countless variations of the Factory pattern, although most variants typically used the same set of primary actors, a client, a factory, and a product. The client is an object that requires an instance of another object (the product) for some purpose. Rather than creating the product instance directly, the client delegates this responsibility to the factory. Once invoked, the factory creates a new instance of the product, passing it back to the client. Put simply, the client uses the factory to create an instance of the product. Below figure shows this logical relationship between these elements of the pattern.

The factory completely abstracts the creation and initialization of the product from the client. This indirection enables the client to focus on its discrete role in the application without concerning itself with the details of how the product is created. Thus, as the product implementation changes over time, the client remains unchanged.

While this indirection is a tangible benefit, the most important aspect of this pattern is the fact that the client is abstracted from both the type of product and the type of factory used to create the product. Presuming that the product interface is invariant, this enables the factory to create any product type it deems appropriate. Furthermore, presuming that the factory interface is invariant, the entire factory along with the associated products it creates can be replaced in a wholesale fashion. Both of these radical modifications can occur without any changes to the client.

Consider an application that models the assembly of a variety of personal computers. The application contains a ComputerAssembler class that is responsible for the assembly of the computer, a Computer class that models the computer being built, and a ComputerFactory class that creates instances of the Computer class. In using the Factory pattern, the ComputerAssembler class delegates responsibility for creation of Computer instances to the ComputerFactory. This ensures that if the instantiation and/or initialization process changes (e.g. new constructor, use of an activator, custom pooling, etc.), the ComputerAssembler does not need to change at all. This is the benefit of abstracting the creation of an object from its use.

In addition, suppose that the business requirements changed and a new type of computer needs to be assembled. Rather than modifying the ComputerAssembler class directly, the ComputerFactory class can be modified to create instances of a new computer class (assuming that this new class has the same interface as Computer). Furthermore, it is also possible to address this requirement by creating a new factory class (that has the same interface as ComputerFactory) that creates instances of the new computer class (again, with the same interface as Computer). As before, nothing in the ComputerAssembler class needs to change, all the logic just continues to work as it had previously.This is the benefit of abstracting the types of the product and factory into invariant interfaces.

Conclusion

As I conclude this examination of the of the Factory pattern, it should be apparent that this pattern offers considerable benefits. From the abstraction of instance creation to the use of immutable product and factory interfaces, this pattern provides a clear mechanism to design flexible system that are highly adaptable. The inclusion of this pattern in the .NET Framework is a clear testament to it usefulness. Regardless of the nature of your application, this pattern can help it weather the winds of change.

Native XML Web Services in SQL Server 2005 - Creating HTTP Endpoints

2009-04-02T11:30:00.007+05:30

With SQL Server 2005 developers will be able to develop Web services in the database tier, making SQL Server a hypertext transfer protocol (HTTP) listener and providing a new type of data access capability for Web services-centric applications.

Native XML Web Services in SQL Server 2005

To begin, you need to be running Windows 2003 or Windows XP SP2 to use this feature and you don't need IIS. In fact, if you are running IIS, it may cause a problem if both SQL Server 2005 and IIS are both listening to port 80 when you try to create your HTTP Endpoint. For this tutorial, I would just stop IIS if you have it running. If you don't want to do that, you will need to change the default port that either IIS or SQL Server 2005 is using to listen to HTTP Requests. The default is 80, and one of them will need to be changed.

Expose Stored Procedure as XML Web Service

My goal is pretty simple. I want to expose a stored procedure, called GetContacts, in my AdventureWorks Database as an XML Web Service. As luck would have it, this is an extremely easy thing to do in SQL Server 2005 without requiring IIS.

CREATE PROCEDURE [dbo].[GetContacts]
AS
BEGIN
SET NOCOUNT ON;

SELECT TOP 20 [FirstName],[LastName] FROM
[Person].[Contact] ORDER BY [LastName];
END

Create HTTP Endpoint

Fire up SQL Server Management Studio, choose the AdventureWorks Database, and open a New Query Window. Create an HTTP Endpoint with the following statement:

CREATE ENDPOINT AW_Contacts
STATE = Started
AS HTTP
(
PATH = '/Contacts',
AUTHENTICATION = (INTEGRATED),
PORTS = (CLEAR),
SITE = '*'
)
FOR SOAP
(
WEBMETHOD 'GetContacts'
(NAME = 'AdventureWorks.dbo.GetContacts'),
WSDL = DEFAULT,
DATABASE = 'AdventureWorks',
NAMESPACE = DEFAULT
)

If you get an error executing this query that mentions another service using the port, make sure you turn off IIS.

A Path = '/Contacts', Site = '*', and Ports = (CLEAR) means that your URL will be to the default host, localhost, not require SSL, and look like the following:

http://localhost/contacts?WSDL

The FOR SOAP part of the command relates the GetContacts Method to the GetContacts Stored Procedure. Once you execute the command, take a peek at the Server Objects to see your HTTP Endpoint:

Fire Up Visual Studio 2005 to Consume the XML Web Service

At this point, you consume the XML Web Service like every other web service. Create a Windows Application, called Native Http, drop a DataGridView on the form, and add a Web Reference specifying the following URL:

http://localhost/contacts?WSDL

Leave the web reference name as localhost just so you can add the following code to the Form Load Event:

localhost.AW_Contacts contacts = new Native_Http.localhost.AW_Contacts();
contacts.Credentials = CredentialCache.DefaultCredentials;
dataGridView1.DataSource = (contacts.GetContacts()[0] as DataSet).Tables[0];

Run the application and magically see the contacts appear in the DataGridView.

Service-Oriented Architecture (SOA) ... Some Basic Info

2009-03-10T18:20:00.005+05:30

What is Service-Oriented Architecture (SOA) ?

Service Oriented Architecture or SOA for short is a new architecture for the development of loosely coupled distributed applications. In fact service-oriented architecture is collection of many services in the network. These services communicate with each other and the communications involves data exchange & even service coordination. Earlier SOA was based on the DCOM or Object Request Brokers (ORBs). Nowadays SOA is based on the Web Services.

Broadly SOA can be classified into two terms: Services and Connections.

Services:
----------
A service is a function or some processing logic or business processing that is well-defined, self-contained, and does not depend on the context or state of other services. Example of Services are Loan Processing Services, which can be self-contained unit for process the Loan Applications. Other example may be Weather Services, which can be used to get the weather information. Any application on the network can use the service of the Weather Service to get the weather information.

Connections:
---------------
Connections means the link connecting these self-contained distributed services with each other, it enable client to Services communications. In case of Web services SOAP over HTTP is used to communicate the between services.

The following figure is a typical example of the service-oriented architecture. It shows how a service consumer sends a service request to a service provider. After accepting the request, service provider send a message to the service consumer. In this case a service provider can also be a service consumer.

Different Technologies Used:
---------------------------------
SOA is much different from point-to-point architectures. SOA comprise loosely coupled, highly interoperable application services. These services can be developed in different development technologies (such as Java, .NET, C++, PERL, PHP), the software components become very reusable i.e. the same C# service may be used by a Java application and / or any other programming language. WSDL defines an standard, which encapsulates / hides the vendor / language specific implementation from the calling client / service.

Why SOA ?
-----------
SOA architecture enables seamless Enterprise Information Integration. Here are some of the Benefits of the Service

Due to its platform independence, it allows companies to use the software and hardware of their choice.
There is no threat of vendor lock-in
SOA enables incremental development, deployment, and maintenance.
Companies can use the existing software (investments) and use SOA to build applications without replacing existing applications
The training costs are low, so the available labor pool can be used for running the applications

Getting Started on your First Web Page

2009-02-11T10:50:00.002+05:30

Creating your first web page can be a daunting and confusing task. Where do I get started? What should I do? However, it does not have to be this way, creating a web page can be a fun and rewarding experience if you just follow a few simple guidelines, which we will outline for you here.

The first thing that you should do when getting ready to construct your first web page is to define it. What do you want your web page to do? Do not just start constructing your page, really think about it. You should think about how you want it to look, what information you want to provide to your prospective customer in order to persuade him to buy your product or service rather than going elsewhere.

Be sure that you organize the page well, think of your Home Page like the Table of Contents page in a book, it is there so that your customers know where to go in your site for their particular needs, or just to familiarize themselves with your product. Lastly, when defining your site you should do your research. Always visit your competitions web site to see how they have organized their site, so you can make yours better, whether it is just including more information about your product, or simply making a better designed site.

Now that you have given some serious thought to how you want your web site to look, and what you want to include in it, you need to think of a name for it. There are various approaches to finding the right name for your web site. The first is to make the name logical, for instance, ****’s web site is ****.com. Another approach is to make the name memorable so that your customers can type it in without thought, the name does not have to be descriptive of the product you sell, for example amazon.com sells books. Further, you should keep the name as short as possible so that it is easy for your customers to type into the url field.

Now that you have your web page named and given some thought into how you want it to look, here are some pointers for building your site. If you have pictures on your web page go over them first with a photo editing program so that the customer’s browser does not have to crunch them. This will also speed up the download speed of your page so that the customer can view quickly without having to wait for large picture files to appear on the screen.

One of the most annoying things for people surfing the web are pages that take a long time to download. All those fancy graphics will not do you any good if instead of waiting for the page to download the viewer closes his browser and goes elsewhere, so consider going light on the pictures and heavy on the information content.

You should also put some serious thought into what color fonts you are going to use, and the background color as well. When in doubt, remember that a white background with black text has been successful for thousands of years!

Your website should also be easy to navigate, all your links should be obvious to the viewer, and should be self explanatory or have information about where the link will take them. Try to keep the number of links you have low, the viewer does not want to spend a lot of time waiting for links to download, chances are, like you, he is pretty busy! Further, always link back to your homepage in order to make navigating your web page easier for your potential customers.

Decide the number of pages you want to have inside of your site, and determine logical titles for them. Think of any pictures that you might want to put on each page and where you are going to put them in order to be most effective. You should plan out your hyperlinks now, as it will make keeping track of them later a lot easier and save you time trying to figure out why they are not working properly. Decide where you want to put any buttons that you might create for hyperlinks as well. Lastly write out any information content you will be putting onto your web page in Microsoft Word first so you can detect any spelling errors you might have made. You can cut and paste parts into your favorite editor later.

So be sure to prepare before you start, think of the content you want to put in, think about your links, think about your web site’s name, draw up an outline on paper before you start constructing the page and most importantly

“Plan Your Work and Work Your Plan”

Practical difference between Interface and Abstract class

2009-02-05T09:23:00.016+05:30

Interface

Interface is used to collect similarities. Wherever we have to implement in the class means follow that similarities

Wherever we have to use (Real life scenario)

- Two person using same code but connection to the database methods only differ to each other. One person use sql based connection another one use oracle based connection. This type of scenario we can use Interface.
- A human and a parrot can both whistle, however it would not make sense to represent Humans and Parrots as subclass of a Whistle class, rather they would most likely be subclasses of an Animal class (likely with intermediate classes), but would both implement the Whistle interface.

What is Interface ?

The behavior of a class
All methods of an Interface are abstract methods.
They cannot have bodies
You cannot create an instance from an interface
An interface can only be implemented
This is the concept of encapsulation
During runtime, actual object instance is associated with the interface type
It needs only the interface at the compile time
Interface does not contain constructor
Multiple inheritance feature can be achieved through interface
Cannot be versioned.

Abstract Class

It is a class that contains one or more abstract methods
It may contain constructor but interface does not contain constructor.
In Interface all methods should be public but not in abstract class
Abstract class we can put sharable code
Its not Possible to create instance of Abstract class
It cannot be instantiated on it’s own, it must be inherited.
It can use One Overriding method
It can specify members that must be implemented in inheriting classes
A class can inherit only one abstract class
It enables us to place common instance behavior.
Offer versioning benefits.
Used for sharing common features among verious objects.

Static Contructors in .Net

2009-02-04T09:35:00.028+05:30

What is a static constructor?

As part of my job I conduct technical interviews for my company. One of the stock question in my interview is can constructors be declared static? Most of the time I get a blunt, no, as the answer. Even some argue that one cannot use the static word along with constructors. A very few who say yes are asked further questions on static constructors like what is the difference between a static constructors and normal constructors? For this also I have got lots of answers like static constructors can be called without creating an object, only static variables can be use etc. Some say static constructors are called only once and when I ask when is that once, People don’t have an answer. So I thought I will try to clear some confusion related to static constructors.

Can constructors be declared Static?

YES

What is the difference between a static constructor and normal constructors?

As we know Normal constructors are used to initialize class variables whereas static constructors are used to initialize class level static variables. Static constructors cannot access any other objects other than static as similar to static methods. Similar to static method, static constructors are class level and not instance level. Static constructors do not take any access modifiers, like public, private, protected etc. They also don’t take any arguments. Static constructors are called only once.

Static constructors are called only once, when is that once?

Static constructors are called only once throughout the life time of the program, i.e. when the first instance of the class having static constructors is created or when a static member is accessed/used whichever happens first.Let me explain further, suppose you have a class called StaticConstructor with a static constructor as shown below.

/***********Code*****************/

using System;
namespace StaticConstructorDemo
{
class StaticConstructor
{
private static string someText;
private static int counter;

static StaticConstructor()
{
someText = "Static constructor executed. No of times: ";
counter++;
}

public static void PrintSomeText()
{
Console.WriteLine(someText + counter.ToString());
}
}

class MainClass
{
static void Main(string[] args)
{
StaticConstructor sc1 = new StaticConstructor();
StaticConstructor sc2 = new StaticConstructor();
StaticConstructor sc3 = new StaticConstructor();
StaticConstructor.PrintSomeText();
}
}
}
/***********End******************/

The above code will print “Static constructor executed. No of times: 1”. The reason is static constructor is called only once when the first instance for the class is created i.e. when sc1 is created.If the above code inside the main method is rewritten like this

/***************Code**************/

class MainClass
{
static void Main(string[] args)
{
StaticConstructor.PrintSomeText();
StaticConstructor sc1 = new StaticConstructor();
StaticConstructor sc2 = new StaticConstructor();
>StaticConstructor sc3 = new StaticConstructor();
}
}
/***************End****************/

The above code will have the same output as the previous code i.e. “Static constructor executed. No of times: 1”. Static constructor is called before the code inside the static method, PrintSomeText(), is executed. As we know static methods can use static members and if a static constructor is not executed then there is every possibility of the system throwing “object reference not set to an instance” error. So static constructors are called before the first instance of the class is created or any static members are accessed/used.

Hope from the above e.g. gives a clear idea...

The 10 Commandments of Great User Experience Design

2008-10-25T21:36:00.002+05:30

Starting a new software development project in the next little while? Praying and hoping that it goes well? Are you worrying about all the little software development intricacies like: Making sure you have a proper source control, ensuring you have a continuous integration environment, making sure you have great developers and making sure they are happy? If you are, you probably haven’t remembered to pay attention to the most important part of the software development process. The User Interface and the User Experience.

While there are literally hundreds of User Experience rules that you could follow, if you simply remember these 10 commandments, you should do just fine! In fact, I recommend you print them out and put them in every developers office, or cubicle. Believe me..you will praise me in the long run.

Publish your application’s goals and objectives, your “mission statement” if you will.
The less choices you present to the user, the better. Users get confused rather quickly.
User Interface should remain consistent from screen to screen.
No “Smart Menus” that change depending on how you use the application. Users hate their application “changing” on them.
Keep the “Noise” to a minimum. People don’t need to know about the business as usual messages. Don’t annoy your user.
Avoid acronyms if at all possible. If you must use them, supply a descriptive message right beside it.
Your application must run lean and mean. As pretty as your interface might be, if the software seems slow, no sale.
Let them explore the application, without fear they will cause a disaster. Undo, Redo, and History features might be a good idea.
Ensure your software works the first time its run. Configurations can occur later, but out of the box, you should have intelligent defaults.
Have an easy way of allowing your users to provide feedback

Every item on this list is very critical for the success of your project. Make sure your software development team is always thinking about these things throughout your next project and you should be fairly happy with the outcome of the project.

I find that typically software developers will end up focusing solely on the architecture and technology of the application they working on, and leave the user experience piece as an afterthought. This can have a huge impact on your timeline, and the happiness of the user’s of your application. How many software developers out there have been on a project where you worked your buts off for months (if not years), and then went to release something to the users, and they where unimpressed with the application because the team didn’t put enough weight on the user experience?

Dictionary VS Hash Table

2008-10-03T17:23:00.004+05:30

We all know how useful a hash table can be, but if you are using the .NET Framework 2.0 you should be using a Dictionary instead. A dictionary and a hash table in .NET 2.0 are very similar but with 1 main difference, a dictionary is faster because it does not need to box and unbox the data as a hash table would.

I made a simple program to see just how much faster a dictionary is than a hash table. I ran the test 20 times for each data set and the results were close each time. A GUID as the key and a boolean as the data.

This is the results of the last test for each dataset.

Time in Milliseconds for 100,000 keys	Dictionary	Hash Table
Inserting	34.41264	76.0970
Reading	18.9005	31.1648
Deleting	21.2474	30.4655

Time in Seconds for 10,000,000 keys	Dictionary	Hash Table
Inserting	6.5704143	26.9096540
Reading	3.1362891	5.6670613
Deleting	3.4623316	4.8830676

Improving Performance with Connection Pooling

2008-08-06T18:06:00.001+05:30

Opening a connection is a database-intensive task. It can be one of the slowest operations that you perform in an ASP.NET page. Furthermore, a database has a limited supply of connections, and each connection requires a certain amount of memory overhead (approximately 40 kilobytes per connection).

If you plan to have hundreds of users hitting your Web site simultaneously, the process of opening a database connection for each user can have a severe impact on the performance of your Web site.

Fortunately, you can safely ignore these bad warnings if you take advantage of connection pooling. When database connections are pooled, a set of connections is kept open so that they can be shared among multiple users. When you request a new connection, an active connection is removed from the pool. When you close the connection, the connection is placed back in the pool.

Connection pooling is enabled for both OleDb and SqlClient connections by default.

To take advantage of connection pooling, you must be careful to do two things in your ASP.NET pages. First, you must be careful to use the same exact connection string whenever you open a database connection. Only those connections opened with the same connection string can be placed in the same connection pool. For this reason you should place your connection string in the web.config file and retrieve it from this file whenever you need to open a connection.

To take advantage of connection pooling in your ASP.NET pages, you also must be careful to explicitly close whatever connection you open as quickly as possible. If you do not explicitly close a connection with the Close() method, the connection is never added back to the connection pool.

Connection pooling options that you can add to the SQL Server connection string:

Connection Lifetime— Destroys a connection after a certain number of seconds. The default value is 0, which indicates that connections should never be destroyed.
Connection Reset— Indicates whether connections should be reset when they are returned to the pool. The default value is true.
Enlist— Indicates whether a connection should be automatically enlisted in the current transaction context. The default value is true.
Max Pool Size— The maximum number of connections allowed in a single connection pool. The default value is 100.
Min Pool Size— The minimum number of connections allowed in a single connection pool. The default value is 0.
Pooling— Determines whether connection pooling is enabled or disabled. The default value is true.

SQL Injection Problem

2008-08-06T17:55:00.002+05:30

SQL injection is a strategy often taken by hackers for attacking databases.

Example1:
An ASP page asks the user for a name and a password, and then sends the following string to the database:
SELECT FROM users WHERE username = 'whatever' AND password = 'mypassword'

It seems safe, but it isn't. A user might enter something like this as her user name:
' OR 1>0 --

When this is plugged into the SQL statement, the result looks like this:
SELECT FROM users WHERE username = '' OR 1>0 -- AND password = ''

This injection comments out the password portion of the statement. It results in a list of all the names in the users table, so any user could get into your system.

The easiest way to prevent this sort of injection is to parse the SQL string and remove any occurrences of "--" before passing the statement.

Example 2:
You also have to beware of injections that contain semicolons because semicolons delimit SQL statements. Think about the implications of a user name like this:
' OR 1>0 ; DELETE Customers ; --

There are numerous ways a malicious user might penetrate your system using SQL injection and various defenses, but the simplest approach is to avoid dynamic SQL. Instead, use stored procedures everywhere.

Thanks to the way SQL passes parameters, injections such as those above will produce errors, and the stored procedure will not execute.

Running an exe or program as SQL Server Job

2008-08-01T13:03:00.005+05:30

This can be achieved by SQL Server Agent which is a Windows service to run scheduled adminstrative tasks or commonly know as jobs. SQL Server agent uses SQL Server t ostore job information. A job consists of steps which can be set using steps wizard during job scheduling.

Job Scheduling process:

Connect to the SQL Server where you want to schedule your job.
Check if SQL Server Agent (you can find it at the bottom most entity) is running, if not run it and set it to run automatic.
Right Click SQL Server Agent. Select New -> Job. This will open a wizard to schedule a new job.
Select Steps from options given on the left side of wizard. This is the main place to set your exe\program as a running step. Give some name to this step, Select Operating System (cmd) for the Type and give the full path of exe in Text box for Command. Below is a sample step set up for running test.exe.
Now Select the job schedules option from left to set the frequency. Give some name to schedule, selection other options as shown in the figure below.
If you want you can set optional Alerts and notification (using SQL notification services) to send out email in case any things fails, succeeds or at any specific event.
The targets option set the DB to look at or put data in. It should commonly be the localhost but you can set a remote SQL Server too here in case you have some DB interaction but then make sure that the account which you are using should have access to the remote server.

Your job is now scheduled to run everyday test.exe. just to make sure that everything run properly go to Agent -> Jobs -> NEW_JOB (the one you just created), right click NEW_JOB and select “start job at step”. This will run the job instantly for you and show the status if the job run successfully or failed.

So now you finally done.

Asp.Net Worker Process Recycling

2008-07-24T13:39:00.004+05:30

If a Web application contains code that causes problems, and you cannot easily rewrite the code, it might be useful to limit the extent of the problems by periodically recycling the worker process that services the application. You can accomplish this by using what is known as Worker Process Recycling. Worker process recycling is the replacing of the instance of the application in memory. IIS 6.0 can automatically recycle worker processes by restarting the worker process, or worker processes, that are assigned to an application pool. This helps keep problematic applications running smoothly, and minimizes problems such as memory leaks. You can trigger the recycling of the worker processes assigned to an application pool by using worker process recycling methods that are based on elapsed time, the number of Hypertext Transfer Protocol (HTTP) requests, a set time of day, and two kinds of memory consumption, in addition to recycling on demand.

To configure all the above settings, go to the Properties window of the application pool in which your Web application is running using the IIS manager. Using the Recycling, Performance, and Health tabs in the Properties window, you can specify values for the above settings. Navigating to the Performance tab in the Properties dialog box of the DemoAppPool results in the following output.

When you set the recycling of worker processes using IIS manager, you also need to take the state management strategy of your ASP.NET application into consideration. Because every time the worker process is recycled, the ASP.NET state information will be lost rendering the application in an invalid state. One alternative to overcome this issue is to maintain state data external to the worker process, such as in a database. However, moving data to an external database to allow recycling can affect server performance in the following two ways:

Performance is reduced because of the added data management that is needed to move the data between the application and the database.
Recycling flushes any in-process data caches, so the caches need to be rebuilt.

If you have an application pool with applications that depend on state data, you must decide whether or not to recycle the worker processes that are assigned to that application pool. If you store state in the same process as that of IIS, and you don't want the state information to be lost, you must not recycle a worker process using the application pool configuration settings.

Encryption Sections of Web.config

2008-07-22T11:32:00.008+05:30

Configuration files are just great ; they let you configure the website .It's a great place to store the information which you are going to be using throughout the application and which is not changing.

You can easily encrypt sections of web.config in ASP.NET 2.0. In the code below I have encrypted the ConnectionStrings section of web.config.

Configuration config = WebConfigurationManager.OpenWebConfiguration(Request.ApplicationPath);
ConfigurationSection configSection = config.GetSection("connectionStrings");

if (configSection.SectionInformation.IsProtected)
{
configSection.SectionInformation.UnprotectSection();
config.Save();
}
else
{
configSection.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
config.Save();
}

.NET Framework 2.0 introduces a protected configuration feature that you can use to encrypt sensitive configuration file data by using a command line tool. The following two protected configuration providers are provided although you can also implement custom providers.

RSAProtectedConfigurationProvider : This is the default provider and uses the RSA public key encryption to encrypt and decrypt data.
DPAPIProtectedConfigurationProvider : This provider uses the Windows Data Protection API (DPAPI) to encrypt and decrypt data.

You can also writing connection string dynamically:

Configuration config = WebConfigurationManager.OpenWebConfiguration(Request.ApplicationPath);
ConnectionStringsSection conSection = (ConnectionStringsSection)config.GetSection("connectionStrings");
conSection.ConnectionStrings["SQLConnectionString"].ConnectionString = "NewConnectionString";
config.Save();

[Please note that when you write to a web.config file the application restarts which means all the session and application variables are lost.]

New Features of VS-2008

2008-07-08T11:33:00.004+05:30

Historically, Microsoft has introduced a new Visual Studio product to accompany a new Framework version, they did that with Framework versions 1.0 - 2.0 as follows:

>> Framework v 1.0 --- VS .NET 2002
>> Framework v 1.1 --- VS .NET 2003
>> Framework v 2.0 --- VS .NET 2005

Obviously, the 2.0 Framework represented major modifications to the coresoftware (new compilers a new CLR, etc) and so, of course there were bugs.There have since been service packs for both the 2.0 Framework and VS 2005 to address these issues.

Then, Microsoft did something a little different, they introduced some new.NET technologies, but instead of creating a *whole* new Framework with newcompilers, a new CLR, etc., they made a new Framework version that just hadwhat was necessary to run the new features (Windows CommunicationFoundation, Windows Workflow, Windows Presentation Foundation) and called that Framework version 3.0. Instead of making a new version of VisualStudio to do along with that, Microsoft created a plethora of add-in's to VS2005 that would make it work with the new 3.0 stuff.

Now, the latest version of the Framework is 3.5 (adds additional support forLINQ and Ajax on top of WF, WPF, and WCF). For this new release (now thatmost of the bugs have been worked out, Microsoft has released Visual Studio2008, which works against the 3.5 Framework (there are no add-in's andservice packs for this - - yet).

Essentially, VS 2008 gives you access to all of the new Framework stuff AND is really VS 2005 with all the bugs worked out. It is considered a very stable product and has the advantage of making all the latest .NET technologies rolled up into it.

Following are the new features that Microsoft has introduced in the VS2008.

LINQ Support
Expression Blend Support
Windows Presentation Foundation
VS 2008 Multi-Targeting Support
Inbuilt AJAX support for ASP.NET
JavaScript Debugging Support
Nested Master Page Support
LINQ Intellisense and Javascript Intellisense support for silverlight applications
Intellisense Support
Intellisense Filtering
Intellisense Box display position
Organize Imports or Usings
Visual Studio 2008 Split View
HTML JavaScript warnings, not as errors
Debugging .NET Framework Library Source Code
In built Silverlight Library
Visual Studio LINQ Designer
Inbuilt C++ SDK
Microsoft Popfly Support

To get detail information about these features Chick Here

Spy on Your Web Host: Checking Uptime

2008-06-26T15:15:00.006+05:30

Your host promises 99.999% uptime, but are they really delivering? Unless you're either checking every couple of seconds, or dishing out on some monitoring service, you really don't have much of an idea.

ASP.NET Web pages served up through IIS are delivered through an ASP.NET "worker process" (aspnet_wp.exe). It's this file that executes your code and puts all the ASP.NET pieces together. If we could access this worker process, we may be able to look at how long it had been running, its current state—and perhaps even a history, showing previous instantiations of the worker process.

Dim strReport As String
Dim objInfo As ProcessInfo = _
ProcessModelInfo.GetCurrentProcessInfo
' Get time information
strReport = "ASP.NET was started at " & objInfo.StartTime.ToString & ". " & "It has been running for " & objInfo.Age.Days & " days, " & objInfo.Age.Hours & " hours and " & objInfo.Age.Minutes & " minutes. "
Response.Write(strReport)
' Get other info
strReport = "The process ID is " & objInfo.ProcessID & ". " & "Current status is " & objInfo.Status.ToString & ". " & "Peak memory used was " & objInfo.PeakMemoryUsed & ". " & "Request count is currently " & objInfo.RequestCount & "."
Response.Write(strReport)

What we're doing here is retrieving a ProcessInfo object containing information about the current worker process. This is then formulated into a string using key properties and spurted out to the user, through Response.Write. Try it out—you'll be given an instant server status report.

The ProcessModelInfo class also has a GetHistory method, allowing you to retrieve information about previous instances of the aspnet_wp.exe process. It returns an array of ProcessInfo objects. Either use a For...Next loop to retrieve this information, or bind direct to a Grid.

There's also a technique for retrieving the amount of time your actual server has been running (not just the ASP.NET worker process). Simply nab the TickCount from the Environment class, which lists the number of milliseconds the machine has been running. After that, either perform a few simple calculations—or, slightly easier, convert it into a period of time (a TimeSpan object), then retrieve the appropriate properties. Here's my snippet of code that does exactly that:

Dim tsAge As TimeSpan = TimeSpan.FromMilliseconds(Environment.TickCount)
Dim intDaysUp As Integer = tsAge.Days
Dim intHoursUp As Integer = tsAge.Hours
Dim intMinsUp As Integer = tsAge.Minutes
Response.Write("The server has been up " & intDaysUp & " days, " & intHoursUp & " hours and " & intMinsUp & " minutes.")

Caption: ASP.NET only been running for 13 minutes? Sounds dodgy. Change your host.

.Net Tips and Tricks (Part -V)

2008-06-26T13:58:00.003+05:30

Force Button Click by Pressing Enter Key
Sometimes, you will notice, that, in an ASP.Net form, depending on the circumstances, pressing the 'Enter' key to submit the form does not work.To force this to happen for a particular button on your page, just put this in the Page_Load routine:
Page.RegisterHiddenField("__EVENTTARGET", "button1")
Then, change 'button1' to the ID of your particular button. Understand, of course, if your cursor is inside of a MultiLine textbox, the default action of the enter key is to create a new line in the textbox, so, if this basically works anywhere outside of that scenario.

Select Specific DropDownList Item
With a dropdown list - you can dynamically select items in the list with a sort of 'built-in' find routine.To select a certain item, based on the Value of the item in the list:
DropDownList.SelectedIndex = DropDownList.Items.IndexOf(DropDownList.Items.FindByValue(YourValueHere))
To select a certain item, based on the Text of the item in the list:
DropDownList.SelectedIndex = DropDownList.Items.IndexOf(DropDownList.Items.FindByText("YourTextHere"))
OR - you can do it this way:
DropDownList.Items.FindByText("TextYouAreLookingFor").Selected = true
or, using the value of the item
DropDownList.Items.FindByValue("ValueYouAreLookingFor").Selected = true

ASP.Net Server Controls Not Showing on pages
It's possible that ASP.Net is not registered correctly on your system.Try running aspnet_regiis from the command prompt.Here's the default location:
C:\[Windows Folder]\Microsoft.NET\Framework\[ASP.Net Version#]\ aspnet_regiis.exe -i
Windows Server 2003, you must use aspnet_regiis -i -enable. This is because of the "Web Service Extensions" feature in IIS 6
(if you install VS.NET or the framework without IIS installed, and then go back in and install IIS afterwards, you have to re-register so that ASP.NET 'hooks' into IIS properly.")

Make a Horizontal Rule Visible or Invisible
If you want to refer to a Horizontal rule in coding, to make it visible or invisible, just use the runat=Server designation, along with an ID and you're ready to go:
[hr id="rule" visible="true" runat="server"/]

Select Specific ListBox Item
If you don't know the exact index number in the list of listbox items (listbox1.selectedindex=x), then you can find an item and select it by using the Value of the item:
ListBox1.Items.FindByValue(MyValue).Selected = true
If you don't know theValue of the item, but you know the text, you can find and select the item using the Text of the item:
ListBox1.Items.FindByText("TextYouAreLookingFor").Selected = true

List all Tables in an MS Access Database
However you decide to display the list of tables from a particular MS Access Database, just create your connection and display code in the same way you would normally do it.
The only change would be your SQL statement. Structure it this way:
SELECT [Name] FROM MSysObjects WHERE [Type] = 1

Javascript - Delete Textbox text onFocus
Let's say you have an ASP.Net TextBox server control that has the text:
"Enter Fax #"
Then, you want the text to disappear when the user clicks inside the TextBox - - here is a very simple solution.
In the Page_Load event, put:
txtFax.Attributes("OnFocus")="document.formName.txtFax.value='';"

.Net Tips and Tricks (Part -IV)

2008-06-26T10:35:00.009+05:30

Numeric-Only Textboxes
If you haven't heard of the built in ASP.Net Validator controls, it's time to learn. There are several, but, for this case, you would use a Regular Expression Validator. The Regular Expression for making sure only numeric data is inserted into the textbox is:
^([0-9]*\d*\d{1}?\d*)$
You'd use it in a Regular Expression Validator, in conjunction with an ASP.Net Textbox, like this:
[asp:TextBox id="txtNumber" Runat="server" /]
[asp:RegularExpressionValidator ID="vldNumber" ControlToValidate="txtNumber" Display="Dynamic" ErrorMessage="Not a number" ValidationExpression="(^([0-9]*\d*\d{1}?\d*)$)" Runat="server"/]

Get the Last Write Time of File
In order to get the last time a file (like an MS Access database, or any other file) was written, you can do the following: Use/import the System.IO namespace, then
Dim sFileWriteTime as File
Label1.Text=sFileWriteTime.GetLastWriteTime(Server.MapPath ("/path/yourMDB.mdb"))

Find Specific Field in DataSet
Sometimes, when we fill DataSet from a Query, we need to get a particular item in one of the DataTable fields for later use. In order to find a particular item, we can use the field name from the database like this, and assign it to a variable:
sOrderNum = Ds.Tables[0].Rows[0]["ordnum"]
We'd just need to have created the variable globally, then, we can use that variable (sOrderNum) easily, anywhere in the page now.

MS Access Update Problems with Parameters
A very common problem, using parameters with MS Access, in ASP.Net is that it does not update the database, but also, it doesn't return an error. The problem, most likely, is that the parameters are not in the same order as the SQL statement. Remember to put the list of parameters in the same order as they hold sql statement, including any parameters in the Clause(s) at the end of the statement.

Check for Null before inserting into Database
Here's a function to ensure a Null value gets inserted into the database.
Function CheckForNULL(strStringToCheck)
if len(trim(strStringToCheck)) = 0 then
CheckForNULL =dbNull.Value
else
CheckForNULL = strStringToCheck
end if
end function
If you have a DateTime field, without a function like this, a default date will be entered (ie 1/1/1900 12:00:00 AM), instead of null, when your insert is executed.

How to Align text in the TextBox Server Control
First, in your StyleSheet (either inline or external), create a class.
For the sake of this tip, we'll call it 'txtAlign', but the name doesn't matter.
Then, add your alignment needs to the class: text-align: right;
Lastly, inside the TextBox Server Control on your page, use the CSSClass property of the textbox to assign the CSS value to the textbox:CSSClass="txtAlign"

How to set focus on an ASP.Net TextBox Control when the page loads
Two things:
1. Give your BODY Tag and ID and include 'Runat=Server'(like - - [body id="bdyMain" runat="Server"])
2. In the Page_Load event:
if not Page.IsPostBack then
bdyMain.attributes("onload")="document.form1.TextBox1.focus();"
end if

How To work with TimeSpan Class
Dim adate As DateTime = DateTime.Parse("06/24/2008")
Dim bdate As DateTime = DateTime.Parse("06/28/2008")
Dim ts As New TimeSpan(bdate.Ticks - adate.Ticks)
Response.Write(ts.TotalDays & " ")
Response.Write(ts.TotalHours & ":" & ts.TotalMinutes & ":" & ts.TotalSeconds & ":" & ts.TotalMilliseconds)

How to Compare Time
Dim t1 As String = DateTime.Parse("4:30 PM").ToString("t")
Dim t2 As String = DateTime.Now.ToString("t")
If DateTime.Compare(t1, t2) <>
Response.Write(t1.ToString() & " is <>
Else
Response.Write(t1.ToString() & " is > than " & t2.ToString())
End If

Loop through all the textbox controls on the ASP.NET Page
You can loop through all the textbox controls on ASP.NET Page using this code.
private void LoopTextBoxes (Control parent)
{
foreach (Control c in parent.Controls)
{
TextBox tb = c as TextBox;
if (tb != null)
//Do something with the TextBox
}
}
And you can start the looping by calling:
LoopTextBoxes(Page);

Disabling a Button Until Processing is Complete
Here's the scenario - let's say you have an Insert subroutine, called 'doInsert'. You want to immediately disable the Submit button, so that the end-user won't click it multiple times, therefore, submitting the same data multiple times.
For this, use a regular HTML button, including a Runat="server" and an 'OnServerClick' event designation - like this:
[INPUT id="Button1" onclick="document.form1.Button1.disabled=true;" type="button" value="Submit - Insert Data" name="Button1" runat="server" onserverclick="doInsert"]
Then, in the very last line of the 'doInsert' subroutine, add this line:
Button1.Disabled=false

.Net Tips and Tricks (Part -III)

2008-06-25T11:38:00.009+05:30

Gridview Sorting - Only Certain Columns
To allow sorting on only certain columns in a Gridview, set the AllowSorting Property to True, but, for those columns you do NOT want to be sorted, using BoundFields, or TemplateFields, remove the SortExpression property.

Why is my button event firing twice?
The most common reason for double click events are situations in which the button markup includes an OnClick event, AND, the event handler (in your code) also has a 'Handles' statement, at the end of the event handler signature - -

Gridview Paging without a Datasource Control
If you are populating your Gridview with code, and not through a DataSource control, to be able to add paging, merely add a PageIndexChanging event for the Gridview:
Protected Sub YourGridview_PageIndexChanging(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewPageEventArgs)
YourGridview.PageIndex = e.NewPageIndex
YourGridview.DataBind()
End Sub

Templates - the Answer to a Consistent Look and Feel
Let's say you have a company, and you have several websites within that company, but you need to have a consistent look and feel for each of them.Create a website with the bare minimum, that you want to look the same in all websites, with Themes, navigation, and whatever else you want.
Then, in VS.Net 2005, click File/Export Template. That's all there is to it. The next time you want a website to look like this template, just click File/New, and choose your template (which will be under 'My Templates'

Using Response object in a Class
If you try this, straight away, you will probably receive an error message, telling you the Response object is not available in this context.
So, in order to get rid of the error message, Import System.Web, and then, change :
Response.(whatever)
to
HttpContext.Current.Response.(whatever)

Add 'Select' feature to existing Button/Imagebutton in TemplateField
If you already have any kind of button, whether it be a plain button, LinkButton, or Imagebutton, in a TemplateField, within a GridView, you can add 'Select' features to it, just as if you had added a 'Select' column.
All you need to do is add 'Select' to the CommandName property. Then, anything you could do with the Select CommandField, you can do with your own TemplateField.

Force TextBox Values to Capital Letters whenever user types(Simple way)
Create a css class with the following definition and apply the cssclass to the Textbox.
.MakeCapsStyle{text-transform: uppercase;}
[asp:textbox id="id" runat="server" cssclass="MakeCapsStyle" /]

Two Databound Fields in Gridview column
Boundfields are great in the Gridview, but they do have their limitations. One is that it only has room for one bound field. So, what do you do when you want two or data fields (like First and Last names) returned to the same column?
Turn the BoundField into a TemplateField, with a label in it:
[asp:TemplateField]
[ItemTemplate]
[asp:Label ID="lblname" runat="server" Text='[%# Eval("Lname") +", "+ Eval("Fname") %' /]
[/ItemTemplate]
[/asp:TemplateField]

Quick and Dirty - Clear Gridview
If you need to completely clear a Gridview quickly, create a sub like this:
Protected Sub ClearGrid(ByVal gv As GridView)
gv.DataSource = Nothing gv.DataSourceID = Nothing gv.DataBind()
End Sub
Then, you can use it by using your Gridview ID:
ClearGrid("YourGridViewID")

Nest Master pages easily
Let's say your scenario is that you want a Master page for your business's website. However, inside that 'shell', you also want a certain design for each department of the business. All you need to do, is create the second 'Department' Master page. Then, inside the Master Directive, include a reference back to the Business Master:
[%@ Master Language="VB" MasterPageFile="~/Business.master" .....
Also, be sure to use different ContentPlaceholder ids, and remember the one caveat - if you're using Nested Masters inside VS.Net 2005, you'll need to only use the html view, since the design view does not support nesting master pages.

Server.Transfer Vs. Response.Redirect
Server.Transfer processes the page from one page directly to the next page without making a round-trip back to the client's browser. This way is faster, with a little less overhead on the server. However, it does NOT update the clients url history list or current url.
Response.Redirect, as expected, is used to redirect the user's browser to another page or site. It DOES perform a trip back to the client where the client's browser is actually redirected to the new page. The browser history list IS updated to reflect the new address.

DataFormatString does not work in Boundfield
The new Gridview control in v2.0 take over the formatting of items in the BoundFields. Therefore, using a DataFormatString by itself won't work. To change the format to, let's say, Currency, we'd need to, not only set the DataFormatString="{0:c}", but we'd need to make use of the HTMLEncode property, setting it to 'False'

Assigning ASP.Net variables to Javascript
Scenario:You have an ASP.Net variable called sCustState, that you also want to use in a Javascript function. Here's how you do make it work, within Javascript, assigning it to a Javascript variable.
var sstate;
sstate='<%#sCustState %>';

Adding a Print Button with Javascript
If you'd like to use an ASP.Net button for printing, all you need to do is :
Add this line to the Page_Load event
btnPrint.Attributes("onClick") ="javascript:window.print();"
Add a button to the page called 'btnPrint'.
Technically, that's it, but, let's say you want to do something a little fancier, using DotNet. Then, add a subroutine (let's call it 'DoPrint'):
Sub doPrint(Source as Object, E as EventArgs)
lblResults.visible="True"
lblResults.text="Page has successfully been sent to the printer!"
End Sub
Then, add a direction to this sub, in the button's tag:
onServerclick="doPrint"

Performance Tips for ASP.NET Applications

2008-06-23T15:19:00.009+05:30

Cache Aggressively
When designing an app using ASP.NET, make sure you design with an eye on caching. On server versions of the OS, you have a lot of options for tweaking the use of caches on the server and client side. There are several features and tools in ASP that you can make use of to gain performance.
Output Caching—Stores the static result of an ASP request. Specified using the @% OutputCache % directive:

Duration—Time item exists in the cache
VaryByParam—Varies cache entries by Get/Post params
VaryByHeader—Varies cache entries by Http header
VaryByCustom—Varies cache entries by browser
Override to vary by whatever you want

Fragment Caching—When it is not possible to store an entire page (privacy, personalization, dynamic content), you can use fragment caching to store parts of it for quicker retrieval later.
a) VaryByControl—Varies the cached items by values of a control.

Cache API—Provides extremely fine granularity for caching by keeping a hashtable of cached objects in memory (System.web.UI.caching). It also:

Includes Dependencies (key, file, time)
Automatically expires unused items
Supports Callbacks

Caching intelligently can give you excellent performance, and it's important to think about what kind of caching you need. Imagine a complex e-commerce site with several static pages for login, and then a slew of dynamically-generated pages containing images and text. You might want to use Output Caching for those login pages, and then Fragment Caching for the dynamic pages. A toolbar, for example, could be cached as a fragment. For even better performance, you could cache commonly used images and boilerplate text that appear frequently on the site using the Cache API.

Use Session State Only If You Need To

One extremely powerful feature of ASP.NET is its ability to store session state for users, such as a shopping cart on an e-commerce site or a browser history. Since this is on by default, you pay the cost in memory even if you don't use it. If you're not using Session State, turn it off and save yourself the overhead by adding @% EnabledSessionState = false % to your asp.

For pages that only read session state, you can choose EnabledSessionState=readonly. This carries less overhead than full read/write session state, and is useful when you need only part of the functionality and don't want to pay for the write capabilities.

Use View State Only If You Need To

An example of View State might be a long form that users must fill out: if they click Back in their browser and then return, the form will remain filled. When this functionality isn't used, this state eats up memory and performance. Perhaps the largest performance drain here is that a round-trip signal must be sent across the network each time the page is loaded to update and verify the cache. Since it is on by default, you will need to specify that you do not want to use View State with @% EnabledViewState = false %.

Batch Compile

Always batch compile before deploying a large page into the Web. This can be initiated by doing one request to a page per directory and waiting until the CPU idles again. This prevents the Web server from being bogged down with compilations while also trying to serve out pages.

Avoid the Autoeventwireup Feature

Instead of relying on autoeventwireup, override the events from Page. For example, instead of writing a Page_Load() method, try overloading the public void OnLoad() method. This allows the run time from having to do a CreateDelegate() for every page.

protected override void OnLoad(EventArgs e)
{
Response.Write("Page Load method Over ridden");
}

Use the Optimal Authentication Procedure

There are several different ways to authenticate a user and some of more expensive than others (in order of increasing cost: None, Windows, Forms, Passport). Make sure you use the cheapest one that best fits your needs.

Use Stored Procedures Whenever Possible

Stored procedures are highly optimized tools that result in excellent performance when used effectively. Set up stored procedures to handle inserts, updates, and deletes with the data adapter. Stored procedures do not have to be interpreted, compiled or even transmitted from the client, and cut down on both network traffic and server overhead. Be sure to use CommandType.StoredProcedure instead of CommandType.Text

Use StringBuilder for Complex String Manipulation

When a string is modified, the run time will create a new string and return it, leaving the original to be garbage collected. Most of the time this is a fast and simple way to do it, but when a string is being modified repeatedly it begins to be a burden on performance: all of those allocations eventually get expensive.

Minimize the Use of Format()

When you can, use toString() instead of format(). In most cases, it will provide you with the functionality you need, with much less overhead.

Optimize Assignments

Use exp += val instead of exp = exp + val. Since exp can be arbitrarily complex, this can result in lots of unnecessary work. This forces the JIT to evaluate both copies of exp, and many times this is not needed. The first statement can be optimized far better than the second, since the JIT can avoid evaluating the exp twice.

Keep Your Datasets Lean

Only put the records you need into the dataset. Remember that the dataset stores all of its data in memory, and that the more data you request, the longer it will take to transmit across the wire.

Limit ASP.NET Server Controls

Exceptions and session state impose overhead. Surprise—so do ASP.NET server controls. They require server-side support, which leads to communication between your server and the client to support the control, and resource consumption on the server. Avoid the temptation to drop the server control onto your form and forget about it. In fact, you might be better off with a regular HTML control. Use the server control only if you plan to control the properties of a control programmatically, use view state to hold data values of the control, or handle server-side events generated by the control.

Use Page.IsPostBack

You need to take a series of steps when your page loads for the first time to perform setup formatting on the page or initialize data. However, you don't need to keep reinventing this wheel the next time a page is requested—and the next and the next. Avoid initializing the data again on the postback.

.Net Tips and Tricks (Part -II)

2008-06-13T13:45:00.024+05:30

How to form Color Picker in ASP.NET
[Click to enlarge]

Make sure to Import the System.Reflections namespace, as well as the System.Drawing namespace, for this example

Prevent caching of webform in Asp.net

private void Page_Load(object sender, System.EventArgs e)
{
if(!Page.IsPostBack)
{
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetAllowResponseInBrowserHistory(false);
}
}

ASP.Net Server Controls Not Showing on pages

Try running aspnet_regiis from the command prompt. Here's the default location: C:\WINNT\Microsoft.NET\Framework\<>\aspnet_regiis.exe -i

Currently logged in user

To get the user ID of the user who is currently logged in, you would get it using this: System.Web.HttpContext.Current.User.Identity.Name

Get windows Identity(win auth)

System.Security.Principal.WindowsIdentity.GetCurrent().Name.ToString();

Disabling a Button Until Processing is Complete

Here's the scenario - let's say you have an Insert subroutine, called 'doInsert'. You want to immediately disable the Submit button, so that the end-user won't click it multiple times, therefore, submitting the same data multiple times.

For this, use a regular HTML button, including a Runat="server" and an 'OnServerClick' event designation - like this:

INPUT id="Button1" onclick="document.form1.Button1.disabled=true;" type="button" value="Submit - Insert Data" name="Button1" runat="server" onserverclick="doInsert"

Then, in the very last line of the 'doInsert' subroutine, add this line: Button1.enabled="True"

Adding a MailTo Link inside a DataGrid

Suppose you have a database table which contains an email field, and you'd like to display that field, as well as others in a DataGrid. Let's go one step further - - let's say you'd like to display that email field as a clickable MailTo link. One way that this can be easily be done using TemplateColumns. First, you create your DataGrid start and end tags. Then, inside these tags, you include 'Columns' start and end tags. That's where you put your TemplateColumn. Here's how to do it

Use Path.GetRandomFileName() or Path.GetTempFileName() when working with temp files
Do not reinvent function for generating unique name for temporary files. Use one of the existing methods:
*** System.IO.Path.GetTempFileName() - use this method if you want to create temporary file in user's temp folder.
*** System.IO.Path.GetRandomFileName() - use this method if you just want to generate unique file name.

Popup Window Code

You can use Javascript to do so. e.g.

input type="Button" Value="Open New" onclick="Javascript:window.open('webform1.aspx');"

Uploading Large Size File
The default file size limit for the FileUpload control in ASP.Net is 4Mb. To get around this, in the HTTPRuntime section of the Web.config file, you can set the 'maxRequestLength' (in kb):
[system.web]
[httpRuntime maxRequestLength="1500000" /]
[/system.web]

How to Register User Controls and Custom Controls in Web.config

ASP.NET 2.0 makes control declarations much cleaner and easier to manage. Instead of duplicating them on all your pages, just declare them once within the new pages->controls section with the web.config file of your application:

Once you register the controls within the web.config file, you can then just use the controls on any page, master-page or user control on your site like so (no registration directives required):
[html]
[body]
[form id="form1" runat="server]
[scott:header ID="MyHeader" runat="server" /]
[/form]
[/body]
[/html]

.Net Tips and Tricks (Part -I)

2008-06-13T12:55:00.014+05:30

Use "App_Offline.htm" feature while updating a web site
"App_Offline.htm" feature provides a super convenient way to bring down an ASP.NET application while you updating a lot of content or making big changes to the site where you want to ensure that no users are accessing the application until all changes are done. The way app_offline.htm works is that you place this file in the root of the application. When ASP.NET sees it, it will shut-down the app-domain for the application and instead send back the contents of the app_offline.htm file in response to all new dynamic requests for the application. When you are done updating the site, just delete the file and it will come back online.

You have developed and deployed a web application on a web server. When users are making a request to the default.aspx file on the web server from their browser, they are being prompted to download the default.aspx file on their computer. What could be the problem.
Problem with aspnet_isapi.dll This behavior means that although the request is going to the IIS, it is not being executed by the asp.net worker process because IIS is not sure what to do with this file. This is because the aspnet_isapi.dll is either not present or IIS is not pointing to aspnet_isapi.dll.

Password matching regular expression
Password must be at least 4 characters, no more than 8 characters, and must include at least one upper case letter, one lower case letter, and one numeric digit. ^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{4,8}$

Make Window Fit any Resolution

Quickly move to matching brace in Visual Studio
Just press Ctrl+] and VS.NET will take you to the matching brace. It also will take you to the matching comment, region or quote depending on what is at the cursor now.

Incremental search in Visual Studio.
Press Ctrl+I.
Start typing the text you are searching for. (Note: you'll see the cursor jump to the first match, highlighting the current search string.)
Press Ctrl+I again to jump to the next occurrence of the search string.
To stop search, press Esc.
Advanced tip: Press Ctrl+Shift+I to search backwards

Clear all text boxes in ASP.Net

This will clear EVERYTHING from the textboxes - even if you had them pre-populated with data. A simple way to just reset it to the condition at Page_Load time, just do this in the Reset SubRoutine: Server.Transfer("YourPageName.aspx")

How to rotate a Label Text?

[asp:Label id="Label1" style="writing-mode:tb-rl" runat="server"]Label[/asp:Label]

Get Row Index with Gridview Select Button
When you autoGenerate a Select button with a Gridview, to find the RowIndex for that particular row, you can use the SelectedIndexChanged Event. Inside that event, try something like this (with a label called 'Label1':
Dim row As GridViewRow = MyGridView.SelectedRow
Dim intRow as Integer=Row.RowIndex
label1.text=intRow.ToString

Auto select Gridview Row when Editing

Let's say you have an editable Gridview, and you'd like to change the backcolor of the row you're editing, when you click the 'Edit' link for that row. It's very simple, and it's done in the Gridview's RowEditing Event.

First, you must set the SelectedIndex of the Gridview to the row you're editing:
YourGridviewID.SelectedIndex = e.NewEditIndex

And, lastly, you must change the backcolor:
YourGridviewID.SelectedRow.BackColor = Drawing.Color.Pink

You can, of course, accomplish any other row formatting options here, also.
Full code and Subroutine is here:
Protected Sub YourGridviewID_RowEditing(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewEditEventArgs) Handles YourGridviewID.RowEditing

YourGridviewID.SelectedIndex = e.NewEditIndex

YourGridviewID.SelectedRow.BackColor = Drawing.Color.Pink

End Sub

System.Configuration Namespace

2008-06-13T11:29:00.015+05:30

The heart of the new .NET 2.0 configuration gem is the System.Configuration namespace. By default, this namespace is available when the System.dll assembly is referenced. It includes all of the configuration features of .NET 1.1, including the old ConfigurationSettings class (now deprecated in .NET 2.0). To gain access to all of the new .NET 2.0 configuration features, however, you must add a reference to the System.Configuration.dll assembly. It is in this assembly that you will find the core of the new configuration system, the ConfigurationManager static class.

The ConfigurationManager class is a globally accessible doorway to an application's configuration. Since the class is static, all of its members are also static. This makes reading configuration such as AppSettings, ConnectionStrings and custom configuration sections a breeze. While this is similar to the ConfigurationSettings class, it also provides several new features that allow more secure access to an application's configuration. These new features also allow configuration settings to be saved to any configuration section: custom or otherwise.

Beyond the ConfigurationManager class lies the life-blood of custom configuration sections. The following outlines the base classes available to help you write your own configuration object model. In addition to a set of base classes is a set of validators that can be used to ensure the accuracy of your custom configuration. Also, in the event that your needs are simple enough, a few pre-made configuration sections are available.

The base types

ConfigurationSection - The base class of all configuration sections
ConfigurationSectionCollection - The base class of a collection of configuration sections
ConfigurationSectionGroup - The base class of a configuration section group
ConfigurationSectionGroupCollection - The base class of a collection of configuration section groups
ConfigurationElement - The base class of a configuration element
ConfigurationElementCollection - The base class of a collection of configuration elements
ConfigurationConverterBase - The base class of a custom converter
ConfigurationValidatorBase - The base class of a custom validator

The support types

ConfigurationManager - Allows global access to all of an application's configuration
Configuration - A class that represents an application's configuration
ConfigurationProperty - A class that represents a single configuration property
ConfigurationPropertyAttribute - An attribute class that supports declarative definition of configuration
ConfigurationPropertyCollection - A collection of configuration properties
ConfigurationPropertyOptions - Enumeration of possible configuration property options

The validation types

CallbackValidator - Allows dynamic validation of a configuration value
CallbackValidatorAttribute - Attribute class for declaratively applying callback validators
IntegerValidator - Allows validation of an integer (Int32) configuration value
IntegerValidatorAttribute - Attribute class for declaratively applying integer validators
LongValidator - Allows validation of a long (Int64) configuration value
LongValidatorAttribute - Attribute class for declaratively applying long validators
PositiveTimeSpanValidator - Allows validation of a positive time span configuration value
PositiveTimeSpanValidatorAttribute - Attribute class for declaratively applying positive time span validators
RegexStringValidator - Allows validation of a string configuration value with a regular expression
RegexStringValidatorAttribute - Attribute class for declaratively applying regex validators
StringValidator - Allows validation of a string configuration value
StringValidatorAttribute - Attribute class for declaratively applying string validators
SubclassTypeValidator - Allows validation that a configuration value derives from a given type
SubclassTypeValidatorAttribute - Attribute class for declaratively applying subclass type validators
TimeSpanValidator - Allows validation of a time span configuration value
TimeSpanValidatorAttribute - Attribute class for declaratively applying time span validators

The converter types

CommaDelimitedStringCollectionConverter - Converts a comma-delimited value to/from CommaDelimitedStringCollection
GenericEnumConverter - Converts between a string and an enumerated type
InfiniteIntConverter - Converts between a string and the standard infinite or integer value
InfiniteTimeSpanConverter - Converts between a string and the standard infinite TimeSpan value
TimeSpanMinutesConverter - Converts to and from a time span expressed in minutes
TimeSpanMinutesOrInfiniteConverter - Converts to and from a time span expressed in minutes or infinite
TimeSpanSecondsConverter - Converts to and from a time span expressed in seconds
TimeSpanSecondsOrInfiniteConverter - Converts to and from a time span expressed in seconds or infinite
TypeNameConverter - Converts between a Type object and the string representation of that type
WhiteSpaceTrimStringConverter - Converts a string to its canonical format, i.e. white space trimmed from front and back

Pre-made configuration sections

AppSettingsSection - This provides the well-known configuration section
ConnectionStringsSection - This provides the new configuration section
ProtectedConfigurationSection - This provides an encrypted configuration section
IgnoreSection - Special configuration section wrapper that is ignored by the configuration parser

Premade configuration collections

CommaDelimitedStringCollection - Used in conjunction with CommaDelimitedStringCollectionConverter
KeyValueConfigurationCollection - Used to configure key/value pairs in your configuration sections
NameValueConfigurationCollection - Used to configure name/value pairs in your configuration sections

In addition to all of the classes described above, you will also find other support types used by ProtectedConfigurationSection. All of the old .NET 1.x configuration classes will also still be available in the System.Configuration namespace, but for the most part they can be ignored.

.Net knowledge base

2008-06-12T15:46:00.017+05:30

The following links are very important inorder to brush up your .Net knowledge.