Regular Expression

Need to find more then one value ( with a formated string .. Ex. {:Test:}) in a sting using RegEx.

//Step A
using System.Text.RegularExpressions;
//Step B
string input = "It contains lot of lines with this {:firstname:} and ({:lastname:})";
MatchCollection m = Regex.Matches(input, "{:[A-Za-z0-9_]+:}");
//Step C
Loop through the MatchCollection and find the each value

Gridview in asp.net

Paging
we need to follow these stpes to implement the paging in gridview

in asp.net page

AllowPaging="true" PageSize="20"
onpageindexchanging="FeaturesListView_PageIndexChanging">

in codebehind page

protected void MyGridView_PageIndexChanging(object sender, GridViewPageEventArgs
e){MyGridView.PageIndex = e.NewPageIndex;
LoadGridView();}

Silver light

http://weblogs.asp.net/dwahlin/archive/2008/05/29/my-latest-silverlight-articles.aspx

Visual studio Thread

Visual Studio 2008 - New Features

A quick list of some of the new features are:

• Multi-Targeting support
• Web Designer and CSS support
• ASP.NET AJAX and JavaScript support
• Project Designer
• Data
• LINQ – Language Integrated Query

http://www.codeproject.com/KB/dotnet/Visual_Studio_2008.aspx

Fav & Interesting sites

CARD making

http://www.toondoo.com/Home.toon

Web.Config

Configuration File Format

ASP.NET configuration files are XML-based text files--each named web.config--that can appear in any directory on an ASP.NET Web application server. Each web.config file applies configuration settings to the directory it is located in and to all virtual child directories beneath it. Settings in child directories can optionally override or modify settings specified in parent directories. The root configuration file--WinNT\Microsoft.NET\Framework\\config\machine.config--provides default configuration settings for the entire machine. ASP.NET configures IIS to prevent direct browser access to web.config files to ensure that their values cannot become public (attempts to access them will cause ASP.NET to return 403: Access Forbidden).

At run time ASP.NET uses these web.config configuration files to hierarchically compute a unique collection of settings for each incoming URL target request (these settings are calculated only once and then cached across subsequent requests; ASP.NET automatically watches for file changes and will invalidate the cache if any of the configuration files change).

For example, the configuration settings for the URL http://myserver/myapplication/mydir/page.aspx would be computed by applying web.config file settings in the following order:

Base configuration settings for machine.
C:\WinNT\Microsoft.NET\Framework\v.1.00\config\machine.config

Overridden by the configuration settings for the site (or the root application).
C:\inetpub\wwwroot\web.config

Overridden by application configuration settings.
D:\MyApplication\web.config

Overridden by subdirectory configuration settings.
D:\MyApplication\MyDir\web.config

If a web.config file is present at the root directory for a site, for example "Inetpub\wwwroot", its configuration settings will apply to every application in that site. Note that the presence of a web.config file within a given directory or application root is completely optional. If a web.config file is not present, all configuration settings for the directory are automatically inherited from the parent directory.

Tools and S/w website collection

Download videos DIRECT from most video sites Copy the link of the page with the video on it and paste it here

http://keepvid.com/ ( ex .. we can download the YouTube videos to our PC )

https://addons.mozilla.org/en-US/firefox/addon/4318 ( for FireFox users )

Security Thread ( SSL and etc .... )

SSL certificate is the short form of secure socket layer certificate. This technology is used widely in the Internet transactions to make them secure. Normally, this technology is used to encrypt important information between the web servers and the client’s web browser by establishing an encrypted and secure link. This helps in making the information of the transaction private and secure. Millions of Internet transactions that happen everyday are using this technology to their advantage.

Netscape created SSL protocol. The protocol works in the following manner:

1. First, web browser requests a secure page from the client side.

2. If the website has SSL certificate, certificate will be sent along with its public key by the web server.

3. After receiving the certificate, client side’s web browser checks for the validity of the certificate. Its checks whether certificate belongs to the site. If so is it still valid and has it been issued by a trusted party (This will be normally tested through a Certificate Authority (CA)). If it fails on any one of these checks the browser will display a warning to the end user letting them know that the site is not secured by SSL.

4. Then the web browser uses its public key to encrypt the data. It then sends it to the web server with the encrypted URL required along with other encrypted http data.

5. Decryption of the symmetric encrypted key will takes place at the web server. To decrypt, web server uses its private key. To decrypt the URL and http data, it uses the symmetric key.

