Enumeration in C#

ENUMERATIONS

An enumeration is a special kind of value type limited to a restricted and unchangeable set of numerical values. By default, these numerical values are integers, but they can also be longs, bytes, etc. (any numerical value except char) as will be illustrated below.

When you define an enumeration you provide literals which are then used as constants for their corresponding values. The following code shows an example of such a definition:

1. public enum DAYS 2. { 3. Monday, 4. Tuesday, 5. Wednesday, 6. Thursday, 7. Friday, 8. Saturday, 9. Sunday 10. }

Note, however, that there are no numerical values specified in the above. Instead, the numerical values are (we think) set up according to the following two rules:

1. For the first literal: if it is unassigned, set its value to 0.

2. For any other literal: if it is unassigned, then set its value to one greater than the value of the preceding literal.

From these two rules, it can be seen that DAYS.Monday will be set to 0, and the values increased until DAYS.Sunday is set to 6. Note also how we are referring to these values - the values specified in an enumeration are static, so we have to refer to them in code using the name of the enumeration: "DAYS.Monday" rather than just "Monday". Furthermore, these values are final - you can't change their runtime value.

The following code demonstrates how you can override the default setting which makes the default values integers. In this example, the enumeration values are set to bytes.

1. enum byteEnum : byte 2. { 3. A, 4. B 5. }

You can also override the default numerical values of any and all of the enumeration elements. In the following example, the first literal is set to value 1. The other literals are then set up according to the second rule given above, so DAYS.Sunday will end up equal to 7.

1. public enum DAYS 2. { 3. Monday=1, 4. Tuesday, 5. Wednesday, 6. Thursday, 7. Friday, 8. Saturday, 9. Sunday 10. }

In the two examples given, the values of each literal has been unique within the enumeration. This is usually how you will want things to be, but in fact the values need not be unique. In the following case, the value of DAYS.Thursday is also set to equal 1. The values assigned to the other literals will follow the rules given previously, so both DAYS.Tuesday and DAYS.Friday will equal 2, etc.

1. public enum DAYS 2. { 3. Monday=1, 4. Tuesday, 5. Wednesday, 6. Thursday=1, 7. Friday, 8. Saturday, 9. Sunday 10. }

Strings in C#

Strings

In C#, you can use strings as array of characters, However, more common practice is to use the string keyword to declare a string variable. The string keyword is an alias for the System.String class.

Creating a String Object

You can create string object using one of the following methods:

· By assigning a string literal to a String variable

· By using a String class constructor

· By using the string concatenation operator (+)

· By retrieving a property or calling a method that returns a string

· By calling a formatting method to convert a value or an object to its string representation

The following example demonstrates this:

using System;

namespace StringApplication

{

   class Program

   {

      static void Main(string[] args)

      {

         //from string literal and string concatenation

         string fname, lname;

         fname = "Rowan";

         lname = "Atkinson";

         

         string fullname = fname + lname;

         Console.WriteLine("Full Name: {0}", fullname);

         

         //by using string constructor

         char[] letters = { 'H', 'e', 'l', 'l','o' };

         string greetings = new string(letters);

         Console.WriteLine("Greetings: {0}", greetings);

         

         //methods returning string

         string[] sarray = { "Hello", "From", "Tutorials", "Point" };

         string message = String.Join(" ", sarray);

         Console.WriteLine("Message: {0}", message);

         

         //formatting method to convert a value

         DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);

         string chat = String.Format("Message sent at {0:t} on {0:D}", waiting);

         Console.WriteLine("Message: {0}", chat);

      }

   }

}

When the above code is compiled and executed, it produces the following result:

Full Name: Rowan Atkinson

Greetings: Hello

Message: Hello From Tutorials Point

Message: Message sent at 5:58 PM on Wednesday, October 10, 2012

String Builder Class

A StringBuilder object is not a string but rather an auxiliary object used for manipulating characters. It contains a buffer, typically initialized with a string but usually larger than that string. This buffer can be manipulated in place without creating a new string: You can insert, append, remove, and replace characters. When you're done manipulating the characters, use StringBuilder's ToString method to extract the finished string from it. 

Both String and StringBuilder contain Unicode characters of type Char and support an indexer that returns Char. Because the String class is immutable, its indexer is read-only, but the StringBuilder indexer is readable/writeable. Listing 20.38 illustrates how to manipulate characters with the StringBuilder class and then place the characters into a String object. 

Listing 20.38: StringBuilder Class Manipulation 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace StringBuilderClass

