Edging DotNet

dotnet concets

2008-10-10T21:01:00.000-07:00

NET Remoting

Microsoft's .NET framework provides a way for a client in one application domain to access objects in another application domain; this is made possible through .NET Remoting.

.NET Remoting is a very flexible technology that allows clients and servers to communicate with each other, no matter where they are located. The client and server can be on the same machine, on different machines on the same network, or in different countries across the world. .NET Remoting makes life easy by providing services and infrastructure components that hide all the complexities from application developers.

.NET Remoting allows us to use different protocols, different serialization formats, configuration settings, etc. .NET Remoting even allows programmers to create and install their own "hooks" in the .NET Remoting pipeline in order to customize the default behavior of the remoting framework (Tracking Services is an example of such a hook)

So how does .NET Remoting work? Well, some of the concepts behind .NET Remoting are borrowed from the old distributed technologies, such as DCOM, CORBA, etc. First of all, always remember that in .NET Remoting, objects are exposed to the outside world through some "Listener" process; that listener process could be a console application, a WinForm application, a Windows service, or even IIS. The listener process specifies the objects that are exposed programmatically or by using the .config file. Once that part is done, client applications connect to the listener process for object creation requests and the listener process then creates and returns the objects back to the client. All communication between client and server application domains is performed by sending and receiving encoded streams of data over some channel.

Channels

The basic purpose of channels is to transport data from one end point to another; .NET comes with two built-in channels, HTTP channel (System.Runtime.Remoting.Channels.Http) and TCP channel (System.Runtime.Remoting.Channels.Tcp).

TCP channel is faster than HTTP channel, and it is good for binary data; whereas HTTP channel is very good when it comes to firewalls and the Internet. You are not limited to these channels; you can create your own custom channels and plug them into .NET Remoting.

Formatters

Formatters, as the name implies, format data or messages for delivery. Once data/message has been formatted, it is transported to other application domains by using the appropriate channel. .NET comes with two built-in formatters, Soap formatter (System.Runtime.Serialization.Formatters.Soap) and Binary formatter (System.Runtime.Serialization.Formatters.Binary).

Soap formatter formats message in Soap 1.1 specification, whereas Binary formatter formats message in pure binary form.

Types of Remoting Objects

There are two types of objects supported by .NET Remoting: server-activated objects (also known as well-known objects) and client-activated objects.

Server-activated objects

Server-activated objects, as the name implies, are created by the server and their lifetime is also managed by the server. The point to catch here is that these objects are not created when a client calls New or Activator.GetObject; rather, the actual instance of the object is created when the client actually invokes a method on proxy.

There is one implication to the above mentioned behavior. Since the object is not created at the time the client calls the New or Activator.GetObject method, we cannot use non-default constructors with server-activated objects. Only default constructors (constructors with no parameters) are supported for such objects.

There are two modes in which server-activated objects can be activated:

Singleton
Only one object will be created on the server to fulfill the requests of all the clients; that means the object is shared, and the state will be shared by all the clients.
SingleCall
Such objects are created on each method call and objects are not shared among clients. State should not be maintained in such objects because such objects are destroyed after each method call.

Client-activated objects

Client-activated objects are created by the server and their lifetime is managed by the client. In contrast to server-activated objects, client-activated objects are created as soon as the client calls New or any other object creation method; therefore, we can use both the default and non-default constructors with client-activated objects. Client-activated objects are specific to the client, and objects are not shared among different clients; object instance exists until the lease expires or the client destroys the object.

Configuration

Like other .NET technologies, .NET Remoting also needs some configuration information in order to work. We can configure our remoting application either programmatically or by using a .config file. For this article, we will discuss .config files.

.NET Remoting configuration settings are packed in the <application> tag in the following XML format:

In order to expose server-activated objects, we use the <service> tag, as shown in the example below:

    objectUri="Customer"/>

The above configuration specifies that we are exposing a SingleCall object whose complete type name is MyObjects.Customer. The class is contained in the MyObjects.DLL assembly; the object's URI is Customer, and the object is accessible through TCP channel on port 1234.

Each server-activated object will have its own <wellknown> tag.

The corresponding client-side .config file would be as follows:

      url="tcp://localhost:1234/Customer"/>

The client-side configuration file is slightly different from the server configuration file. We are using the <client> tag instead of the <service> tag; similarly we are using the url attribute in the <wellknown> tag on the client-side to specify the exact location of the server object.

For client-activated objects, we use the <activated> tag (both on sever and the client), instead of the <wellknown> tag. Following example shows how to expose a client-activated object.

The corresponding client-side configuration file would look as follows:

· What’s a Windows process?
It’s an application that’s running and had been allocated memory.

· What’s typical about a Windows process in regards to memory allocation?
Each process is allocated its own block of available RAM space, no process can access another process’ code or data. If the process crashes, it dies alone without taking the entire OS or a bunch of other applications down.

· Explain what relationship is between a Process, Application Domain, and Application?
A process is an instance of a running application. An application is an executable on the hard drive or network. There can be numerous processes launched of the same application (5 copies of Word running), but 1 process can run just 1 application.

· What are possible implementations of distributed applications in .NET?
.NET Remoting and ASP.NET Web Services. If we talk about the Framework Class Library, noteworthy classes are in System.Runtime.Remoting and System.Web.Services.

· What are the consideration in deciding to use .NET Remoting or ASP.NET Web Services?
Remoting is a more efficient communication exchange when you can control both ends of the application involved in the communication process. Web Services provide an open-protocol-based exchange of informaion. Web Services are best when you need to communicate with an external organization or another (non-.NET) technology.

· What’s a proxy of the server object in .NET Remoting?
It’s a fake copy of the server object that resides on the client side and behaves as if it was the server. It handles the communication between real server object and the client object. This process is also known as marshaling.

· What are remotable objects in .NET Remoting?
Remotable objects are the objects that can be marshaled across the application domains. You can marshal by value, where a deep copy of the object is created and then passed to the receiver. You can also marshal by reference, where just a reference to an existing object is passed.

· What are channels in .NET Remoting?
Channels represent the objects that transfer the other serialized objects from one application domain to another and from one computer to another, as well as one process to another on the same box. A channel must exist before an object can be transferred.

· What security measures exist for .NET Remoting in System.Runtime.Remoting?
None. Security should be taken care of at the application level. Cryptography and other security techniques can be applied at application or server level.

· What is a formatter?
A formatter is an object that is responsible for encoding and serializing data into messages on one end, and deserializing and decoding messages into data on the other end.

· Choosing between HTTP and TCP for protocols and Binary and SOAP for formatters, what are the trade-offs?
Binary over TCP is the most effiecient, SOAP over HTTP is the most interoperable.

· What’s SingleCall activation mode used for?
If the server object is instantiated for responding to just one single request, the request should be made in SingleCall mode.

· What’s Singleton activation mode?
A single object is instantiated regardless of the number of clients accessing it. Lifetime of this object is determined by lifetime lease.

· How do you define the lease of the object?
By implementing ILease interface when writing the class code.

· Can you configure a .NET Remoting object via XML file?
Yes, via machine.config and application level .config file (or web.config in ASP.NET). Application-level XML settings take precedence over machine.config.

· How can you automatically generate interface for the remotable object in .NET with Microsoft tools?
Use the Soapsuds tool.

State Management in ASP.Net

Web Pages developed in ASP.Net are HTTP based and HTTP protocol is a stateless protocol. It means that web server does not have any idea about the requests from where they coming i.e from same client or new clients. On each request web pages are created and destroyed.

So, how do we make web pages in ASP.Net which will remember about the user, would be able to distinguish b/w old clients(requests) and new clients(requests) and users previous filled information while navigating to other web pages in web site?

Solution of the above problem lies in State Management.

ASP.Net technology offers following state management techniques.

Client side State Management

o Cookies

o Hidden Fields

o View State

o Query String

Server side State Management

o Session State

o Application State

These state management techniques can be understood and by following simple examples and illustrations of the each techniques.

Client Side State Management

Cookies

A cookie is a small amount of data which is either stored at client side in text file or in memory of the client browser session. Cookies are always sent with the request to the web server and information can be retrieved from the cookies at the web server. In ASP.Net, HttpRequest object contains cookies collection which is nothing but list of HttpCookie objects. Cookies are generally used for tracking the user/request in ASP.Net for example, ASP.Net internally uses cookie to store session identifier to know whether request is coming from same client or not. We can also store some information like user identifier (UserName/Nick Name etc) in the cookies and retrieve them when any request is made to the web server as described in following example. It should be noted that cookies are generally used for storing only small amount of data(i.e 1-10 KB).

Code Sample

//Storing value in cookie
HttpCookie cookie = new HttpCookie("NickName");
cookie.Value = "David";
Request.Cookies.Add(cookie);
//Retrieving value in cookie
if (Request.Cookies.Count > 0 && Request.Cookies["NickName"] != null)
lblNickName.Text = "Welcome" + Request.Cookies["NickName"].ToString();
else
lblNickName.Text = "Welcome Guest";

Cookies can be permanent in nature or temporary. ASP.Net internally stores temporary cookie at the client side for storing session identifier. By default cookies are temporary and permanent cookie can be placed by setting "Expires" property of the cookie object.

Hidden Fields

A Hidden control is the control which does not render anything on the web page at client browser but can be used to store some information on the web page which can be used on the page.

HTML input control offers hidden type of control by specifying type as "hidden". Hidden control behaves like a normal control except that it is not rendered on the page. Its properties can be specified in a similar manner as you specify properties for other controls. This control will be posted to server in HttpControl collection whenever web form/page is posted to server. Any page specific information can be stored in the hidden field by specifying value property of the control.

ASP.Net provides HtmlInputControl that offers hidden field functionality.

Code Sample

//Declaring a hidden variable
protected HtmlInputHidden hidNickName;
//Populating hidden variable
hidNickName.Value = "Page No 1";
//Retrieving value stored in hidden field.
string str = hidNickName.Value;

Note:Critical information should not be stored in hidden fields.

View State/Control State

ASP.Net technology provides View State/Control State feature to the web forms. View State is used to remember controls state when page is posted back to server. ASP.Net stores view state on client site in hidden field __ViewState in encrypted form. When page is created on web sever this hidden control is populate with state of the controls and when page is posted back to server this information is retrieved and assigned to controls. You can look at this field by looking at the source of the page (i.e by right clicking on page and selecting view source option.)

You do not need to worry about this as this is automatically handled by ASP.Net. You can enable and disable view state behaviour of page and its control by specifying 'enableViewState' property to true and false. You can also store custom information in the view state as described in following code sample. This information can be used in round trips to the web server.

Code Sample

//To Save Information in View State
ViewState.Add ("NickName", "David");
//Retrieving View state
String strNickName = ViewState ["NickName"];

Query String

Query string is the limited way to pass information to the web server while navigating from one page to another page. This information is passed in url of the request. Following is an example of retrieving information from the query strings.

Code Sample

//Retrieving values from query string
String nickname;
//Retrieving from query string
nickName = Request.Param["NickName"].ToString();

But remember that many browsers impose a limit of 255 characters in query strings. You need to use HTTP-Get method to post a page to server otherwise query string values will not be available.

Server Side State Management

Session State