6. Along with the symmetric key the web server sends back the requested html document and http data in the encrypted form.

7. Using the symmetric key, the web browser at the client side decrypts the http data and html document. Then web browser displays the information.

In this way, Secure Socket Layer protocol helps in making very secure Internet transactions.

Normally a SSL certificate contains your company name, your domain name, and your address with country, state, and city. It will also tell the web browser about the details of your CA and your SSL certificate expiration date.

You can get more information about SSL certificates and various products from www.ssl.com. Its top management, which includes its President Leo Grove and its Vice President Jade Chaney, are working really hard with its partners to provide the best possible products to all types of enterprises. Feel free to browse through the site and it’s blogs to learn all the new advancements in the SSL protocol and Certificate.

How we use Web Services in our Web page?

free web services available :http://www.webservicex.net/WS/WSDetails.aspx?WSID=10&CATID=2

(This service is used for currency convertor this is free service tht is available on net )

Now go to ur website where u want to use this service and

From the website menu- Add the web References and paste this url in url column n then click on GO.It will tak few sec to connect and onces it connected to ur web service, Web reference name option actvate, give any proxy name there like aa,bb etc which u like. Click on Add reference n this window automatically closed n connection established.

With the help of Proxy name i.e aa we can access all the properties of this webservice in our website.

Now for the consumption of this webservice make a one object of this webservice :