{

    class Program

    {

        static void Main(string[] args)

        {

            String MyName;

            StringBuilder MyOtherName = new StringBuilder("Hello");

            MyOtherName.Remove(2, 3); // produces "He"

            MyOtherName.Insert(2, "lp"); // produces "Help"

            MyOtherName.Replace('l', 'a'); // produces "Heap"

            MyName = MyOtherName.ToString();

        }

    }

}

You can use either String or StringBuilder for string operations. Deciding which to use depends on the frequency of the string modification. If you modify the string frequently-in operations like reassigning, appending, removing, and replacing some characters-you should choose the StringBuilder class. However, if your methods do not change the string value much, registering the String class to the .NET Framework's internal string table will save space in memory for duplicate strings. The framework also provides you faster access to string literal values stored in variables. The .NET Framework automatically handles these operations behind the scenes for you. 

Arrays in C#

The Array Type

Another data type is the Array, which can be thought of as a container that has a list of storage locations for a specified type. When declaring an Array, specify the type, name, dimensions, and size.

An array stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type stored at contiguous memory locations.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables. A specific element in an array is accessed by an index.

All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.

Declaring Arrays

To declare an array in C#, you can use the following syntax:

datatype[] arrayName;

where,

· datatype is used to specify the type of elements in the array.

· [ ] specifies the rank of the array. The rank specifies the size of the array.

· arrayName specifies the name of the array.

For example,

double[] balance;

Initializing an Array

Declaring an array does not initialize the array in the memory. When the array variable is initialized, you can assign values to the array.

Array is a reference type, so you need to use the new keyword to create an instance of the array. For example,

double[] balance = new double[10];

Assigning Values to an Array

You can assign values to individual array elements, by using the index number, like:

double[] balance = new double[10];

balance[0] = 4500.0;

You can assign values to the array at the time of declaration, as shown:

double[] balance = { 2340.0, 4523.69, 3421.0};

You can also create and initialize an array, as shown:

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

You may also omit the size of the array, as shown:

int [] marks = new int[]  { 99,  98, 92, 97, 95};

You can copy an array variable into another target array variable. In such case, both the target and source point to the same memory location:

int [] marks = new int[]  { 99,  98, 92, 97, 95};

int[] score = marks;

When you create an array, C# compiler implicitly initializes each array element to a default value depending on the array type. For example, for an int array all elements are initialized to 0.

Accessing Array Elements

An element is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example,

double salary = balance[9];

ArrayList

It represents an ordered collection of an object that can be indexed individually. It is basically an alternative to an array. However, unlike array you can add and remove items from a list at a specified position using an index and the array resizes itself automatically. It also allows dynamic memory allocation, adding, searching and sorting items in the list.

Methods and Properties of ArrayList Class

The following table lists some of the commonly used properties of the ArrayList class:

Property	Description
Capacity	Gets or sets the number of elements that the ArrayList can contain.
Count	Gets the number of elements actually contained in the ArrayList.
IsFixedSize	Gets a value indicating whether the ArrayList has a fixed size.
IsReadOnly	Gets a value indicating whether the ArrayList is read-only.
Item	Gets or sets the element at the specified index.

The following table lists some of the commonly used methods of the ArrayList class:

Sr.No.	Methods
1	public virtual int Add(object value);  Adds an object to the end of the ArrayList.
2	public virtual void AddRange(ICollection c);  Adds the elements of an ICollection to the end of the ArrayList.
3	public virtual void Clear();  Removes all elements from the ArrayList.
4	public virtual bool Contains(object item);  Determines whether an element is in the ArrayList.
5	public virtual ArrayList GetRange(int index, int count);  Returns an ArrayList which represents a subset of the elements in the source ArrayList.
6	public virtual int IndexOf(object);  Returns the zero-based index of the first occurrence of a value in the ArrayList or in a portion of it.
7	public virtual void Insert(int index, object value);  Inserts an element into the ArrayList at the specified index.
8	public virtual void InsertRange(int index, ICollection c);  Inserts the elements of a collection into the ArrayList at the specified index.
9	public virtual void Remove(object obj);  Removes the first occurrence of a specific object from the ArrayList.
10	public virtual void RemoveAt(int index);  Removes the element at the specified index of the ArrayList.
11	public virtual void RemoveRange(int index, int count);  Removes a range of elements from the ArrayList.
12	public virtual void Reverse();  Reverses the order of the elements in the ArrayList.
13	public virtual void SetRange(int index, ICollection c);  Copies the elements of a collection over a range of elements in the ArrayList.
14	public virtual void Sort();  Sorts the elements in the ArrayList.
15	public virtual void TrimToSize();  Sets the capacity to the actual number of elements in the ArrayList.