Session state is used to store and retrieve information about the user as user navigates from one page to another page in ASP.Net web application. Session state is maintained per user basis in ASPNet runtime. It can be of two types in-memory and out of memory. In most of the cases small web applications in-memory session state is used. Out of process session state management technique is used for the high traffic web applications or large applications. It can be configured with some configuration settings in web.conig file to store state information in ASPNetState.exe (windows service exposed in .Net or on SQL server.

In-memory Session state can be used in following manner

Code Sample

//Storing informaton in session state
Session["NickName"] = "Ambuj";
//Retrieving information from session state
string str = Session["NickName"];

Session state is being maintained automatically by ASP.Net. A new session is started when a new user sents first request to the server. At that time session state is created and user can use it to store information and retrieve it while navigating to different web pages in ASP.Net web application.

ASP.Net maintains session information using the session identifier which is being transacted b/w user machine and web server on each and every request either using cookies or querystring (if cookieless session is used in web application).

Application State

Application State is used to store information which is shared among users of the ASP.Net web application. Application state is stored in the memory of the windows process which is processing user requests on the web server. Application state is useful in storing small amount of often-used data. If application state is used for such data instead of frequent trips to database, then it increases the response time/performance of the web application.

In ASP.Net, application state is an instance of HttpApplicationState class and it exposes key-value pairs to store information. Its instance is automatically created when a first request is made to web application by any user and same state object is being shared across all subsequent users.

Application state can be used in similar manner as session state but it should be noted that many user might be accessing application state simultaneously so any call to application state object needs to be thread safe. This can be easily achieved in ASP.Net by using lock keyword on the statements which are accessing application state object. This lock keyword places a mutually exclusive lock on the statements and only allows a single thread to access the application state at a time. Following is an example of using application state in an application.

Code Sample

//Stroing information in application state
lock (this)
{
Application["NickName"] = "David";
}
//Retrieving value from application state
lock (this)
{
string str = Application["NickName"].ToString();
}

Using ASP.NET Session State

Session state settings in ASP.NET are configured through the ASP.NET XML configuration file config.web. We'll look at config.web in more detail in a later column, but for this discussion of session state let's look at it briefly.

Config.web

There are two types of configuration files: a machine configuration file and an application configuration file, both named config.web. The two are identical, except that the machine configuration file applies settings to all applications but the application configuration files are either restrictive or expansive on an application-by-application basis.

In Beta 1, the machine config.web file is in the WinNT\Microsoft.NET\Framework\v1.0.2204 directory, while the optional application configuration files exist in the application's directory. Application config.web files are optional in the sense that if an application config.web file doesn't exist, the machine config.web settings are used instead. ASP.NET session state settings can be made in the machine config.web file and overridden in a particular application's config.web file.

Note: Changes made to config.web are applied immediately, unlike classic ASP, where the server has to be stopped and started for settings to take affect.

Session configuration

Below is a sample config.web file used to configure the session state settings for an ASP.NET application:

Copy Code

        mode="inproc"
      cookieless="false" 
      timeout="20" 
      sqlconnectionstring="data source=127.0.0.1;user id=;password="
      server="127.0.0.1" 
      port="42424" 
  />

The settings above are used to configure ASP.NET session state. Let's look at each in more detail and cover the various uses afterward.

Mode. The mode setting supports three options: inproc, sqlserver, and stateserver. As stated earlier, ASP.NET supports two modes: in process and out of process. There are also two options for out-of-process state management: memory based (stateserver), and SQL Server based (sqlserver). We'll discuss implementing these options shortly.
Cookieless. The cookieless option for ASP.NET is configured with this simple Boolean setting.
Timeout. This option controls the length of time a session is considered valid. The session timeout is a sliding value; on each request the timeout period is set to the current time plus the timeout value
Sqlconnectionstring. The sqlconnectionstring identifies the database connection string that names the database used for mode sqlserver.
Server. In the out-of-process mode stateserver, it names the server that is running the required Windows NT service: ASPState.
Port. The port setting, which accompanies the server setting, identifies the port number that corresponds to the server setting for mode stateserver.

Sample session state application

Before we use session state, we need an application to test it with. Below is the code for a simple Visual Basic® application that writes to and reads from session state, SessionState.aspx:

Copy Code

                OnServerClick="Session_Add" Value="Add to Session State">
                OnServerClick="CheckSession" Value="View Session State">

This simple page wires up two server-side events for the Add and View buttons, and simply sets the session state to the value in the text box.

There are four general configuration settings we can look at in more detail: in-process mode, out-of-process mode, SQL Server mode, and Cookieless.

In-process Mode

In-process mode simply means using ASP.NET session state in a similar manner to classic ASP session state. That is, session state is managed in process and if the process is re-cycled, state is lost. Given the new settings that ASP.NET provides, you might wonder why you would ever use this mode. The reasoning is quite simple: performance. The performance of session state, e.g. the time it takes to read from and write to the session state dictionary, will be much faster when the memory read to and from is in process, as cross-process calls add overhead when data is marshaled back and forth or possibly read from SQL Server.

In-process mode is the default setting for ASP.NET. When this setting is used, the only other session config.web settings used are cookieless and timeout.

If we call SessionState.aspx, set a session state value, and stop and start the ASP.NET process (iisreset), the value set before the process was cycled will be lost.

Out-of-process Mode

Included with the .NET SDK is a Windows® NT service: ASPState. This Windows service is what ASP.NET uses for out-of-process session state management. To use this state manager, you first need to start the service. To start the service, open a command prompt and type:

Copy Code

net start aspstate

What you'll see is:

Figure 1. Starting the Windows NT service ASPState at the command prompt

At this point, the Windows NT Service ASPState has started and is available to ASP.NET. Next, we need to configure ASP.NET to take advantage of this service. To do this we need to configure config.web:

Copy Code

        mode="stateserver"
      cookieless="false" 
      timeout="20" 
      sqlconnectionstring="data source=127.0.0.1;user id=;password="
      server="127.0.0.1" 
      port="42424" 
  />

We changed only from inproc mode to stateserver mode. This setting tells ASP.NET to look for the ASP state service on the server specified in the server and port settings—in this case, the local server.

We can now call SessionState.aspx, set a session state value, stop and start the IIS process (iisreset), and continue to have access to the values for our current state.

SQL Server Mode

The SQL Server mode option is similar to that of the Windows NT Service, except that the information persists to SQL Server rather than being stored in memory.

To use SQL Server as our session state store, we first must create the necessary tables and stored procedures that ASP.NET will look for on the identified SQL Server. The .NET SDK provides us with a SQL script (state.sql) to do just that.

state.sql

The state.sql file contains the SQL commands used to create the ASPState database. This script creates two tables and several stored procedures. ASP.NET uses both the tables and the procedures to store data in SQL Server. I would recommend reading through state.sql to learn more about what it is doing.

The state.sql file can be found in [system drive]\winnt\Microsoft.NET\Framework\[version]\

Applying the state.sql script

To apply the state.sql script, use the command line tool SQL Server provides: osql.exe. Using an sa equivalent SQL user, the syntax below is used:

Copy Code

osql –S [server name] –U [user] –P [password]

Note: A lightweight version of SQL Server is installed when the .NET SDK is installed.

Here's what you should see:

Figure 2. Using the SQL Server command line tool to apply state.sql script

After running osql, start and stop SQL Server; part of what state.sql added were some start-up stored procedures that need to be run. Next, modify the configuration settings to set the mode to sqlserver and modify the sqlconnectionstring to identify the appropriate SQL Server serving the ASPState database. For example:

Copy Code

        mode="sqlserver"
      cookieless="false" 
      timeout="20" 
      sqlconnectionstring="data source=MySqlServer;
                           user id=ASPState;
                           password=1Gr8State"
      server="127.0.0.1" 
      port="42424" 
  />

Again, similar to the Windows NT service state manager, we can now call SessionState.aspx, set a session state value, stop and start the IIS process (iisreset), and continue to have access to the values for our current state. In fact, we could cluster the SQL Servers such that if one SQL Server happened to be unavailable, another server that was replicating its data could take its place. This provides a level of reliability that was not available in ASP.

Cookieless State

The last new feature that we can configure for ASP.NET session state is cookieless session state. Essentially this feature allows sites whose clients choose not to use cookies to take advantage of ASP.NET session state.

This is done by modifying the URL with an ID that uniquely identifies the session:

Copy Code

http://localhost/(lit3py55t21z5v55vlm25s55)/Application/SessionState.aspx

ASP.NET will modify relative links found within the page and embed this ID. Thus, as long as the user follows the path of links the site provides, session state can be maintained. However, if the end user re-writes the URL, the session state instance will most likely be lost.

The IIS 4.0 Resource Kit provided a similar feature. It was implemented as an ISAPI filter that could modify the incoming and outgoing byte stream to write and read the necessary information. The difference between this and the ASP.NET feature is the effort required to use the feature. In ASP.NET, it's simply a matter of flipping a Boolean value in the config.web file:

Copy Code

        mode="stateserver"
      cookieless="true" 
      timeout="20" 
      sqlconnectionstring="data source=127.0.0.1;user id=;password="
      server="127.0.0.1" 
      port="42424" 
  />

Once cookieless is set to true, ASP.NET will do the work necessary to enable cookieless session state. Also note that all modes are supported for cookieless sessions.

Performance and Reliability Considerations

It's worth mentioning, briefly, some of the performance and reliability issues you should consider when using ASP.NET session state modes.

In process. In process will perform best because the session state memory is kept within the ASP.NET process. For Web applications hosted on a single server, applications in which the user is guaranteed to be re-directed to the correct server, or when session state data is not critical (in the sense that it can be re-constructed or re-populated), this is the mode to choose.
Out of process. This mode is best used when performance is important but you can't guarantee which server a user will request an application from. With out-of-process mode, you get the performance of reading from memory and the reliability of a separate process that manages the state for all servers.
SQL Server. This mode is best used when the reliability of the data is fundamental to the stability of the application, as the database can be clustered for failure scenarios. The performance isn't as fast as out of process, but the tradeoff is the higher level of reliability.

Improvements in ASP.NET 2.0

ASP.NET 2.0 was designed to make web development easier and quicker.

Design goals for ASP.NET 2.0:

Increase productivity by removing 70% of the code
Use the same controls for all types of devices
Provide a faster and better web server platform
Simplify compilation and installation
Simplify the administration of web applications

What's New in ASP.NET 2.0?

Some of the new features in ASP.NET 2.0 are:

Master Pages, Themes, and Web Parts
Standard controls for navigation
Standard controls for security
Roles, personalization, and internationalization services
Improved and simplified data access controls
Full support for XML standards like, XHTML, XML, and WSDL
Improved compilation and deployment (installation)
Improved site management
New and improved development tools

The new features are described below.

Master Pages

ASP.NET didn't have a method for applying a consistent look and feel for a whole web site.

Master pages in ASP.NET 2.0 solves this problem.

A master page is a template for other pages, with shared layout and functionality. The master page defines placeholders for content pages. The result page is a combination (merge) of the master page and the content page.

Themes

Themes is another feature of ASP.NET 2.0. Themes, or skins, allow developers to create a customized look for web applications.

Design goals for ASP.NET 2.0 themes:

Make it simple to customize the appearance of a site
Allow themes to be applied to controls, pages, and entire sites
Allow all visual elements to be customized

Web Parts

ASP.NET 2.0 Web Parts can provide a consistent look for a site, while still allowing user customization of style and content.

New controls:

Zone controls - areas on a page where the content is consistent
Web part controls - content areas for each zone

Navigation

ASP.NET 2.0 has built-in navigation controls like

Site Maps
Dynamic HTML menus
Tree Views

Security

Security is very important for protecting confidential and personal information.

In ASP.NET 2.0 the following controls has been added:

A Login control, which provides login functionality
A LoginStatus control, to control the login status
A LoginName control to display the current user name
A LoginView control, to provide different views depending on login status
A CreateUser wizard, to allow creation of user accounts
A PasswordRecovery control, to provide the "I forgot my password" functionality

Roles and Personalization

Internet communities are growing very popular.

ASP.NET 2.0 has personalization features for storing user details. This provides an easy way to customize user (and user group) properties.

Internationalization

Reaching people with different languages is important if you want to reach a larger audience.

ASP.NET 2.0 has improved support for multiple languages.

Data Access

Many web sites are data driven, using databases or XML files as data sources.

With ASP.NET this involved code, and often the same code had to be used over and over in different web pages.

A key goal of ASP.NET 2.0 was to ease the use of data sources.

ASP.NET 2.0 has new data controls, removing much of the need for programming and in-depth knowledge of data connections.

Mobility Support

The problem with Mobile devices is screen size and display capabilities.

In ASP.NET, the Microsoft Mobile Internet Toolkit (MMIT) provided this support.

In ASP.NET 2.0, MMIT is no longer needed because mobile support is built into all controls.

Images

ASP.NET 2.0 has new controls for handling images:

The ImageMap control - image map support
The DynamicImage control - image support for different browsers

These controls are important for better image display on mobile devices, like hand-held computers and cell phones.

Automatic Compilation

ASP.NET 2.0 provides automatic compilation. All files within a directory will be compiled on the first run, including support for WSDL, and XSD files.

Compiled Deployment (Installation) and Source Protection

ASP.NET 2.0 also provides pre-compilation. An entire web site can be pre-compiled. This provides an easy way to deploy (upload to a server) compiled applications, and because only compiled files are deployed, the source code is protected.

Site Management

ASP.NET 2.0 has three new features for web site configuration and management:

New local management console
New programmable management functions (API)
New web-based management tool

Development Tools

With ASP.NET Visual Studio.NET was released with project and design features targeted at corporate developers.

With ASP.NET 2.0, Visual Studio 2005 was released.

Key design features for Visual Studio 2005 include:

Support for the features described above
Upload files from anywhere (FTP, File System, Front Page....)
No project files, allowing code to be manipulated outside Visual Studio
Integrated Web Site Administration Tool
No "build" step - ability to compile on first run

All non-static pages and applications (static: "HTML only" pages, images, etc.) are
interpreted and executed by the server. Application pools (AppPools) were
introduced in IIS 6 as a way of keeping the effects from the code executed by
different virtual servers as encapsulated as possible.

Each application pool gets it own worker process on the system. By doing this, each
application in a pool will never have an effect on applications in other pools. If
an application causes a process to crash, for example, this only affects the pool
in which it is in. The Web server and other pools continue to run normally.

Resources such as memory (RAM), CPU load and required CPU time can be limited
separately for each application pool. Pools that generate too many errors within a
specific time frame can be disabled automatically.

Application pools can be restarted automatically (recycling), e.g. every night or
if certain resources are exceeded. Note however, that all information on the
current sessions (session variables) will be lost.

You can create as many application pools as you want. The number is limited only by
the resources on the server. Note however, that each running pool consumes system
resources for process management (overhead). Your system easily supports around 25
application pools without noticeable performance loss. The exact number depends on:

1. Your server's memory and CPU load
2. The number and type of applications in the pools
3. The number of requests for these applications
4. The resource needs of other applications/programmes running on the server

Applications can be assigned to a specific pool in their properties. You can assign
an application pool at the bottom of the "Home Directory" tab (or a "directory" if
it is a lower-level application). New pools can be created by right-clicking
on "Application Pools".

Because each pool is assigned an identity (user), all applications in the pool run
using these permissions. Applications running in a pool as Administrator (not
recommended!) would then have administrative rights, can read related files, power
down the server, etc. Use the "Network Service" identity or a custom user to
restrict access.

In this part, we will take a look at one of the new features in IIS 6.0, named Application Pool, and demonstrate the use of application pools in isolating ASP.NET Web applications, thereby increasing the reliability of your ASP.NET Web applications. Then, we also will explore how these application pools affect ASP.NET applications in terms of the identity that is used to run your ASP.NET applications. Along the way, we will also look at the steps to be followed for creating application pools and assigning ASP.NET applications to run under a specific application pool. Finally, we will illustrate how to configure an application pool to run using the credentials of a specific user account.

What is an Application Pool?

An Application Pool can contain one or more applications and allows us to configure a level of isolation between different Web applications. For example, if you want to isolate all the Web applications running in the same computer, you can do this by creating a separate application pool for every Web application and placing them in their corresponding application pool. Because each application pool runs in its own worker process, errors in one application pool will not affect the applications running in other application pools. Deploying applications in application pools is a primary advantage of running IIS 6.0 in worker process isolation mode because you can customize the application pools to achieve the degree of application isolation that you need.

When you configure application pools for optimum availability, you also should consider how to configure application pools for application security. For example, you might need to create separate application pools for applications that require a high level of security, while allowing applications that require a lower level of security to share the same application pool. In the later part of this article, we will see how to configure identities at the application pool level.

Creating a new Application Pool

Creating a new application pool is a very simple process that is carried out by using the IIS manager. When you create a new application pool, you have the following two options:

You can either create a new application pool from scratch or
You can create a new application by importing the configuration settings from an external XML file

To create a new application pool from scratch, right-click on the Application Pools node from the tree view and select New->Application Pool from the context menu. You will be presented with the following screen, where you need to enter a name for the application pool.

When creating a new application, you also have the option of inheriting the settings from an existing application pool. For example, if you want your new application pool to inherit the settings from the DefaultAppPool, you can do that by selecting the option Use existing application pool as a template in the above screen. After you pick this option, the Application Pool name dropdown box will be enabled from where you can select an existing application pool.

After the pool is created, you can save the settings of the application pool to an external XML file any time by right-clicking the application pool and selecting the option All Tasks->Save Configuration to a File that is available from the context menu. This is an extremely useful feature that makes it possible for you to easily recreate the same application pool on the same server or on a different server with minimal effort.

Configuring Identity for ASP.NET Web Applications

In previous versions of IIS, worker processes ran as LocalSystem, a powerful account that has system administrator privileges on the server. Because LocalSystem has access to almost all resources on the operating system, this caused security implications. As mentioned previously, in IIS 6.0, you can set the identity of the worker process at the application pool level. The identity of an application pool is the account under which the application pool's worker process runs. By default, application pools operate under the NetworkService account, which has low-level user access rights. The NetworkService account has the following seven privileges:

Adjust memory quotas for a process
Generate security audits
Log on as a service
Replace process level token
Impersonate a client after authentication
Allow logon locally
Access this computer from the network

By running the worker process using a very low-privileged account such as NetworkService, you can reduce the security vulnerability. However, by using IIS manager, you can configure the application pool to run as any of the following pre-defined accounts:

NetworkService
LocalSystem
LocalService

To configure identity for an application pool, right-click the application pool and select Properties from the context menu. In the Properties dialog box, select the Identity tab and you will see the following screen.

In the above dialog box, when you select the Predefined option, you can select any of the pre-defined accounts from the dropdown box. Instead of using a pre-defined account, if you want your application pool to run under a different account, select the Configurable option and then set the User name and Password in the textboxes. This approach is particularly useful especially when you are running multiple applications or sites on one Web server. For example, if an ISP hosts two companies—who may even be competitors—on one Web server, it has to guarantee that these two applications run in isolation from each other. More importantly, the ISP has to make sure that a malicious administrator for one application can't access the data of the other application. You can accomplish this level of isolation by using the configurable worker process identity.

· Each computer on which the common language runtime is installed has a machine-wide code cache called the 'Global Assembly Cache'. The global assembly cache (or GAC as it is commonly known) stores assemblies specifically designated to be shared by several applications on the computer. The global assembly cache is located in 'Windows/WinNT' directory and inherits the directory's access control list that administrators have used to protect the folder.

Assemblies installed in GAC should adhere to a specific versioning scheme that will allow them for side-by-side execution (multiple versions of the same assembly can be maintained in the GAC) of different code versions.

Shared Assemblies including all the important .NET System assemblies implementing the Framework Class Library reside within GAC. The GAC was originally called Fusion Cache and is implemented using Fusion.dll in .NET Framework.

Assemblies placed in the GAC must have the same assembly name and file name (not including the file name extension). For example, an assembly with the assembly name of 'myAssembly' must have a file name of either 'myAssembly.exe' or 'myAssembly.dll'.

· Scenarios for installing Assemblies in GAC

There are multiple reasons why an assembly should be installed in GAC:

File Security:

Administrators usually protect the 'Windows/WinNT' directory using an access control list (ACL) to control access. Because the GAC is located in 'Windows/WinNT' folder, this means that the GAC folder inherits the access rights from the 'Windows/WinNT' folder, and only administrators can modify the contents of the GAC. This will ensure that assemblies that are installed in GAC are not being accidentally removed/modified by in-experienced users.
Shared Location:

GAC acts as a common place for installing assemblies that are shared by multiple applications on the same machine. A common misconception is that in order to make the .NET assemblies available to COM InterOp or to the unmanaged code, the assemblies should be installed in GAC. However, this does not mandate installing assemblies in the GAC. Only those assemblies that are shared with other applications on the same machine should be installed in GAC.
Side-by-Side versioning:

Side-by-side execution means having the ability to install and use multiple versions of the same assembly. In simple words side-by-side versioning means having the same assembly present with multiple versions but with the same name. GAC can contain multiple copies of the same assembly with different versions, which allows a robust support for versioning in the Common Language Runtime.
As an additional search location:

When an assembly needs to be loaded by the Common Language Runtime, the CLR first checks the GAC for the assembly.

· Pre-Requisites for installing an assembly in GAC

To install an assembly in GAC, the assembly must be signed with a strong name.

Quote:

Originally Posted by .NET Framework Documentation

A strong name consists of the assembly's identity — its simple text name, version number, and culture information (if provided) — plus a public key and a digital signature. It is generated from an assembly file (the file that contains the assembly manifest, which in turn contains the names and hashes of all the files that make up the assembly), using the corresponding private key.

In order to help assemblies to sign with a string name, one can use the Strong Name Tool. Further information can also be found in the following article.

· Installing/uninstalling an assembly in GAC

There are multiple ways of installing an assembly in GAC:

Using Windows Installer:

This is a preferred way for installing shared assemblies and should be the only way to install the shared assemblies on production systems (or non-development machines).
Global Assembly Cache Tool:

The Global Assembly Cache Utility Tool can be used to install or uninstall assemblies in GAC. It also allows us to view or manipulate the contents of the GAC. The common syntax of 'GACUTIL.exe' is:

Code:

gacutil [options] [assemblyName | assemblyPath | assemblyListFile]

To install a strong named assembly from the command prompt in the GAC use:

Code:

gacutil /i myAssembly.dll

To uninstall a strong named assembly from the command prompt in the GAC use:

Code:

gacutil /u myAssembly.dll

To view the contents of the GAC we can use:

Code:

gacutil /l

To check if an assembly ('myAssembly.dll') is already present in the GAC:

Code:

gacutil /l myAssembly.dll

Other ways:

There are other ways also to install/uninstall the assemblies to/from GAC and to view the contents. Following links will give some insight on these tools:

Advantages of using GAC are:

Strong name signature verification: All shared assemblies must have strong name signatures. These signature are verified when the assembly is installed into the gac. Once verified the signatures are not verified each time the assembly is referenced. In contrast, shared assemblies deployed outside the assembly have their signatures verified each time the assembly is loaded.

Performance:CLR to look into the GAC first when resolving an Assembly reference. If it doesn't find the requested assembly in the GAC then it looks in the application directory and follows the rest of the probing logic algorithm. Clearly there is a performance gain by putting the assembly in the first place to be searched.
Deploying bug fixes:Administrators can use the gac to deploy bug fixes intended to be picked up by all applications. By deploying the fix to the gac and stating the appropriate version policy in the machine configuration file, an admin can ensure that all applications on the machine will begin to use the fix.

DotIntevriew preperation

2008-09-26T08:08:00.000-07:00

State Management in ASP.NET
Web form pages are HTTP-Based, they are stateless, which means they don’t know whether the requests are all from the same client, and pages are destroyed and recreated with each round trip to the server, therefore information will be lost, therefore state management is really an issue in developing web applications
We could easily solve these problems in ASP with cookie, query string, application, session and so on. Now in ASP.NET, we still can use these functions, but they are richer and more powerful, so let’s dive into it.
Mainly there are two different ways to manage web page’s state: Client-side and Server-side.
1.Client-side state management :There is no information maintained on the server between round trips. Information will be stored in the page or on the client’s computer.
A. Cookies.
A cookie is a small amount of data stored either in a text file on the client's file system or in-memory in the client browser session. Cookies are mainly used for tracking data settings. Let’s take an example: say we want to customize a welcome web page, when the user request the default web page, the application first to detect if the user has logined before, we can retrieve the user informatin from cookies:
[c#]
if (Request.Cookies[“username”]!=null)
lbMessage.text=”Dear “+Request.Cookies[“username”].Value+”, Welcome shopping here!”;
else
lbMessage.text=”Welcome shopping here!”;

If you want to store client’s information, you can use the following code:
[c#]
Response.Cookies[“username’].Value=username;

So next time when the user request the web page, you can easily recongnize the user again.B. Hidden Field
A hidden field does not render visibly in the browser, but you can set its properties just as you can with a standard control. When a page is submitted to the server, the content of a hidden field is sent in the HTTP Form collection along with the values of other controls. A hidden field acts as a repository for any page-specific information that you would like to store directly in the page. Hidden field stores a single variable in its value property and must be explicitly added it to the page.
ASP.NET provides the HtmlInputHidden control that offers hidden field functionality.
[c#]
protected System.Web.UI.HtmlControls.HtmlInputHidden Hidden1;
//to assign a value to Hidden field
Hidden1.Value=”this is a test”;
//to retrieve a value
string str=Hidden1.Value;

Note: Keep in mind, in order to use hidden field, you have to use HTTP-Post method to post web page. Although its name is ‘Hidden’, its value is not hidden, you can see its value through ‘view source’ function.
C. View State

Each control on a Web Forms page, including the page itself, has a ViewState property, it is a built-in struture for automatic retention of page and control state, which means you don’t need to do anything about getting back the data of controls after posting page to the server.

Here, which is useful to us is the ViewState property, we can use it to save information between round trips to the server.
[c#]
//to save information
ViewState.Add(“shape”,”circle”);
//to retrieve information
string shapes=ViewState[“shape”];

Note: Unlike Hidden Field, the values in ViewState are invisible when ‘view source’, they are compressed and encoded.

D. Query Strings
Query strings provide a simple but limited way of maintaining some state information.You can easily pass information from one page to another, But most browsers and client devices impose a 255-character limit on the length of the URL. In addition, the query values are exposed to the Internet via the URL so in some cases security may be an issue.
A URL with query strings may look like this:

http://www.examples.com/list.aspx?categoryid=1&productid=101

When list.aspx is being requested, the category and product information can be obtained by using the following codes:
[c#]
string categoryid, productid;
categoryid=Request.Params[“categoryid”];
productid=Request.Params[“productid”];

Note: you can only use HTTP-Get method to post the web page, or you will never get the value from query strings.

2. Server-side state management:
Information will be stored on the server, it has higher security but it can use more web server resources.
A. Aplication object
The Application object provides a mechanism for storing data that is accessible to all code running within the Web application, The ideal data to insert into application state variables is data that is shared by multiple sessions and does not change often.. And just because it is visible to the entire application, you need to used Lock and UnLock pair to avoid having conflit value.
[c#]
Application.Lock();
Application[“mydata”]=”mydata”;
Application.UnLock();
B. Session object

Session object can be used for storing session-specific information that needs to be maintained between server round trips and between requests for pages. Session object is per-client basis, which means different clients generate different session object.The ideal data to store in session-state variables is short-lived, sensitive data that is specific to an individual session.

Each active ASP.NET session is identified and tracked using a 120-bit SessionID string containing URL-legal ASCII characters. SessionID values are generated using an algorithm that guarantees uniqueness so that sessions do not collide, and SessionID’s randomness makes it harder to guess the session ID of an existing session.
SessionIDs are communicated across client-server requests either by an HTTP cookie or a modified URL, depending on how you set the application's configuration settings. So how to set the session setting in application configuration? Ok, let’s go further to look at it.

Every web application must have a configuration file named web.config, it is a XML-Based file, there is a section name ‘sessionState’, the following is an example:

‘cookieless’ option can be ‘true’ or ‘false’. When it is ‘false’(default value), ASP.NET will use HTTP cookie to identify users. When it is ‘true’, ASP.NET will randomly generate a unique number and put it just right ahead of the requested file, this number is used to identify users, you can see it on the address bar of IE:

http://localhost/Management/(2yzakzez3eqxut45ukyzq3qp)/Default.aspx

Ok, it is further enough, let is go back to session object.
[c#]
//to store information
Session[“myname”]=”Mike”;
//to retrieve information
myname=Session[“myname”];
C. Database

Database enables you to store large amount of information pertaining to state in your Web application. Sometimes users continually query the database by using the unique ID, you can save it in the database for use across multiple request for the pages in your site.

Summary

ASP.NET has more functions and utilities than ASP to enable you to manage page state more efficient and effective. Choosing among the options will depand upon your application, you have to think about the following before making any choose:
· How much information do you need to store?
· Does the client accept persistent or in-memory cookies?
· Do you want to store the information on the client or server?
· Is the information sensitive?
· What kind of performance experience are you expecting from your pages?
Client-side state management summary
Method Use when
Cookies You need to store small amounts of information on the client and security is not an issue.
View state You need to store small amounts of information for a page that will post back to itself. Use of the ViewState property does supply semi-secure functionality.
Hidden fields You need to store small amounts of information for a page that will post back to itself or another page, and security is not an issue. Note You can use a hidden field only on pages that are submitted to the server.
Query string You are transferring small amounts of information from one page to another and security is not an issue. Note You can use query strings only if you are requesting the same page, or another page via a link.
Server-side state management summary
Method Use when
Application state object You are storing infrequently changed, application-scope information that is used by many users, and security is not an issue. Do not store large quantities of information in an application state object.
Session state object You are storing short-lived information that is specific to an individual session, and security is an issue. Do not store large quantities of information in a session state object. Be aware that a session state object will be created and maintained for the lifetime of every session in your application. In applications hosting many users, this can occupy significant server resources and affect scalability.
Database support You are storing large amounts of information, managing transactions, or the information must survive application and session restarts. Data mining is a concern, and security is an issue.
Developing ASP.NET programme is really funny, once you jump into it, you can feel the power of it. Next time let us talk about another topic: Cache. Enjoy .Net!!

Diff bewteen cust & user control

Custom controls are controls that are developed by the developer
or a third party vendor. Custom controls are not provided along with
.NET.

Difference between Custom Controls and User Controls.

1.User Control is a page file with extension .ascx which can only be used within
a single application. But custom controls are assemblies(dll files) that can be
used in multiple applications.

2.User Controls cannot be added to the ToolBox of VS.NET . To use a user Control with in an
aspx page u have to drag the user Control from the solution Explorer to designer page.
But Custom Controls can be added to ToolBox of VS.NET.

3.User Controls can be viewed as a sort of generic controls during the design time.
The proper GUI of user controls can be viewed only during the run time.
But Custom Controls can be viewed during the design time.

4. User controls are created from existing Webserver and html server controls .
But a developer who creates custom controls have to render every thing from the scratch.

5.Since the dll assembly of a custom control is being used,a custom control developed in C# can be used in a project developed in VB.NET or any other managed code and vice versa.
This is not possible with user controls.They are language spefic

We cannot give any examples for custom controls since they are developed either by a developer of a third party vendor.

Re: How do you create a permanent cookie? Answer
# 1
Cookie is like a temporary file which contains a name and a
value pair and resides in the client.

cookie prepared or modified by the server side script will
be appended to the response and will be sent to the client.

dim cook as httpcookie
cook=new httpcookie("items")
cook.value=textbox1.text
response.appendcookie(cook).
Re: How do you create a permanent cookie? Answer
# 2
You can set the permanent cookied by setting the expiry
date to the MaxDate

<%
Response.Cookies("username") = "you"
Response.Cookies("username").Expires = Date.MaxValue
%>
Re: How do you create a permanent cookie? Answer
# 3
by setting the expiry property greater than
datetime.minvalue...

PI Imort or latform Import = DLL Imort – UnManaged code

Diff b/w dg and dr
Datagrid is
* one which has advanced features and lets you do lot many things like paging and sorting your data without much effort.
* DataGrid can hold text data, but not linked or embedded objects.

Whereas a DataRepeater is
* which does not have the paging feature but we can do it by coding.
* one which can hold other controls and can embed objects.
* It can embed a Datagrid within it but not viceversa.

Apart from this a Data Repeater
--is used in places where you need more control over the rendering of your data
-- have very flexible templates that give you total control over the formatting of your data

Repeator Control:
·
1)Read-only; no inherent support for selection or editing ·
2)No inherent look; you lay out the list by creating templates.
3)List can be vertical, horizontal, all on one line, or in any format you specify. ·
4)No default paging; all data is displayed in a single list. ·
5)Separators between elements can be defined using a template

Datagrid:

1)Default look is a grid (customizable table) ·
2)Can customize look of table extensively. ·
3)Options for auto-formatting. ·
4)Can specify output using bound columns, columns of buttons or hyperlinks, and custom
columns created using templates. ·
5)No separator template. However, the grid renders in a table, and you can specify table border size and color. ·
6)WYSIWYG template editing ·
7)Items support styles for custom look. ·
8)Editable contents, including deletion ·
9)Single and multiple selection ·
10)Optional paged output ·Support for sorting ·
11)Support for custom functionality that can be applied to items

