.NET TUTOR

C# Coding Standards and Best Programming Practices

2010-05-03T11:17:00.001-07:00

1. Introduction

Anybody can write code. With a few months of programming experience, you can write 'working applications'. Making it work is easy, but doing it the right way requires more work, than just making it work.

Believe it, majority of the programmers write 'working code', but not ‘good code'. Writing 'good code' is an art and you must learn and practice it.

Everyone may have different definitions for the term ‘good code’. In my definition, the following are the characteristics of good code.

· Reliable
· Maintainable
· Efficient

Most of the developers are inclined towards writing code for higher performance, compromising reliability and maintainability. But considering the long term ROI (Return On Investment), efficiency and performance comes below reliability and maintainability. If your code is not reliable and maintainable, you (and your company) will be spending lot of time to identify issues, trying to understand code etc throughout the life of your application.

2. Purpose of coding standards and best practices

To develop reliable and maintainable applications, you must follow coding standards and best practices.

The naming conventions, coding standards and best practices described in this document are compiled from our own experience and by referring to various Microsoft and non Microsoft guidelines.

There are several standards exists in the programming industry. None of them are wrong or bad and you may follow any of them. What is more important is, selecting one standard approach and ensuring that everyone is following it.

3. How to follow the standards across the team

If you have a team of different skills and tastes, you are going to have a tough time convincing everyone to follow the same standards. The best approach is to have a team meeting and developing your own standards document. You may use this document as a template to prepare your own document.

Distribute a copy of this document (or your own coding standard document) well ahead of the coding standards meeting. All members should come to the meeting prepared to discuss pros and cons of the various points in the document. Make sure you have a manager present in the meeting to resolve conflicts.

Discuss all points in the document. Everyone may have a different opinion about each point, but at the end of the discussion, all members must agree upon the standard you are going to follow. Prepare a new standards document with appropriate changes based on the suggestions from all of the team members. Print copies of it and post it in all workstations.

After you start the development, you must schedule code review meetings to ensure that everyone is following the rules. 3 types of code reviews are recommended:

Peer review – another team member review the code to ensure that the code follows the coding standards and meets requirements. This level of review can include some unit testing also. Every file in the project must go through this process.
Architect review – the architect of the team must review the core modules of the project to ensure that they adhere to the design and there is no “big” mistakes that can affect the project in the long run.
Group review – randomly select one or more files and conduct a group review once in a week. Distribute a printed copy of the files to all team members 30 minutes before the meeting. Let them read and come up with points for discussion. In the group review meeting, use a projector to display the file content in the screen. Go through every sections of the code and let every member give their suggestions on how could that piece of code can be written in a better way. (Don’t forget to appreciate the developer for the good work and also make sure he does not get offended by the “group attack”!)

4. Naming Conventions and Standards

Note :
The terms Pascal Casing and Camel Casing are used throughout this document.
Pascal Casing - First character of all words are Upper Case and other characters are lower case.
Example: BackColor
Camel Casing - First character of all words, except the first word are Upper Case and other characters are lower case.
Example: backColor

1. Use Pascal casing for Class names

public class HelloWorld
{
   ...
}

2. Use Pascal casing for Method names

void SayHello(string name)
{
   ...
}

3. Use Camel casing for variables and method parameters

int totalCount = 0;
void SayHello(string name)
{
   string fullMessage = "Hello " + name;
   ...
}

4. Use the prefix “I” with Camel Casing for interfaces ( Example: IEntity )

5. Do not use Hungarian notation to name variables.

In earlier days most of the programmers liked it - having the data type as a prefix for the variable name and using m_ as prefix for member variables. Eg:

string m_sName;
int nAge;

However, in .NET coding standards, this is not recommended. Usage of data type and m_ to represent member variables should not be used. All variables should use camel casing.

Some programmers still prefer to use the prefix m_ to represent member variables, since there is no other easy way to identify a member variable.

6. Use Meaningful, descriptive words to name variables. Do not use abbreviations.

Good:

string address
int salary

Not Good:

string nam
string addr
int sal

7. Do not use single character variable names like i, n, s etc. Use names like index, temp

One exception in this case would be variables used for iterations in loops:

for ( int i = 0; i < count; i++ )
{
   ...
}

If the variable is used only as a counter for iteration and is not used anywhere else in the loop, many people still like to use a single char variable (i) instead of inventing a different suitable name.

8. Do not use underscores (_) for local variable names.

9. All member variables must be prefixed with underscore (_) so that they can be identified from other local variables.

10. Do not use variable names that resemble keywords.

11. Prefix boolean variables, properties and methods with “is” or similar prefixes.

Ex: private bool _isFinished

12. Namespace names should follow the standard pattern

...

13. Use appropriate prefix for the UI elements so that you can identify them from the rest of the variables.

There are 2 different approaches recommended here.

a. Use a common prefix ( ui_ ) for all UI elements. This will help you group all of the UI elements together and easy to access all of them from the intellisense.

b. Use appropriate prefix for each of the ui element. A brief list is given below. Since .NET has given several controls, you may have to arrive at a complete list of standard prefixes for each of the controls (including third party controls) you are using.

Control
Prefix
Label
lbl
TextBox
txt
DataGrid
dtg
Button
btn
ImageButton
imb
Hyperlink
hlk
DropDownList
ddl
ListBox
lst
DataList
dtl
Repeater
rep
Checkbox
chk
CheckBoxList
cbl
RadioButton
rdo
RadioButtonList
rbl
Image
img
Panel
pnl
PlaceHolder
phd
Table
tbl
Validators
val

14. File name should match with class name.

For example, for the class HelloWorld, the file name should be helloworld.cs (or, helloworld.vb)

15. Use Pascal Case for file names.

5. Indentation and Spacing

1. Use TAB for indentation. Do not use SPACES. Define the Tab size as 4.

2. Comments should be in the same level as the code (use the same level of indentation).

Good:

// Format a message and display

string fullMessage = "Hello " + name;
DateTime currentTime = DateTime.Now;
string message = fullMessage + ", the time is : " + currentTime.ToShortTimeString();
MessageBox.Show ( message );

Not Good:

// Format a message and display
string fullMessage = "Hello " + name;
DateTime currentTime = DateTime.Now;
string message = fullMessage + ", the time is : " + currentTime.ToShortTimeString();
MessageBox.Show ( message );

3. Curly braces ( {} ) should be in the same level as the code outside the braces.


4. Use one blank line to separate logical groups of code.

Good:
   bool SayHello ( string name )
   {
   string fullMessage = "Hello " + name;
   DateTime currentTime = DateTime.Now;

   string message = fullMessage + ", the time is : " + currentTime.ToShortTimeString();

   MessageBox.Show ( message );

   if ( ... )
   {
   // Do something
   // ...

   return false;
   }

   return true;
   }

Not Good:

   bool SayHello (string name)
   {
   string fullMessage = "Hello " + name;
   DateTime currentTime = DateTime.Now;
   string message = fullMessage + ", the time is : " + currentTime.ToShortTimeString();
   MessageBox.Show ( message );
   if ( ... )
   {
   // Do something
   // ...
   return false;
   }
   return true;
   }

5. There should be one and only one single blank line between each method inside the class.

6. The curly braces should be on a separate line and not in the same line as if, for etc.

Good:
   if ( ... )
   {
   // Do something
   }

Not Good:

   if ( ... ) {
   // Do something
   }

7. Use a single space before and after each operator and brackets.

Good:
   if ( showResult == true )
   {
   for ( int i = 0; i < 10; i++ )
   {
   //
   }
   }

Not Good:

   if(showResult==true)
   {
   for(int i= 0;i<10;i++)
   {
   //
   }
   }

8. Use #region to group related pieces of code together. If you use proper grouping using #region, the page should like this when all definitions are collapsed.

9. Keep private member variables, properties and methods in the top of the file and public members in the bottom.

6. Good Programming practices

1. Avoid writing very long methods. A method should typically have 1~25 lines of code. If a method has more than 25 lines of code, you must consider re factoring into separate methods.

2. Method name should tell what it does. Do not use mis-leading names. If the method name is obvious, there is no need of documentation explaining what the method does.

Good:
   void SavePhoneNumber ( string phoneNumber )
   {
   // Save the phone number.
   }

Not Good:

   // This method will save the phone number.
   void SaveDetails ( string phoneNumber )
   {
   // Save the phone number.
   }

3. A method should do only 'one job'. Do not combine more than one job in a single method, even if those jobs are very small.

Good:
   // Save the address.
   SaveAddress ( address );

   // Send an email to the supervisor to inform that the address is updated.
   SendEmail ( address, email );

   void SaveAddress ( string address )
   {
   // Save the address.
   // ...
   }

   void SendEmail ( string address, string email )
   {
   // Send an email to inform the supervisor that the address is changed.
   // ...
   }

Not Good:

   // Save address and send an email to the supervisor to inform that
// the address is updated.
   SaveAddress ( address, email );

   void SaveAddress ( string address, string email )
   {
   // Job 1.
   // Save the address.
   // ...

   // Job 2.
   // Send an email to inform the supervisor that the address is changed.
   // ...
   }

4. Use the c# or VB.NET specific types (aliases), rather than the types defined in System namespace.

   int age; (not Int16)
   string name; (not String)
   object contactInfo; (not Object)


Some developers prefer to use types in Common Type System than language specific aliases.

5. Always watch for unexpected values. For example, if you are using a parameter with 2 possible values, never assume that if one is not matching then the only possibility is the other value.

Good:

If ( memberType == eMemberTypes.Registered )
{
   // Registered user… do something…
}
else if ( memberType == eMemberTypes.Guest )
{
   // Guest user... do something…
}
else
{
   // Un expected user type. Throw an exception
   throw new Exception (“Un expected value “ + memberType.ToString() + “’.”)

   // If we introduce a new user type in future, we can easily find
// the problem here.
}

Not Good:

If ( memberType == eMemberTypes.Registered )
{
   // Registered user… do something…
}
else
{
   // Guest user... do something…

// If we introduce another user type in future, this code will
// fail and will not be noticed.
}

6. Do not hardcode numbers. Use constants instead. Declare constant in the top of the file and use it in your code.

However, using constants are also not recommended. You should use the constants in the config file or database so that you can change it later. Declare them as constants only if you are sure this value will never need to be changed.

7. Do not hardcode strings. Use resource files.

8. Convert strings to lowercase or upper case before comparing. This will ensure the string will match even if the string being compared has a different case.

if ( name.ToLower() == “john” )
{
   //…
}

9. Use String.Empty instead of “”

Good:

If ( name == String.Empty )
{
   // do something
}

Not Good:

If ( name == “” )
{
   // do something
}

10. Avoid using member variables. Declare local variables wherever necessary and pass it to other methods instead of sharing a member variable between methods. If you share a member variable between methods, it will be difficult to track which method changed the value and when.

11. Use enum wherever required. Do not use numbers or strings to indicate discrete values.

Good:
   enum MailType
   {
   Html,
   PlainText,
   Attachment
   }

   void SendMail (string message, MailType mailType)
   {
   switch ( mailType )
   {
   case MailType.Html:
   // Do something
   break;
   case MailType.PlainText:
   // Do something
   break;
   case MailType.Attachment:
   // Do something
   break;
   default:
   // Do something
   break;
   }
   }

Not Good:

   void SendMail (string message, string mailType)
   {
   switch ( mailType )
   {
   case "Html":
   // Do something
   break;
   case "PlainText":
   // Do something
   break;
   case "Attachment":
   // Do something
   break;
   default:
   // Do something
   break;
   }
   }
12. Do not make the member variables public or protected. Keep them private and expose public/protected Properties.

13. The event handler should not contain the code to perform the required action. Rather call another method from the event handler.

14. Do not programmatically click a button to execute the same action you have written in the button click event. Rather, call the same method which is called by the button click event handler.

15. Never hardcode a path or drive name in code. Get the application path programmatically and use relative path.

16. Never assume that your code will run from drive "C:". You may never know, some users may run it from network or from a "Z:".

17. In the application start up, do some kind of "self check" and ensure all required files and dependancies are available in the expected locations. Check for database connection in start up, if required. Give a friendly message to the user in case of any problems.

18. If the required configuration file is not found, application should be able to create one with default values.

19. If a wrong value found in the configuration file, application should throw an error or give a message and also should tell the user what are the correct values.