public partial class _Default : System.Web.UI.Page
{
aa.CurrencyConvertor obj = new aa.CurrencyConvertor();

after u create object

go to ur .aspx page n put some textbox,button etc according to ur reqirement n then link tht button to ur webservice object

for example

we place 1 textbox where we want to show the currencyconverter result
and 1 button

On the click of this button result appeared in textbox

protected void Button1_Click(object sender, EventArgs e)
{
TextBox1.Text = obj.ConversionRate(aa.Currency.ZMK, aa.Currency.ZWD).ToString();

}


here ZMK,ZWD are the country code

How to install assembly to GAC?

In order to share a .NET assembly with multiple applications installed on the same machine, it needs to be installed into the Global Assembly Cache (GAC). This article will walk you through the process of giving your assembly a strong name, and installing it into the GAC.
The Contrived .NET class

using System;

public class aspZone
{
public int Add(int x, int y)
{
return(x + y);
}
}


Listing 1 - dotNETComponent.cs

The code in Listing 1 is the same contrived sample you've seen in other articles on this site. But to be installed in the GAC, it needs to be given a Strong Name.
What's in a Strong Name?

A strong name is made up of the full class name including the namespace, the version number, culture information (which can be null if culture neutral), plus a public key and a digital signature.

The .NET Framework provides a utility to create a key pair (sn.exe). Run the following at a command line.


C:\dotNET>sn -k dotNETComponent.snk

Microsoft ® .NET Framework Strong Name Utility
Version 1.0.2914.16
Copyright © Microsoft Corp. 1998-2001. All rights reserved.

Key pair written to dotNETComponent.snk

C:\dotNET>


Output 1 - sn.exe
Then add the necessary attributes to the .cs file as shown in Listing 2.


using System;
using System.Reflection;

[assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyKeyFile("dotNETComponent.snk")]
public class aspZone
{
public int Add(int x, int y)
{
return(x + y);
}
}


Listing 2 - dotNETComponent.cs
Then compile the assembly.

C:\dotNET>csc -t:library dotNETComponent.cs


Microsoft ® Visual C# Compiler
Version 7.00.9254 [CLR version v1.0.2914]
Copyright © Microsoft Corp 2000-2001. All rights reserved.

Output 2 - csc.exe

Installing the assembly into the GAC

From a command prompt, in the same directory where dotNETComponent.dll resides, run gacutil.exe as seen in Output 3 below:

C:\dotNET>gacutil /i dotNETComponent.dll

Microsoft ® .NET Global Assembly Cache Utility.
Version 1.0.2914.16
Copyright © Microsoft Corp. 1998-2001. All rights reserved.

Assembly successfully added to the cache

C:\dotNET>

Output 3 - gacutil.exe

The assembly can now be used from other assemblies on the server, regardless of their physical location.

Design Thread

GIF to ICON online converter .......

http://www.chami.com/html-kit/services/favicon/

create survey for FREE for your needs

http://www.surveymonkey.com/Default.aspx

http://www.polldaddy.com/features/

ASP.net Performance, Tips & Tricks Thread

1. http://samples.gotdotnet.com/quickstart/aspplus/doc/perftuning.aspx

2. http://www.realsoftwaredevelopment.com/2007/08/20-tips-to-impr.html

3. http://msdn2.microsoft.com/en-us/library/ms973839.aspx

4. http://msdn.microsoft.com/msdnmag/issues/05/01/ASPNETPerformance/

5. http://msdn.microsoft.com/msdnmag/issues/05/01/ASPNETPerformance/

6.. http://www.sql-server-performance.com/tips/asp_net_performance_p1.aspx ( SQL )


7. http://www.codeproject.com/KB/aspnet/10ASPNetPerformance.aspx

TIPS & TRICKS

ASP.NET 2.0 is an awesome framework for developing Web applications. If you've worked with it for awhile then that's no secret. It offers some great new features that you can implement with a minimal amount of code. I wanted to start a list of some of the most simple (yet cool) things you could do with it that required little or no C#/VB.NET code. If you have other suggestions add a comment and I'll update the list if the suggestion is a simple task that can be applied easily.

1. Maintain the position of the scrollbar on postbacks: In ASP.NET 1.1 it was a pain to maintain the position of the scrollbar when doing a postback operation. This was especially true when you had a grid on the page and went to edit a specific row. Instead of staying on the desired row, the page would reload and you'd be placed back at the top and have to scroll down. In ASP.NET 2.0 you can simply add the MaintainScrollPostionOnPostBack attribute to the Page directive:
@ Page Language="C#" MaintainScrollPositionOnPostback="true" AutoEventWireup="true" CodeFile="..." Inherits="..."

2. Set the default focus to a control when the page loads: This is another extremely simple thing that can be done without resorting to writing JavaScript. If you only have a single textbox (or two) on a page why should the user have to click in the textbox to start typing? Shouldn't the cursor already be blinking in the textbox so they can type away? Using the DefaultFocus property of the HtmlForm control you can easily do this.
form id="frm" DefaultFocus="txtUserName" runat="server"
...
form

3. Set the default button that is triggered when the user hits the enter key: This was a major pain point in ASP.NET 1.1 and required some JavaScript to be written to ensure that when the user hit the enter key that the appropriate button on the form triggered a "click" event on the server-side. Fortunately, you can now use the HtmlForm control's DefaultButton property to set which button should be clicked when the user hits enter. This property is also available on the Panel control in cases where different buttons should be triggered as a user moves into different Panels on a page.
form id="frm" DefaultButton="btnSubmit" runat="server"
...
form

4. Locate nested controls easily: Finding controls within a Page's control hierarchy can be painful but if you know how the controls are nested you can use the lesser known "$" shortcut to find controls without having to write recursive code. If you're looking for a great way to recursively find a control (in cases where you don't know the exact control nesting) check out my good buddy Michael Palermo's blog entry. The following example shows how to use the DefaultFocus property to set the focus on a textbox that is nested inside of a FormView control. Notice that the "$" is used to delimit the nesting:
form id="form1" runat="server" DefaultFocus="formVw$txtName"
div
asp:FormView ID="formVw" runat="server"
ItemTemplate
Name:
asp:TextBox ID="txtName" runat="server"
Text='<%# Eval("FirstName") + " " + Eval("LastName") %>'
ItemTemplate
asp:FormView
div
form

This little trick can also be used on the server-side when calling FindControl(). I blogged about this awhile back if you'd like more details. Here's an example:

TextBox tb = this.FindControl("form1$formVw$txtName") as TextBox;
if (tb != null)
{
//Access TextBox control
}

5. Strongly-typed access to cross-page postback controls: This one is a little more involved than the others, but quite useful. ASP.NET 2.0 introduced the concept of cross-page postbacks where one page could postback information to a page other than itself. This is done by setting the PostBackUrl property of a button to the name of the page that the button should postback data to. Normally, the posted data can be accessed by doing something like PreviousPage.FindControl("ControlID"). However, this requires a cast if you need to access properties of the target control in the previous page (which you normally need to do). If you add a public property into the code-behind page that initiates the postback operation, you can access the property in a strongly-typed manner by adding the PreviousPageType directive into the target page of the postback. That may sound a little confusing if you haven't done it so let me explain a little more.

If you have a page called Default.aspx that exposes a public property that returns a Textbox that is defined in the page, the page that data is posted to (lets call it SearchResults.aspx) can access that property in a strongly-typed manner (no FindControl() call is necessary) by adding the PreviousPageType directive into the top of the page:

@ PreviousPageType VirtualPath="Default.aspx"

By adding this directive, the code in SearchResults.aspx can access the TextBox defined in Default.aspx in a strongly-typed manner. The following example assumes the property defined in Default.aspx is named SearchTextBox.
TextBox tb = PreviousPage.SearchTextBox;

This code obviously only works if the previous page is Default.aspx. PreviousPageType also has a TypeName property as well where you could define a base type that one or more pages derive from to make this technique work with multiple pages. You can learn more about PreviousPageType here.

6. Strongly-typed access to Master Pages controls: The PreviousPageType directive isn't the only one that provides strongly-typed access to controls. If you have public properties defined in a Master Page that you'd like to access in a strongly-typed manner you can add the MasterType directive into a page as shown next (note that the MasterType directive also allows a TypeName to be defined as with the PreviousPageType directive):

@ MasterType VirtualPath="MasterPage.master"

You can then access properties in the target master page from a content page by writing code like the following:
this.Master.HeaderText = "Label updated using MasterType directive with VirtualPath attribute.";

You can find several other tips and tricks related to working with master pages including sharing master pages across IIS virtual directories at a previous blog post I wrote.

7. Validation groups: You may have a page that has multiple controls and multiple buttons. When one of the buttons is clicked you want specific validator controls to be evaluated rather than all of the validators defined on the page. With ASP.NET 1.1 there wasn't a great way to handle this without resorting to some hack code. ASP.NET 2.0 adds a ValidationGroup property to all validator controls and buttons (Button, LinkButton, etc.) that easily solves the problem. If you have a TextBox at the top of a page that has a RequiredFieldValidator next to it and a Button control, you can fire that one validator when the button is clicked by setting the ValidationGroup property on the button and on the RequiredFieldValidator to the same value. Any other validators not in the defined ValidationGroup will be ignored when the button is clicked. Here's an example:

form id="form1" runat="server"

Search Text: asp:TextBox ID="txtSearch" runat="server"

asp:RequiredFieldValidator ID="valSearch" runat="Server"
ControlToValidate="txtSearch" ValidationGroup="SearchGroup"

asp:Button ID="btnSearch" runat="server" Text="Search"
ValidationGroup="SearchGroup"
....
Other controls with validators and buttons defined here
/form

8. Finding control/variable names while typing code: This tip is a bit more related to VS.NET than to ASP.NET directly, but it's definitely helpful for those of you who remember the first few characters of control variable name (or any variable for that matter) but can't remember the complete name. It also gives me the chance to mention two great downloads from Microsoft. First the tip though. After typing the first few characters of a control/variable name, hit CTRL + SPACEBAR and VS.NET will bring up a short list of matching items. Definitely a lot easier than searching for the control/variable definition. Thanks to Darryl for the tip. For those who are interested, Microsoft made all of the VS.NET keyboard shortcuts available in a nice downloadable and printable guide. Get the C# version here and the VB.NET version here.

That's all for now. There are a lot of other things that could be mentioned and I'll try to keep this post updated. Have a great (simple) ASP.NET 2.0 tip or trick? Post the details in the comments and I'll add it if the content is appropriate for the list. Make sure to list your name so I can give proper credit.

For those who are interested, you can also view videos I've put together that show how to accomplish different tasks from working with AJAX, to ASP.NET to Web Services and WCF at the following URL:

http://weblogs.asp.net/dwahlin/archive/tags/Video/default.aspx

Virus / Security / Spam thread ......

Find ur IP whether in SPAM list or not

http://www.spamhaus.org/index.lasso

Widows / XP & OS thread

XP tips

http://www.prbcorp.com/workshop/ws/full/Windows_XP_Tips/

100 Windows Command

Accessibility Controls
access.cpl

Add Hardware Wizard
hdwwiz.cpl

Add/Remove Programs
appwiz.cpl

Administrative Tools
control admintools

Automatic Updates
wuaucpl.cpl

Bluetooth Transfer Wizard
fsquirt

Calculator
calc

Certificate Manager
certmgr.msc

Character Map
charmap

Check Disk Utility
chkdsk

Clipboard Viewer
clipbrd

Command Prompt
cmd

Component Services
dcomcnfg

Computer Management
compmgmt.msc

Date and Time Properties
timedate.cpl

DDE Shares
ddeshare

Device Manager
devmgmt.msc

Direct X Control Panel (If Installed)*
directx.cpl

Direct X Troubleshooter
dxdiag

Disk Cleanup Utility
cleanmgr

Disk Defragment
dfrg.msc

Disk Management
diskmgmt.msc

Disk Partition Manager
diskpart

Display Properties
control desktop

Display Properties
desk.cpl

Display Properties (w/Appearance Tab Preselected)
control color

Dr. Watson System Troubleshooting Utility
drwtsn32

Driver Verifier Utility
verifier

Event Viewer
eventvwr.msc

File Signature Verification Tool
sigverif

Findfast
findfast.cpl

Folders Properties
control folders

Fonts
control fonts

Fonts Folder
fonts

Free Cell Card Game
freecell

Game Controllers
joy.cpl

Group Policy Editor (XP Prof)
gpedit.msc

Hearts Card Game
mshearts

Iexpress Wizard
iexpress

Indexing Service
ciadv.msc

Internet Properties
inetcpl.cpl


IP Configuration (Display Connection Configuration)
ipconfig /all

IP Configuration (Display DNS Cache Contents)
ipconfig /displaydns

IP Configuration (Delete DNS Cache Contents)
ipconfig /flushdns

IP Configuration (Release All Connections)
ipconfig /release

IP Configuration (Renew All Connections)
ipconfig /renew

IP Configuration (Refreshes DHCP & Re-Registers DNS)
ipconfig /registerdns

IP Configuration (Display DHCP Class ID)
ipconfig /showclassid

IP Configuration (Modifies DHCP Class ID)
ipconfig /setclassid


ava Control Panel (If Installed)
jpicpl32.cpl

Java Control Panel (If Installed)
javaws

Keyboard Properties
control keyboard

Local Security Settings
secpol.msc

Local Users and Groups
lusrmgr.msc

Logs You Out Of Windows
logoff

Mcft Chat
winchat

Minesweeper Game
winmine

Mouse Properties
control mouse

Mouse Properties
main.cpl

Network Connections
control netconnections

Network Connections
ncpa.cpl

Network Setup Wizard
netsetup.cpl

Notepad
notepad

Nview Desktop Manager (If Installed)
nvtuicpl.cpl

Object Packager
packager

ODBC Data Source Administrator
odbccp32.cpl

On Screen Keyboard
osk

Opens AC3 Filter (If Installed)
ac3filter.cpl

Password Properties
password.cpl

Performance Monitor
perfmon.msc

Performance Monitor
perfmon

Phone and Modem Options
telephon.cpl

Power Configuration
powercfg.cpl

Printers and Faxes
control printers

Printers Folder
printers

Private Character Editor
eudcedit

Quicktime (If Installed)
QuickTime.cpl

Regional Settings
intl.cpl

Registry Editor
regedit

Registry Editor
regedit32

Remote Desktop
mstsc

Removable Storage
ntmsmgr.msc

Removable Storage Operator Requests
ntmsoprq.msc

Resultant Set of Policy (XP Prof)
rsop.msc

Scanners and Cameras
sticpl.cpl

Scheduled Tasks
control schedtasks

Security Center
wscui.cpl

Services
services.msc

Shared Folders
fsmgmt.msc

Shuts Down Windows
shutdown

Sounds and Audio
mmsys.cpl

Spider Solitare Card Game
spider

SQL Client Configuration
cliconfg

System Configuration Editor
sysedit

System Configuration Utility
msconfig

System File Checker Utility (Scan Immediately)
sfc /scannow

System File Checker Utility (Scan Once At Next Boot)
sfc /scanonce

System File Checker Utility (Scan On Every Boot)
sfc /scanboot

System File Checker Utility (Return to Default Setting)
sfc /revert

System File Checker Utility (Purge File Cache)
sfc /purgecache

System File Checker Utility (Set Cache Size to size x)
sfc /cachesize=x

System Properties
sysdm.cpl

Task Manager
taskmgr

Telnet Client
telnet

User Account Management
nusrmgr.cpl

Utility Manager
utilman

Windows Firewall
firewall.cpl

Windows Magnifier
magnify

Windows Management Infrastructure
wmimgmt.msc

Windows System Security Tool
syskey

Windows Update Launches
wupdmgr

Windows XP Tour Wizard
tourstart

English & Communications

http://www.english-at-home.com

Input Validation Cheat Sheet

http://michaeldaw.org/input_validation_cheat_sheet/

Google Cheat Sheet ....

http://www.google.com/help/cheatsheet.html

.Net architecture & core concepts

.Net Framework basics

When we speak about .Net, we mean by .NET framework. .NET Framework is made up of the Common Language Runtime (CLR), the Base Class Library (System Classes). This allows us to build our own services (Web Services or Windows Services) and Web Applications (Web forms Or Asp .Net), and Windows applications (Windows forms). We can see how this is all put together.?


Above Picture shows overall picture, demonstrating how the .NET languages follows rules provided by the Common Language Specifications (CLS). These languages can all be used?Independently to build application and can all be used with built-in data describers (XML) and data assessors (ADO .NET and SQL). Every component of the .NET Framework can take advantage of the large pre- built library of classes called the Framework Class Library (FCL). Once everything is put together, the code that is created is executed in the Common Language Runtime. Common Language Runtime is designed to allow any .NET-compliant language to execute its code. At the time of writing, these languages included VB .Net, C# and C++ .NET, but any language can become .NET- compliant, if they follow CLS rules. The following sections will address each of the parts of the architecture.

.Net Common Language Specifications (CLS):

In an object-oriented environment, everything is considered as an object. (This point is explained in this article and the more advanced features are explained in other articles.) You create a template for an object (this is called the class file), and this class file is used to create multiple objects.
TIP: Consider a Rectangle. You may want to create many Rectangle in your lifetime; but each Rectangle will have certain characteristics and certain functions. For example, each rectangle will have a specific width and color. So now, suppose your friend also wants to create a Rectangle. Why reinvent the Rectangle? You can create a common template and share it with others. They create the Rectangle based on your template. This is the heart of object-oriented programming?the template is the class file, and the Rectangle is the objects built from that class. Once you have created an object, your object needs to communicate with many other Objects.

Even if it is created in another .NET language doesn?t matter, because each language follows the rules of the CLS. The CLS defines the necessary things as common variable types (this is called the Common Type System CTS ), common visibility like when and where can one see these variables, common method specifications, and so on. It doesn?t have one rule which tells how C# composes its objects and another rule tells how VB .Net does the same thing . To steal a phrase, there is now ?One rule to bind them all.? One thing to note here is that the CLS simply provides the bare rules. Languages can adhere to their own specification. In this case, the actual compilers do not need to be as powerful as those that support the full CLS.
The Common Language Runtime (CLR):

The heart of .net Framework is Common Language Runtime (CLR). All .NET-compliant languages run in a common, managed runtime execution environment. With the CLR, you can rely on code that is accessed from different languages. This is a huge benefit. One coder can write one module in C#, and another can access and use it from VB .Net. Automatic object management, the .NET languages take care of memory issues automatically. These are the few listed?benefits which you get from CLR.
Microsoft Intermediate Language (MSIL):

So how can many different languages be brought together and executed together??Microsoft Intermediate Language (MSIL) or, as it?s more commonly known, Intermediate Language (IL). In its simplest terms, IL is a programming language.?If you wanted to, you could write IL directly, compile it, and run it. But why would want to write such low level code? Microsoft has provided with higher-level languages, such as C#, that one can use. Before the code is executed, the MSIL must be converted into platform-specific code. The CLR includes something called a JIT compiler in which the compiler order is as follows.

Source Code => Compiler => Assembley =>Class Loader =>Jit Compiler =>Manged Native Code=>Execution.

The above is the order of compilation and execution of programs. Once a program is written in a .Net compliant language, the rest all is the responsibility of the frame work.

--------------------------------------------------

ASSEMBLIES

Assemblies are basically the compiled code in .Net which contains the code in Microsoft Intermediate Langauge and one more thing that assembiles do for us as compared to dlls is they can maintain versioning with the help of the manifest.
You dont need to register the assemblies after compiling like we needed in dlls. you can put the assemblies in the bin folder and refer the namespaces from there.
In short find the assembly description as :
Assemblies are the building blocks of .NET Framework applications; they form the fundamental unit of deployment, version control, reuse, activation scoping, and security permissions. An assembly is a collection of types and resources that are built to work together and form a logical unit of functionality. An assembly provides the common language runtime with the information it needs to be aware of type implementations. To the runtime, a type does not exist outside the context of an assembly.

Differences Between Shared and Private Assemblies and how to use them.

Shared and Private Assembly: A private assembly is a assembly that is available to particular applications where they are kept. And cannot be references outside the scope of the folder where they are kept.
In contrast, Shared Assemblies are the assemblies that are accessible globally/shared across the machine to all the applications. For using the shared assemblies you need to register the assembly with a strong name in the global assembly cache(GAC) using gacutil.exe. GAC can be found on all the computers with .Net framework installed.

----------------------------------
Assembly vs DLL

1.Dot NET assembly is the component standard specified by the .NET, so dot net assemblies are understandable to only Microsoft.NET and can be used only in .NET managed applications.

DLL contains library code to be used by any program running on Windows. A DLL may contain either structured or object oriented libraries.

2. assembly :

An assembly is the smallest unit that you use to define the version of an application. The version of an assembly determines the version of the types and the other resources that it contains. The .NET Framework allows the execution of multiple versions of the same assembly on the same machine. The side-by-side execution of assemblies overcomes the problem known as "DLL hell," which is one of the major problems associated with COM applications.

DLL:

A Dynamic Link Library (DLL) is a file that is loaded at runtime, and its functions linked
dynamically at that time. This allows for multiple applications that use the same library functions to all share one DLL, and if the code in the DLL needs to be fixed, the DLL can be replaced, and all applications that use it will get the benefit of the update. Static libraries are different from DLLs in that each application gets its own copy of the functions, and they are embedded into the Exe at compile/link time. If the library functions need to be fixed, every application that uses them must be recompiled to get the fixes.

Assembly ..... concept ... :-)

http://www.dnzone.com/ShowDetail.asp?NewsId=698

OOPS concepts .....

Constructor

C# supports two types of constructor, a class constructor (static constructor) and an instance constructor (non-static constructor).

Static constructor is used to initialize static data members as soon as the class is referenced first time, whereas an instance constructor is used to create an instance of that class with keyword. A static constructor does not take access modifiers or have parameters and can't access any non-static data member of a class.

Since static constructor is a class constructor, they are guaranteed to be called as soon as we refer to that class or by creating an instance of that class.

You may say, why not initialize static data members where we declare them in the code. Like this :

private static int id = 10;
private static string name = "jack";

Static data members can certainly be initialized at the time of their declaration but there are times when value of one static member may depend upon the value of another static member. In such cases we definitely need some mechanism to handle conditional initialization of static members. To handlesuch situation, C# provides static constructor.

Let me explain you with examples :

//File Name : Test.cs
using System;
namespace Constructor
{
class Test
{
//Declaration and initialization of static data member
private static int id = 5;
public static int Id
{
get
{
return id;
}
}
public static void print()
{
Console.WriteLine("Test.id = " + id);
}
static void Main(string[] args)
{
//Print the value of id
Test.print();
}
}
}

In the above example, static data member is declared and initialized in same line. So if you compile and run this program your output would look similar to this :

Test.id = 5

Lets create one more class similar to class Test but this time the value of its static data member would depend on the value of static data member of class Test.id.

//File Name : Test1.cs
using System;
namespace Constructor
{
class Test1
{
private static int id ;
//Static constructor, value of data member id is set conditionally here.
//This type of initialization is not possible at the time of declaration.
static Test1()
{
if( Test.Id < id =" 20;">
{
id = 100;
}
Console.WriteLine("Static Constructor for Class Test1 Called..");
}
public static void print()
{
Console.WriteLine("Test1.id = " + id);
}
static void Main(string[] args)
{
//Print the value of id
Test1.print();
}
}
}

As you can see in the above static constructor, static data member is initialized conditionally. This type of initialization is not possible at the time of declaration. This is where static constructor comes in picture. So if you compile and run this program your output would look similar to this :

Static Constructor for Class Test1 Called..
id = 20

Since in class Test was initialized with a value of 5, therefore in class Test1 got initialized to a value of 20.

Some important point regarding static constructor from C# Language Specification and C# Programmer's Reference :

1) The static constructor for a class executes before any instance of the class is created.
2) The static constructor for a class executes before any of the static members for the class are referenced.
3) The static constructor for a class executes after the static field initializers (if any) for the class.
4) The static constructor for a class executes at most one time during a single program instantiation
5) A static constructor does not take access modifiers or have parameters.
6) A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
7) A static constructor cannot be called directly.
8) The user has no control on when the static constructor is executed in the program.
9) A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.

Hopefully, this would clear the confusion some of developers have about static constructor.