.Net : C#

Tech.Ed 2006 - for geeks in Chennai

sachinjoshi — Sat, 10 Jun 2006 18:13:00 GMT

Tech.Ed 2006 in Chennai will be held at Chennai Trade Centre and kick starts on 15th June and will end with a bang(entertainment/party) on 17th June.

Where is Chennai Trade Centre?
Chennai Trade Centre
Mount Poonamallee High Road
Nandambakkam
Chennai: 600089
Ph: 91-44-22316033, 22315551

Map of Chennai Trade Centre is available at http://www.indiasoft.ind.in/venue_map.htm

Complete details of all the session is available at http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032295913&Culture=en-IN

Visit http://forums.techedindia.com/ a forum started by MVP's to answer all your developer and IT Pro related questions.

Visit http://spaces.msn.com/vineetgupta/ and know what Vineet Gupta is cooking for the TechEd sessions. He is loaded with and willing to share his wisdom on Data Platform and Architecture tracks.

String.IsNullOrEmpty(String)

sachinjoshi — Sat, 10 Jun 2006 09:09:00 GMT

As simple as it gets, C# 2.0 has brought with it loads of language features. Some made a huge difference and few less talked about.

One of them is String's IsNullOrEmpty method, let's do a comparision of C# 1.1 and 2.0 logic to check for a empty and null string.

We have been doing this past several years, a condition where in we check a string object is null or empty and perform certain actions based on the the outcome of the condition.

//C# 1.1 Sample code

string sParam = null;

if( (sParam != null) && (sParam != string.Empty) ) {

//Do something

}

//C# 2.0 Sample code

string sParam = null;

if( string.IsNullOrEmpty(sParam) ) {

//Do something

}

Now the difference is pretty clear....same logic but well simplified. Many of you will be wondering why the method IsNullOrEmpty is a static member of string class. Point here is we are checking for null or empty string and if that instance of string is null then it will throw a NullReference exception.

Can the word simply be more simplied?

String.Contains(String)

sachinjoshi — Sat, 10 Jun 2006 09:07:00 GMT

In our .Net 1.1 days we used to check whether a string object contains a specified string(text) using IndexOf method.

Here is the typical code to check the existence of a string in an string object.

//Sample code

string sName = "John Smith";

if(sName.IndexOf("Smith") > -1) {

//Smith exists in string object sName

}

Now let's take a closer look at the above code...... What we want is to know whether an instance of string contains some string(text).

Did I say contains......that's exactly C# .Net 2.0 provides us with.

Let's revisit the same functionality using 2.0

//Sample code

string sName = "John Smith";

if(sName.Contains("Smith")) {

//Smith exists in string object sName

}

Wallah.....it's so simple and sophisticated.

System.Nullable A.k.a Nullable types

sachinjoshi — Fri, 09 Jun 2006 17:10:00 GMT

Developers were always looking forward to the inclusion of Nullable types in C#. I love the way it's been implemented using generics. Before we go in to the specifics of Nullable types; let's look at what is a Nullable type and it's usage.

What's a Nullable type?
A nullable type is a value type which can be assigned a null value. Type's like int/bool/double/etc... now can be assigned null values.

Usage:
A simple case for nullable type is while assigning a database column value to a value type.

Example:
int iEmpId = 0;
//Will throw an error if the DataReader value is null
iEmpId = (int)drEmployee["id"];

Now let's see how a value type can be promoted to a Nullable type with the magic of generics.

Declaring a nullable type is straight forward..

System.Nullable iEmpId;
or
int? iEmpId; //that's a shorthand
iEmpId = null; //Allowed as it's Nullable
if(iEmpId.HasValue){
//do something
}

So for assigning a value from let's say a datareader, we could do something like this.

int? iEmpId = null;
iEmpId = (int?)drEmployee["id"];
if(iEmpId.HasValue){
//do something
}

Hmm that certainly makes sense, isn't it?

Interned string

sachinjoshi — Fri, 09 Jun 2006 09:05:00 GMT

Interned string is nothing but a locked up version of a string, so that it can be shared.

Memory allocation can be avoided by using string.Empty.

string sFirstName = string.Empty;

The C# compiler is intelligent enough to generate code based on our declaration, if we declare a string object with either string.Empty it just refers to a shared empty string object. As we know string object are immutable(cannot be changed) once created so any assignment will not affect the shared string object.

Generics an overview

sachinjoshi — Thu, 08 Jun 2006 15:38:00 GMT

We all have come across a situation where we need to store a collection of a specific type.

Let's say for example we have a class called Customer and we need to have a collection of customers.

Simple way of doing that may be to use ArrayList and add customer class to it. But we have to pay a heavy price for using an ArrayList.

For those of you who don't know the pitfalls of using ArrayList, let me briefly list it out.

The default initial capacity of an ArrayList is 16, even if you add only 2 items to the ArrayList object it will still occupy memory area of 16 elements.
Assume you have added 17th element in your ArrayList object then your object will grow to 32 capacity, that's real waste of memory.
ArrayList stores everything as object and so any value type you store goes through an overhead of boxing and unboxing. Boxing and Unboxing is the most performance intensive operation in .Net as it has to convert a value type to a reference type and the vice versa.
There is no type safety as you can store any type in an ArrayList object.

Now where do the Generics come in picture.......??

Well they are the saviors in this .Net world, don't believe me then look how simple and smart generics are.

Now we have a class called Customer and I want a collection of Customer to store n numbers of customers.

//Sample code
objCustomerColl = new List();

Essentially what we are doing in the above given line of code is we are using the List class which is part of the System.Collections.Generic namespace.
The declaration is pretty simple we are telling the compiler that create a list of Customer class.

With this simple piece of code we have our CustomerCollection ready for use.
Now we can add, remove and perform many different operations on it.

//Sample code
objCustomerColl.Add(new Customer());
Points to be noted....

This generic list is type safe.

If you use a value type to create a generic list it doesn't require boxing/unboxing.
All the incrementing/decrementing of the list is done under the hood.

Few more examples of Generic list....just to give you an idea of how powerfull are generics.

List IntCollection = new List();
List StringCollection = new List();