20. Error messages should help the user to solve the problem. Never give error messages like "Error in Application", "There is an error" etc. Instead give specific messages like "Failed to update database. Please make sure the login id and password are correct."

21. When displaying error messages, in addition to telling what is wrong, the message should also tell what should the user do to solve the problem. Instead of message like "Failed to update database.", suggest what should the user do: "Failed to update database. Please make sure the login id and password are correct."

22. Show short and friendly message to the user. But log the actual error with all possible information. This will help a lot in diagnosing problems.

23. Do not have more than one class in a single file.

24. Have your own templates for each of the file types in Visual Studio. You can include your company name, copy right information etc in the template. You can view or edit the Visual Studio file templates in the folder C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\ItemTemplatesCache\CSharp\1033. (This folder has the templates for C#, but you can easily find the corresponding folders or any other language)

25. Avoid having very large files. If a single file has more than 1000 lines of code, it is a good candidate for refactoring. Split them logically into two or more classes.

26. Avoid public methods and properties, unless they really need to be accessed from outside the class. Use “internal” if they are accessed only within the same assembly.

27. Avoid passing too many parameters to a method. If you have more than 4~5 parameters, it is a good candidate to define a class or structure.

28. If you have a method returning a collection, return an empty collection instead of null, if you have no data to return. For example, if you have a method returning an ArrayList, always return a valid ArrayList. If you have no items to return, then return a valid ArrayList with 0 items. This will make it easy for the calling application to just check for the “count” rather than doing an additional check for “null”.

29. Use the AssemblyInfo file to fill information like version number, description, company name, copyright notice etc.

30. Logically organize all your files within appropriate folders. Use 2 level folder hierarchies. You can have up to 10 folders in the root folder and each folder can have up to 5 sub folders. If you have too many folders than cannot be accommodated with the above mentioned 2 level hierarchy, you may need re factoring into multiple assemblies.

16. Make sure you have a good logging class which can be configured to log errors, warning or traces. If you configure to log errors, it should only log errors. But if you configure to log traces, it should record all (errors, warnings and trace). Your log class should be written such a way that in future you can change it easily to log to Windows Event Log, SQL Server, or Email to administrator or to a File etc without any change in any other part of the application. Use the log class extensively throughout the code to record errors, warning and even trace messages that can help you trouble shoot a problem.

17. If you are opening database connections, sockets, file stream etc, always close them in the finally block. This will ensure that even if an exception occurs after opening the connection, it will be safely closed in the finally block.

18. Declare variables as close as possible to where it is first used. Use one variable declaration per line.

19. Use StringBuilder class instead of String when you have to manipulate string objects in a loop. The String object works in weird way in .NET. Each time you append a string, it is actually discarding the old string object and recreating a new object, which is a relatively expensive operations.

Consider the following example:

public string ComposeMessage (string[] lines)
{
   string message = String.Empty;

   for (int i = 0; i < lines.Length; i++)
   {
   message += lines [i];
   }

   return message;
}

In the above example, it may look like we are just appending to the string object ‘message’. But what is happening in reality is, the string object is discarded in each iteration and recreated and appending the line to it.

If your loop has several iterations, then it is a good idea to use StringBuilder class instead of String object.

See the example where the String object is replaced with StringBuilder.

public string ComposeMessage (string[] lines)
{
   StringBuilder message = new StringBuilder();

   for (int i = 0; i < lines.Length; i++)
   {
   message.Append( lines[i] );
   }

   return message.ToString();
}

7. Architecture

1. Always use multi layer (N-Tier) architecture.

2. Never access database from the UI pages. Always have a data layer class which performs all the database related tasks. This will help you support or migrate to another database back end easily.

3. Use try-catch in your data layer to catch all database exceptions. This exception handler should record all exceptions from the database. The details recorded should include the name of the command being executed, stored proc name, parameters, connection string used etc. After recording the exception, it could be re thrown so that another layer in the application can catch it and take appropriate action.

4. Separate your application into multiple assemblies. Group all independent utility classes into a separate class library. All your database related files can be in another class library.

8. ASP.NET

1. Do not use session variables throughout the code. Use session variables only within the classes and expose methods to access the value stored in the session variables. A class can access the session using System.Web.HttpCOntext.Current.Session

2. Do not store large objects in session. Storing large objects in session may consume lot of server memory depending on the number of users.

3. Always use style sheet to control the look and feel of the pages. Never specify font name and font size in any of the pages. Use appropriate style class. This will help you to change the UI of your application easily in future. Also, if you like to support customizing the UI for each customer, it is just a matter of developing another style sheet for them

9. Comments

Good and meaningful comments make code more maintainable. However,

1. Do not write comments for every line of code and every variable declared.

2. Use // or /// for comments. Avoid using /* … */

3. Write comments wherever required. But good readable code will require very less comments. If all variables and method names are meaningful, that would make the code very readable and will not need many comments.

4. Do not write comments if the code is easily understandable without comment. The drawback of having lot of comments is, if you change the code and forget to change the comment, it will lead to more confusion.

5. Fewer lines of comments will make the code more elegant. But if the code is not clean/readable and there are less comments, that is worse.

6. If you have to use some complex or weird logic for any reason, document it very well with sufficient comments.

7. If you initialize a numeric variable to a special number other than 0, -1 etc, document the reason for choosing that value.

8. The bottom line is, write clean, readable code such a way that it doesn't need any comments to understand.

9. Perform spelling check on comments and also make sure proper grammar and punctuation is used.

10. Exception Handling

1. Never do a 'catch exception and do nothing'. If you hide an exception, you will never know if the exception happened or not. Lot of developers uses this handy method to ignore non significant errors. You should always try to avoid exceptions by checking all the error conditions programmatically. In any case, catching an exception and doing nothing is not allowed. In the worst case, you should log the exception and proceed.

2. In case of exceptions, give a friendly message to the user, but log the actual error with all possible details about the error, including the time it occurred, method and class name etc.

3. Always catch only the specific exception, not generic exception.

Good:

   void ReadFromFile ( string fileName )
   {
   try
   {
   // read from file.
   }
   catch (FileIOException ex)
   {
   // log error.
   // re-throw exception depending on your case.
   throw;
   }
   }

Not Good:

void ReadFromFile ( string fileName )
{
   try
   {
   // read from file.
   }
   catch (Exception ex)
   {
   // Catching general exception is bad... we will never know whether
   // it was a file error or some other error.
   // Here you are hiding an exception.
   // In this case no one will ever know that an exception happened.

   return "";
   }
}


4. No need to catch the general exception in all your methods. Leave it open and let the application crash. This will help you find most of the errors during development cycle. You can have an application level (thread level) error handler where you can handle all general exceptions. In case of an 'unexpected general error', this error handler should catch the exception and should log the error in addition to giving a friendly message to the user before closing the application, or allowing the user to 'ignore and proceed'.

5. When you re throw an exception, use the throw statement without specifying the original exception. This way, the original call stack is preserved.

Good:

catch
{
   // do whatever you want to handle the exception

   throw;
}

Not Good:

catch (Exception ex)
{
   // do whatever you want to handle the exception

   throw ex;
}

6. Do not write try-catch in all your methods. Use it only if there is a possibility that a specific exception may occur and it cannot be prevented by any other means. For example, if you want to insert a record if it does not already exists in database, you should try to select record using the key. Some developers try to insert a record without checking if it already exists. If an exception occurs, they will assume that the record already exists. This is strictly not allowed. You should always explicitly check for errors rather than waiting for exceptions to occur. On the other hand, you should always use exception handlers while you communicate with external systems like network, hardware devices etc. Such systems are subject to failure anytime and error checking is not usually reliable. In those cases, you should use exception handlers and try to recover from error.

7. Do not write very large try-catch blocks. If required, write separate try-catch for each task you perform and enclose only the specific piece of code inside the try-catch. This will help you find which piece of code generated the exception and you can give specific error message to the user.

8. Write your own custom exception classes if required in your application. Do not derive your custom exceptions from the base class SystemException. Instead, inherit from ApplicationException.

Web Services

2010-05-03T09:29:00.002-07:00

Webservices are services exposed over the internet. Typically, webservice is just like any other class library, written in any language. What make it a 'web service' is, it can be accessed across internet.

Eventhough webservice is a new technology with a wide range of usage, it is a pretty simple concept. It doesn't require much additional knowledge to create web services if you are already familiar with C# or VB.NET. (Web services are not specific to .NET. Even Java has web service applications, but here we are discussing only the .NET web services.)

As we mentioned, web services are exposed over internet. To make this happen, it has to be hosted with a web site. Othen than hosted as part of a web site to make this visible across internet, web services have no web pages or UI. It is just a set of classes with public/private methods and properties.

Web services are a group of [web] methods. Consumer applications can treat this as just another class library. Regular class libraries are located along with the same application and we can call any methods in the class libraries (assemblies). But in case of web services, the assembly is located in the internet server. The consumer application will not have direct access to the assembly. Consumer applications have to add a reference to the webservice URL and then call methods in it. The method call goes across the internet using SOAP protocal and results are returned across internet in the form of XML. The communication across internet happens transparently and the application need not know anything about this communication.

Creating a simple web service

If you are using VS.NET, it won't take more than 2-3 minutes to create your first webservice. Follow the steps below to create a web service:

Choose New Projectfrom VS.NET and create a C# project of type 'ASP.NET Web Service' and give the name 'MyWebService'

The new project will have a default page 'Service1.asmx'. This is your first web service page. Web service pages have the extension .asmx (like ASP.NET pages have the extension.aspx)

The code behind file 'Service1.asmx.cs' have a class 'Service1'. This is like other regular classes with the only difference that it inherits the system classSystem.Web.Services.WebService. This is required for web service classes.

VS.NET creates a sample method for you. All you have to do is, uncomment the following method in Service1.asmx.cs

//[WebMethod]
//public string HelloWorld()
//{
//return "Hello World";
//}

Note that this method is pretty much same as any other regular method.
The only difference is, it has an attribute [WebMethod]. This attribute make
the method visible across internet. If you remove this attribute, your
application will still compile, but the consumer applications cannot call this
method across internet.

Ok, thats all you have to do to create a simple webservice. Build your solution and your web service is ready to be called by other applications.

Create a consumer application

A wide range of applications can consume the web services, including web page, other web services, windows applications etc. let us create a sample windows application and call our web service.

Create a new C# Windows Application.

Right click on the 'References' in the Solution Explorer, under your project name. Choose 'Web References'.

Another window will open and will allow you to specify the URL of the web service to be referenced.

Type the URL of your web service in the space provided for 'URL'. If you have created the web service in the local machine's default web site, the URL might be like this :

http://localhost/MyWebService/Service1.asmx

If you have given a different name fro the project or if you have changed the default service name, then your URL may differ. Type the URL and press enter. It will attempt to connect with the web service and if succeeded it will retrieve the public web methods and display. Once you get this success screen, press the 'Add Reference' button on the screen to add the web reference to your application. There is a space to specify the 'web reference name', which will have the default value 'localhost'. Leave it as it is.

Now you are ready to make calls to the webservice. Just use the following code in your application:

localhost.Service1 service = new localhost.Service1();
string result = service.HelloWorld();

MessageBox.Show( result );

Let us analyze our code. The first line creates an instance of the Service1 class, just like any regular class. Only thing is it uses the namespace 'localhost'. This is same as the 'web reference name' we specified while adding the web reference. We can use any web reference name when we add the reference and have to use the same name as namespace while making calls to the web service class.

In the second line, we are actually calling the web method 'HelloWorld()' and it returns the result as a string. Note this is just like any other method call. So, your application makes the call to web service as if it is calling any local class library calls!! The communication with web service, wrapping your calls in SOAP/XML, retrieve results from web service, unwrap the SOAP/XML to get the actual result etc are done behind the scene by the framework and you need not do any additional work to make all this work.

Now you can go back to your web service, add more methods with different parameters and play around with that. You will be able to call methods in the web service just like you use any local class. Note that when you make any changes to the method name or parameters, or if you add new methods, you will need to refresh your web reference to get access to the updated web service methods. To do this, go to the Server Explorer, right click on the web reference name 'localhost' under the 'Web References'. Then choose 'Refresh'. This will communicate with the web service again and retrieve the latest web service data.

How does all this work?

To make calls to any classes, your application need to know the details of the class. To successfully compile your code, it has to have information about the class, what are the public methods and properties etc. But in your sample code which calls the web service, the actual Service1class resides in the web (in your case, in your local web server). So how does the application compile without having the 'Service1' class in your application?

This is where the framework help you. When you add a 'web reference' to the web service URL, VS.NET actually creates local proxy in your application. A local proxy is a minimal version of the actual class. The proxy has just the sufficient information about the 'real class', which is required for your application to successfully compile. The proxy class has the list of all public web methods in the real web service class and it knows the parameters and their data types of each method.

The most important thing is, your application is actually using this proxy class and not the real web service class.

localhost.Service1 service = new localhost.Service1();
string result = service.HelloWorld();

MessageBox.Show( result );

In the above code, localhost.Service1is actually the proxy class (a representative of a real class), which is created automatically by VS.NET when you added the web reference. You are creating an instance of the proxy class and calling the 'HelloWorld()' method of this proxy. Since the proxy class knows that it is 'only a proxy of the real class', it redirects all calls to the 'real web service class'. The method 'HelloWorld()' in the proxy class takes care of converting the call to a web request using SOAP/XML. After retrieving the result of the web request to the real web service class, this proxy class takes the responsibility of parsing the SOAP/XML response and returning only the result string to the calling applicationn. So the proxy class does all the dirty job for you.

The proxy class has no implementation of the functionality. It just redirects the call to the web service. So, if you make any changes to the implementation in the web service, still you will get the 'updated result' when you make calls to web service. But, if you change the method name, or change the parameter types in the web service and do not 'refresh the web reference', then your application will compile with the old proxy. But when the proxy redirect the call to the web service, it will find that the parameters or method names do not match and it will fail. So, if there is any change in the method names or parameters, you must refresh your web reference.

We will explore more features of web services in another chapter. Please complete the following feedback, if this article is incomplete or misleading. Please let us know if there is anyway we can improve this article.

You can download web service samples from our projects section.

Introduction to XML

2010-05-03T09:29:00.000-07:00

XML stands for eXtended Markup Language. XML has some similarities to HTML, which is also another Markup Language (HyperText Markup Language).

An important difference between XML and HTML is, XML is used to define data, while HTML is basically used to display/format text. Main use of HTML is to make web pages. But XML is used in a wide variety of applications now and is becoming a standard for data exchange between different paltforms.
Unlike HTML, XML has no pre-defined set of tags. You can define your own tags to structure and organize your data. Let us see some sample XML :

The above piece of XML is quite self explanatory. It is used to represent the data related to a company. One thing to note here is, the tags like , etc are not predefined. Any XML document can have it's own set of tags. Only thing is, a valid XML document should follow some rules (like each tag should have a matching closing tag. There more such rules...)

Need for XML

XML is a platform neutral standard. Since it is represented in plain text, any platform can understand it. You can use XML to exchange data between Unix and Windows, Mainframes and windows applications and virtually any other platforms. It is a simple, easy to use *language* to exchange/store data.

In real world, if you have to store data, you have several choices. One of the most common mechanism is databases. Databases are the best choice if you have lot of data to be stored/manipulated. But if you have to send data to another application or platform, databases will not be much helpful. Suppose you have your data stored in an SQL Server database. What if your manager ask you to give the list of Employees in the Sales department ? How will you give the data to him? You cannot give your SQL Server database to him. He may not have a SQL Server software or he may not have the technical expertise to view data from SQL Server. XML is very helpful in such scenarios. You just need to generate an XML from the SQL Server database with the required records and hand over the XML as a print out or email. XML is so simple so that any one can simply read it using any text editor.

There are several XML viewers and editors available, which will help you read XML in the form of a tree view. Internet Explorer is a good XML viewer. Simply copy the above XML and save into a file called 'sample.xml'. Then open the xml file in internet explorer and see how it works!

You can define your own XML tags based on your needs. You can have nested tags too, which help you organize the data any way you want it. See a slightly different version of the above XML:


 
  
  
  
 
 
 
  
   
    Fred
    

3000 Briarcliif Way
Fred@spiderkerala.com
    
     616 304 1093
     616 304 1093
    
      
  
  
  
   
    Joe
    

3960 Whispering Way
Joe@spiderkerala.com
    
     616 304 1093
     616 304 1093

The XML data altogether is called an 'XML Document'. .NET gives several classes to read and manipulate XML Documents. We will explore some of them in upcoming chapters.

You might have seen our Tutorial Index, which lists all chapters. You can click on any chapter title and navigate to the corresponding page. This index is populated from an XML file.

Click here to view the XML file, from which we load our tutorial chapters.

The reason we load it from an XML file is, our chapters are continuously changing and we add new chapters frequently. All our chapters have a link to Next Chapter. If we hard-code these links in all chapters, we have to make changes in several places when we change the order of some chapters or when we add new chapters. There is all possibility that we might make some mistakes and some of the chapters may lead to 'wrong next chapter'. In our current implementation, we programmatically read the XML file and display the Tutorial Index. Also, each page has a piece of code which read the current page URL and find the Next Page Url from the XML file based on the current page URL. This mechanism helps us add new chapters without making any changes to existing pages. All we have to do is, just insert one line of entry in the XML file and the changes will be automatically reflected in all other relevant pages. Even if we want to re-order some of the chapters, we just need to re-arrange the entries in the XML file.

We use the following code to load our Chapter Index from the XML file:

public string GetChapters( string filePath )
{
 // Create an xml document.
 XmlDocument doc = new XmlDocument();   

 // Load the XML from the file.
 doc.Load(filePath);

 // Retrieve all categories from the xml.
 XmlNodeList categories  = doc.SelectNodes("DotNetSpider/tutorials/Category");

 string chapterString = "";
 int chapter = 0;

 // Iterate through all the categories
 foreach ( XmlNode categoryNode in categories )
 {
  // Add category name to the string.
  chapterString += "

" + categoryNode.Attributes["Name"].Value + "
";

  // Get all chapters in the current category.
  XmlNodeList chapters = categoryNode.SelectNodes("Chapter");

  // Loop through all chapters in the current category and add to the string.
  foreach ( XmlNode chapterNode in chapters )
  {
   ++chapter;

   chapterString += "      
Chapter " + chapter +       " : " +       chapterNode.Attributes["Name"].Value + "";   }  }   // Return the string, which contains the list of chapters.  return chapterString; }

We explored some areas where XML can be used. But XML can be used in a very wide range of ways. We will explore more advanced uses of XML in another chapter.

XML Specification

We gave a very brief introduction to XML in this chapter. This chapter is meant to give a very brief introduction and we haven't covered many important aspects of XML here. We will explain most of them in some other chapters.

XML has become a standard now and you can read the rules and specification for this standard here : http://www.w3.org/TR/2004/REC-xml-20040204

Custom Exceptions

2010-05-03T09:28:00.002-07:00

The Microsoft .NET team has done a good job by providing us a rich set of Exception classes. Most of the time, these exception classes are sufficient enough to handle any common error situation. However, it may be required that our application would need some additional exception classes, that are not available in .NET Framework.

The .NET Framework exception handling mechanism allows us to create our own custom exception classes and use it in our applications.

Custom Exceptions

All exceptions in .NET are derived from the root exception class - System.Exception. There are two other
exception classes immediately derived from the System.Exception :

System.SystemException

System.ApplicationException

All exceptions thrown by the .NET Framework is derived from the SystemException class. If we raise any exception from our application, it should be derived from the System.ApplicationException. This will differentiate our exceptions from the system generated exceptions.

It is easy to create a custom exception class. Just create a new class and mark it as derived from System.ApplicationException

public class UserNotExistsException : System.ApplicationException 
 {
 }

Now we have derived a custom exception class and we can use it in ourr application. See the sample code, showing how we
can throw ourr custom exception.

public void UpdateUser( User userObj )
 {
  if ( some error condition )
  {
   throw new UserNotExistsException();
  }
 }

The 'throw' statement allows us to raise an exception programmatically. Here we are creating a new object of type 'UserNotExistsException' and throwing it. Another class or method which calls our method should handle this exception.

try
 {
  UpdateUser( userObj );
 }
 catch ( UserNotExistsException ex )
 {
  MessageBox.Show ( ex.Message );
 }

In this sample, we are calling the method UpdateUser(...), which might throw an exception of type UserNotExistsException. If this exception is raised, it will go to our catch block and we are showing a message to the user.

Enhancing our custom exception

In the custom exception we defined above, we haven't specified any constructor. But since we derive it from the ApplicationException, it will use the public constructors available in AppicationException. It is a good idea to provide at least one constructor, which takes an error message as a parameter.

public class UserNotExistsException : System.ApplicationException 
 {
  public UserNotExistsException ( string message ) : base ( message )
  {
  }
 }

Now, when we throw this exception, we have to pass an error message to the constructor. The error handlers will be able to retrieve this message from the Exception object and show a better message to the user.

public void UpdateUser( User userObj )
 {
  if ( some error condition )
  {
   throw new UserNotExistsException( "The user you are trying to update does not exists." );
  }
 }

See the exception handler code :

try
 {
  UpdateUser( userObj );
 }
 catch ( UserNotExistsException ex )
 {
  MessageBox.Show ( ex.Message );
 }

Now the user will see the more friendly error message which we passed as part of the exception, while throwing it.

You can customize the custom exception classes such a way that it passes any information you want including the date and time the exception occurred, the method name in which the exception was first raised, user name of the current user etc. You may also provide a Save() method for your custom exception class so that when a caller catch our custom exception, he can call the Save() method, which will record the error information to the disk.

Exception classes in .NET

2010-05-03T09:28:00.000-07:00

NET Framework provides several classes to work with exceptions. When there is an exception, the .NET framework creates an object of type 'Exception' and 'throws' it. This Exception object contains all information about the 'error'.

If you enclose your code within the try-catch block, you will receive the exception object in the 'catch' block when the exception occurs. You can use this object to retrieve the information regarding the error and take appropriate action.

try
{
// Code which can cause an exception.
}
catch(Exception ex)
{
// Code to handle exception
MessageBox.Show ( ex.Message );
}

Within the catch block, you can use the Exception object to get more information about the error. The exception object exposes a property called 'Message', which gives a description about the error. This may not be a very friendly message for the end user. But you can use it to log the error and show another friendly message to the user.

The System.Exception class

In .NET, all exceptions are derived from the Exception class. The Exception class is defined inside the System namespace.Other derived exception classes are spread across many other namespaces.

Since all other exceptions are derived from the System.Exception class, if you catch System.Exception, that would cover all exceptions derived from System.Exception also. So, the statement catch (Exception) would catch all exceptions of type System.Exception and all derived exceptions. In .NET, all exceptions are derived from System.Exception. So,catch (Exception) will catch all posibble exceptions in your .NET application.

Specify what exception type you want to catch

See the catch block in the above sample code. catch ( Exception ex ) - specifies that we want to catch all exceptions of Type Exception. So, if there is an exception of Type Exception, it will be caught by the catch block.

If you specify an exception Type in the catch statement, it will catch all exceptions of the specified type and all types derived from it.

See the following sample :

try
{
// Code which can cause an exception.
}
catch(System.Web.HttpException ex)
{
// Code to handle exception
MessageBox.Show ( ex.Message );
}

The above example will only catch the exception of type System.Web.HttpException and any other exception derived from it. So, if there is any exception of typeSystem.ArithmeticException, it will not be handled and it may lead to program termination.

Handling specific Exception types

In my previous article, I mentioned few examples from real life - "When you ride a bike, you may wear a helmet. When you go for boating, you might use a life jacket. A car driver might use seat belts while driving at high speed in a high way. What is the purpose ? To handle exceptions (accidents), right ? We do not know when it might happen, so we are prepared to 'handle' such situations any time. "

Yes, a helmet helps a bike rider when he meet with an accident. A life jacket may be helpful in water and a seat belt would help a car driver. But what if some one ride a bike with a helpmet, life jacket and a seat belt ? That may not look good, right ?

Similarly, in Exception handling, you do not need to catch all exceptions. You need to catch only the 'expected' exceptions. Which means,if you are doing an arithmetic calculation, you must handle ArithmeticException and DivideByZeroException. When you are accessing the web from your code, you must handle HttpException.

The bottom line is, depending on the nature of the code, you must handle the appropriate, specific exceptions, instead of catching the father of all exceptions (System.Exception).

Multiple catch blocks

You can have any number of catch blocks for each try block. For example, if you are doing some operation which involve web access and also some arithmetic operations, you can handle both System.Web.HttpException and System.ArithmeticException. See the sample below:

try
{
// Code which can cause a web exception or arithmetic exception.
}
catch(System.Web.HttpException ex)
{
MessageBox.Show ( "A web exception occurred." );
}
catch(System.ArithmeticException ex)
{
MessageBox.Show ( "An arithmetic exception occurred." );
}

Program Flow

When an exception occurs within a try block, the program control will jump to the first catch block and compare if the exception type is same the as the type specified in the catch block. If the type matches, it will execute the catch block. If the types do not match, it will jump to the next catch block and compare. Like this, it will compare against all catch blocks until a match is found. If there is no catch block found which matches the exception type, it will become an unhandled exception and will lead to program termination

Catch derived exceptions first and base exception last

A base exception type will match the derived exceptions also. If there is a catch block with the type 'Exception', it will catch all types of exceptions. So, you have multiple catch blocks, you must specify the derived exception types first and the base types last. See the following code:

try
{
// Code which can cause a web exception or arithmetic exception.
}
catch (System.Exception ex)
{
MessageBox.Show ( "An exception occurred." );
}
catch (System.Web.HttpException ex)
{
MessageBox.Show ( "A web exception occurred." );
}

In the above code, assume there is a web exception occurred. The exception type will be compared against the first catch block. Since the WebException is derived from System.Exception or oneof it's derived classes, the types will match and the first catch block will be executed. So, you might be expecting that the catch (System.Web.HttpException)block will be executed, but it would never get called because of the catch(System.Exception ex) before that.

You must change the above code as shown below :

try
{
// Code which can cause a web exception or arithmetic exception.
}
catch (System.Web.HttpException ex)
{
MessageBox.Show ( "A web exception occurred." );
}
catch(System.Exception ex)
{
MessageBox.Show ( "An exception occurred." );
}

Now, if there is a web exception, it will go to the catch (System.Web.HttpException ex) block. All other exceptions will go to catch (System.Exception ex).

Some commonly used .NET Exception classes

System.ArithmeticException - This is the base class for exceptions that occur during arithmetic operations, such as System.DivideByZeroException and System.OverflowException.

System.ArrayTypeMismatchException - ArrayTypeMismatchException is thrown when a an incompatible object is attpemted to store into an Array.

System.DivideByZeroException - This exception is thrown when an attempt to divide a number by zero.

System.IndexOutOfRangeException - IndexOutOfRangeException is thrown when attempted to access an array using an index that is less than zero or outside the bounds of the array.

System.InvalidCastException - Thrown when an explicit type conversion from a base type or interface to a derived type fails at run time.

System.NullReferenceException - This exception is thrown when an object is accessed but it is null.

System.OutOfMemoryException - OutOfMemoryException is thrown if the 'new' operation (creating new object) fails due to in sufficient memory.

System.OverflowException - OverflowException is thrown when an arithmetic operation overflows.

System.StackOverflowException - StackOverflowException is thrown when the execution stack is exhausted by having too many pending method calls, most probably due to infinite loop.

ArgumentException - The exception that is thrown when one of the arguments provided to a method is not valid.

Exception Handling in .NET

2010-05-03T09:27:00.001-07:00

If you write a program, it is for sure that it will have errors and issues. You cannot avoid them. But what you can do is write the code such a way that it is easy to find the errors and issues so that you can solve them easily. You need the real skill to write 'maintainable code'.

What is maintainable code ?
If an existing application is given to a new employee in the company and ask him to fix a problem in that,most probably he will come back with the answer : "oh, it is stupid code.. I can't figure out what they have written. Instead of trouble shooting the issues in this code, I can re write the entire application with less time."

This is a common scenario in the programming world. The above answer shows the code is not a maintainable code. Over a period of time, there will be lot of changes required in existing applications to adapt to the new requirements. Only if you write 'maintainable code', you can enhance your application when new requirements come up and solve issues.

There is no specific set of rules to make an application 'maintainable'. There are lot of factors involved in it including following coding standards, writing lot of comments within code, writing self explanatory code, separating application into multiple well defined layers, having good exception handling etc.

What is an 'Exception' ?

'Exception' is an error situation that a program may encounter during runtime. For example, your program may be trying to write into a file, but your hard disk may be full. Or, the program may be trying to update a record in database, but that record may be already deleted. Such errors may happen any time and unless you handle such situation properly, your application may have un predictable behaviour.

What is the difference between 'Exception' and 'Error' ?

Error is an expected situation in an application. For example, you want to create a file in the folder "C:\Projects\Test\". If you attempt to create a file when this folder doesn't exists, it will make the operating system throw an exception. But you should not leave it to the operating system to throw the exception. This has to be handled through code. You must first check for the existence of the folder before you attempt to write the file. If the folder doesn't exists, you must first create the folder. This is how a stable application should be written.

Exception is a runtime error that the program may encounter during the execution of the program. For example, hard disk may be full when you attempt to write into a file, network connection may be lost while your application is communicating with another computer etc. There is no clear definition, but typically, Exceptions are unpredictable errors during runtime.

What is 'Exception Handling'?

When you ride a bike, you may wear a helmet. When you go for boating, you might use a life jacket. A car driver might use seat belts while driving at high speed in a high way. What is the purpose ? To handle exceptions (accidents), right ? We do not know when it might happen, so we are prepared to 'handle' such situations any time.

An exception can occur anytime during the execution of an application. Your application must be prepared to face such situations. An application will crash if an exception occurs and it is not handled.

"An exception handler is a piece of code which will be called when an exception occurs."

.NET Framework provides several classes to work with exceptions. The keywords try, catch are used to handle exceptions in .NET. You have to put the code (that can cause an exception) in a try block. If an exception occurs at any line of code inside a try block, the control of execution will be transfered to the code inside the catch block.

Syntax :

try
{
// Code which can cause an exception.
}
catch(Exception ex)
{
// Code to handle exception
}

Just like a bike rider wrap his head in a helmet to protect from accident, the above syntax will protect the code within the try block from accidents (exceptions).

If any statement within the try block raises an exception, the control of execution will be transfered to the first line within the catch block. You can write the error handling code in the catch block, like recording the error message into a log file, sending an email to the administrator about the problem occurred, showing an appropriate error message to the user etc.

See the following code :

try
{
Statement 1
Statement 2
Statement 3
}
catch(Exception ex)
{
Statement 4
Statement 5
}
            
Statement 6

In normal flow of program, the statements 1, 2, 3, 6 will be executed. Statements 4 and 5 will be executed only if an exception occurs.

Assume there is an exception at statement 2. In this scenario, statements 1, 2, 4, 5 and 6 will be executed. Statement 3 will not be executed at all, because an exception occurred at statement 2 and program flow was transferred to the catch block.

'finally' block

You can optionally use a 'finally' block along with the try-catch. The 'finally' block is guaranteed to be executed even if there is an exception.

Sample Code :

try
{
Statement 1
Statement 2
Statement 3
}
catch(Exception ex)
{
Statement 4
Statement 5
}
finally
{
Statement 6
Statement 7
}
            
Statement 8

In normal flow of program, the statements 1, 2, 3, 6, 7 and 8 will be executed. Statements 4 and 5 will be executed only if an exception occurs.

Assume there is an exception at statement 2. In this scenario, statements 1, 2, 4, 5, 6, 7 and 8 will be executed.

Note that the statements 6 and 7 are executed in both the cases. The bottom line is, the code within the 'finally' block is executed whether there is an exception or not.

You can use the finally block to do any code cleanup. For example, you are doing some database operations inside a try block.

try
{
Statement 1 - Open database
Statement 2 - Execute Query
Statement 3 - Close Database
}
catch(Exception ex)
{
Statement 4 - Show messagebox to user
}

In the above code sample, what will happen if an exception occurs when the statement 2 is executed ? The catch block will be executed and a message box will be shown to the user. But the Statement 3 is never executed in that case, which means the database will not be closed.

Here is where the finally block will be helpful.

try
{
Statement 1 - Open database
Statement 2 - Execute Query
}
catch(Exception ex)
{
Statement 3 - Show messagebox to user
}
finally
{
Statement 4 - Close Database
}

See the improved code. We have moved the code to close the database to the 'finally' block. The statement to close the database will be executed whether there is an exception or not.

Why should we catch exceptions ?

Why should you use a helmet when you ride a bike ? To protect your head from crashing when there is an accident, right ? Just like that, exception handling will protect your application from crashing when there is an exceptions.

If an exception is not 'handled' in code, the application will crash and user will see an ugly message. Instead, you can catch the exception, log the errors and show a friendly message to the user.

DataSet, DataTable, DataRow

2010-05-03T09:26:00.001-07:00

DataSet and DataTable are the key components in ADO.NET programming. In simple words, DataSet represents an in memory representation of the database. We can load an entire database into a DataSet and manipulate the data in memory. If you aremore familiar with DataSet, you can Add, Edit and Update data in the dataset and then just call a single method 'AcceptChanges()' whichwill save all the changes back to the database.

A DataSet contains one or more DataTables

A DataTable contains DataRows.

What is DataSet ?

A DataSet is an in memory representation of data loaded from any data source. Even though the most common data sourceis database, we can use DataSet to load data from other data sources including XML files etc. In this article, we will talk about the role of DataSet in manipulating data from database.

In .NET, a DataSet is a class provided by the .NET Framework. The DataSet class exposes several proeprties and methods that can be used to retrieve, manipulate and save data from various data sources.

Just like any other classes in object oriented programming, we have to create an instance of DataSet class to work with data. Typically, we may create a new instance of a DataSet and use other classes provided by .NET Framework to populate the DataSet. See the following example:

string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\Samples\\Employee.mdb";

OleDbConnection myConnection = new OleDbConnection( connectionString );

string query = "select * from EMPLOYEE_TABLE";

OleDbDataAdapter myAdapter = new OleDbDataAdapter( query, myConnection );

DataSet employeeData = new DataSet();
myAdapter.Fill ( employeeData );

Here we are creating a OleDbConnection object and we are just passing the object to the OleDbDataAdapterobject. Also, we pass the 'select ...' query to the OleDbDataAdapter. Next, we call the '.Fill()' method of the OleDbDataAdapter. This step will populate the dataset ( called 'employeeData' ) with the data retrieved for the sql statement 'select * from EMPLOYEE'.

As you already know, a DataSet can contain a collection of tables. But in the above case, our sql statement will retrieve data from only one table. So, our DataSet will have only one table.

Commonly used properties and methods of DataSet

Property : Tables

The Tables propertly allows us to retrieve the tables contained in the DataSet. This property returns a DataTableCollection object. The following sample code demonstrates iterating through the collection of tables in a data set and print the name of all the tables.

DataSet employeeData = new DataSet();
myAdapter.Fill( employeeData );

// Repeat for each table in the DataSet collection.
foreach ( DataTable table in employeeData.Tables )
{
MessageBox.Show ( table.TableName );
}

Or, you can use the indexer to access any specific table in the collection.

DataSet employeeData = new DataSet();
myAdapter.Fill( employeeData );

// Repeat for each table in the DataSet collection.
for ( int i = 0; i < employeeData.Tables.Count; i++ )
{
DataTable table = employeeData.Tables[i];
MessageBox.Show ( table.TableName );
}

Method : GetXml()

The GetXml() method returns the XML representation of the data from the DataSet.

DataSet employeeData = new DataSet();
myAdapter.Fill( employeeData );

string xmlData = employeeData.GetXml();

Method : WriteXml(...)

The WriteXml() method allows to save XML representation of the data from the DataSet to an XML file. There are many overloaded method available, which takes various parameters. The example shown below takes a file name as parameter and saves the data in DataSet into xml format to the file name specified as parameter. We can optionally save only the data or both data and schema.

DataSet employeeData = new DataSet();
myAdapter.Fill( employeeData );

employeeData.WriteXml( "c:\\MyData.xml" );

Method : ReadXml(...)

The ReadXml() method allows to load the DataSet from an XML representation of the data. There are many overloaded method available, which takes various parameters. The example shown below takes a file name as parameter and loads the data from XML file into the DataSet. This method can be used to load either the data only or both data and schema from the XML.

DataSet employeeData = new DataSet();
employeeData.ReadXml( "c:\\MyData.xml" );

There is another method called 'ReadXmlSchema()', which can be used to load only the schema from a file.

The methods WriteXml() and ReadXml() are useful to save the data from a database into some temporary files, transport to other places or keep it as a local file and load later. Many applications, including the SpiderAlerts tool available for download from this site, uses DataSet to manipulate data and saves/retrieves them from local disk using the WriteXml() and ReadXml() methods.

The SpiderAlerts tool communicates with webservices in our site and retrieves the alerts in the form of a DataSet. Once the Alerts are retrieved, it is saved into local computer using the WriteXml method. (This implementation may be changed soon in the future versions of this tool. We are considering saving(serializing) the DataSet into Isolated Storage (IsolatedStorage is a new feature part of the .NET Framework - it is a kind of hidden file system)

A DataTable is a class in .NET Framework and in simple words a DataTable object represents a table from a database.

DataSet and DataTable are the key components in ADO.NET programming. While DataSet can be used to represent a database as a whole, a DataTable object can be used to represent a table in the Database/DataSet. A DataSet can contain several DataTables.

In typical database oriented applications, DataSet and DataTable are used a lot to manipulate data. DataAdapter or other classes can be used to populate a DataSet. Once a DataSet is populated, we can access the DataTables contained within the DataSet.

Just like any database table contains multiple rows (records), a DataTable can contain multiple DataRows. Each row contains multiple fields representing each column in the table.

The typical process to retrieve records from a database in ADO.NET includes the following steps:

Open a connection to database

Use a data adapter to fill a DataSet.

Access the DataTable contained in the DataSet

Access the DataRows contained in the DataTable.

The following sample code explains these steps. This sample code retrieves data from an MS Access database.

string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\Samples\\Employee.mdb";
OleDbConnection myConnection = new OleDbConnection( connectionString );

string query = "select * from EMPLOYEE_TABLE";

OleDbDataAdapter myAdapter = new OleDbDataAdapter( query, myConnection );
DataSet employeeData = new DataSet();
myAdapter.Fill( employeeData );

// Repeat for each table in the DataSet collection.
foreach ( DataTable table in employeeData.Tables )
{
 // Repeat for each row in the table.
 foreach ( DataRow row in table.Rows )
 {
  MessageBox.Show( "Employee Number : " + row["EmployeeNumber"].ToString() );
MessageBox.Show( "Name : " + row["Name"].ToString() );
MessageBox.Show( "Address : " + row["Address"].ToString() );
 }
}

How to create a DataTable

In most of the cases, we just access the DataTable in a DataSet. We do not need to create a new instance of the DataTable. When a DataSet is populated from database, the DataTable is created with proper schema and data.

If we explicitely create DataTable, we have to create the proper schema. It is bit confusing if you are not very familiar with the database structure and schema.

Create, Read, Update, Delete - ADO.NET sample

2010-05-03T09:25:00.003-07:00

This chapter demonstrates the basic database operations using the ADO.NET classes. The sample code in this chapter uses the OleDb Provider.

Here is some sample code to execute a simple query.

string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\Samples\\Employee.mdb";

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

string query = "insert into EMPLOYEE_TABLE (EmployeeID, Name, Address) VALUES (101, 'John', '3960 CliffValley Way')";

OleDbCommand myCommand = new OleDbCommand();
myCommand.CommandText = query;
myCommand.Connection = myConnection;
myCommand.ExecuteNonQuery();

myConnection.Close();

Let us analyze the code. First we have declared a connection string. The connection string points to an MS Access database. Before you execute this code, make sure you have the database in the path specified. Or, change the path accordingly.

In the next step, we are creating a OleDbConnectionobject and passing the connection string to this object. The line 'myConnection.Open();' will open a connection to the MS Access database specified in the connection string. If the database doesn't exists or if it is not able to open a connection for some other reason, the '.Open' call will fail.

Next step is, creating a OleDbCommand object. This command object is used to execute sql statements and uses the connection opened by the OleDbConnection object.

Note that before executing a command, we have to establish a valid connection to the database.

And finally, after we have executed with the command, we will close the connection.

The above sample code executes a sql statement and returns no data from database. We are calling the method 'ExecuteNonQuery()' on the command object. If we have a 'select ...' statement which returns data from database, we cannot use the 'ExecuteNonQuery()' method.

The following sample demonstrates using OleDbDataAdapterObject and DataSet to retrieve data from databbase.

string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\Samples\\Employee.mdb";

OleDbConnection myConnection = new OleDbConnection( connectionString );

string query = "select * from EMPLOYEE_TABLE";

OleDbDataAdapter myAdapter = new OleDbDataAdapter( query, myConnection );
DataSet employeeData = new DataSet();
myAdapter.Fill ( employeeData );

Here we are creating a OleDbConnection object and we are just passing the object to the OleDbDataAdapterobject. Also, we pass the 'select ...' query to the OleDbDataAdapter. Next, we call the '.Fill()' method of the OleDbDataAdapter. This step will populate the dataset ( called 'employeeData' ) with the data retrieved for the sql statement 'select * from EMPLOYEE'.

As you already know, a DataSet can contain a collection of tables. But in our case, our sql statement will retrieve data from only one table. So, our DataSet will have only one table.

We can iterate through the table in the dataset and retrieve all the records. See the following code demonstrating this:

string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\Samples\\Employee.mdb";
OleDbConnection myConnection = new OleDbConnection( connectionString );

string query = "select * from EMPLOYEE_TABLE";

OleDbDataAdapter myAdapter = new OleDbDataAdapter( query, myConnection );
DataSet employeeData = new DataSet();
myAdapter.Fill( employeeData );

// Repeat for each table in the DataSet collection.
foreach ( DataTable table in employeeData.Tables )
{
// Repeat for each row in the table.
foreach ( DataRow row in table.Rows )
{
MessageBox.Show( "Employee Number : " + row["EmployeeNumber"].ToString() );
MessageBox.Show( "Name : " + row["Name"].ToString() );
MessageBox.Show( "Address : " + row["Address"].ToString() );
}
}

The above code retrieves all the records from the employee table and displays all the fields. You can download a sample project demonstrating the basic database operations.

Accessing database using ADO.NET in C# or VB.NET

2010-05-03T09:25:00.001-07:00

This tutorial will teach you Database concepts and ADO.NET in a very simple and easy-to-understand manner with many code snippets and samples. This is primarily meant for beginners and if you are looking for any advanced ADO.NET topics, this may not be the right page for you.

Database Concepts

Database is the media to store data. If you have an application that has to store and retrieve data, your application must be using a database.

A File is the simplest form of saving the data in the disk, but is not the most efficient way of managing application data. A database is basically a collection of one or more files, but in a custom format, and data is organized in a specific format such a way that it can be retrieved and stored very efficiently.

Some examples for databases are :

MS Access

SQL Server

Oracle

MS Access is a very light weight database provided by Microsoft for applications with less number of users and relatively small quantity of data. MS Access saves data into database files with the extension .mdb. Usually, MS Access comes along with MS Office package. If you already have the .mdb database file, you can freely use it with your application and you do not need MS Access software. The MS Access software is required only if you want to directly open the database and manipulate the data or change the database schema.

SQL Server (Microsoft product) and Oracle (Oracle Corp.) are more complex, advanced, relational databases and they are much more expensive. It can support large number of users and very high quantity of data. If you are developing a software, which might be accessed simulatenously by 100s of users or if you expect your data may grow 100s of MBs, you might consider one of these. (We are learning Microsoft .NET.. so you might want to consider the SQL Server than Oracle, for which Microsoft provides special data access components!!)

In this tutorial, we will be using only MS Access for simplicity. Most of the samples provided in this site uses MS Access database for simplicity and easy download.

ADO.NET

ADO.NET is the data access model that comes with the .NET Framework. ADO.NET provides the classes required to communicate with any database source (including Oracle, Sybase, Microsoft Access, Xml, and even text files).

DataAccess Providers in .NET

ADO.NET comes with few providers, including:

OleDb

SqlClient

There are other providers available, but we are not including them here as this tutorial is meant for beginners! When you want them, search for ADO.NET providers in Google or MSDN

Microsoft made the SQL Server. So they gave a separate provider, specifically made for SQL Server. We can use the OleDb provider for all other database sources including MS Access, Oracle, Sybase etc. There is a separate provider available for Oracle.

A DATA PROVIDER is a set of classes that can be used to access, retrieve and manipulate data from the databases.

Both OleDb and SqlClient has its own set of classes, but they have the same concepts. We would like to classify the classes into two broad categories (this is not a microsoft classification, anyway!)

Classes for communicate with database

Classes for holding/manipulating data

The job of first category of classes is to communicate with database and send or retrieve data from the database. The second category of the classes will be used as a carrier of data.

Classes for communicating with database

The Connection, Command, DataReader, and DataAdapter
objects are the core elements of the ADO.NET provider model.

Object	Description	SqlClient Objects	OleDb Objects
Connection	Establishes a connection to a specific data source.	SqlConnection	OleDbConnection
Command	Executes a command against a data source.	SqlCommand	OleDbCommand
DataReader	Reads a forward-only, read-only stream of data from a data source.	SqlDataReader	OleDbDataReader
DataAdapter	Populates a DataSet and resolves updates with the data source.	SqlDataAdapter	OleDbDataAdapter

Each provider may have classes equivalent to above objects. The name of the classes vary slightly to represent the provider type appropriately.

Depending on the type of database you work on, you will have to choose either OleDb or SqlClient (or, some other provider) objects. Since all our samples use MS Access database, we will be using OleDb objects in all the samples. If you like to use SqlServer, you just need to replace the OleDb objects with the equivalent SqlClient objects.

Classes for holding data

The following are the main classes used to hold data in Ado.NET:

DataSet

DataTable

DataRow

A DataSet is an in-memory representation of the database.

DataSet contains DataTables (and more...)

DataTable represents a database table

DataTable contains DataRows (and more...)

A DataRow represents a record in a database table.

DataRow is a collection of all fields in a record.

We can use the DataAdapter or DataReader to populate data in DataSet. Once we populate data from database, we can loop through all Tables in the DataSet and through each record in each Table.

On the first look, this may look bit confusing, but once you understand the concept and get familiar with the Ado.NET classes, you will appreciate the power and flexibility of Ado.NET.

Soon, we will publish several ADO.NET samples here. Please check back soon.

Debugging in VS.NET

2010-05-03T09:24:00.001-07:00

If you make a syntax error, then the compiler will tell you and you can easily solve the issue. But what if there is a logical error? You may never know what went wrong, just by looking into the code. During runtime, the application may give wrong results, which may not be noticed immediately by anyone. When someone report that your "calculator program" gives the result 10 when adding 5 and 4, what will you do? A logical error in a small calculator program may be an easy to fix issue, but what if it is a very complex accounting software?

The Debugger becomes a very handy tool in such situations. A Debugger is a software process that help you monitor the execution of your code. Microsoft gives us a very powerful debugger, integrated with the VS.NET. When you execute your code in debug mode, you can watch how it executes each line of code. You can run (debug) the application step by step, line by line and see the value of each variable at any point of time. You can visually count how many times a whileloop executes and see whether it executes the ifblock or else block.

So, in short, debugger help you watch how your code is executed. You can see how your calculator program calculates 5 + 4 = 10 and easily figure out the logical error.

Debugging your project

Running your project in Debug mode doesn't need lot of work. Just choose the menu : Debug > Start or press F5. Now your application will run in debug mode. To run your application in non-debug mode, choose the menu : Debug > Start without Debugging or press Ctrl F5.

You may not feel any difference whether you run in debug mode or non-debug mode. In both the cases, your application runs as usual! To find the difference, you can use breakpoints

.BreakPoints

BreakPoints are used to stop the execution at certain lines of code in the application and monitor the values of various variables etc at that point of time. To put breakpoints, click on any line of code and press F9or click on the leftbar of any line of code. When a breakpoint is enabled, the line will be highlighted with BROWN color and a BROWN circle will appear on the left bar (See image below). To remove a breakpoint, press F9 again.

Open your project and mark breakpoints in different lines of code. Now start the debugger by pressing F5. Note that every time the execution passes through the lines marked as 'breakpoint', execution stops there. You can press F5 to continue the execution again. Or, press F10 to continue the execution line by line! When the execution stops on a breakpoint, or when you continue execution line by line by pressing F10, you can point your mouse over any variable and it will show you the value of that variable at that point of time. You can see how the values are changed at each line of code and this helps you easily figure out the logical errors. This process is called 'Debugging'. Next time, when you hear someone complaining about his 'debugging nightmares', you know what it is!

Change path of execution

When the execution reaches a breakpoint, you can see a little YELLOW Arrow on the leftbar of the current line of code and the line will be highlighted with YELLOW color (See image below). When you press the F10, the execution will proceed to the next line of code.

You can change this execution path by clicking on the yellow arrow on the leftbar and dragging it into any other line of code. For example, if you are currently inside an if block, you can drag the execution to the else block (or, to some other line of code), thus changing the application behaviour the way you want! Don't you agree that the Debugger is a very powerful tool?

Quick Watch

While debugging, you can view the value of any variable instantly by pointing the mouse over the variable (See image below. You can see a very small light yellow window showing name = "Little John". This is displayed when the mouse is pointed over the variable name). But this will work only for simple types like int, string etc. In case of types like DataTable, DataSet, ArrayList etc, you can right click on the object name and choose Quick Watch. A small window will open and will show you the complete object. You can expand the properties of the object and view the values of each proeprty. In case of a DataSet, you can Quick Watch the dataset and expand each table inside the dataset, each row in each table, each column in each row etc. Thus the Quick Watch will help you view the values of the 'complete object'.

Watch Window

When you debug the application and step through each line, it is not really necessary to point the mouse on each variable to view the value. Just add the variable to the 'Watch Window' and the values are always visible in the little 'Watch Window' in the bottom of your VS.NET (see image below. The variable nameis added to the watch window). To add any variable to Watch Window, righ click on the variable and choose 'Add Watch'. You can choose the same option from the 'Quick Watch' window also.

The 'Watch Window' may be minimized by default. You can point your mouse on the 'Watch' icon in the bottom of the VS.NET to expand this window. Use the 'push button' in the watch window to keep it always expanded.If 'Watch Window' is not visible in the bottom, select the menu option from VS.NET main menu : Debug > Windows > Watch > Watch 1

System.Diagnostics.Debug.WriteLine

You may use System.Diagnostics.Debug.WriteLineto print any values into the output window while debugging.Ex:

System.Diagnostics.Debug.WriteLine( "*** My name is : " + name );System.Diagnostics.Debug.WriteLine( "+++ See the Output window now." );System.Diagnostics.Debug.WriteLine( "=== End." );

See the image below to see how it appears in the output window.

Advanced features

The debugger comes with several other advanced features like conditional breakpoints, CallStack etc. You may find more information from MSDN or other web sites. To keep it simple and helpful for beginners, we have mentioned only the commonly used features of VS.NET debugger.

Application Configuration Files

2010-05-03T09:23:00.003-07:00

NET gives an easy way to store configuration information in a ApplicationConfiguration File. In the simple implementation, you can store information as Key-Value pairs.

For example, consider a case where you have to use a DataSource in your application. If you hardcore the DataSource information in your code, you will have a bad time when you have to change this datasource. You have to change your source code and re-compile it. This won't work everytime you give your product to different customers or when you run your application in different machines!

In earlier days, programmers used to store this information in special files called ".ini" files or in system registry. The application can read the information from the .ini file or registry and no need to re-compile the code when the values are changed in .ini file or registry.

But this is a pain most of the time. It is not fun opening the registry, locate your entries and make appropriate changes. It is quite possible that you may mess up with some important entries in the registry and make your system not running any more. In fact, in secured systems, administrator may deny access to the registry and users will not have the choice to edit the registry at all.

.NET gives you a simple and easy solution for this problem - the ApplicationConfiguration File. Each application can have a configuration file, which is actually an XML file. You can use any text editor (including notepad) to open the configuration file and change the values. The application will load the values from this configuration file and you do not have to change your source code everytime you change your DataSource or any other information stored in configuration file.

app.config for Windows applications

Windows applications in VS.NET uses the name 'app.config' by default for the configuration file. This will not be automatically created when you create a Windows application. If you need a configuration file for your application, open your project in VS.NET, go to the 'Solution Explorer' and right click on the project name. Choose Add > Add new item from the menu and select 'Application Configuration file' from the list of choices. This will create an app.config file for you in the application root.

By default, the app.config file will have the following content:

To store values in configuration file, you can create xml elements in the
format

See the sample config entries below:

And to read from this config file, just use the following code in your application:

string dbPath = System.Configuration.ConfigurationSettings.AppSettings["DatabasePath"];
string email = System.Configuration.ConfigurationSettings.AppSettings["SupportEmail"];

ConfigurationSettings is the class
used to access the contents of the configuration file. Since this class is part
of the namespace System.Configuration,
we have to use the fully qualified name System.Configuration.ConfigurationSettings.
As a shortcut, you can use the using directive
on top of the file like below:

using System.Configuration;

If you have the above directive on top of the file, then you can directly use
the class ConfigurationSettings.

string dbPath = ConfigurationSettings.AppSettings["DatabasePath"];
string email = ConfigurationSettings.AppSettings["SupportEmail"];

In VB.NET, you have to use "( ... )" instead of the "[ ... ]", as shown below:

Dim dbPath as String = ConfigurationSettings.AppSettings("DatabasePath")
Dim email as String = ConfigurationSettings.AppSettings("SupportEmail")

Note:

When you compile your application, VS.NET will automatically create a file called .exe.config in your bin\debug folder. The contents of the app.config will be automatically copied to this new config file when you compile the application. When you deliver the application to the end user, you have to deliver the exe and this new config file called .exe.config and NOT the app.config. Users can modify the data in .exe.config file and application will read the data from the config file, when restarted.

web.config for web applications

The web applications use the same concept, but they use a config file with the name 'web.config'. There are couple of things to note in this case.

web.config is created automatically by VS.NET when you create any web project.

When you compile the web application, web.config is NOT renamed or copied to the BIN folder.

web.config has several default entries in it to support web/IIS configuration & security.

You can add the section in the web.config and add your key/value pairs in that section.

You can have separate web.config files for each directory in your web application, in addition to the one in the root. For each web page, by default system will look for a web.config in the same folder as the page and if not found, then looks in the parent folder.

C# sample for retrieving html content from any websites

2010-05-03T09:23:00.001-07:00

This chapter will teach you how to retrieve content of any website using .NET classes.

This chapter and the attached sample application demonstrates the usage of following .NET classes and methods:

System.Net.WebRequest() - Class to perform the web related operations.

System.Net.WebRequest.Create(url) - Create a web request.

System.Net.WebRequest.GetResponse() - Get the html content of the URL.

System.IO.StreamReader - Read from file.

C# sample for basic file operations

2010-05-03T09:22:00.001-07:00

This chapter will teach you the basic file operations. In the attached sample application, you can type some text and save into a text file. Also, you can select a text file and display the content in a textbox.

In addition to the basic file operations, you can learn some good programming practices and error handling/validation techniques.

This chapter and the attached sample application demonstrates the usage of following .NET classes and methods:

System.IO.Path.GetExtension() - Method to check the extension of a file.

System.IO.File.Exists() - Check if a file alread exists.

System.Windows.Forms.OpenFileDialog - "File Open Dialog" to choose a file from the disk.

DialogResult.OK - Result from a File Open Dialog.

MessageBox.Show() - Displaying a message to the user.

string.Trim() - Remove white space characters from beginning and end of string.

throw new Exception() - Create and throw a new exception.

System.IO.StreamWriter - Stream writer to write into files.

System.IO.StreamReader - Read from file.

Application.Exit() - Closing an application.

Displaying Simple MessageBox

2010-05-03T09:21:00.001-07:00

This chapter and the attached sample application will give you a brief idea about the following:

Reading the text value from a textbox

Displaying a message box

About the sample application This application has 1 textbox and a button. If you type anything in the textbox and press the button, it will display the same text you typed in a MessageBox.

Download and unzip the sample application from this page. After you unzip, you will get several files. Some of the important files are :

1. Chapter1.csproj - This is the C# project file. Double click this file to
open the project.

2. Form1.cs - This is the file for the Form1 in teh sample application.

After you open the project, see the 'Solution Explorer' bar on the right side of the Visual Studio. You can click on that to expand it, which will display the list of all files in the project. (Or, you can go to the menu 'View > Solution Explorer' to open the solution explorer.

Click on 'Form1.cs' in the solution explorer to open the Form. Now you can see the Form in 'design mode'. Right click on the 'Form1.cs' in the solution explorer and choose 'View Code' to see the source code behind this Form (Or, press F7 from the Form to see the code).

Let us analyze the code:

The code has lot of Visual Studio generated code. For timebeing ignore all those code and scroll down to the event handler code in the bottom of the file.

System.Windows.Forms.MessageBox.Show( "You typed : " + txtMessage.Text );


DialogResult result = MessageBox.Show( "Did you like this application ?", 
"Caption", MessageBoxButtons.YesNo, MessageBoxIcon.Question );
if ( result == DialogResult.Yes ) 
      MessageBox.Show("You selected YES");
else
      MessageBox.Show("You selected NO");

The first line will simply display a messagebox and show the text typed by the user. 'MessageBox' is a class inside the namespace 'System.Windows.Forms'. We have a statement 'using System.Windows.Forms' on top of the source code. This is like a source code. This will help us avoid typing 'System.Windows.Forms.' everytime when we want to use a class inside this namespace.

The next few lines of code do a bit more. Here we are displaying a message box, with some additional attributes.

The second optional parameter of the 'Show' method is the 'caption' for the messagebox.

The third parameter tells that the messagebox will have two buttons - YES and NO. You have several other options like MessageBoxButtons.OK, MessageBoxButtons.OKCancel etc.

And, the last parameter says 'display a question Icon in the messagebox'. There are many other types of icons you can display.

And another important part is, the MessageBox returns a value when the user press a button to close the messagebox. Our MessageBox asks a question 'Did you like this application ?" and gives two options to the user - YES or NO.

The return value is of type 'DialogResult' and is assigned to the variable 'result'. We are checking the value of the result and depending on whether user pressed the YES button or NO button, appropriate message will be displayed.

WinForms

2010-05-03T09:20:00.003-07:00

WinForms is the most commonly used feature of .NET.
'Windows' based applications in .NET is called 'WinForms'. The .NET framework comes with a good number of classes to support 'Form' based application development.
A WinForm application will have atleast one 'Form' (window), which would be used for the interaction between the application and user. A Form can contain other controls like TextBox, Label, Button etc. Large WinForms applications will have several 'Forms', some of them used to capture data from user and some of them used to display data to user. By performing certain actions in each form, user can navigate to other 'Forms' in the application.

Event driven programming

Event Driven programming model is the most commonly used feature in modern programming. In this model, you will write appropriate code for each event. Examples for events are

Button Click

Mouse Move

Mouse Click

Key Press

In Winforms application, users interact with the application using various actionsin the window (like clicking a button, moving mouse, pressing keys in keyboard etc). These actions will generate various events. When an event is generated, the code written for that event will be executed.

For example, in a user registration screen, you may have several controls like text boxes where user can enter their name, address, age etc. Once user enter all the information, he may press the 'Submit' button. As a developer, you would have written code in the button click event, to save this user entered data into a database. This is how typically a WinForms based application works in an event driven programming model.

To create WinForms applications:

Open Visual Studio .NET

Select the menu : File > New > Project

Choose from the project types : Visual C# Projects

From the Templates, choose the application type 'Windows Application'

Enter the project name in the space for 'Name'.

Make sure the 'Location' is pointing to your folder. You may press the Browse button to select your personal folder, so that all your projects will be saved in your folder.

Press 'OK' to create the projet. By default the project will be created with a sample form, named 'Form1'. You can drag and drop controls into this form, from the 'Toolbox' on the left hand side of the VS.NET.

Namespaces

2010-05-03T09:20:00.001-07:00

A Namespace is a group of related classes. It is a good practice to group related classes into a namespace when you create a class library.

The main advantage of using namespaces is, to avoid conflicts when you have multiple classes with the same name. For example, .NET comes with a class called 'Form'. Suppose you also write another class called 'Form' in your application and if you refer to the class 'Form', how does the compiler know which Form you are refering to ?

Here is the importance of 'namespace'. You can refer to the .NET Form using the fully qualified name, including the namespace like this :

System.Windows.Forms.Form

And you can refer to your own Form like this :

MyApplication.Form, where MyApplication is your namespace.

So, namespaces allow you to avoid name conflicts!

All classes in .NET class library are grouped into namespaces. You can use all the classes using the fully qualified name, including the namespace also along with the class name.

System.Windows.Forms.Form

System.String

System.Double

If you want to declare a Button object, you must do the following :

System.Windows.Forms.Button myButton;

It is not mandatory to use the namespace also along with the name. You may use the using directive on top of the class and safely avoid the need to write the fully qualified name everytime when you refer to a class.

using System.Windows.Forms.Button;

If you have the above line of code on top of the class file, you don't need to type the namespace name System.Windows.Forms with all the classes in this namespace. You can simply use class name directly as shown below:

Button myButton;

.NET Namespaces

Here is a list of some of the namespaces in .NET class library.

System

System.Xml

System.Data

System.Data.OleDb

System.Data.SqlClient

Property in C# class

2010-05-03T09:19:00.003-07:00

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.

Classes and Object model in .NET

2010-05-03T09:19:00.001-07:00

We will start with an introduction to what is object oriented programming, how to write simple classes, creating objects etc.

What is a 'class' ?

In modern object oriented programming, large computer programs are divided into several 'classes'. Typically, a large project will have several hundred classes. A class represents an entity in a program. For example, if you are doing a small program called calculator, you will typically have a single (or more) class called 'Calculator' (you can give any name for your class). The class will have several 'methods', that will do the functionality of the class.

So, your calculator may have methods like the following:
Add()
Subtract()
Multiply()
Divide()

Here is a sample calculator class, written in C# :


using System;

public class Calculator
{
             public int Add(int value1, int value2)
             {
                        return value1 + value2;
              }

             public int Subtract(int value1, int value2)
             {
                       return value1 - value2;
             }

             public int Multiply(int value1, int value2)
             {
                      return value1 * value2;
             }

            public int Divide(int value1, int value2)
            {
                     return value1 / value2;
            }
}

Classes and objects

[To be added.]

Object model in .NET

[To be added.]

DataTypes in C#

2010-05-03T09:18:00.000-07:00

DataTypes are the basic building block of any language. Microsoft has tried to standardise the datatypes in .NET framework by introducing a limited, fixed set of types that can be used to represent almost anything in programming world.

C++ was very rich in datatypes, but that leads to confusion too. Especially, when you write components that may be consumed by applications written in other platforms, you have to make sure the types used are compatible with other platforms too!

.NET types start from a clean slate. All .NET languages share the same types. So, they are all compatible and no worries.This means, you can call C# code from VB.NET and vice versa, without worrying about type conversions.

.NET data types are either structures or classes, part of the System namespace. For example, the following data types are implemented as struct in .NET:

Int16

Int32

Double

(String is implemented as a class in .NET, for various reasons.)

If you are not very familiar with struct and class, don't worry about it. You can just use them as if they are simple data types.

Here is how you can declare variables of type Int, Double and String:

Int16 age, employeeNumber;

Double salary;

String name, address;

You can use any of the .NET data types directly in any .NET language - in C#, VB.NET or xyz.NET.But in addition to the .NET types, each language provides a set of primitive types, which map to the corresponding types in .NET class library. This is why you may see some people use string and some others use String. There is no big difference. string is a primitive data type in C# and String is the corresponding class in .NET class library. The string in C# is mapped to the class in .NET class library. So, whether you use string orString,there is no real difference.

DataTypes in C# and the corresponding class/struct in .NET class library

The following list shows the list of data types available in C# and their corresponding class/struct in .NET class library.

C# Data type	Mapped to .NET class/struct
sbyte	System.SByte
byte	System.Byte
char	System.Char
float	System.Single
decimal	System.Decimal
double	System.Double
ushort	System.UInt16
short	System.Int16
uint	System.UInt32
int	System.Int32
ulong	System.UInt64
long	System.Int64
bool	System.Boolean
string	System.String
object	System.Object

Value Types & Reference Types

In C# data types are classified into two :

value types

reference types

The following tables shows some of the differences between values types and reference types.

value types	reference types
allocated on stack	allocated on heap
a value type variable contains the data itself	reference type variable contains the address of memory location where data is actually stored.
when you copy a value type variable to another one, the actual data is copied and each variable can be independently manipulated.	when copying a reference type variable to another variable, only the memory address is copied. Both variables will still point to thesame memory location, which means, if you change one variable, the value will be changed for the other variable too.
integer, float, boolean, double etc are value types.	string and object are reference types.
struct is value type.	classes and interfaces are reference types.

C# Language Syntax

2010-05-03T09:17:00.000-07:00

C# Language Syntax and essentials

his article will show you the basic statements in C# language and language syntax.

Declaring Variables

The following sample shows different ways you can declare a variable:
int a;
int salary, incomeTax, sum;
int count = 10;

string name;
string fullName= "Little John";

Loop Statements

while
int i = 0;
while ( i < 5 )
{
Console.WriteLine ( i );
++i;
}

The above loop repeates 5 times and prints the value of i.
The output of above code would be like this :
0
1
2
3
4

for
for ( int i = 0; i < 5; i++ )
{
Console.WriteLine ( i );
}

The above loop repeates 5 times just like the while loop and prints the value of i.
The output of above code would be like this :

0
1
2
3
4

do ... while

int i = 0;
do
{
Console.WriteLine ( i );
i++;
}
while ( i < 5 );

The above loop is pretty much same as the while loop. The only difference is, the condition is checked only after executing the code inside the loop.

foreach

string [] names = new string[]{ "Little John", "Pete", "Jim", "Bill" };
foreach ( string name in names )
{
Console.WriteLine ( name );
}

foreach loop can be used to iterate through a collection like array, ArrayList etc.
The above code displays the following output:

Little john
Pete
Jim
Bill

Conditional Operators

if ... else

This is the conditional operator, used to selectively execute portions of code, based on some conditions.

string name = "Little John";
if ( name == "Jim" )
{
Console.WriteLine( "you are in 'if' block" );
}
else
{
Console.WriteLine( "you are in 'else' block" );
}

in the above case, it prints :

you are in 'else' block

Flow Control Statements

break

'break' statement is used to break out of loops ('while', 'for', switch' etc).

string [] names = new string[] { "Little John", "Pete", "Jim", "Bill" };
foreach ( string name in names )
{
Console.WriteLine ( name );
if ( name == "Pete" )
break;
}

In the above sample, it iterates through the array of 4 items, but when it encounters the name "Pete", it exits the loop and will not continue in the loop anymore.
The output of above sample would be :

Little John
Pete

continue

'continue' statement is also used to in the loops ('while', 'for' etc). When executed, 'continue' statement will move the exection to the next iteration in the loop, without continuing the lines of code after the 'continue' inside the loop.

string [] names = new string[]{ "Little John", "Pete", "Jim", "Bill" };

foreach ( string name in names )
{
if ( name == "Pete" )
continue;

Console.WriteLine ( name );
}

In the above sample, when the value of name is "Pete", it executes the 'continue' which will change the execution to the next iteration, without executing the lines below it. So, it will not print the name, if the name is "Pete".
The output of above sample would be :

Little John
Jim
Bill

switch

if you have to writeseveral if...else conditions in your code, switch statement is a better way of doing it. The following sample is self explanatory:

int i = 3;
switch ( i )
{
case 5:
Console.WriteLine( "Value of i is : " + 5 );
break;
case 6:
Console.WriteLine( "Value of i is : " + 6 );
break;
case 3:
Console.WriteLine( "Value of i is : " + 3 );
break;
case 4:
Console.WriteLine( "Value of i is : " + 4 );
break;
default:
Console.WriteLine( "Value of i is : " + i );
break;
}

In the above sample, depending on the value of the conditional item, it executes appripriate case. In our code, since the value of i is 3, it executes the third case. The output will be as shown below:

Value of i is : 3

"Hello World" Application

2010-05-03T09:16:00.000-07:00

It is time to get started with code. In this chapter, we will show you how to write your first C# program. This chapter assumes that you have already installed and configured Visual Studio .NET in your computer.

Here we will guide you through step by step process to create your first sample .NET application. All our sample code will be using C# syntax. Readers are suggested to stick to this new elegant language, than going back to your favorite VB style.

Hello World Application using C#

Let us get started the traditional way, with a 'Hello World' application. We hope you all have Visual Studio.NET installed on your computer. If you have VS.NET, goto the menu option File > New > Project. Select 'Visual C# projects' and choose the project template 'Console Application'. This will create a default

A simple C# program would look like the following.


 using System;

 public class Hello
 {
  public static void Main (string[] args)
  {
   Console.WriteLine("Hello C# World");
  }
 }

When you create a new Console Application, it will create a default class and you can just insert one line of code into it:

Console.WriteLine("Hello C# World");

Now compile and run your first program by pressing Ctrl + F5. You will see the following result :

> Hello C# World

You are done! You got your first C# program successfully running.

If you do not have VS.NET, you may use any editor (including notepad) to create your first C# program. Create a new file with the name sample.cs and type the C# code shown. Now go to the command prompt and navigate to the folder where you have the .NET framework installed. Compile your csharp file by using the command 'csc':

csc c:\samples\sample.cs

csc is the C# compiler. The above command will produce the output file sample.exe. You can run the sample.exe and you will see the output from the program.

Analyzing your first program

See the first line of code :

using System;

"System" is a namespace and the "using" directive says that all classes in the "System" namespace can beused in this class without using the fully qualified name. In our class, "Console" is a class in the namespace "System". To use this class you have to actually write :System.Console.WriteLine ("...");

But the using System; directive on top of the classallows us to use the class without including the namespace. So, you can now simply write :

Console.WriteLine("...");

If you are familiar with Object Oriented Programming, you might not need more explanation for the next line - declaring a class.

public static void Main (string[] args) - is the Main method, which is thestarting point of the application.

string[] args is the list of arguments that are passed to this application. (In our case, we are not passing any command line parameters).

Console.WriteLine("...") is another line of important code. Console is a class, part of .NET class library included in System namespace. WriteLine is a method part if this class and used to printoutput to the default Console.

Visual Studio .NET

2010-05-03T09:12:00.000-07:00

What is Visual Studio.NET ?

Many people always get confused with Visual Studio .NET (VS.NET) and .NET technology. VS.NET is just an editor, provided by Microsoft to help developers write .NET programs easily . VS.NET editor automatically generates lot of code, allows developers to drag and drop controls to a form, provide short cuts to compile and build the application etc.

Understand Visual Studio .NET

VisualStudio is a very user friendly tool. But there are enough stuff to confuse any one new to Visual Studio family. The purpose of this chapter is to make you familiar with different options in Visual Studio.NET (VS.NET) We will not cover the entire visual studio guide. We are just explaining the most commonly used features of VS.NET.

When you work on any project, VS.NET has several child windows to assist you in the application development. These windows are attached on the left, bottom and right sides of the main window. You can click on these small windows to expand it and see the content of them. Some of the most commonly used child windows are explained below. Most of these windows will be enabled only when you have created a project and working on a WebForm/WinForm.

Toolbox

s all the drag and drop controls for your application. Depending on the kind of application you are working on, the toolbox will show appropriate controls and you can drag and drop them to your form. If you are developing a web application, toolbox will show ASP.NET controls and if you are developing a Windows application, it will show Windows controls (like Radio button, text box, buttons etc).

You can simply drag and drop any controls from the toolbox to your form. After you drag and drop any control, double click on the control to go the default event associated with the control.

The Toolbox will be enabled only when you have a WebForm or WinForm opened in Design mode and is usually located on TOP LEFT corner of the VS.NET.

By default, all windows including Toolbox will be displayed as Minimized (Marked as A in picture). You will see only the small icon and the text 'Toolbox' written vertically on the left bar of VS.NET. You can click on this minimized window to expand it (Expanded window is marked as C.). When you move the mouse away from the window, it will again automatically minimize. You can keep the toolbox always expanded by pressing the pushpin (Marked with B.)

The above behaviour is common for all the windows explained below. They will be minimized by default and you can point the mouse over it to expand it. Use the pushbutton to keep it expanded.

Design mode & HTML mode

If you are developing a web application, you can switch between design mode and HTML mode for any web form. When you are in HTML mode, it will show you the HTML tags and ASP.NET code and you can manually edit it. YOu can switch to the Design mode by clicking the Design button on BOTTOM LEFT corner of VS.NET. In design mode, you can see how your ASP.NET page is going to look like when some one view your web page. Also, you can drag and drop controls from the toolbox, which will automatically generate the HTML for it.

Typically, developers switch between these two modes very frequently. You can go to design mode to drag/drop controls, right click on the controls to set correct properties etc. Then, click on the HTML mode to view the generated HTML. You can manually cmake changes to the automatically generated HTML. If you change any properties in HTML mode, the changes will be reflected when you switch to Design Mode

Solution Explorer

Solution Explorer, located on TOP RIGHT corner of VS.NET, displays your solution, all projects included in each solution and the list of files in each project. They are listed in the form of a tree control.

ypically, for a single application, you will have 1 solution and one or more projects. When you create a new application, you are have to create single Visual Studio project. In more complex applications, there may be more than one projects. All these projects are grouped into a single solution. Even if you do not create a solution separately, a solution will be automatically created for you.

To add a new file to your project, you can right click on the project name (JustTestis the project name in the picture) and choose the menu option Add. It will give you the option to choose a file type. You can choose an appropriate type.

For WinForms and WebForms, you can see the file in design mode and the code associated with it. Double click on any form and it will be opened in design mode. Right click on any form and select the menu option 'View Code' to view the code associate with the form.

Output

Output window, located on BOTTOM LEFT corner of VS.NET, displays the result of your project compilation. When you compile your project, all errors, warnings and compilation results will be displayed in this window.

In addition to the Output window, they are few other windows located in the BOTTOM LEFT corner of VS.NET.

Task List - shows individual tasks. Typically, when you compile your project, all errors and warnings will be added to your task list. You can double click on any item in the task list to go directly to the code associated with the task

.Command Window - you can execute code statements here. When you are debugging, you can evaluate the value of any variables by typing ? followed by the variable name.

Find Results - when you search for any text in file(s) using VS.NET, the results will be displayed in this window.

Projects

VS.NET allows you to create several types of projects. Most of the time you will be using one of two categories:

Windows Application - to create any standard windows application.

ASP.NET Web Application - to create a web site.

Creating a Project

To create a new project, choose the main menu : File > New > Project.

It will give you several options. First you must select a type from the left side of the popup - you may chooseVisual Basic Projects or Visual C# projects based on the language you plan to use for development.

After selecting a type, you choose a template from the right side. You may choose Windows Application, ASP.NET Web Application or any other templatebased on the nature of the application you want.

When you create a Windows Project or ASP.NET Web Project, VS.NET will add a sample file by default. You can simply Build your new project and see how it works.

Building a project

To try this, create a new Windows Project as explained above. It will create a sample form. Go to the main menu and select the menu item Build > Build Solution.

This process will compile all the files included in your project and show you the result in the Output window. If the result shows '0 failed', your build is success and your application is ready to deliver!!

To Run the application you just Built, go to the main menu and select Debug > Start Without Debugging. This will launch the application you just developed.

You can drag and drop several controls to the form and try running it.

When you compile (build) the code, if there is any errors or warnings, the details will be shown in the 'Task List' window. You can click on the specific item in this window to go directly to the line of code associated with the error.

Introducing the .NET Framework with C#

2010-05-03T08:55:00.001-07:00

What Is .NET ?

This chapter gives you an introduction to the .NET technology and explains what is .NET.

.NET is a major technology change for Microsoft and the software world. Just like the computer world moved from DOS to Windows, now they are moving to .NET. But don't be surprised if you find anyone saying that "I do not like .NET and I would stick with the good old COM and C++". There are still lot of people who like to use the bullock-cart instead of the latest Honda car.

The simple answer is 'it is the technology from Microsoft, on which all other Microsoft technologies will be depending on in future.'.

.NET technology was introduced by Microsoft, to catch the market from the SUN's Java. Few years back, Microsoft had only VC++ and VB to compete with Java, but Java was catching the market very fast. With the world depending more and more the Internet/Web and java related tools becoming the best choice for the web applications, Microsoft seemed to be loosing the battle. Thousands of programmers moved to java from VC++ and VB. This was alarming for Microsoft and many of the Microsoft fan's kept on asking "is Microsoft sleeping?". And Microsoft had the answer. One fine morning, they announced : "We are not sleeping. We have the answer for you.". And that answer was .NET.

But Microsoft has a wonderful history of starting late but catching up quickly. This is true in case of .NET too. Microsoft put their best men at work for a secret project called Next Generation Windows Services (NGWS)., under the direct supervision of Mr. Bill Gates. The outcome of the project is what we now know as .NET. Even though .NET has borrowed most of it's ideas from Sun's J2EE, it has really outperformed their competitors.

Microsoft's VC++ was a powerful tool. But it was too complex. It has too many datatypes, and developers had to learn many libraries including WIndows SDK, MFC, ATL, COM etc. There were many datatype compatibility issues while exchanging data between different layers. Visual Basic was too easy, and many serious programmers hated it just for that reason. Even though Visual basic was very easy to use, it was not very flexible to develop serious applications. SUN's Java became a very good choice for these reasons. It had the flixibility and power of C++ and at the same time easy enough to catch the attention of VB programmers.

Microsoft recognised these factors and they introducd the .NET considering all these factors. All unwanted complexities are eliminated and a pure object oriented programming model was introduced. This makes programmer's life very easy.

.NET framework comes with a single class library. And thats all programmers need to learn!! Whether they write the code in C# or VB.NET or J#, it doesn't matter, you just use the .NET class library. There is no classes specific to any language. There is nothing more you can do in a language, which you can't do in any other .NET language. You can write code in C# or VB.NET with the same number of lines of code, same performance and same efficiency, because eveyone uses same .NET class library.

What is .NET ?

It is a platform neutral framework.

Is a layer between the operating system and the programming language.

It supports many programming languages, including VB.NET, C# etc.

.NET provides a common set of class libraries, which can be accessed from any .NET based programming language. There will not be separate set of classes and libraries for each language. If you know any one .NET language, you can write code in any .NET language!!

In future versions of Windows, .NET will be freely distributed as part of operating system and users will never have to install .NET separately.

What is Not ?

.NET is not an operating system.

.NET is not a programming language.

".NET is a framework"

Are you confused by this definition? Well, that is OK. It is really confusing!

We cannot define .NET as a 'single thing'. It is a new, easy, and extensive programming platform. It is not a programming language, but it supports several programming languages. By default .NET comes with few programming languages including C# (C Sharp), VB.NET, J# and managed C++. .NET is a common platform for all the supported languages. It gives a common class library, which can be called from any of the supported languages. So, developers need not learn many libraries when they switch to a different language. Only the syntax is different for each language.

When you write code in any language and compile, it will be converted to an 'Intermediate Language' (Microsoft Intermediate Language - MSIL). So, your compiled executable contains the IL and not really executable machine language. When the .NET application runs, the .NET framework in the target computer take care of the execution. (To run a .NET application, the target computer should have .NET framework installed.) The .NET framework converts the calls to .NET class libraries to the corresponding APIs of the Operating system.

Whether you write code in C# or VB.NET, you are calling methods in the same .NET class libraries. The same .NET framework executes the C# and VB.NET applications. So, there won't be any performance difference based on the language you write code.

What is Visual Studio.NET ?

Many people always get confused with Visual Studio .NET (VS.NET) and .NET technology. VS.NET is just an editor, provided by Microsoft to help developers write .NET programs easily. VS.NET editor automatically generates lot of code, allows developers to drag and drop controls to a form, provide short cuts to compile and build the application etc.

VS.NET is not a required thing to do .NET programming. You can simply use a notepad or any other simple editor to write your .NET code!!! And you can compile your .NET programs from the command prompt.

Well, what I said is true theoretically.. but if you decide to use notepad for .NET programming, by the time you develop few sample applications, Microsoft would have introduced some other new technology and .NET would be outdated. You may not want that. So, let us go by VS.NET, just like every other .NET guys.

.NET supported languages

Currently .NET supports the following languages:

VB.NET

C++

The above languages are from Microsoft. Many third parties are writing compilers for other languages with .NET support.Difference between VB and VB.NETBelieve us, there is not much in common between VB and VB.NET other than the name. VB.NET is a totally new programming language. It just retains the syntax of old VB. So, if you are a vb programmer, probably you may like VB.NET than C# just because of the syntax.

In addition to this, VB.NET still support many of the old VB functions just for backward compatibility. But if you are a serious .NET programmer, we strongly suggest never use old VB functions in VB.NET. So, switching from VB to VB.NET is just like learning a new programming language, with very small similarities between them.

C# or VB.NET ? Which one to choose ?

As we mentioned in earlier chapters, it makes no much difference. Whether you write code in VB.NET or C#, when you compile, your code will get converted to MSIL (Microsoft Intermediate language). It is this MSIL which you deliver to your customer in the form of a DLL or EXE. The MSIL is executed by the same .NET framework, whether you wrote it originally in C# or VB.NET.

The MSIL generated by C# and VB.NET is almost 99% is the same! Many believe that C# has the power of C++ and VB.NET has the user friendliness of VB. That is not true. Both are equally powerfull and friendly.

VB.NET has backward compatibility with old Visual basic. So, it supports old vb functions. C# is a fresh, clean language. So strongly support using C# instead of VB.NET just for this clean compiler.

Many old VB guys usually like to stick with VB.NET and are kind of scared of C#. We are sure that you will not take more than few days to get familiar with C# syntax. This online tutorial is based on C# and all samples will be provided in C#.

Is it platform independent ?

Many people ask this question "Java is platform independent, what about .NET ?".

The answer is "Yes" and "No" !

The code you write is platform independent, because whatever you write is getting compiled into MSIL. There is no native code, which depends on your operating system or CPU. But when you execute the MSIL, the .NET framework in the target system will convert the MSIL into native platform code.

So, if you run your .NET exe in a WIndows machine, the .NET framework for Windows will convert it into Windows native code and execute. If you run your .NET application in Unix or Linux, the .NET framework for Unix/Linuxwill convert your code into Unix/Linux native code and execute. So, your code is purely platform independent and runs anywhere!

But wait, we said it wrong... there is no .NET framework for Unix or Linuxavailable now. Microsoft has written the .NET framework only for Windows. If you or some one else write a .NET framework for other platforms in future, your code will run there too. So, let us wait until someone write .NET framework for Linux before you run your .NET code in Linux.

Is it worth learning .NET ?

Are you sure you have a very good job now and your job is safe for next 10 years? Then, probably you don't need to waste your time to learn this new technology.

If you are not sure about the future of your job, better spend sometime and make sure you have fuel to run for next few years!

How long it will take to learn .NET ?

It all depends on how fast you can learn. If you are familiar with Visual Basic or C++, you can come to speed in .NET within 1-2 months. If you are a new to programming, we estimate 6 months will be a reasonable period to become comfortable with .NET world.

Future of .NET

Microsoft is moving all its technologies to be .NET based or .NET related. The next version of SQL Server even supports writing stored procedures in .NET languages. .NET runtime will be part of all Operating Systems by default.

In short, if you like to work on Microsoft technologies for programming, .NET would be the only choice you will have.

.Net Framework

2010-05-01T03:53:00.001-07:00

.NET framework

A software development and execution environment designed by {Microsoft} as a direct competitor to {Java}. .NET framework should not be confused with {Microsoft}'s past labeling of a line of products as ".NET". .NET simplifies interoperability between languages and machines on {Microsoft Windows} especially, although not specifically, for web based services. Essentially the .NET framework consists of the CLR (common language runtime), CTS (common type system), CLS (common language system), and IL (intermediate language). The CLR consists of a number of resources provided to .NET applications such as the security model, type system and .NET classes (c.f. Java classes). The CTS is the range of all types that .NET understands although it is not necessarily the case that a .NET program will understand all of these types. The CLS however is a subset of the CTS which all .NET languages must support: any two .NET languages can interoperate via. the CLS. All .NET languages are at some stage compiled into the IL, a {byte-code} like language. However unlike a standard Java run time environment, the IL is converted to {machine code} either upon installation of the software or at {run time} by a {just in time compiler} (JIT). The IL is not interpretted. .NET's main weakness is that Microsoft have ignored the {Unix} and {mainframe} environments, effectively ruling .NET out of use in many {enterprise} environments. However there is {Mono} - an {open source} .NET framework for Unix}. .NET was based on research by Steven Lucco on a product called {OmniVM}, sold by {Colusa software}. Attracted to OmniVM since VB and C/C++ environments were already available, Microsoft bought Colusa in 1996. Microsoft provides .NET compilers for {C#}, {C++}, {VB}, and {Jscript}. (2003-09-24)