Introduction:

1. Classes are reference types and structs are value types.

Since classes are reference type, a class variable can be assigned null.But we cannot assign null to

a struct variable, since structs are value type.

struct AStruct
{
int aField;
}
class AClass
{
int aField;
}
class MainClass
{
public static void Main()
{
AClass b = null; // No error.
AStruct s = null; // Error [ Cannot convert null to 'AStruct'

because it is a value type ].
}
}

2. When you instantiate a class, it will be allocated on the heap.When you

instantiate a struct, it gets created on the stack.

3. You will always be dealing with reference to an object ( instance ) of a class. But

you will not be dealing with references to an instance of a struct ( but dealing directly

with them ).

4. When passing a class to a method, it is passed by reference. When passing a

struct to a method, it's passed by value instead of as a reference.

5. You cannot have instance Field initializers in structs.But classes can have

initializers.

class MyClass
{
int myVar =10; // no syntax error.
public void MyFun( )
{
// statements
}
}
struct MyStruct
{
int myVar = 10; // syntax error.
public void MyFun( )
{
// statements
}
}

6. Classes can have explicit parameterless constructors. But structs cannot have

explicit parameterless constructors.

class MyClass
{
int myVar = 10;
public MyClass( ) // no syntax error.
{
// statements
}
}

struct MyStruct
{
int myVar;
public MyStruct( ) // syntax error.
{
// statements
}

7. Classes must be instantiated using the new operator. But structs can be

instantiated without using the new operator.

MyClass aClassObj; // MyClass aClassObj=new MyClass(); is the correct

format.
aClassObj.myVar=100;//NullReferenceException(because aClassObj does not contain a

reference to an object of type myClass).

MyStruct aStructObj;
aStructObj.myVar=100; // no exception.

face="verdana"size="2">
8. Classes support inheritance.But there is no inheritance for structs.
( structs don't support inheritance polymorphism )

So we cannot have a base structure and a derived structure.

(1)
struct MyStruct
{
int aStructVar;
internal void aStructMethod()
{
// statements
}
}
class MyClass : MyStruct // Syntax error.
{
int aClassVar;
int aClassMethod()
{
// statements
}
}

(2)
class MyClass
{
int aClassVar;
int aClassMethod()
{
// statements
}
}

struct MyStruct : MyClass // Syntax error.
{
int aStructVar;
internal void aStructMethod()
{
// statements
}
}

Note : Like classes, structures can implement interfaces

9. Since struct does not support inheritance, access modifier of a member of a struct cannot be protected or protected internal.

10. It is not mandatory to initialize all Fields inside the constructor of a class.
But all the Fields of a struct must be fully initialized inside the constructor.

class MyClass //No error( No matter whether the Field ' MyClass.myString ' is

initialized or not ).
{
int myInt;
string myString;

public MyClass( int aInt )
{
myInt = aInt;
}
}

struct MyStruct // Error ( Field ' MyStruct.myString ' must be fully assigned

before it leaves the constructor ).
{
int myInt;
string myString;

public MyStruct( int aInt )
{
myInt = aInt;
}
}

11. A class is permitted to declare a destructor.But a struct is not

permitted to declare a destructor.

struct MyStruct
{
int myInt;
public MyStruct( )
{
}
~MyStruct( ) //Error.
{
Console.WriteLine("Destructor of MyStruct object");
}
}

class MyClass
{
int myInt;
public MyClass( )
{
}
~MyClass( ) // No Error.
{
Console.WriteLine("Destructor of MyClass object");
}
}

12. classes are used for complex and large set data. structs are simple to use.

structs are useful whenever you need a type that will be used often and is mostly just a

piece of data.

A Sample Code:

using System;
class MainClass
{

static void Main( )
{
Console.WriteLine( "Struct \n" );
MyStruct var1=new MyStruct( );

var1.Member="Initialized";

// value of var1 is assigned to var2
MyStruct var2=var1;// stmt --> [A]

//var1.str & var2.str are different memory locations in the stack.
Console.WriteLine(var1.Member+"\n"+var2.Member);
Console.WriteLine( "---------------" );

var1.Member="Assigned";
Console.WriteLine( var1.Member+"\n"+var2.Member );

Console.WriteLine( "\nClass\n" );
MyClass obj1=new MyClass( );

obj1.Member="Initialized";

// reference(or simply address)of an object stored in obj1 is assigned to

obj2.
MyClass obj2=obj1;// stmt --> [B]

//obj1 & obj2 are 2 reference variables in the stack.They points to a

single object
//in the heap.So obj1.str & obj2.str represent same memory location in the heap.
Console.WriteLine( obj1.Member+"\n"+obj2.Member );
Console.WriteLine( "---------------" );

obj1.Member="Assigned";
Console.WriteLine( obj1.Member+"\n"+obj2.Member );
}
}

public struct MyStruct
{
string str;
public string Member
{
get
{
return str;
}
set
{
str=value;
}
}
}

public class MyClass
{
string str;
public string Member
{
get
{
return str;
}
set
{
str=value;
}
}
}
Output:
Struct

Initialized
Initailized
---------------
Assigned
Initailized

Class

Initialized
Initailized
---------------
Assigned
Assigned

Summary:

Through this article I tried to enumerate certain differences of Classes and

Structures in C#.

In the Sample Code: I have made an attempt to show the difference in output
when similar statements are executed, first time for a struct( in stmt --> [A] ) and second

time for a
class( in stmt --> [B] ).

If you have any suggestions or found any errors in this article, please mail me.

Question
What is the difference between abstraction and encapsulation?
[edit]
Answer
Abstraction: In bare terms it means “Understanding”. Better understanding of the system leads to good solution.
Data Abstraction: Data Abstraction (In OOP also known as Object Abstraction) purely talks about the understanding of the Developer about the system that is specific to the given DATA.
So there can be Levels of Abstraction to understand the system which differs from developer to developer. Better systems can be developed with higher levels of abstraction.
Difference: Encapsulation is the deliverables of Abstraction. Encapsulation barely talks about grouping up your abstraction to suit the developer needs. Abstraction solves the problem in the design side while encapsulation is the implementation
Property in C# class

Property in C# class

How do you access member variables of any class from outside the class ? In most of the languages including C++ , you will make the member variables public so that you can create an instance of the class and directly access the public fields, as shown below:

public class Car
{
// private fields.
public string color;

// constructor
public Car()
{
}
}

The above class has one public field : color. You may access this field from outside the class as shown below:

Car car = new Car();

car.color = "red";

string color = car.color;

But this is the old way ! This would still work with C#, but the suggested approach is to use "Property" instead of directly accessing member variables.

The following code snippet shows how to create "Property" in a class.

public class Car
{
// private fields.
private string color;

// constructor
public Car()
{
}

public string Color
{
get
{
return color; // return the value from privte field.
}
set
{
color = value; // save value into private field.
}
}
}

The above class has one private field - color. Then we have one "Property" called 'Color', which is used to represent the private field. Note that the field is private and the Property is public. (We have used the same name with upper/lower case to represent the 'Property' and 'field', but you may give any name you want.)

Each property has two parts :
· get
· set

The get part is executed when you access the value of the Property as shown below:

Car car = new Car();

string color = car.Color;

When executed, the above get accessor will return the value stored in the field 'color'.
The set part is executed when you assign a value to the Property as shown below:

Car car = new Car();

car.Color = "RED";

When executed, the above set accessor will assign the value "RED" to the private field 'color'. (Note that'value' is a keyword, which will have the value assigned to it.)
So, what is the difference ?

On the first look, there is no difference! You can achieve the same behaviour by writing 2 different methods ( like SetColor(...), GetColor() ).
First advantage of using property is, code looks cleaner than having 2 separate methods. You can simply call a property as if it was a field in the class Well, then you may ask why make it 2 methods, we can make it a public field, so that we can access it by creating an instance of the class.
The main advantage over using a Property instead of a public field is, with the property, you will get a chance to write few lines of code (if you want) in the get and set accessors. So, you can perform some validation or any other logic before returning any values or assigning to the private field.

See the modifed class below:

public class Car
{
// private fields.
private string color;

// constructor
public Car()
{
}

public string Color
{
get
{
if ( color == "" )
return "GREEN";
else
return color;
}
set
{
if ( value == "" )
thrown new Exception ("Wrong value.");
else
color = value;
}
}
}

Let us analyze the get part first. Here we are checking whether there is a valid value in the field 'color' before we return the value. If it is empty, we are getting a chance to return a default value 'Green'. This way, we can make sure that whoever calls the property 'Color' will always get a valid color, never an empty string.

In the set part, we are doing a validation to make sure we always assign a a valid value to our field. If someone assign an empty string to the 'Color' property, he will get an exception (error).

Car car = new Car();

car.Color = "";

The above code will throw an error because we are trying to assign an empty string and the set accessor will throw an error if it an empty string. This way, we can make sure that we allow only valid values to be assigned.
So, i guess now you would appreciate the purpose of "Property". So, no more public fields! Always have private fields and write public properties as wrapper for them if required to expose them to outside the class.
Re: What are the access-specifiers available in c#? Answer
# 1
The access-specifiers available in C# are:

1. public - The member can be accessed from anywhere
2. internal - The member can only be accessed from type it
originates from or other types in the same assembly
3. protected - The member can only be accessed from the type
it originates from or from detrieved types of the
originating type
4. protected internal - implies protected OR internal ( not
protected AND internal )
5. private - The member is only accessible by other members
within the type it originates from.

What is GAC?
A shared assembly has version constraints. It is stored in the Global Assembly Cache (GAC). GAC is a repository of shared assemblies maintained by the .NET runtime. The shared assemblies may be used by many applications. To make an assembly a shared assembly, it has to be strongly named.

To know more on how to share an assembly, create a strongly named assembly Click Here

GAC is located at C:\Windows\Assembly OR C:\Winnt\Assembly

How to share an assembly? How to make it strongly named? What is SN.EXE?
In order to share an assembly with many applications, it must have a strong name.

In order to convert a private assembly to a shared assembly, i.e. to create a strongly named assembly, follow the steps below...
1) Create a strong key using the sn.exe tool. This is used to created a cryptographic key pair. The key pair that is generated by the Strong Name tool can be kept in a file or we can store it our your local machine's Crytographic Service Provider (CSP). For this, goto the .NET command interpreter, and type the following...

sn -k C:\samplekey.snk

This will create a strong key and save it to the location C:\samplekey.snk

2) If the key is stored in a file, just like we have done above, we use the attribute AssemblyKeyFileAttribute. This belongs to the namespace System.Reflection.AssemblyKeyFileAttribute.

If the key was in the CSP, we would make use of System.Reflection.AssemblyKeyNameAttribute.

Go to the assemblyinfo.vb file of your project. Open this file. Make the following changes in this file...

We may write this in our code as well, like this...

Imports System.Reflection

Namespace StrongName
Public class Sample
End Class
End Namespace

3) Build your project. Your assembly is now strongly named.

Installing the Shared assembly in GAC...
Go to .NET command interpreter, use the tool gacutil.exe
Type the following...
gacutil /i sampleclass.dll To uninstall it, use... gacutil /u sampleclass.dll Visual Studio.NET provides a GUI tool for viewing all shared assemblies in the GAC.

Folder of GAC: C:\Windows\Assembly OR C:\Winnt\Assembly

what is the difference between dataset and datareader?
DataReader:
DataReader is purely connection oriented. It will make use connection exclusively. When we close the DataReader then the connection will be released so that it can be used for other purpose.
When the application requires only reading data only once then we have to choose DataReader. DataReader will consume only one record memory space in the client application process.

Dataset:
It can be defined as a "In memory database for the client application. This will maintain collection of tables called as data tables.
Dataset is purely disconnected

Dataset acts as an in memory database.
It's connection less.
Can edit ,apply relations using dataset Data reader has no such facility
DataReader is Connection Oriented
Readonly farword only

Data Reader:-
Data Reader is a read only and forward only data
You can access one table at a time.
Data reader cant persist the data.
Data Reader is connected architecture.
Data Reader is faster than Data Adapter
Data Reader is faster than dataset operation
Data Set:
Data Set is disconnected architecture.
Data Set is persist the data.
You can access more than one table
Data Set is main for storage tool in ADO.Net

Hi,

Difference between them are as follows:

1>Dataset works on disconnected architecture whereas datareader works on connected architecture.

2>Dataset is scrollable whereas datareader is forward only record set.

3>We can create relations in dataset whereas we can't create relation in datareader.

4>Dataset supports integeration with XML whereas Datareader doesn't support.

5>Dataset communicates with the dataadapter only whereas datareader communicates with the command object.

Thanks and Regards
S.S.Bajoria
DateReader is an forward only and read only cursor type if you are accessing data through DataRead it shows the data on the web form/control but you can not perform the paging feature on that record(because it's forward only type). Reader is best fit to show the Data (where no need to work on data)
DataAdapter is not only connect with the Databse(through Command object) it provide four types of command (InsertCommand, UpdateCommand, DeleteCommand, SelectCommand), It supports to the disconnected Architecture of .NET show we can populate the records to the DataSet. where as Dataadapter is best fit to work on data.
·
· AdSense Revenue

Gifts

Active Members
Today
· ANIL PANDEY (190)
· Pradeep Kintal... (144)
· abhay (81)
Last 7 Days
· Satyanarayan Su... (1086)
· ANIL PANDEY (1031)
· Ravi Kiran ... (531)
more...

differences b/w connected and disconnected archetecture
Following are some major differences between both
v As in classic ADO we had client and server side cursors they are no more
present in ADO.NET. Note it's a disconnected model so they are no more
applicable.
v Locking is not supported due to disconnected model.
v All data persist in XML as compared to classic ADO where data
persisted in Binary format also.
Read Foll very carefully

DATA Reader
The DataReader has a defined set of operations that revolve
around its connected, forward-only, read-only nature (the
read-only DataReader is also known as the firehose cursor of
ADO.NET). A DataReader is a stream of data that is returned
from a database query. When the query is executed, the first
row is returned to the DataReader via the stream. The stream
then remains connected to the database, poised to retrieve
the next record. The DataReader reads one row at a time from
the database and can only move forward, one record at a
time. As the DataReader reads the rows from the database,
the values of the columns in each row can be read and
evaluated, but they cannot be edited.

DATA Adapter
The DataSet is the main data storage tool in the ADO.NET
disconnected architecture. Unlike the DataReader, the
DataSet is not connected directly to a database through a
Connection object when you populate it. Instead, to fill a
DataSet from a database you first create a DataAdapter
object (such as a SqlDataAdapter) for the provider and
associate it with a SqlConnection object. Then the
SqlDataAdapter can broker the data retrieval for the DataSet
by issuing a SqlCommand against the database through the
SqlConnection, retrieving the data, and filling the DataSet.

You can think of the SqlDataAdapter as a bridge between the
connected and disconnected objects. One of its purposes is
to serve as the route for a rowset to get from the database
to the DataSet. For example, when the SqlDataAdapter's Fill
method is executed it opens its associated SqlConnection
object (if not already open) and issues its associated
SqlCommand object against the SqlConnection. Behind the
scenes, a SqlDataReader is created implicitly and the rowset
is retrieved one row at a time in succession and sent to the
DataSet. Once all of the data is in the DataSet, the
implicit SqlDataReader is destroyed and the SqlConnection is
closed.
when we discus on connected and disconnect architecture
then two term open one os dataset and another is datareader

A DataReader is a read-only stream of data returned from the database as the query executes. It only contains one row of data in memory at a time and is restricted to navigating forward only in the results one record at a time. The DataReader does support access to multiple result sets, but only one at a time and in the order retrieved. Just as in the original version of ADO, the data is no longer available through the DataReader once the connection to the data source is closed, which means a DataReader requires a connection to the database throughout its usage. Output parameters or return values are only available through the DataReader once the connection is closed.

DataSet is the core of the ADO.NET disconnected architecture and is used to store data in a disconnected state.
NFS
Normalization:
In relational database design, the process of organizing data to minimize redundancy. Normalization usually involves dividing a database into two or more tables and defining relationships between the tables. The objective is to isolate data so that additions, deletions, and modifications of a field can be made in just one table and then propagated through the rest of the database via the defined relationships.

There are three main normal forms, each with increasing levels of normalization:

First Normal Form (1NF): Each field in a table contains different information. For example, in an employee list, each table would contain only one birthdate field.
Second Normal Form (2NF): Each field in a table that is not a determiner of the contents of another field must itself be a function of the other fields in the table.
Third Normal Form (3NF): No duplicate information is permitted. So, for example, if two tables both require a birthdate field, the birthdate information would be separated into a separate table, and the two other tables would then access the birthdate information via an index field in the birthdate table. Any change to a birthdate would automatically be reflect in all tables that link to the birthdate table.
There are additional normalization levels, such as Boyce Codd Normal Form (BCNF), fourth normal form (4NF) and fifth normal form (5NF). While normalization makes databases more efficient to maintain, they can also make them more complex because data is separated into so many different tables.
There are 5 normal forms.

It is necessary for any database to be in the third normal form to maintain referential integrity and non-redundance.

First Normal Form: Every field of a table (row,col) must contain an atomic value

Second Normal Form: All columns of a table must depend entirely on the primary key column.

Third Normal Form: All columns of a table must depend on all columns of a composite primary key.

Fourth Normal Form: A table must not contain two or more independent multi-valued facts. This normal form is often avoided for maintenance reasons.

Fifth Normal Form: is about symmetric dependencies.
Each normal form assumes that the table is already in the earlier normal form.
NORMALIZATION is a body of rules addressing analysis and conversion of data structures into relations that exhibit more desirable properties of internal consistency,minimal redundancy and maximum stability.

What is the difference between abstract class and interface?
If a class is to serve the purpose of providing common fields and members to all subclasses, we create an Abstract class. For creating an abstract class, we make use of the abstract keyword. Such a class cannot be instantiated. Syntax below:
abstract public class Vehicle { }
Above, an abstract class named Vehicle has been defined. We may use the fields, properties and member functions defined within this abstract class to create child classes like Car, Truck, Bike etc. that inherit the features defined within the abstract class. To prevent directly creating an instance of the class Vehicle, we make use of the abstract keyword. To use the definitions defined in the abstract class, the child class inherits from the abstract class, and then instances of the Child class may be easily created.
Further, we may define abstract methods within an abstract class (analogous to C++ pure virtual functions) when we wish to define a method that does not have any default implementation. Its then in the hands of the descendant class to provide the details of the method. There may be any number of abstract methods in an abstract class. We define an abstract method using the abstract keyword. If we do not use the abstract keyword, and use the virtual keyword instead, we may provide an implementation of the method that can be used by the child class, but this is not an abstract method.
Remember, abstract class can have an abstract method, that does not have any implementation, for which we use the abstract keyword, OR the abstract class may have a virtual method, that can have an implementation, and can be overriden in the child class as well, using the override keyword. Read example below
Example: Abstract Class with Abstract method
namespace Automobiles
{
public abstract class Vehicle
{
public abstract void Speed() //No Implementation here, only definition
}
}

Example: Abstract Class with Virtual method
namespace Automobiles
{
public abstract class Vehicle
{
public virtual void Speed() //Can have an implementation, that may be overriden in child class
{
...
}
}

Public class Car : Vehicle
{
Public override void Speed()
//Here, we override whatever implementation is there in the abstract class
{
... //Child class implementation of the method Speed()
}
}
}

An Interface is a collection of semantically related abstract members. An interface expresses through the members it defines, the behaviors that a class needs to support. An interface is defined using the keyword interface. The members defined in an interface contain only definition, no implementation. The members of an interface are all public by default, any other access specifier cannot be used. See code below:
Public interface IVehicle //As a convention, an interface is prefixed by letter I
{
Boolean HasFourWheels()
}
Time to discuss the Difference between Abstract Class and Interface

1) A class may inherit only one abstract class, but may implement multiple number of Interfaces. Say a class named Car needs to inherit some basic features of a vehicle, it may inherit from an Aabstract class named Vehicle. A car may be of any kind, it may be a vintage car, a sedan, a coupe, or a racing car. For these kind of requirements, say a car needs to have only two seats (means it is a coupe), then the class Car needs to implement a member field from an interface, that we make, say ICoupe.
2) Members of an abstract class may have any access modifier, but members of an interface are public by default, and cant have any other access modifier.
3) Abstract class methods may OR may not have an implementation, while methods in an Interface only have a definition, no implementation.
Basic ADO.NET objects

Figure 2-1. How ADO.NET works
Description
· ADO.NET uses two types of objects to access the data in a database: datasets, which can contain one or more data tables, and .NET data provider objects, which include data adapters, commands, and connections.
· A dataset stores data from the database so that it can be accessed by the application. The .NET data provider objects retrieve data from and update data in the database.
· To retrieve data from a database and store it in a data table, a data adapter object issues a Select statement that’s stored in a command object. Next, the command object uses a connection object to connect to the database and retrieve the data. Then, the data is passed back to the data adapter, which stores the data in the dataset.
· To update the data in a database based on the data in a data table, the data adapter object issues an Insert, Update, or Delete statement that’s stored in a command object. Then, the command object uses a connection to connect to the database and update the data.
· The data provider remains connected to the database only long enough to retrieve or update the specified data. Then, it disconnects from the database and the application works with the data via the dataset object. This is referred to as a disconnected data architecture.
· All of the ADO.NET objects are implemented by classes in the System.Data namespace of the .NET Framework. However, the specific classes used to implement the connection, command, and data adapter objects depend on the .NET data provider you use.

Common Language Runtime (CLR)

The .NET Framework provides a Runtime environment called the Common Language Runtime or (CLR) that handles the execution of the code and provides useful services for the implementation of the application. CLR takes care of code management upon program execution and provides various services such as memory management, thread management, security management and other system services. The managed code targets CLR benefits by using useful features such as cross-language integration, cross-language exception handling, versioning, enhanced security, deployment support, and debugging. It is a framework layer that resides above the Operating System. .Net programs don’t directly communicate with the Operating System but through CLR.

Common Language Specification (CLS)

Earlier we used the term ‘.NET Compliant Language’ and stated that all the .NET compliant languages can make use of CLR and FCL. But what makes a language ‘.NET compliant language’? The answer is Common Language Specification (CLS). Microsoft has released a small set of specification that each language should meet to qualify as a .NET Compliant Language. As IL is a very rich language, it is not necessary for a language to implement all the IL functionality, rather it meets the small subset of it, CLS, to qualify as a .NET compliant language, which is the reason why so many languages (procedural and OO) are now running under .Net umbrella. CLS basically addresses to language design issues and lays certain standards like there should be no global function declaration, no pointers, no multiple inheritance and things like that. The important point to note here is that if you keep your code within CLS boundary, your code is guaranteed to be usable in any other .Net language.

Common Type System (CTS)

.NET also defines a Common Type System (CTS). Like CLS, CTS is also a set of standards. CTS defines the basic data types that IL understands. Each .NET compliant language should map its data types to these standard data types. This makes it possible for the 2 languages to communicate with each other by passing/receiving parameters to/from each other. For example, CTS defines a type Int32, an integral data type of 32 bits (4 bytes) which is mapped by C# through int and VB.Net through its Integer data type.

Hope it helps.
Biography
Asp.Net Developer

name1

2008-09-26T06:30:00.000-07:00

What is an abstract class, and when should it be used?

Abstract classes are classes that contain one or more abstract methods. An abstract method is a method that is declared, but contains no implementation.

Abstract classes may not be instantiated, and require subclasses to provide implementations for the abstract methods.

Let's look at an example of an abstract class, and an abstract method.

Suppose we were modeling the behavior of animals, by creating a class hierachy that started with a base class called Animal. Animals are capable of

doing different things like flying, digging and walking, but there are some common operations as well like eating and sleeping. Some common operations

are performed by all animals, but in a different way as well. When an operation is performed in a different way, it is a good candidate for an abstract

method (forcing subclasses to provide a custom implementation). Let's look at a very primitive Animal base class, which defines an abstract method for

making a sound (such as a dog barking, a cow mooing, or a pig oinking).

public abstract Animal

{

public void eat(Food food)

{

// do something with food....

}

public void sleep(int hours)

{

try

{

// 1000 milliseconds * 60 seconds * 60 minutes * hours

Thread.sleep ( 1000 * 60 * 60 * hours);

}

catch (InterruptedException ie) { /* ignore */ }

}

public abstract void makeNoise();

}

Note that the abstract keyword is used to denote both an abstract method, and an abstract class. Now, any animal that wants to be instantiated (like a dog

or cow) must implement the makeNoise method - otherwise it is impossible to create an instance of that class. Let's look at a Dog and Cow subclass that

extends the Animal class.

public Dog extends Animal

{

public void makeNoise() { System.out.println ("Bark! Bark!"); }

}

public Cow extends Animal

{

public void makeNoise() { System.out.println ("Moo! Moo!"); }

}

Now you may be wondering why not declare an abstract class as an interface, and have the Dog and Cow implement the interface.

Sure you could - but you'd also need to implement the eat and sleep methods.

By using abstract classes, you can inherit the implementation of other (non-abstract) methods.

You can't do that with interfaces - an interface cannot provide any method implementations.

Boxing and Unboxing in C# .Net

Introduction

In this article I will explain the concepts of Boxing and UnBoxing. C# provides us with Value types and Reference Types. Value Types are stored on the stack

and Reference types are stored on the heap. The conversion of value type to reference type is known as boxing and converting reference type back to the

value type is known as unboxing.

Let me explain you little more about Value and Reference Types.

Value Types

Value types are primitive types that are mapped directly to the FCL. Like Int32 maps to System.Int32, double maps to System.double. All value types are

stored on stack and all the value types are derived from System.ValueType. All structures and enumerated types that are derived from System.ValueType

are created on stack, hence known as ValueType.

Reference Types

Reference Types are different from value types in such a way that memory is allocated to them from the heap. All the classes are of reference type.

C# new operator returns the memory address of the object.

Examples

Lets see some examples to have a better understanding of Value Types and Reference Types. Since we know that all ValueTypes are derived from

System.Value we can write something like this:

System.ValueType r = 5;

So what do you think about the above line of code. Will it compile ? Yes it will compile. But wait what type is it cause I don't remember any type

which is called System.ValueType since its a base class from which all value types inherit. So is it Int32, Int64,double, decimal etc. It turns out that

the type for variable 'r' is System.Int32. The Question arrises why Int32 and why not Int16. Well its because it is mapped to Int32 by default depending

upon the Initial value of the variable.

You cannot write something like this since System.ValueType is not a primitive type its a base class for primitive value types and these mathematical

operations can be performed on primitive types.

System.ValueType r = 10;

r++;

In the above example I told you that variable 'r' will be a System.Int32 variable but if you don't believe me than you can find out yourself using the

GetType() method:

System.ValueType r = 5;

Console.WriteLine(r.GetType()) // returns System.Int32;

Here are few samples you can try on your own:

System.ValueType r = 23.45;

Console.WriteLine(r.GetType()); // what does this print

//-------------------------------------------------------

System.ValueType r = 23.45F;

Console.WriteLine(r.GetType()); // What does this print

//-------------------------------------------------------

System.ValueType r = 2U;

Console.WriteLine(r.GetType()); // What does this print

//-------------------------------------------------------

System.ValueType r = 'c';

Console.WriteLine(r.GetType()); // What does this print

//-------------------------------------------------------

System.ValueType r = 'ac';

Console.WriteLine(r.GetType()); // tricky

//-------------------------------------------------------

System.ValueType r = "Hello World";

Console.WriteLine(r.GetType()); // tricky

Boxing

Lets now jump to Boxing. Sometimes we need to convert ValueTypes to Reference Types also known as boxing. Lets see a small example below.

You see in the example I wrote "implicit boxing" which means you don't need to tell the compiler that you are boxing Int32 to object because it takes

care of this itself although you can always make explicit boxing as seen below right after implicit boxing.

Int32 x = 10;

object o = x ; // Implicit boxing

Console.WriteLine("The Object o = {0}",o); // prints out 10

//-----------------------------------------------------------

Int32 x = 10;

object o = (object) x; // Explicit Boxing

Console.WriteLine("The object o = {0}",o); // prints out 10

Unboxing

Lets now see UnBoxing an object type back to value type. Here is a simple code that unbox an object back to Int32 variable. First we need to box it so

that we can unbox.

Int32 x = 5;

object o = x; // Implicit Boxing

x = o; // Implicit UnBoxing

So, you see how easy it is to box and how easy it is to unbox. The above example first boxs Int32 variable to an object type and than simply unbox

it to x again. All the conversions are taking place implicitly. Everything seems right in this example there is just one small problem which is that the

above code is will not compile. You cannot Implicitly convert a reference type to a value type. You must explicitly specify that you are unboxing as

shown in the code below.

Int32 x = 5;

object o = x; // Implicit Boxing

x = (Int32)o; // Explicit UnBoxing

Lets see another small example of unboxing.

Int32 x = 5; // declaring Int32

Int64 y = 0; // declaring Int64 double

object o = x; // Implicit Boxing

y = (Int64)o; // Explicit boxing to double

Console.WriteLine("y={0}",y);

This example will not work. It will compile successfully but at runtime It will generate an exception of System.InvalidCastException. The reason is

variable x is boxed as Int32 variable so it must be unboxed to Int32 variable. So, the type the variable uses to box will remain the same when unboxing

the same variable. Of course you can cast it to Int64 after unboxing it as Int32 as follows:

Int32 x = 5; // declaring Int32

Int64 y = 0; // declaring Int64 double

object o = x; // Implicit Boxing

y = (Int64)(Int32)o; // Unboxing and than casting to double

Console.WriteLine("y={0}",y);

I am sure that you all have grasp the basic understanding of Boxing and Unboxing. Happy Coding and practice a lot !

webFarm Vs webGardens

A web farm is a multi-server scenario. So we may have a server in each state of US. If the load on one server is in excess then the other servers step in

to bear the brunt.

How they bear it is based on various models.

1. RoundRobin. (All servers share load equally)

2. NLB (economical)

3. HLB (expensive but can scale up to 8192 servers)

4. Hybrid (of 2 and 3).

5. CLB (Component load balancer).

A web garden is a multi-processor setup. i.e., a single server (not like the multi server above).

How to implement webfarms in .Net:

Go to web.config and Here for mode = you have 4 options.

a) Say mode=inproc (non web farm but fast when you have very few customers).

b) Say mode=StateServer (for webfarm)

c) Say mode=SqlServer (for webfarm)

Whether to use option b or c depends on situation. StateServer is faster but SqlServer is more reliable and used for mission critical applications.

How to use webgardens in .Net:

Go to web.config and Change the false to true. You have one more attribute that is related to webgarden in the same tag called cpuMask.

OOP & C#

The skeleton of object - oriented programming is of course the concepts of class. This C# tutorial on OOPS explains classes and their importance in

implementation of object ? oriented principles.

Any language can be called object ? oriented if it has data and method that use data encapsulated in items named objects. An object ? oriented

programming method has many advantages, some of them are flexibility and code reusability.

All the programming languages supporting Object oriented Programming will be supporting these three main concepts:

1. Encapsulation

2. Inheritance

3. Polymorphism

Encapsulation in C#:

Encapsulation is process of keeping data and methods together inside objects. In this way developer must define some methods of object?s interaction.

In C# , encapsulation is realized through the classes. A Class can contain data structures and methods. Consider the following class.

public class Aperture

{

public Aperture()

{

}

protected double height;

protected double width;

protected double thickness;

public double GetVolume()

{

double volume = height*width*thickness;

if(volume<0)

return 0;

return volume;

}

In this example we encapsulate some data such as height, width, thickness and method GetVolume. Other methods or objects can interact with this

object through methods that have public access modifier. It must be done using ?.? operator.

Inheritance in C#:

In a few words, Inheritance is the process of creation new classes from already existing classes. The inheritance feature allows us to reuse some

parts of code. So, now we have some derived class that inherits base class?s members. Consider the following code snippet:

public class Door : Aperture

{

public Door() : base()

{

}

public bool isOutside = true;

}

As you see to inherit one class from another, we need to write base class name after ?:? symbol. Next thing that was done in code Door () ?

constructor also inherits base class constructor. And at last we add new private field. All members of Aperture class are also in Door class. We

can inherit all the members that has access modifier higher than protected.

Polymorphism in C#:

Polymorphism is possibility to change behavior with objects depending of object?s data type. In C# polymorphism realizes through the using

of keyword virtual and override. Let look on the example of code:

public virtual void Out()

{

Console.WriteLine("Aperture virtual method called");

}

//This method is defined in Aperture class.

public override void Out()

{

Console.WriteLine("Door virtual method called");

}

Now we need to re-define it in our derived Door class. The usage of virtual methods can be clarified when we creating an instance of derived

class from the base class:

Aperture ap = new Door();

ap.Out();

In such cases, the runtime keeps record of all the virtual function details in a table called VMT(Virtual Method Table) and then in runtime

dynamically picks the correct version of the function to be used. Here it uses Out() method from derived class of course.

To compile the attached example you need to run .NET console and run the next command: csc filename.cs .

ASP.NET Web Parts Overview

ASP.NET Web Parts is an integrated set of controls for creating Web sites that enable end users

to modify the content, appearance, and behavior of Web pages directly from a browser.

System.Collections namespace; these classes are used to hold collections of values or objects in memory and are commonly known as arrays.

The three commonly used collection classes are

ArrayList,

Hashtable and

SortedList

Create an ArrayList

The ArrayList object is a collection of items containing a single data value.

Items are added to the ArrayList with the Add() method.

The following code creates a new ArrayList object named mycountries and four items are added:

AutoPostBack="True" onSelectedIndexChanged="displayMessage" />

The Hashtable object contains items in key/value pairs. The keys are used as indexes, and very quick searches can be made for values by searching

through their keys.

Items are added to the Hashtable with the Add() method.

EXAMPLE:

AutoPostBack="True" onSelectedIndexChanged="displayMessage" />

The SortedList object contains items in key/value pairs. A SortedList object automatically sort the items in alphabetic or numeric order.

Items are added to the SortedList with the Add() method. A SortedList can be sized to its final size with the TrimToSize() method.

The following code creates a SortedList named mycountries and four elements are added:

AutoPostBack="True" onSelectedIndexChanged="displayMessage" />

Maintaining the ViewState

When a form is submitted in classic ASP, all form values are cleared. Suppose you have submitted a form with a lot of information and the server

comes back with an error. You will have to go back to the form and correct the information. You click the back button, and what happens.......

ALL form values are CLEARED, and you will have to start all over again! The site did not maintain your ViewState.

When a form is submitted in ASP .NET, the form reappears in the browser window together with all form values. How come? This is because ASP .NET

maintains your ViewState. The ViewState indicates the status of the page when submitted to the server. The status is defined through a hidden field

placed on each page with a

value="dDwtNTI0ODU5MDE1Ozs+ZBCF2ryjMpeVgUrY2eTj79HNl4Q=" />.....some code

Validation Server Controls

A Validation server control is used to validate the data of an input control. If the data does not pass validation, it will display an error message to the user.

Validation Server Control Description

CompareValidator Compares the value of one input control to the value of another input control or to a fixed value

CustomValidator Allows you to write a method to handle the validation of the value entered

RangeValidator Checks that the user enters a value that falls between two values

RegularExpressionValidator Ensures that the value of an input control matches a specified pattern

RequiredFieldValidator Makes an input control a required field

ValidationSummary Displays a report of all validation errors occurred in a Web page

AJAX = Asynchronous JavaScript and XML

AJAX is not a new programming language, but a technique for creating better, faster, and more interactive web applications.

With AJAX, your JavaScript can communicate directly with the server, using the JavaScript XMLHttpRequest object. With this object, your JavaScript can

trade data with a web server, without reloading the page.

AJAX uses asynchronous data transfer (HTTP requests) between the browser and the web server, allowing web pages to request small bits of information

from the server instead of whole pages.

The AJAX technique makes Internet applications smaller, faster and more user-friendly.

AJAX is a browser technology independent of web server software.

AJAX Uses HTTP Requests

In traditional JavaScript coding, if you want to get any information from a database or a file on the server, or send user

information to a server, you will have to make an HTML form and GET or POST data to the server. The user will have to click the "Submit" button to

send/get the information, wait for the server to respond, then a new page will load with the results.

Because the server returns a new page each time the user submits input, traditional web applications can run slowly and tend to be less user-friendly.

With AJAX, your JavaScript communicates directly with the server, through the JavaScript XMLHttpRequest object

With an HTTP request, a web page can make a request to, and get a response from a web server - without reloading the page. The user will stay on the

same page, and he or she will not notice that scripts request pages, or send data to a server in the background.

What is Difference Between Interface and abstract Class

Interface :

1.Interface have only Signature.

2.All the Methods are Public , It doesn't have access Modifier Controls

3.It have used Multiple inheritence in the Object oriented Language

4.All the Methods are Abstract.

5.It does not have Contructor,destructor,Fileds

6.A Class May inherits several Interfaces

Abstract Class:

1.Abstract Class have Method defination and Implementation

2.It have control the Access Modifiers

3.It does not allow multiple Inheritence

4.Some methods are concrete

5. It have Contructor and destructor

6.Only one abstract have to derived

What is the difference between a DLL and an EXE?

In .NET, an assembly may become a DLL or an EXE. Yet, there is a major underlying difference

between the two.

An EXE is an executable file, that may run on its own. Its independant. Where as a DLL is a

Dynamic Link Library, that binds to an exe, or another DLL at runtime.

A DLL has an exposed interface, through which members of the assembly may be accessed

by those objects that require it.

A DLL runs in tandem with the application space in memory, as the application references it.

Whereas an EXE is independant, and runs as an independant process.

Structures and Enumerations are Value-Types. This means, the data that they contain is stored

as a stack on the memory. Classes are Reference-Types, means they are stored as a heap on

the memory.

Structures are implicitly derived from a class called System.ValueType.

The purpose of System.ValueType is to override the virtual methods defined by

System.Object. So when the runtime encounters a type derived from System.ValueType,

then stack allocation is achieved. When we allocate a structure type, we may also use the

new keyword. We may even make a constructor of a structure, but, remember,

A No-argument constructor for a structure is not possible. The structure's constructor should

always have a parameter.

What is the difference between String and StringBuilder?

Both String and StringBuilder are classes used to handle strings.

The most common operation with a string is concatenation. This activity has to be performed

very efficiently. When we use the "String" object to concatenate two strings, the first string is

combined to the other string by creating a new copy in the memory as a string object, and

then the old string is deleted. This process is a little long. Hence we say "Strings are immutable".

When we make use of the "StringBuilder" object, the Append method is used. This means,

an insertion is done on the existing string. Operation on StringBuilder object is faster than

String operations, as the copy is done to the same location. Usage of StringBuilder is more

efficient in case large amounts of string manipulations have to be performed.

What is the difference between Server.Transfer and Response.Redirect?

Both "Server" and "Response" are objects of ASP.NET. Server.Transfer and Response.Redirect both are used to transfer a user from one page to another. But there is an underlying difference.

//Usage of Server.Transfer & Response.Redirect

Server.Transfer("Page2.aspx");

Response.Redirect("Page2.aspx");

The Response.Redirect statement sends a command back to the browser to request the next

page from the server. This extra round-trip is often inefficient and unnecessary, but this

established standard works very well. By the time Page2 is requested, Page1 has been

flushed from the server’s memory and no information can be retrieved about it unless the

developer explicitly saved the information using some technique like session, cookie,

application, cache etc.

The more efficient Server.Transfer method simply renders the next page to the browser

without an extra round trip. Variables can stay in scope and Page2 can read properties

directly from Page1 because it’s still in memory. This technique would be ideal if it wasn’t

for the fact that the browser is never notified that the page has changed. Therefore, the

address bar in the browser will still show “Page1.aspx” even though the Server.Transfer

statement actually caused Page2.aspx to be rendered instead. This may occasionally be

a good thing from a security perspective, it often causes problems related to the browser

being out of touch with the server. Say, the user reloads the page, the browser will request

Page1.aspx instead of the true page (Page2.aspx) that they were viewing. In most cases,

Response.Redirect and Server.Transfer can be used interchangeably. But in some cases,

efficiency or usability may be the deciding factor in choosing.

Static Classes and Static Class Members (C# Programming Guide)

Static classes and class members are used to create data and functions that can be accessed

without creating an instance of the class. Static class members can be used to separate data

and behavior that is independent of any object identity: the data and functions do not change

regardless of what happens to the object. Static classes can be used when there is no data or

behavior in the class that depends on object identity.

The main features of a static class are:

They only contain static members.

They cannot be instantiated.

They are sealed.

They cannot contain Instance Constructors (C# Programming Guide).

Static Members

A static method, field, property, or event is callable on a class even when no instance of the

class has been created. If any instances of the class are created, they cannot be used to access

the static member. Only one copy of static fields and events exists, and static methods and

properties can only access static fields and static events. Static members are often used to

represent data or calculations that do not change in response to object state; for instance,

a math library might contain static methods for calculating sine and cosine.

Static class members are declared using the static keyword before the return type of the

member

What is the difference between ExecuteScalar and ExecuteNonQuery? What is ExecuteReader?

ExecuteScalar - Returns only one value after execution of the query. It returns the first field in

the first row. This is very light-weight and is perfect when all your query asks for is one item.

This would be excellent for receiving a count of records (Select Count(*)) in an sql statement,

or for any query where only one specific field in one column is required.

ExecuteNonQuery - This method returns no data at all. It is used majorly with Inserts and

Updates of tables. It is used for execution of DML commands.

Example:

SqlCommand cmd = new SqlCommand("Insert Into t_SomeTable Values('1','2')",con);

//note that con is the connection object

con.Open();

cmd.ExecuteNonQuery(); //The SQL Insert Statement gets executed

ExecuteReader - This method returns a DataReader which is filled with the data that is retrieved

using the command object. This is known as a forward-only retrieval of records. It uses our SQL

statement to read through the table from the first to the last record.

What is the difference between a DataReader and Dataset in ADO.NET?

A DataReader works in a connected environment, whereas DataSet works in a disconnected environment.

A DataReader object represents a forward only, read only access to data from a source.

It implements IDataReader & IDataRecord interfaces. For example, The SQLDataReader

class can read rows from tables in a SQL Server data source. It is returned by the

ExecuteReader method of the SQLCommand class, typically as a result of a SQL Select

statement. The DataReader class' HasRows property can be called to determine whether the

DataReader retrieved any rows from the source. This can be used before using the Read method to check whether any data has been retrieved.

Example

Dim objCmd as New SqlCommand("Select * from t_Employees", objCon)

objCon.Open()

Dim objReader as SqlDataReader

objReader = objCom.ExecuteReader(CommandBehavior.CloseConnection)

If objReader.HasRows = True then

Do While objReader.Read()

ListBox1.Items.Add(objReader.GetString(0) & vbTab & objReader.GetInt16(1))

Loop

End If

objReader.Close()

(NOTE: XmlReader object is used for Forward only Read only access of XML).

A DataSet represents an in-memory cache of data consisting of any number of inter-related

DataTable objects. A DataTable object represents a tabular block of in-memory data. Further,

a DataRow represents a single row of a DataTable object. A Dataset is like a mini-database

engine, but its data is stored in the memory. To query the data in a DataSet, we can use a

DataView object.

Example

Dim objCon as SqlConnection =

New SqlConnection("server=(local);database=NameOfYourDb;user id=sa; password=;)

Dim da as New SqlDataAdapter

Dim ds as DataSet = New DataSet

da.SelectCommand.Connection = objCon 'The Data Adapter manages on its own,

opening & closing of connection object

da.SelectCommand.CommandText = "Select * from t_SomeTable"

da.Fill(ds,"YourTableName")

Suppose you want to bind the data in this dataset to a gridview

Gridview1.DataSource = ds

Gridview1.DataMember = "YourTableName"

Gridview1.Databind()

What is a property? What is an event?

Property - A property is a thing that describes the features of an object. A property is a piece of

data contained within a class that has an exposed interface for reading/writing. Looking at this

definition, we might think we could declare a public variable in a class and call it a property.

While this assumption is somewhat valid, the real technical term for a public variable in a class

is a field. The main difference between a field and a property is in the inclusion of an interface.

We make use of Get and Set keywords while working with properties. We prefix the variables

used within this code block with an underscore. Value is a keyword, that holds the value which

is being retrieved or set.ss="a">

Private _Color As String

Public Property Color()

Get

Return _Color

End Get

Set(ByVal Value)

_Color = Value

End Set

End Property

Event - An action that an object does. When something happens, we say an event has happened

. For example, when a button is clicked, we say it is the click( ) event. When a mouse hovers on

an image, we say the mouseover( ) event has taken place.

What is Serialization? What is serializable attribute used for?

Serialization - The process of converting an object into a stream of bytes. This stream of bytes can be persisted. Deserialization is an opposite process,

which involves converting a stream of bytes into an object. Serialization is used usually during remoting (while transporting objects) and to persist file

objecst & database objects.

.NET provides 2 ways for serializtion 1) XmlSerializer and 2) BinaryFormatter/SoapFormatter

The XmlSerializer is used for Web Services. The BinaryFormatter & SoapFormatter is used for Remoting. While using XmlSerializer, it is required that the

target class has parameter less constructors, has public read-write properties and has fields that can be serialized. The XmlSerializer has good support for

XML documents. It can be used to construct objects from existing XML documents. The XmlSerializer enables us to serialize and deserialize objects to

an XML format.

SoapFormatter enables us to serialize & deserialize objects to SOAP format. They can serialize private and public fields of a class. The target class must

be marked with the Serializable attribute. On deserialization, the constructor of the new object is not invoked.

The BinaryFormatter has the same features as the SoapFormatter except that it formats data into binary format. The BinaryForamatter (and the

SoapFormatter) has two main methods. Serialize and Deserialize. To serialize an object, we pass an instance of the stream and the object to the

Serialize method. To Deserialize an object, you pass an instance of a stream to the Deserialize method.

Delegate in C#

Definition:

Delegate is type which holds the method(s) reference in an object. It is also reffered as a type safe function pointers.

Advantages:

Encapsulating the method's call from caller.

Effective use of Delegat improves the performance of application.

Used to call a method asynchronously.

Multicast Delegate

It is a Delegate which holds the reference of more than one methods.

Multicast delegates must contain only methods that return void, else there is a run-time exception.

Simple Program using Multicast Delegate

delegate void Delegate_Multicast(int x, int y);

Class Class2

{

static void Method1(int x, int y) {

Console.WriteLine("You r in Method 1");

}

static void Method2(int x, int y) {

Console.WriteLine("You r in Method 2");

}

public static void Main()

{

Delegate_Multicast func = new Delegate_Multicast(Method1);

func += new Delegate_Multicast(Method2);

func(1,2); // Method1 and Method2 are called

func -= new Delegate_Multicast(Method1);

func(2,3); // Only Method2 is called

}

Explanation:

In the above example you can see that two methods are defined named method1 and method2 whchi takes two integer parameters and return type as void.

In the main method the Delegate object is created using the following statement

Delegate_Multicast func = new Delegate_Multicast(Method1);

Then the Delegate is added using the += operator and removed using -= operator.

SQL Server Reporting Services

2008-09-24T23:34:00.001-07:00

Easily Create Reports using the ReportViewer

You can implement complex reports and graphs that can be exported to Excel or Adobe PDF using the free Microsoft ReportViewer. For this example we will create a Survey and enter some data. We will then create a DotNetNuke module that will use the ReportViewer to display a simple report and graph.

Create a Survey

Add the Survey module to a page in your DotNetNuke site (see this page for instructions).

Enter a few questions.

Configure the Survey to use Registered User Vote Tracking.

Then, submit answers with a few different users. You will have to log in as each user to do this.

Create the DotNetNuke Module

First, install the latest version of DotNetNuke from DotNetNuke.com (see this page for assistance). From the menu bar select File then Open Web Site... to open the site in Visual Studio.

In the Solution Explorer, right-click on the App_Code folder and select New Folder.

Name the folder "SurveyReport".

Right-click on SurveyReport and select Add new Item...

From the Add New Item menu select DataSet and name it SureyData.xsd. Click the Add button.

The TableAdapter Configuration Wizard will appear. Select SiteSqlServer from the drop-down and click Next.

Select Use SQL statements on the next screen and click Next.

Click the Query Builder button.

When the Add Table box appears, click the Refresh button and ensure that you see Surveys in the list of tables.

Click Close on the Add Table box and Cancel on the Query Builder box, and enter the following in the box on the Enter a SQL Statement step and click Finish.

SELECT SurveyOptions.OptionName, SurveyOptions.Votes, Surveys.Question
FROM SurveyOptions INNER JOIN
Surveys ON SurveyOptions.SurveyID = Surveys.SurveyID

You have now configured a Table adapter that contains the data for your report.

Add the ReportViewer control

In the Solution Explorer, right-click on the DesktopModules folder and select New Folder.

Name the folder "SurveyReport".

Next, right-click on the SurveyReport folder and select Add New Item...

Select Web User Control, enter View.ascx for the name, select Visual Basic for the language, ensure that Place code in a separate file is checked, and click the Add button.

In the Solution Explorer, double-click on the View.ascx.vb file and open it in the code editing window.

Enter the following code and save the page:

Imports System
Imports DotNetNuke
Imports DotNetNuke.Common
Imports System.Collections.Generic
Imports System.Web.UI.WebControls
Imports System.Collections

Partial Class DesktopModules_SurveyReport_View
Inherits Entities.Modules.PortalModuleBase

End Class

In the Solution Explorer, double-click on View.ascx to open it in the code editing window.

Switch to Design view.

From the Toolbox, under the Data section select ReportViewer and drag it to the design surface of the View.ascx page.

Click the < arrow in the upper right-hand corner of the ReportViewer control to display the Task menu. Click on the Design a new report link.

The report designer will appear.

Switch to Toolbox.

From the Toolbox, select Table and drag it to the design surface.

Switch back to Website Data Sources.

Expand the SurveyData node (if it is not already expanded).

Drag the Question, OptionName, and Votes fields to a separate columns on the Detail row (the second row) on the Table. The name of the field will automatically appear in the Header row.

From the Toolbar menu select Build then Build Web Site. The site should build without errors.

Select the View.ascx page, and on the design view, click the < arrow in the upper right-hand corner of the ReportViewer control to expand the ReportViewer Tasks menu. From that menu, for the Choose Report option, select the .rdlc report that is located in the DesktopModules\SureyReport folder.

Save the page.

Create the module definition

Navigate to the DotNetNuke site using the web browser and log in as the Host account. From the Host menu, select Module Definitions.

From the Module Definitions menu select Create Module Definition.

Enter "SurveyReport" for Module Name, Folder Name, and Friendly Name. Then click the Create link.

Next, enter "SurveyReport" for New Definition and click the Add Definition link.

Click the Add Control link.

On the Edit Module Control page enter "SurveyReport" for Title, select the DesktopModules/SurveyReport/View.ascx from the Source drop-down, ensure that Type is set to View and click the Update link.

Navigate to a page in the DotNetNuke site, and from the administration menu, select SurveyReport from the Module drop-down and click the Add link.

The module will now appear.

Add a Chart

Return to Visual Studio navigate to the report designer.

Switch to the Toolbox and select and drag a Chart control to the design surface.

Switch to Website Data Sources.

Carefully drag each field first on top of the colored part of the chart graphic then into each chart section so the layout resembles the graphic above.

Right-click on the report and select properties

On the Legend tab select Table for Layout and the lower middle square for Position.

On the 3D Effect tab, click the Display chart with 3-D visual effect.

Click the OK button.

Switch to the View.ascx page and click once on the ReportViewer control. In the control properties set the Height and Width to 800px.

Hold down the Ctrl key and the Shift key and click the S key (Ctrl+Shift+S) to save all pages. Refresh the page in the web browser. The finished report should now appear.

Add Parameters

Switch back to Visual Studio.

In the design view of View.ascx, place a DropDownList above the report control. From it's Tasks menu, select Edit Items.

In the ListItem Collection Editor, enter values you would like to search on. and click the OK button.

On it's Tasks menu of the DropDownList, select Enable AutoPostBack.

Right-click on the SureyData.xsd file (in the Solution Explorer) and select View Designer to bring up the Data Adapter designer, Right-click on the header of the DataTable and select Configure...

Click the Query Builder button.

In the Filter column for the Question row, enter "@Question" and click the OK button.

Click Finish.

Save the Page.

In the design view on the View.ascx page, click on the Tasks menu for the ObjectDataSource control (located at the bottom of the page) and click Refresh Schema, then click Configure Data Source....

Click Next.

Select the GetData method that takes (String Question) in the dropdown and click Next. (If you don't see it click Cancel, save all files and try again. If you still don't see it close and re-open Visual Studio.

Select Control for Parameter source and the DropDown control for the ControlID. Click Finish. Save all pages.

Refresh the page in the web browser. The finished report should now appear.

When you select an option from the drop-down and click the Refresh () icon the report will now filter.

SQL Server Interview Questions

2008-09-24T00:03:00.000-07:00

Introduction

In this article we will go through the most basic and frequently asked interview questions on SQL Server. Please do not think that I am writing this article to show shortcuts to candidates who are searching for jobs on SQL Server. But I think no matter how much experience you have, an interview is a different ball game. A good project executioner can get knocked off on simple SQL Server questions. This article will be a complete series, so here's my first from the series - SQL Server Interview Questions Part 1.

Feel free to write to me at shiv_koirala@yahoo.com or else you can also visit my website for more such interview questions.

Happy job hunting....

Interview Questions on Database Concepts

(Q) What is a database or database management system (DBMS)?

(Q) What is the difference between DBMS and RDBMS?

(DB) What are COD rules?

(Q) Is Access database a RDBMS?

(Q) What is the main difference between ACCESS and SQL SERVER?

(Q) What is the difference between MSDE and SQL SERVER 2000?

(Q) What is SQL SERVER Express 2005 Edition?

(DB) What is SQL Server 2000 Workload Governor?

(Q) What is the difference between SQL SERVER 2000 and 2005?

(Q) What are E-R diagrams?

(Q) How many types of relationships exist in database designing?

(Q) What is normalization? What are the different type of normalization?

(Q) What is denormalization?

(DB) Can you explain Fourth Normal Form?

(DB) Can you explain Fifth Normal Form?

(DB) What is the difference between Fourth and Fifth normal form?

(DB) Have you heard about sixth normal form?

(Q) What is Extent and Page?

(DB) What are the different sections in Page?

(Q) What are page splits?

(Q) In which files does SQL Server actually store data?

(DB) Can we have a different collation for database and table?

Chapter 1: Database Concepts

(Q) What is a Database or Database Management System (DBMS)?

Twist: What is the difference between a file and a database? Can files qualify as a database?

Note: Probably these questions are too basic for experienced SQL SERVER guys. But from a fresher’s point of view, it can be a difference between getting a job and being jobless.

Database provides a systematic and organized way of storing, managing and retrieving from a collection of logically related information.
Secondly, the information has to be persistent, that means even after the application is closed the information should be persisted.
Finally, it should provide an independent way of accessing data and should not be dependent on the application to access the information.

Ok, let me spend a few more sentences on explaining the third aspect. Below is a simple figure of a text file that has personal detail information. The first column of the information is Name, second Address and finally Phone Number. This is a simple text file, which was designed by a programmer for a specific application.

Figure 1.1: Non-Uniform Text File

It works fine in the boundary of the application. Now, some years down the line a third party application has to be integrated with this file. In order for the third party application to be integrated properly, it has the following options:

Use the interface of the original application.
Understand the complete details of how the text file is organized, example the first column is Name, then Address and finally Phone Number. After analyzing, write a code which can read the file, parse it etc. Hmm, lot of work, right.

That’s what the main difference is between a simple file and a database; database has an independent way (SQL) of accessing information while simple files do not (That answers my twisted question defined above). File meets the storing, managing and retrieving part of a database, but not the independent way of accessing data.

Note: Many experienced programmers think that the main difference is that file cannot provide multi-user capabilities which a DBMS provides. But if you look at some old COBOL and C programs where files were the only means of storing data, you can see functionalities like locking, multi-user etc. provided very efficiently. So it’s a matter of debate. If some interviewers think of this as a main difference between files and database, accept it… going in to debate means probably losing a job.

(Just a note for fresher’s: Multi-user capabilities mean that at one moment of time more than one user should be able to add, update, view and delete data. All DBMS' provides this as in-built functionalities, but if you are storing information in files, it’s up to the application to write logic to achieve these functionalities).

(Q) What is the Difference between DBMS and RDBMS?

As mentioned before, DBMS provides a systematic and organized way of storing, managing and retrieving from a collection of logically related information. RDBMS also provides what DBMS provides, but above that, it provides relationship integrity. So in short, we can say:

RDBMS = DBMS + REFERENTIAL INTEGRITY

For example, in the above Figure 1.1, every person should have an Address. This is a referential integrity between Name and Address. If we break this referential integrity in DBMS and files, it will not complain, but RDBMS will not allow you to save this data if you have defined the relation integrity between person and addresses. These relations are defined by using “Foreign Keys” in any RDBMS.

Many DBMS companies claimed that their DBMS product was RDBMS compliant, but according to industry rules and regulations, if the DBMS fulfills the twelve CODD rules, it’s truly a RDBMS. Almost all DBMS (SQL SERVER, ORACLE etc.) fulfill all the twelve CODD rules and are considered truly as RDBMS.

Note: One of the biggest debates is whether Microsoft Access is an RDBMS? We will be answering this question in later section.

(DB)What are CODD Rules?

Twist: Does SQL SERVER support all the twelve CODD rules?

Note: This question can only be asked on two conditions when the interviewer is expecting you to be at a DBA job or you are complete fresher, yes and not to mention the last one he treats CODD rules as a religion. We will try to answer this question from the perspective of SQL SERVER.

In 1969, Dr. E. F. Codd laid down 12 rules, which a DBMS should adhere to in order to get the logo of a true RDBMS.

Rule 1: Information Rule

"All information in a relational database is represented explicitly at the logical level and in exactly one way - by values in tables."

In SQL SERVER, all data exists in tables and are accessed only by querying the tables.

Rule 2: Guaranteed Access Rule

"Each and every datum (atomic value) in a relational database is guaranteed to be logically accessible by resorting to a combination of table name, primary key value and column name."

In flat files, we have to parse and know the exact location of field values. But if a DBMS is truly an RDBMS, you can access the value by specifying the table name, field name, for instance Customers.Fields [‘Customer Name’].

SQL SERVER also satisfies this rule. In ADO.NET we can access field information using table name and field names.

Rule 3: Systematic Treatment of Null Values

"Null values (distinct from the empty character string or a string of blank characters and distinct from zero or any other number) are supported in fully relational DBMS for representing missing information and inapplicable information in a systematic way, independent of data type.”

In SQL SERVER, if there is no data existing, NULL values are assigned to it. Note NULL values in SQL SERVER do not represent spaces, blanks or a zero value; it is a distinct representation of missing information and thus satisfies rule 3 of CODD.

Rule 4: Dynamic On-line Catalog Based on the Relational Model

"The database description is represented at the logical level in the same way as ordinary data, so that authorized users can apply the same relational language to its interrogation as they apply to the regular data."

The Data Dictionary is held within the RDBMS. Thus, there is no need for off-line volumes to tell you the structure of the database.

Rule 5: Comprehensive Data Sub-language Rule

"A relational system may support several languages and various modes of terminal use (for example, the fill-in-the-blanks mode). However, there must be at least one language whose statements are expressible, per some well-defined syntax, as character strings and that is comprehensive in supporting all the following items:

Data Definition
View Definition
Data Manipulation (Interactive and by program)
Integrity Constraints
Authorization
Transaction boundaries ( Begin, commit and rollback)"

SQL SERVER uses SQL to query and manipulate data, which has a well-defined syntax and is being accepted as an international standard for RDBMS.

Note: According to this rule, CODD has only mentioned that some language should be present to support it, but not necessary that it should be SQL. Before the 80’s, different’s database vendors were providing their own flavor of syntax until in 1980, ANSI-SQL came in to standardize this variation between vendors. As ANSI-SQL is quite limited, every vendor including Microsoft introduced their additional SQL syntax in addition to the support of ANSI-SQL. You can see SQL syntax varying from vendor to vendor.

Rule 6: View-updating Rule

"All views that are theoretically updatable are also updatable by the system."

In SQL SERVER, not only views can be updated by the user, but also by SQL SERVER itself.

Rule 7: High-level Insert, Update and Delete

"The capability of handling a base relation or a derived relation as a single operand applies not only to the retrieval of data, but also to the insertion, update and deletion of data."

SQL SERVER allows you to update views that in turn affect the base tables.

Rule 8: Physical Data Independence

"Application programs and terminal activities remain logically unimpaired whenever any changes are made in either storage representations or access methods."

Any application program (C#, VB.NET, VB6, VC++ etc) does not need to be aware of where the SQL SERVER is physically stored or what type of protocol it is using, the database connection string encapsulates everything.

Rule 9: Logical Data Independence

"Application programs and terminal activities remain logically unimpaired when information-preserving changes of any kind that theoretically permit un-impairment are made to the base tables."

Application programs written in C# or VB.NET do not need to know about any structure changes in SQL SERVER database. Example: adding of new field etc.

Rule 10: Integrity Independence

"Integrity constraints specific to a particular relational database must be definable in the relational data sub-language and storable in the catalog, not in the application programs."

In SQL SERVER, you can specify data types (integer, nvarchar, Boolean etc.) which put in data type checks in SQL SERVER rather than through application programs.

Rule 11: Distribution Independence

"A relational DBMS has distribution independence."

SQL SERVER can spread across more than one physical computer and across several networks; but from application programs, it has not a big difference but just specifying the SQL SERVER name and the computer on which it is located.

Rule 12: Non-subversion Rule

"If a relational system has a low-level (single-record-at-a-time) language, that low level cannot be used to subvert or bypass the integrity Rules and constraints expressed in the higher level relational language (multiple-records-at-a-time)."

In SQL SERVER whatever integrity rules are applied on every record are also applicable when you process a group of records using application program in any other language (example: C#, VB.NET, J# etc.).

Readers can see from the above explanation that SQL SERVER satisfies all the CODD rules, some database gurus consider SQL SERVER as not truly being an RDBMS, but that’s a matter of debate.

(Q) Is Access Database a RDBMS?

Access fulfills all rules of CODD, so from this point of view, yes it’s truly an RDBMS. However, many people can contradict it as a large community of Microsoft professionals think that Access is not an RDBMS.

(Q) What is the Main Difference between ACCESS and SQL SERVER?

As mentioned before, Access fulfills all the CODD rules and behaves as a true RDBMS. But there’s a huge difference from an architecture perspective, due to which many developers prefer to use SQL SERVER as the major database rather than Access. Following is the list of architecture differences between them:

Access uses file server design and SQL SERVER uses the Client / Server model. This forms the major difference between SQL SERVER and ACCESS.
Note: Just to clarify what is client server and file server I will make a quick description of widely accepted architectures. There are three types of architectures:

Main frame architecture (This is not related to the above explanation but just mentioned as it can be useful during an interview and also for comparing with other architectures)
File sharing architecture (Followed by ACCESS)
Client Server architecture (Followed by SQL SERVER).

In Main Frame architecture, all the processing happens on central host server. User interacts through a dumb terminal that only sends keystrokes and information to the host. All the main processing happens on the central host server. So the advantage in such type of architecture is that you need least configuration clients. But the disadvantage is that you need a robust central host server like Main Frames.

In File sharing architecture, which is followed by Access database, all the data is sent to the client terminal and then processed. For instance, if you want to see customers who stay in India, in File Sharing architecture all customer records will be sent to the client PC regardless whether the customer belongs to India or not. On the client PC customer records from India are sorted/filtered out and displayed, in short all processing logic happens on the client PC. Therefore, in this architecture, the client PC should have heavy configuration and it increases network traffic as a lot of data is sent to the client PC. However, the advantage of this architecture is that your server can be of a low configuration.

Figure 1.2: File Server Architecture of Access

In client server architecture, the above limitation of the file server architecture is removed. In client server architecture, you have two entities, client and the database server. File server is now replaced by database server. Database server takes up the load of processing any database related activity and the client does any validation aspect of database. As the work is distributed between the entities it increases scalability and reliability. Second, the network traffic also comes down as compared to file server. For example if you are requesting customers from India, database server will sort/ filter and send only Indian customer details to the client, thus bringing down the network traffic tremendously. SQL SERVER follows the client-server architecture.

Figure 1.3: Client Server Architecture of SQL SERVER

The second issue comes in terms of reliability. In Access, the client directly interacts with the Access file, in case there is some problem in the middle of a transaction, there are chances that an Access file can get corrupt. But in SQL SERVER, the engine sits in between the client and the database, so in case of any problems in the middle of a transaction, it can revert back to its original state.
Note: SQL SERVER maintains a transaction log by which you can revert back to your original state in case of any crash.
When your application has to cater to a huge load demand, highly transactional environment and high concurrency, then its better to go for SQL SERVER or MSDE.
But when it comes to cost and support, Access stands better than SQL SERVER. In case of SQL SERVER, you have to pay for per client license, but Access runtime is free.

Summarizing: SQL SERVER gains points in terms of network traffic, reliability and scalability whereas Access gains points in terms of cost factor.

(Q) What is the Difference between MSDE and SQL SERVER 2000?

MSDE is a royalty free, redistributable and cut short version of the giant SQL SERVER database. It is primarily provided as a low cost option for developers who need a database server, which can easily be shipped and installed. It can serve as a good alternative for Microsoft Access database as it overcomes quite a few problems which Access has.

Below is a complete list, which can give you a good idea of the differences:

Size of database: Microsoft Access and MSDE have a limitation of 2GB while SQL SERVER has 1,048,516 TB1.
Performance degrades in MSDE 2000 when maximum number of concurrent operations goes above 8 or is equal to 8. It does not mean that you cannot have more than eight concurrent operations but the performance degrades. Eight-connection performance degradation is implemented by using SQL SERVER 2000 workload governor (we will be looking into more detail of how it works). As compared to SQL SERVER 2000, you can have 32,767 concurrent connections.
MSDE does not provide OLAP and Data warehousing capabilities.
MSDE does not have support facility for SQL mail.
MSDE 2000 does not have GUI administrative tool such as enterprise manager, Query analyzer or Profiler. But there are roundabout ways by which you can manage MSDE 2000:

Old command line utility OSQL.EXE
VS.NET IDE Server Explorer: Inside VS.NET IDE, you have a functionality which can give you a nice GUI administrative tool to manage IDE.
SQL SERVER WEB Data administrator installs a web based GUI which you can use to manage your database.
For any details refer here.

SQL-DMO objects can be used to build your custom UI
There are many third party tools, which provide administrative capability GUI, which is out of scope of the book as it is only meant for interview questions.
MSDE does not support Full text search.

Summarizing: There are two major differences: The first is the size limitation (2 GB) of the database and second is the concurrent connections (eight concurrent connections) which are limited by using the workload governor. During an interview, this answer will suffice if the interviewer is really testing your knowledge.

(Q) What is SQL SERVER Express 2005 Edition?

Twist: What is the difference between SQL SERVER Express 2005 and MSDE 2000?

Note: Normally comparison is when the product is migrating from one version to other version. When SQL SERVER 7.0 was migrating to SQL 2000, asking differences was one of the favorite questions.

SQL SERVER Express edition is a scaled down version of SQL SERVER 2005 and the next evolution of MSDE.

Listed below are some major differences between them:

MSDE maximum database size is 2GB while SQL SERVER Express has around 4GB.
In terms of programming language support MSDE has only TSQL, but SQLSERVER Express has TSQL and .NET. In SQL SERVER Express 2005, you can write your stored procedures using .NET.
SQL SERVER Express does not have connection limitation, which MSDE had and was controlled through the workload governor.
There was no XCOPY support for MSDE, SQL SERVER Express has it.
DTS is not present in SQL SERVER express while MSDE has it.
SQL SERVER Express has reporting services while MSDE does not.
SQL SERVER Express has native XML support and MSDE does not.

Note: Native XML support means now in SQL SERVER 2005:

You can create a field with data type XML.
You can provide SCHEMA to the SQL SERVER fields with XML data type.
You can use new XML manipulation techniques like XQUERY also called as XML QUERY.

There is a complete chapter on SQL SERVER XML Support, so till then this will suffice.

Summarizing: The major difference is the database size (2 GB and 4 GB), support of .NET support in stored procedures and native support for XML. This much can convince the interviewer that you are clear about the differences.

(DB) What is SQL Server 2000 Workload Governor?

Workload governor limits the performance of SQL SERVER Desktop engine (MSDE) if the SQL engine receives more load than what is meant for MSDE. MSDE was always meant for trial purpose and non-critical projects. Microsoft always wanted companies to buy their full blow version of SQL SERVER, so in order that they can put limitation on MSDE performance and number of connections, they introduced Workload governor.

Workload governor sits between the client and the database engine and counts the number of connections per database instance. If Workload governor finds that the number of connections exceeds eight connections, it starts stalling the connections and slowing down the database engine.

Note: It does not limit the number of connections but makes the connection request go slow. By default 32,767 connections are allowed both for SQL SERVER and MSDE. But it just makes the database engine go slow above eight connections.

What is the Difference between SQL SERVER 2000 and 2005?

Twist: What is the difference between Yukon and SQL SERVER 2000?

Note: This question will be one of the favorites during SQL SERVER interviews. I have marked the points which should be mentioned by developers as PG and DBA for Database Administrator.

Following are some major differences between the two versions:

(PG) The most significant change is the .NET integration with SQL SERVER 2005. Stored procedures, user-defined functions, triggers, aggregates, and user-defined types can now be written using your own favorite .NET language (VB.NET, C#, J# etc.). This support was not there in SQL SERVER 2000 where the only language was T-SQL. In SQL 2005, you have support for two languages T-SQL and .NET.
(PG) SQL SERVER 2005 has reporting services for reports which is a newly added feature and does not exist for SQL SERVER 2000. It was a separate installation for SQL Server 2000.
(PG) SQL SERVER 2005 has introduced two new data types varbinary (max) and XML. If you remember in SQL SERVER 2000, we had image and text data types. Problem with image and text data types is that they assign the same amount of storage irrespective of what the actual data size is. This problem is solved using varbinary (max) which acts depending on amount of data. One more new data type is included XML which enables you to store XML documents and does schema verification. In SQL SERVER 2000, developers used varchar or text data type and all validation had to be done programmatically.
(PG) SQL SERVER 2005 can now process direct incoming HTTP request without IIS Web server. In addition, stored procedure invocation is enabled using the SOAP protocol.
(PG) Asynchronous mechanism is introduced using server events. In Server event model the server posts an event to the SQL Broker service, later the client can come and retrieve the status by querying the broker.
For huge databases, SQLSERVER has provided a cool feature called “Data partitioning”. In data partitioning, you break a single database object such as a table or an index into multiple pieces. But for the client application accessing the single database object, “partitioning” is transparent.
In SQL SERVER 2000, if you rebuilt clustered indexes even the non-clustered indexes where rebuilt. But in SQL SERVER 2005 building the clustered indexes does not build the non-clustered indexes.
Bulk data uploading in SQL SERVER 2000 was done using BCP (Bulk copy program’s) format files. Now in SQL SERVER 2005 bulk, data uploading uses XML file format.
In SQL SERVER 2000 there were maximum 16 instances, but in 2005 you can have up to 50 instances.
SERVER 2005 has support of “Multiple Active Result Sets” also called as “MARS”. In previous versions of SQL SERVER 2000 in one connection, you could only have one result set. Now in one SQL connection, you can query and have multiple results set.
In previous versions of SQL SERVER 2000, system catalog was stored in the master database. In SQL SERVER 2005, it’s stored in a resource database which is stored as sys object. You cannot access the sys object directly as in the older version we were accessing the master database.
This is one of the hardware benefits which SQL SERVER 2005 has over SQSERVER 2000 – support of hyper threading. WINDOWS 2003 supports hyper threading; SQL SERVER 2005 can take advantage of the feature unlike SQL SERVER 2000 which did not support hyper threading.
Note: Hyper threading is a technology developed by INTEL which creates two logical processors on a single physical hardware processor.
SMO will be used for SQL Server Management.
AMO (Analysis Management Objects) to manage Analysis Services servers, data sources, cubes, dimensions, measures, and data mining models. You can mapm AMO in old SQL SERVER with DSO (Decision Support Objects).
Replication is now managed by RMO (Replication Management Objects).
Note: SMO, AMO and RMO are all using .NET Framework.
SQL SERVER 2005 uses current user execution context to check rights rather than ownership link chain, which was done in SQL SERVER 2000.
Note: There is a question on this later see for execution context questions.
In previous versions of SQL SERVER the schema and the user name was same, but in current, the schema is separated from the user. Now the user owns schema.
Note: There are questions on this, refer “Schema” later.
Note: Ok below are some GUI changes.
Query analyzer is now replaced by query editor.
Business Intelligence development studio will be used to create Business intelligence solutions.
OSQL and ISQL command line utility is replaced by SQLCMD utility.
SQL SERVER Enterprise manager is now replaced by SQL SERVER Management studio.
SERVER Manager which was running in system tray is now replaced by SQL Computer manager.
Database mirror concept is supported in SQL SERVER 2005, which was not present in SQL SERVER 2000.
In SQL SERVER 2005 Indexes can be rebuilt online when the database is in actual production. If you look back in SQL SERVER 2000, you cannot do insert, update, and delete operations when you are building indexes.
(PG) Other than Serializable, Repeatable Read, Read Committed, and Read Uncommitted isolation levels, there is one more new isolation level “Snapshot Isolation level”.
Note: We will see “Snapshot Isolation level” in detail in the coming questions.

Summarizing: The major significant difference between SQL SERVER 2000 and SQL SERVER 2005 is in terms of support of .NET Integration, Snap shot isolation level, Native XML support, handling HTTP request, Web service support and Data partitioning. You do not have to really say all the above points during an interview. A sweet summary and you will rock.

(Q) What are E-R diagrams?

E-R diagram also termed as Entity-Relationship diagram shows the relationship between various tables in the database. Example: Tables Customer and Customer Addresses have a one to many relationship (i.e. one customer can have multiple addresses) this can be shown using the ER diagram. ER diagrams are drawn during the initial stages of a project to forecast how the database structure will shape up. Below is a screen shot of a sample ER diagram of “Asset Management” which ships free with Access.

Figure 1.4: Asset management ER diagram.

(Q) How many Types of Relationship Exist in Database Designing?

There are three major relationship models:

One-to-one

Figure 1.5: One-to-One relationship ER diagram
One-to-many
In this many records in one table correspond to the one record in another table.
Example: Every one customer can have multiple sales. So there exist one-to-many relationships between customer and sales table.
One Asset can have multiple Maintenance. So Asset entity has one-to-many relationship between them as the ER model shows below.

Figure 1.6: One-to-Many Relationship ER diagram
Many-to-many
In this, one record in one table corresponds to many rows in another table and also vice-versa.
For instance: In a company, one employee can have many skills like Java , C# etc. and also one skill can belong to many employees.
Given below is a sample of many-to-many relationship. One employee can have knowledge of multiple Technology. So in order to implement this, we have one more table Employee Technology which is linked to the primary key of Employee and Technology table.

Figure 1.7: Many-to-Many Relationship ER diagram

(Q) What is Normalization? What are the Different Types of Normalization?

Note: A regular .NET programmer working on projects often stumbles on this question, which is but obvious. The bad part is sometimes the interviewer can take this as a very basic question to be answered and it can be a turning point for the interview. So let's cram it.

It is set of rules that have been established to aid in the design of tables that are meant to be connected through relationships. This set of rules is known as Normalization.

Benefits of Normalizing your database include:

Avoiding repetitive entries
Reducing required storage space
Preventing the need to restructure existing tables to accommodate new data
Increased speed and flexibility of queries, sorts, and summaries

Note: During an interview, people expect to answer a maximum of three normal forms and that's what is expected practically. Actually you can normalize database to fifth normal form. But believe this book, answering three normal forms will put you in a decent shape during an interview.

The three normal forms as follows:

First Normal Form

For a table to be in first normal form, data must be broken up into the smallest units possible. In addition to breaking data up into the smallest meaningful values, tables in first normal form should not contain repetitions groups of fields.

Figure 1.8: Repeating groups example

In the above example, city1 and city2 are repeating. In order for these tables to be in First normal form, you have to modify the table structure as follows. Also note that the Customer Name is now broken down to first name and last name (First normal form data should be broken down to the smallest unit).

Figure 1.9: Customer table normalized to first normal form

Second Normal Form

The second normal form states that each field in a multiple field primary key table must be directly related to the entire primary key. In other words, each non-key field should be a fact about all the fields in the primary key.

In the above table of customer, city is not linked to any primary field.

Figure 1.10: Normalized customer table.

Figure 1.11: City is now shifted to a different master table.

That takes our database to a second normal form.

Third Normal Form

A non-key field should not depend on another Non-key field. The field Total is dependent on Unit price and qty.

Figure 1.12: Fill third normal form

So now the Total field is removed and is the multiplication of Unit price * Qty.

(Q) What is Denormalization?

Denormalization is the process of putting one fact in numerous places (it is vice-versa of normalization). Only one valid reason exists for denormalizing a relational design - to enhance performance. The sacrifice to performance is that you increase redundancy in a database.

(DB) Can you Explain Fourth Normal Form?

Note: Whenever the interviewer is trying to go above the third normal form, there can be two reasons, ego or to fail you. Three normal forms are really enough, practically anything more than that is an overdose.

In fourth normal form, it should not contain two or more independent multi-valued facts about an entity and it should satisfy “Third Normal form”.

So let us try to see what multi-valued facts are. If there are two or more many-to-many relationship in one entity and they tend to come to one place, it is termed as “multi-valued facts”.

Figure 1.13: Multi-valued facts

In the above table, you can see that there are two many-to-many relationships between Supplier / Product and “Supplier / Location (or in short multi-valued facts). In order for the above example to satisfy the fourth normal form, both the many-to-many relationships should go in different tables.

Figure 1.14: Normalized to Fourth Normal form.

(DB) Can you Explain Fifth Normal Form?

Note: UUUHHH if you get this question after joining the company, do ask him if he himself really uses it?

Fifth normal form deals with reconstructing information from smaller pieces of information. These smaller pieces of information can be maintained with less redundancy.

Example: Dealers sell Product which can be manufactured by various Companies. Dealers in order to sell the Product should be registered with the Company. So these three entities have a mutual relationship within them.

Figure 1.15: Not in Fifth Normal Form.

The above table shows some sample data. If you observe closely, a single record is created using lot of small information. For instance: JM Associate can sell sweets under the following two conditions:

JM Associate should be an authorized dealer of Cadbury
Sweets should be manufactured by Cadbury company

These two smaller bits of information form one record of the above given table. So in order for the above information to be “Fifth Normal Form” all the smaller information should be in three different places. Below is the complete fifth normal form of the database.

Figure 1.16: Complete Fifth Normal Form

(DB) What is the Difference between Fourth and Fifth normal form?

Note: There is a huge similarity between Fourth and Fifth normal form, i.e. they address the problem of “Multi-Valued facts”.

“Fifth normal form” multi-valued facts are interlinked and “Fourth normal form” values are independent. For instance in the above two questions Supplier/Product and Supplier/Location are not linked. While in fifth form, the Dealer/Product/Companies are completely linked.

(DB) Have you Heard about Sixth Normal Form?

Note: Arrrrggghhh yes there exists a sixth normal form also. But note guys you can skip this statement. Just in case you want to impress the interviewer...

If you want a relational system in conjunction with time, you use sixth normal form. At this moment SQL Server does not support it directly.

(Q) What is Extent and Page?

Twist: What is the relationship between Extent and Page?

Extent is a basic unit of storage to provide space for tables. Every extent has a number of data pages. As new records are inserted new data, pages are allocated. There are eight data pages in an extent. So as soon as the eight pages are consumed, it allocates a new extent with data pages.

While extent is basic unit storage from a database point of view, page is a unit of allocation within extent.

(DB) What are the Different Sections in Page?

Page has three important sections:

Page header
Actual data i.e. Data row
Row pointers or Row offset

Page header has information like timestamp, next page number, previous page number etc.

Data rows are where your actual row data is stored. For every data row, there is a row offset which points to that data row.

Figure 1.17: General view of a Extent

(Q) What are Page Splits?

Pages are contained in extent. Every extent will have around eight data pages. But all the eight data pages are not created at once; they are created depending on data demand. So when a page becomes full it creates a new page, this process is called as “Page Split”.

(Q) In which Files does SQL Server Actually Store Data?

Any SQL Server database is associated with two kinds of files: *.mdf and *.ldf. *.mdf files are actual physical database files where your data is stored finally. *.ldf (LOG) files are actually data, which is recorded from the last time data was committed in the database.

Figure 1.18: MDF and LDF files.

(Q) What is Collation in SQL Server?

Collation refers to a set of rules that determine how data is sorted and compared. Character data is sorted using rules that define the correct character sequence, with options for specifying case-sensitivity, accent marks, kana character types, and character width.

Figure 1.19: Collation according to language

Note: Different languages will have different sort orders.

Case Sensitivity

If A and a, B and b, etc. are treated in the same way, then it is case-insensitive. A computer treats A and a differently because it uses ASCII code to differentiate the input. The ASCII value of A is 65, while a is 97. The ASCII value of B is 66 and b is 98.

Accent Sensitivity

If a and A, o and O are treated in the same way, then it is accent-insensitive. A computer treats a and A differently because it uses ASCII code for differentiating the input. The ASCII value of a is 97 and A 225. The ASCII value of o is 111 and O is 243.

Kana Sensitivity

When Japanese kana characters Hiragana and Katakana are treated differently, it is called Kana sensitive.

Width Sensitivity

When a single-byte character (half-width) and the same character when represented as a double-byte character (full-width) are treated differently then it is width sensitive.

(DB) Can We Have a Different Collation for Database and Table?

Yes, you can specify different collation sequence for both the entities differently.

Paper-1

2008-09-18T06:33:00.000-07:00

Describe the role of inetinfo.exe, aspnet_isapi.dll andaspnet_wp.exe in the page loading process.
inetinfo.exe is theMicrosoft IIS server running, handling ASP.NET requests among other things.When an ASP.NET request is received (usually a file with .aspx extension), the ISAPI filter aspnet_isapi.dll takes care of it by passing the request tothe actual worker process aspnet_wp.exe.
What’s the difference between Response.Write() andResponse.Output.Write()?
Response.Output.Write() allows you to write formatted output.
What methods are fired during the page load?
Init() - when the page is instantiated
Load() - when the page is loaded into server memory
PreRender() - the brief moment before the page is displayed to the user as HTML
Unload() - when page finishes loading.
When during the page processing cycle is ViewState available?
After the Init() and before the Page_Load(), or OnLoad() for a control.
What namespace does the Web page belong in the .NET Framework class hierarchy?
System.Web.UI.Page
Where do you store the information about the user’s locale?
System.Web.UI.Page.Culture
What’s the difference between Codebehind="MyCode.aspx.cs" andSrc="MyCode.aspx.cs"?
CodeBehind is relevant to Visual Studio.NET only.
What’s a bubbled event?
When you have a complex control, like DataGrid, writing an event processing routine for each object (cell, button, row, etc.) is quite tedious. The controls can bubble up their eventhandlers, allowing the main DataGrid event handler to take care of its constituents.
Suppose you want a certain ASP.NET function executed on MouseOver for a certain button. Where do you add an event handler?
Add an OnMouseOver attribute to the button. Example: btnSubmit.Attributes.Add("onmouseover","someClientCodeHere();");
What data types do the RangeValidator control support?
Integer, String, and Date.
Explain the differences between Server-side and Client-side code?
Server-side code executes on the server. Client-side code executes in the client's browser.
What type of code (server or client) is found in a Code-Behind class?
The answer is server-side code since code-behind is executed on the server. However, during the code-behind's execution on the server, it can render client-side code such as JavaScript to be processed in the clients browser. But just to be clear, code-behind executes on the server, thus making it server-side code.
Should user input data validation occur server-side or client-side? Why?
All user input data validation should occur on the server at a minimum. Additionally, client-side validation can be performed where deemed appropriate and feasable to provide a richer, more responsive experience for the user.
What is the difference between Server.Transfer and Response.Redirect? Why would I choose one over the other?
Server.Transfer transfers page processing from one page directly to the next page without making a round-trip back to the client's browser. This provides a faster response with a little less overhead on the server. Server.Transfer does not update the clients url history list or current url. Response.Redirect is used to redirect the user's browser to another page or site. This performas a trip back to the client where the client's browser is redirected to the new page. The user's browser history list is updated to reflect the new address.
Can you explain the difference between an ADO.NET Dataset and an ADO Recordset?
Valid answers are:
· A DataSet can represent an entire relational database in memory, complete with tables, relations, and views.
· A DataSet is designed to work without any continuing connection to the original data source.
· Data in a DataSet is bulk-loaded, rather than being loaded on demand.
· There's no concept of cursor types in a DataSet.
· DataSets have no current record pointer You can use For Each loops to move through the data.
· You can store many edits in a DataSet, and write them to the original data source in a single operation.
· Though the DataSet is universal, other objects in ADO.NET come in different versions for different data sources.
What is the Global.asax used for?
The Global.asax (including the Global.asax.cs file) is used to implement application and session level events.
What are the Application_Start and Session_Start subroutines used for?
This is where you can set the specific variables for the Application and Session objects.
Can you explain what inheritance is and an example of when you might use it?
When you want to inherit (use the functionality of) another class. Example: With a base class named Employee, a Manager class could be derived from the Employee base class.
Whats an assembly?
Assemblies are the building blocks of the .NET framework. Overview of assemblies from MSDN
Describe the difference between inline and code behind.
Inline code written along side the html in a page. Code-behind is code written in a separate file and referenced by the .aspx page.
Explain what a diffgram is, and a good use for one?
The DiffGram is one of the two XML formats that you can use to render DataSet object contents to XML. A good use is reading database data to an XML file to be sent to a Web Service.
Whats MSIL, and why should my developers need an appreciation of it if at all?
MSIL is the Microsoft Intermediate Language. All .NET compatible languages will get converted to MSIL. MSIL also allows the .NET Framework to JIT compile the assembly on the installed computer.
Which method do you invoke on the DataAdapter control to load your generated dataset with data?
The Fill() method.
Can you edit data in the Repeater control?
No, it just reads the information from its data source.
Which template must you provide, in order to display data in a Repeater control?
ItemTemplate.
How can you provide an alternating color scheme in a Repeater control?
Use the AlternatingItemTemplate.
What property must you set, and what method must you call in your code, in order to bind the data from a data source to the Repeater control?
You must set the DataSource property and call the DataBind method.
What base class do all Web Forms inherit from?
The Page class.
Name two properties common in every validation control?
ControlToValidate property and Text property.
Which property on a Combo Box do you set with a column name, prior to setting the DataSource, to display data in the combo box?
DataTextField property.
Which control would you use if you needed to make sure the values in two different controls matched?
CompareValidator control.
How many classes can a single .NET DLL contain?
It can contain many classes.

Web Service Questions

What is the transport protocol you use to call a Web service?
SOAP (Simple Object Access Protocol) is the preferred protocol.
True or False: A Web service can only be written in .NET?
False
What does WSDL stand for?
Web Services Description Language.
Where on the Internet would you look for Web services?
http://www.uddi.org
True or False: To test a Web service you must create a Windows application or Web application to consume this service?
False, the web service comes with a test page and it provides HTTP-GET method to test.

State Management Questions

What is ViewState?
ViewState allows the state of objects (serializable) to be stored in a hidden field on the page. ViewState is transported to the client and back to the server, and is not stored on the server or any other external source. ViewState is used the retain the state of server-side objects between postabacks.
What is the lifespan for items stored in ViewState?
Item stored in ViewState exist for the life of the current page. This includes postbacks (to the same page).
What does the "EnableViewState" property do? Why would I want it on or off?
It allows the page to save the users input on a form across postbacks. It saves the server-side values for a given control into ViewState, which is stored as a hidden value on the page before sending the page to the clients browser. When the page is posted back to the server the server control is recreated with the state stored in viewstate.
What are the different types of Session state management options available with ASP.NET?
ASP.NET provides In-Process and Out-of-Process state management. In-Process stores the session in memory on the web server. This requires the a "sticky-server" (or no load-balancing) so that the user is always reconnected to the same web server. Out-of-Process Session state management stores data in an external data source. The external data source may be either a SQL Server or a State Server service. Out-of-Process state management requires that all objects stored in session are serializable.

ASP.Net Page life Cycle

2008-09-18T06:21:00.000-07:00

Introduction

This article describes the life cycle of the page from the moment the URL is hit from the web browser till the HTML code is generated and sent to the web browser. Let us start by looking at some keywords that are involved in the life cycle of the page.

Background

IIS: IIS (Internet Information Server) is a complete Web server that makes it possible to quickly and easily deploy powerful Web sites and applications. It is the default web server used with .NET. When a Web server (for ASP.NET applications, typically IIS) receives a request, it examines the file-name extension of the requested file, determines which ISAPI extension should handle the request, and then passes the request to the appropriate ISAPI extension. (By default, ASP.NET handles file name extensions that have been mapped to it, such as .aspx, .ascx, .ashx, and .asmx.)

Note:
a. If a file name extension has not been mapped to ASP.NET, ASP.NET will not receive the request. It will be handled by the IIS. The requested page/image/file is returned without any processing.
b. If you create a custom handler to service a particular file name extension, you must map the extension to ASP.NET in IIS and also register the handler in your application's Web.config file.

ASPNET_ISAPI.DLL: This dll is the ISAPI extension provided with ASP.NET to process the web page requests. IIS loads this dll and sends the page request to this dll. This dll loads the HTTPRuntime for further processing.
ASPNET_WP.EXE: Each worker process (ASPNET_WP.EXE) contains an Application Pool. Each Application Pool can contain any number of Applications. Application Pool is also called as AppDomain. When a web page is requested, IIS looks for the application pool under which the current application is running and forwards the request to respective worker process.

HTTP Pipeline: HTTP Pipeline is the general-purpose framework for server-side HTTP programming that serves as the foundation for ASP.NET pages as well as Web Services. All the stages involved from creating HTTP Runtime to HTTP Handler is called HTTP Pipeline.

HTTP Runtime: Each AppDomain has its own instance of the HttpRuntime class—the entry point in the pipeline. The HttpRuntime object initializes a number of internal objects that will help carry the request out. The HttpRuntime creates the context for the request and fills it up with any HTTP information specific to the request. The context is represented by an instance of the HttpContext class. Another helper object that gets created at such an early stage of the HTTP runtime setup is the text writer—to contain the response text for the browser. The text writer is an instance of the HttpWriter class and is the object that actually buffers any text programmatically sent out by the code in the page. Once the HTTP runtime is initialized, it finds an application object to fulfill the request. The HttpRuntime object examines the request and figures out which application it was sent to (from the pipeline's perspective, a virtual directory is an application).

HTTP Context: This is created by HTTP Runtime. The HttpContext class contains objects that are specific to the current page request, such as the HttpRequest and HttpResponse objects. You can use this class to share information between pages. It can be accessed with Page.Context property in the code.

HTTP Request: Provides access to the current page request, including the request headers, cookies, client certificate, query string, and so on. You can use this class to read what the browser has sent. It can be accessed with Page.Request property in the code.

HTTP Response: Provides access to the output stream for the current page. You can use this class to inject text into the page, to write cookies, and more. It can be accessed with Page.Response property in the code.

HTTP Application: An application object is an instance of the HttpApplication class—the class behind the global.asax file. HTTPRuntime uses HttpApplicationFactory to create the HTTPApplication object. The main task accomplished by the HTTP application manager is finding out the class that will actually handle the request. When the request is for an .aspx resource, the handler is a page handler—namely, an instance of a class that inherits from Page. The association between types of resources and types of handlers is stored in the configuration file of the application. More exactly, the default set of mappings is defined in the section of the machine.config file. However, the application can customize the list of its own HTTP handlers in the local web.config file. The line below illustrates the code that defines the HTTP handler for .aspx resources.

HttpApplicationFactory: Its main task consists of using the URL information to find a match between the virtual directory of the URL and a pooled HttpApplication object.

HTTP Module: An HTTP module is an assembly that is called on every request that is made to your application. HTTP modules are called as part of the ASP.NET request pipeline and have access to life-cycle events throughout the request. HTTP modules let you examine incoming and outgoing requests and take action based on the request. They also let you examine the outgoing response and modify it. ASP.NET uses modules to implement various application features, which includes forms authentication, caching, session state, and client script services. In each case, when those services are enabled, the module is called as part of a request and performs tasks that are outside the scope of any single page request. Modules can consume application events and can raise events that can be handled in the Global.asax file.

HTTP Handler: An ASP.NET HTTP handler is the process that runs in response to a request that is made to an ASP.NET Web application. The most common handler is an ASP.NET page handler that processes .aspx files. When users request an .aspx file, the request is processed by the page handler. We can write our own handler and handler factory if we want to handle the page request in a different manner.

Note: HTTP modules differ from HTTP handlers. An HTTP handler returns a response to a request that is identified by a file name extension or family of file name extensions. In contrast, an HTTP module is invoked for all requests and responses. It subscribes to event notifications in the request pipeline and lets you run code in registered event handlers. The tasks that a module is used for are general to an application and to all requests for resources in the application.

Life Cycle of Page

1. Web page request comes from browser.
2. IIS maps the ASP.NET file extensions to ASPNET_ISAPI.DLL, an ISAPI extension provided with ASP.NET.
3. ASPNET_ISAPI.DLL forwards the request to the ASP.NET worker process (ASPNET_WP.EXE or W3P.EXE).
4. ISAPI loads HTTPRuntime and passes the request to it. Thus, HTTP Pipelining has begun.
5. HTTPRuntime uses HttpApplicationFactory to either create or reuse the HTTPApplication object.
6. HTTPRuntime creates HTTPContext for the current request. HTTPContext internally maintains HTTPRequest and HTTPResponse.
7. HTTPRuntime also maps the HTTPContext to the HTTPApplication which handles the application level events.
8. HTTPApplication runs the HTTPModules for the page requests.
9. HTTPApplication creates HTTPHandler for the page request. This is the last stage of HTTPipelining.
10. HTTPHandlers are responsible to process request and generate corresponding response messages.
11. Once the request leaves the HTTPPipeline, page level events begin.
12. Page Events are as follows: PreInit, Init, InitComplete, PreLoad, Load, Control evetns (Postback events), Load Complete, PreRender, SaveStateComplete, Render and Unload.
13. HTTPHandler generates the response with the above events and sends back to the IIS which in turn sends the response to the client browser.

Events in the life cycle of page

PreInit: All the Pre and Post events are introduced as part of .NET Framework 2.0. As the name suggests this event is fired before the Init method is fired. Most common functionalities implemented in this method include

a. Check the IsPostBack property
b. Set the master page dynamically
c. Set the theme property of the page dynamically
d. Read or Set the profile property values.
e. Re-create the dynamic controls

Init: This event is raised after all controls in the page are initialized and any skin settings have been applied. This event is used to read or initialize control properties. It can be used to register events for some controls for which the events are not specified in the aspx page.
Ex: OnClick event of the Button can be registered in the Init rather than specifying in the OnClick property of the Button in the aspx page.

InitComplete: Use this event for processing tasks that require all initialization be complete.

PreLoad: Use this event if you need to perform processing on your page or control before the Load event. After the Page raises this event, it loads view state for itself and all controls, and then processes any postback data included with the Request instance.

Load: The Page calls the OnLoad event method on the Page, then recursively does the same for each child control, which does the same for each of its child controls until the page and all controls are loaded. Use the OnLoad event method to set properties in controls and establish database connections.

Control events: Use these events to handle specific control events, such as a Button control's Click event or a TextBox control's TextChanged event.

LoadComplete: Use this event for tasks that require that all other controls on the page be loaded.

PreRender: This is the last event raised before the HTML code is generated for the page. The PreRender event also occurs for each control on the page. Use the event to make final changes to the contents of the page or its controls.

SaveStateComplete: Before this event occurs, ViewState has been saved for the page and for all controls. Any changes to the page or controls at this point will be ignored.
Use this event perform tasks that require view state to be saved, but that do not make any changes to controls.

Render: This is the stage where the HTML code for the page is rendered. The Page object calls the Render method of each control at this stage. All ASP.NET Web server controls have a Render method that writes out the control's markup that is sent to the browser.

UnLoad: This event occurs for each control and then for the page. In controls, use this event to do final cleanup for specific controls, such as closing control-specific database connections.
For the page itself, use this event to do final cleanup work, such as closing open files and database connections, or finishing up logging or other request-specific tasks.

Edging DotNet: Use Secured Secured String for password

2008-09-12T22:37:00.000-07:00

Edging DotNet: Use Secured Secured String for password

Use Secured Secured String for password

2008-09-12T03:28:00.000-07:00

How to: Use strings in a secure manner with SecureString class

The classic System.String type doesn’t provide enough security for storing sensitive data like passwords, credit card numbers or personal information. If a String object contains sensitive information, there is a risk the information could be revealed after it is used because your application cannot delete the data from computer memory. Starting with the .NET Framework 2.0 the SecureString class is available. It was designed to provide encryption for sensitive data and other useful functions.

System.String

The most important factors that don’t recommend the System.String type as a secure type are:

System.String is not encrypted. Anyone who can read your process' memory will be able to see the value of the string easily. Also, if your process gets swapped out to disk, the unencrypted contents of the string will be sitting in your swap file.
System.String is immutable. Because of this you can not modify an existing string without create a copy of it first and you can not clear the content of a string. You may end up with several copies of your sensitive data in memory which are hard to hide from a possible attacker.
System.String can be moved around in memory by the Garbage Collector (GC). This happens because of the Garbage Collector's generations mechanism.
System.String can’t be disposed on demand. No one can predict when a specific string will be reclaimed by the Garbage Collector (GC). It is possible that some strings to survive long time after the application was closed.

The byte array workaround

Before .NET 2.0, the recommended way to handle sensitive data was to use the byte array. A byte array can be handled almost in a string manner but with some extra advantages:

Each byte from the byte array can be encrypted and decrypted using any encoding algorithm.
We can clean-up the content of it.
We can dispose a byte array on demand.

The SecureString class

Let’s see what are the advantages that recommend the SecureString class to be better than Sytem.String or even than the byte array method:

A SecureString object is similar to a String object in that it has a text value. So it helps you to write cleaner code then the byte array method.
The value of a SecureString object is automatically encrypted when its value is initialized or modified. It will be automatically decrypted when it will be accessed.
The value of a SecureString can be modified until your application marks it as read-only. You'll find AppendChar(), InsertAt(), RemoveAt(), and SetAt() methods as well as a Length property.
The value of a SecureString can be deleted from computer memory by either your application or the .NET Framework Garbage Collector. This includes clearing the entire content.
The Garbage Collector (GC) will not move the encrypted string around in memory, so you never have to worry about multiple copies of your string sitting in your address space.

The SecureString class has no members that inspect, compare, or convert the value of a SecureString. The absence of such members helps protect the value of the instance from accidental or malicious exposure. Anyway you can you can use the appropriate members of the Marshal class, such as the SecureStringToBSTR method, to manipulate the value of a SecureString object.

Let me show you an example of how a SecureString should be used:

static void Main(string[] args)
{
    Console.WriteLine("Please enter your password to be encrypted:");
    SecureString password = ReadPassword();
    Console.WriteLine("Decripted password:");
    PrintPassword(password);
    Console.WriteLine("Press any key to quit");
    Console.ReadKey();
}
 
public static SecureString ReadPassword()
{
    SecureString password = new SecureString();                        
    ConsoleKeyInfo key = Console.ReadKey(true);
    while (key.Key != ConsoleKey.Enter)
    {
        password.AppendChar(key.KeyChar);
        key = Console.ReadKey(true);
    }
 
    password.MakeReadOnly(); // make the password read-only.
    return password; // return the encrypted password.
}
 
public static void PrintPassword(SecureString password)
{
    // decrypt the password and get a reference to it...
    IntPtr bstr = Marshal.SecureStringToBSTR(password);
 
    try
    {
        // Printing the decrypted password...
        Console.WriteLine(Marshal.PtrToStringBSTR(bstr));
    }
 
    finally
    {
        Marshal.ZeroFreeBSTR(bstr);
    }
}

How to: Retrieve database schema information using ADO.NET

2008-09-11T23:56:00.000-07:00

How to: Retrieve database schema information using ADO.NET

Sometimes we need to know what is the internal structure of a database in addition to its data. This might turn very useful when the database structure is dynamic. This information is called Database Metadata or Database Schema.

Using OleDbConnection.GetOleDbSchemaTable method

The OleDbConnection class provides a special method for doing this. It is called GetOleDbSchemaTable and returns a DataTable that is populated with the schema information.

Here is an example of how this method can be used:

DataTable tblDbSchema = oleDb.GetOleDbSchemaTable(OleDbSchemaGuid.Columns, null);

This method accepts two parameters:

The first one is an enumeration value that specifies what kind of information to be contained by the schema output, such as tables, columns, procedures, indexes and keys.

The second parameter is a restriction array. You can use this array to filter the schema table’s content. First array item will be used against the first column in the schema table; the second array item will be used against the second column in the schema table, and so on.

Here is an example of how to retrieve the column schema from the "Customer" table using an Access database. Because each value in the Object array corresponds to a DataColumn in the resulting DataTable, the Restrictions array should have the following structure:

{TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE}

string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=DatabaseFile.mdb";

OleDbConnection oleDb = new OleDbConnection(connectionString);

oleDb.Open();

object[] arrRestrict;

arrRestrict = new object[] { null, null, "Customers", null };

DataTable tblDbSchema = oleDb.GetOleDbSchemaTable(OleDbSchemaGuid.Columns, arrRestrict);

oleDb.Close();

Using the SqlDataReader.GetSchemaTable method

The SqlDataReader class provide a special method for this called GetSchemaTable.

string strQuery = "SELECT * FROM Employees";

string strConn = "user id=sa;password=foo;initial catalog=northwind;data source=localhost;";

SqlConnection conn = new SqlConnection(strConn);

SqlCommand cmd = new SqlCommand(strQuery, conn);

conn.Open();

SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);

// Get the schema table.

DataTable tblSchema = rdr.GetSchemaTable();

conn.Close();

rdr.Close();

Each row in the returned table represent each data field in the database table. And each column has predefined name corresponding to different attribute of the fields. For a complete list of these column names and their usage, please read the documentation.

Using a SQL query for SQL Server databases

Another way to get the schema for a SQL Server database is to execute a SQL query like in the following example:

string strConn = "user id=sa;password=foo;initial catalog=northwind;data source=localhost;";

SqlConnection conn = new SqlConnection(strConn);

SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM Information_Schema.Tables where Table_Type = 'BASE TABLE'", conn);

DataTable dt = new DataTable();

da.Fill(dt);

Implementing Garbage Collector

2008-09-11T22:01:00.000-07:00

The Garbage Collector (GC) can be considered the heart of the .NET Framework. It manages the allocation and release of memory automatically for any .NET application.

Basic rules

The Garbage Collector (GC) can’t be controlled by the application.
All garbage-collectable objects are allocated from one contiguous range of address space and are grouped by age.
There are never any gaps between objects in the managed heap.
The order of objects in memory remains the order in which they were created.
The oldest objects are at the lowest addresses (managed heap bottom), while new objects are created at increasing addresses (managed heap top).
Periodically the managed heap is compacted by removing dead objects and sliding the live objects up toward the low-address end of the heap.

The GC generations

All the living objects from the managed heap are divided in three groups by their age. Those groups are generically called "Generations". Those generations are very useful to prevent memory fragmentation on the managed heap. The Garbage Collector (GC) can search for dead object on each generation at a time (partial collections), to improve the collecting performance.

Now let’s see what the Garbage Collector (GC) is using each generation for:

Generation 0 (Gen0) contains all the newly created objects and it is located on the top of the heap zone (higher memory addresses). All the objects contained by Gen0 are considered short-lived object and the Garbage Collector (GC) is expecting to them to be quickly destroyed in order to release the used memory space. Due to this presumption, the Garbage Collector (GC) will try to collect dead objects most often from Gen0 because it is cheapest.
Generation 1 (Gen1) contains all the living objects from Gen0 that have survived to several Gen0 collects. So those objects are upgraded from Generation 0 to Generation 1. Gen1 is defined in the middle of the heap zone and it is exposed to fewer garbage collects than Gen0. Gen1’s collects are more expensive than the Gen0’s so the Garbage Collector (GC) will try to avoid them if it is not really necessary.
Generation 2 (Gen2) contains all the living objects from Gen1 that have survived to several Gen2 collects. Those objects are considered long-lived objects and destroying them is very expensive. Because of this, the Garbage Collector (GC) will hardly try to collect them. The Gen2 zone is located on the bottom of the managed heap zone (lowest memory addresses).

Collecting the Garbage

The GC is able to collect the garbage in two ways: full collections (searching the entire managed heap for dead objects) and partial collections (searching only a single generation zone).

When the GS starts collecting the garbage, performing a full or partial collection, the first thing it does is to stop the application execution. So, at least from this point of view, collecting dead objects is an expensive task! For a full collection, the application can be stopped for a very long time!

The second step is to identify the root objects. A root object is an object having no references from other objects. For example the global members of an application are suitable to be root objects. Starting with these roots, the GC follows each reference contained by them inspecting recursively all the child objects. In this way the GC will have found every reachable or live object. The other objects, the unreachable ones, are now condemned to be collected.

If a partial collection is performed, the GC will iterate only thru objects having same age or younger. For example, a Gen1 root may have child objects from Gen1 or Gen0. Considering this, inspecting Gen2 roots is equivalent to perform a full collection, which is very expensive, because Gen2 objects may have references to children from Gen1 and Gen0.

All the live objects have been found will have their age incremented and be upgraded to the next generation, if necessary. Upgrading an object to the next generation involves moving its data on a different memory location of the managed heap. In order to not affect the performance too much, an object must have been survived more than one collection on its current generation to be upgraded on the next one.

Things you MUST dispose

When the .NET Framework instantiates an object, it allocates memory for that object on the managed heap. The object remains on the heap until it's no longer referenced by any active code, at which point the memory it's using is reclaimed by the Garbage Collector (GC). Before the GC deallocates the memory, the framework calls the object's Finalize() method, but developers are responsible for calling the Dispose() method.

Dispose GUI elements

Dialog forms. In .NET, a dialog form is a form opened by calling the ShowDialog() method. Unlike modeless forms, the Close method is not called by the .NET Framework when the user clicks the close form button of a dialog box or sets the value of the DialogResult property. Instead the form is hidden and can be shown again without creating a new instance of the dialog box. Because a form displayed as a dialog box is not closed, you must call the Dispose() method of the form when the form is no longer needed by your application.
GDI+ resources. The GDI+ resources, like: pens, brushes and fonts, need to be disposed because they encapsulate GDI+ handles in them and GDI+ is build in C++ (unmanaged code). To release the GDI+ resources, we must call the Dispose() method for each of them.

The proper usage is to create, use and dispose of an item in the right place. For example:

void override OnPaint(PaintEventArgs e)

{

Pen p = new Pen(Color.Blue, 1); // create

e.Graphics.DrawLine(p, 0, 0, 20, 20); // use

p.Dispose(); // dispose

}

Don't use GDI+ resources like this:

g.DrawLine(new Pen(Color.Blue, 1), 0, 0, 20, 20);

The Pen object in this case is created inline and never disposed of. However, when using one of the ready-made pens from Pens or SystemPens, you must never dispose the object! This is also true for ready-made brushes.

The Graphics object, if is returned by Control.CreateGraphics() method, must be also disposed as soon as it is not needed anymore. If the Graphics object is accessed thru PaintEventArgs you don't have to call Dispose() because .NET will handle that for you. You can read more about GDI+ in this article: GDI+ Windows rendering API.

Dispose data sources

Database connections. Dispose any database connection you don't need anymore to ensure no resources are being held by it. Also, the Dispose method of a connection object automatically calls its Close method.
Stream objects. This includes files and memory streams, anything inheriting from the Stream class. Calling Dispose allows the resources used by the stream to be reallocated for other purposes. Before releasing all the resources, this method disposes the stream, by writing any changes to the backing store and closing the stream.

C# Tip: Forcing Garbage Collection in .NET

There might be times in your application when you want to force the .NET Garbage Collector (GC) to spin through all unused objects and de-allocate them. The method for accomplishing this task is the GC.Collect method. When you call GC.Collect, the GC will run each object's finalizer on a separate thread. Therefore, another method to keep in mind is GC.WaitForPendingFinalizers. This synchronous method that will not return until the GC.Collect has finished its work.

Here's a simple example of using these two methods:

using System;

namespace GCCollect

  class Account

    public Account(string accountNumber)

      this.accountNumber = accountNumber;

      Console.WriteLine("Account::Acount - c'tor");

    ~Account()

      Console.WriteLine("Account::~Acount - d'tor");

    protected string accountNumber;

    override public string ToString() { return accountNumber; }

};

  class Class1

    [STAThread]

    static void Main(string[] args)

      CreateAccount("111006116");

      GC.Collect();

      GC.WaitForPendingFinalizers();

      Console.WriteLine("Application ending");

    public static void CreateAccount(string accountNumber)

      Console.WriteLine("CreateAccount - instantiate Account object");

      Account account = new Account(accountNumber);

      Console.WriteLine("CreateAccount - created account number {0}",

                        account);

If you build and run this example, you will receive the following output:

CreateAccount - instantiate Account object

Account::Acount - c'tor

CreateAccount - created account number 111006116

Account::~Acount - d'tor

Application ending

Note a couple of issues here:

I allocated the Account object in a different method than the Main method. This is because if I allocated the Account object in the Main method and then called GC.Collect in the same method, the Account object would technically still be associated with running code and would therefore not be eligible for collection.
While I used a simple single object example here to illustrate calling the GC.Collect method, the GC.Collect method is designed not to control specific object destruction, but to allow for the forcing of collection for all of unused objects. Therefore, it's a very expensive operation and should only be used in cases where you want/need to force global collection.
For situations where you want to force the finalization of a specific object, you should implement the Dispose pattern, which I'll cover in a separate article.