Chapter 2 - Core C# Programming Constructs Part 1

The content and code of this article is referenced from book Pro C#5.0 and the .NET 4.5 Framework by Apress. The intention of the writing is to review the konwledge and gain better understanding of the .net framework. 

1. System Data Types and Corresponding C# keywords

The same as other programming languages, c# defines keywords for data types, used to represent local variables, class data member variables, method return values and parameters. 

C# shorthand	System Type	Range
bool	System.Boolean	true/false
sbyte	System.SByte	-128 to 127 (8 bit number)
byte	System.Byte	0 to 255 (8 bit number)
short	System.Int16	-32768 to 32767 (16 bit number)
ushort	System.UInt16	0 to 65535 (16 bit number)
int	System.Int32	32 bit number
uint	System.UInt32	32 bit number
long	System.Int64	64 bit number
ulong	System.UInt64	64 bit number
char	System.Char	16 bit character
float	System.Single	32 bit floating point number
double	System.Double	64 bit floating point number
decimal	System.Decimal	128 bit floating point number
string

1.1 Variable declaraction and Initialization

When you are declaring a local variable, you do so by specifying the data type followed by the variable's name. e.g int num1 = 0; string name="jason";

Be aware that it is a compiler error to make use a local variable before assigning an initial value. 

 

1.2 Data type class hierarchy

In C#, all data type class are ultimately derived from System.Object. Also note that many numerical data types derived from a class named System.ValueType. All the descendents fo ValueType are automatically allocated on the stack, and , therefore, have a very predictable lifetime. On the other hand, other types such as Sytem.String, System.Array, System.Exception etc are not allocated on the stack, but on the garbage-collected heap. 

 

1.2.1 Numerical Data Types

All numerical data types support MinValue/MaxValue properties. e.g int.MaxValue, double.MinValue

 

1.2.2 Boolean data type

The only valid values for System.Boolean type are "true | false", and bool.TrueString and bool.FalseString yields those value respectively. 

 

1.2.3 System.Char

As you may already know, a string represents a contiguous set of characters (e.g "test"), while the char can represent a single slot in a string (e.g 't')

However, System.Char is able to provide you with more information about the value,  whether it is digit, punctuation, or alphabetical. 

char.IsDigit('h'), char.IsLetter('h'), char.IsWhiteSpace('hello ', 5), char.IsPunctuation('?')

 

1.2.4 Parsing value from string

The .net data types provide the ability to generate a variable of their underlying type given a textual equivalent. 

e.g bool b = bool.Parse("True"); double b = double.Parse("99.884");

 

2. Working with string data

2.1 Basic string manipulation

public static void Main (string[] args)
{
    string testString = "test from tim bo"; //string declaration
    Console.WriteLine("value of the string is {0}", testString);
    Console.WriteLine ("Length of the string is {0}", testString.Length);
    Console.WriteLine ("string in uppercase: {0}", testString.ToUpper());
    Console.WriteLine ("string in lowercase: {0}", testString.ToLower());
    Console.WriteLine ("string contains the letter t? {0}", testString.Contains ("t"));
    Console.WriteLine ("replace word test in the string with text, {0}", testString.Replace ("test", "text"));
}

2.2 String concatenation

string variables can be connected together to build larger strings via + operator, but underlying, the compiler is actually calling the static String.Concat() method. Both approachs are absolutely working, but + operator can save some keystrokes. 

public static void Main (string[] args)
{
    string text1 = "my name is ";
    string text2 = "tim";
    Console.WriteLine (text1 + text2);
    Console.WriteLine(string.Concat(text1, text2));
}

2.3 Escape Characters

C# string literals may contains various escape characters, which qualify how the character data should be printed to the output stream. Each escape character begins with a backslash '\', followed by a specific token. 

Character	Meaning
\'	inserts a single quote into a string literal
\"	insert a double quote into a string literal
\\	inserts a backslash into a string literal.
\a	triggers a system alert
\n	inserts a new line
\r	inserts a carriage return
\t	inserts a horizontal tab into the string literal

public static void Main (string[] args)
{
    Console.WriteLine("column1\tcolumn2\tcolumn3\t");
    Console.WriteLine ("file path is C:\\documents\\chapter1");
    Console.WriteLine ("insert new line. \n\n\n");
}

2.4 Define verbatim strings

when you prefix a string with the @ symbol, you have created what is termed a verbatim string. Using verbatim strings, you disable the procesing of a literal's escape characters and print out a string as it is. 

Console.WriteLine(@"c:\documents\chapter1");

 

2.5 String equality

 A reference type is an object allocated on the garbage-collected managed heap. By default, when you compare for equality on reference type (== or !=), you will be returned true if the references are pointing to the same object in memory. However, even though string data type is indeed a reference type, the equality operators have been redefined to compre the values of strings, not the object in memory to which they refer. 

public static void Main (string[] args)
{
    //variables
    string s1 = "hello";
    string s2 = "test"; 

    //test equality
    Console.WriteLine("s1 == s2, {0}", s1 == s2); //return false
    Console.WriteLine("s1 == Hello, {0}", s1 == "Hello"); //return false, case sensitive
    Console.WriteLine("s1.Equal(s2), {0}", s1.Equals(s2));//return false;

}

 

2.6 strings are immutable

One of the interesting aspects of System.String is that after you assign a string object with its initial value, the character data cannot be changed. The methods of the string type are, in fact, returning you a brand new string object in a modified format. So the string class can be inefficient and result in bloated code if misued, especially when performing string concatenation. 

Fortunately, .net does provide a class named StringBuilder within System.Text to resolve this issue. When you call members of this type, you are directly modifying the object's internal character data. 

 

public static void Main (string[] args)
{
       //declare string builder
       StringBuilder sb = new StringBuilder("Initial value");
    //append value to sb
    sb.AppendLine ("line1");  
    sb.AppendLine ("line2");
    Console.WriteLine (sb.ToString ());
}

 

3. Narrowing and widening data type conversions

3.1Widening data

public static void Main (string[] args)
{
    short number1 = 9, number2 = 10;
    Console.WriteLine ("{0} + {1} = {2}", number1, number2, Add(number1, number2));
}

static int Add(int x , int y)  //method which accept two int number, and returns the sum of two ints
{
    return x + y;    
}

When we look at the example, notice that Add method excepts to be sent two int parameters. However, the main method is, in fact, sending two short variables. While this might seem like a complete and total mismatch of data types, the program compiles and executes without error and returns 19 as result. 

The reason the compier runs successfully is due to the fact that there is no loss of data. The compiler implicitly widens each short to an int. Formally speaking, widening is the term used to define an implicit upward cast that does not result in a loss of data, e.g int to float, float to double. 

 

3.2 Narrowing data

Formally speaking, the CLR (common language runtime) was unable to apply a narrowing operations. As you can guess, narrowing is the logic opposite of widening, in that a larger value is stored within a smaller data type variable. It is important to point out that all narrowing conversions result in a compiler error. 

public static void Main (string[] args)
{
    short number1 = 30000, number2 = 30000;
    short answer = Add (number1, number2); //error
    Console.WriteLine ("{0} + {1} = {2}", number1, number2, Add(number1, number2));
}

 The compiler error occurs becuase the answer 60000 can not be stores as short, as it overflows the bounds of this data type. 

When you wish to inform the compiler that you are willing to deal with a possible loss of data due to a narrowing operation, you must apply an explicit cast using the C# casting operator(). 

static void NarrowingAttempt()
{
    byte myByte = 0;
    int myInt = 200;

    //explicityly cast the int into a byte
    myByte = (byte)myInt;
    Console.WriteLine ("Value of myByte:{0}", myByte);
}

 

3.3 Checked keywork

 

public static void Main (string[] args)
{
    //byte valuel can go up to 255
    byte b1 = 100;
    byte b2 = 250;

    byte sum = (byte)(b1 + b2);
    Console.WriteLine ("The sum value is {0}", sum);   //the result is 94
}

You might be surprised to get sum result 94, instead of 350. Actually, the reason is simple, given that System.Byte can hold a value between 0 to 255, sum not contains the overflow value 350 - 256 = 94. 

To handle the overflow or underflow conditions in you application, you have two options. Your first choice is to leverage your wits and programming skills to handle it manually. The other option is to use keywork checked. If an overflow has occurred, you will receive a runtim exception: System.OverflowException. 

public static void Main (string[] args)
{
    //byte valuel can go up to 255
    byte b1 = 100;
    byte b2 = 250;
    try
    {
        checked
        {
            byte sum = (byte)(b1 + b2);
            Console.WriteLine ("The sum value is {0}", sum);               
        }    
    }
    catch(OverflowException ex) 
    {
        Console.WriteLine (ex.Message);    
    }

}

 

3.4 Setting project-wide overflow checking

As an alternative, the c# compiler supports the /checked flag. When enabled, all of your arithmetic will be evaluated for overflow without the need to make use of the c# checked keyword. 

 

3.5 Unchecked

Now, assuming you have enabled this project-wide setting, given that the /checked flag will evaluate all arithmetric logic, c# provides the unchecked keyword to disable the throwing of an overflow exception. 

unchecked
{
    byte sum = (byte)(b1 + b2);
    Console.WriteLine ("The sum value is {0}", sum);               
}    

 

4. Understanding implicity typed local variables

Up until this point in the chapter, when we have been defining local variables, we're explicitly specified the underlying data type of each variable being declared. c# does provide for implicitly typing of local variables using the var keyword. The var keyword can be used in place of specifying a specific data type. And the compiler will automatically infer the underlying data type based on the initial value used to initialize the local data point. 

public static void Main (string[] args)
{
    var myInt = 0;  //int type
    var myBool = true; //boolean type
    var myString = "test"; //string
}

 

4.1 restriction on implicity type 

There are various restrictions regarding to the use of the var keyword. First and foremost, implicit typing applies only to local variables in a method or property scope. It is illegal to use the var keyword to define return values, parameters, or field data of a custom type. 

Also, local variables declared with var keyword must be assigned an initial value at the exact time of declaration and cannot be assigned the initial value of null. It make sense, because the compiler is relying on the value to decide the underlying data type. 

var myData; //error

var myInt; //error

myInt = 0;

 

4.2 implicit typed data is strongly typed data

Be very aware that implicit typing of local variables results in storngly typed data. Therefore, use of the var keyword is not the same technique used with scripting language, where a variable can hold values of different types over its lifetime. (often termed dynamic typing)

 

public static void Main (string[] args)
{            
    var s = "string variable";
    s = "this is fine";

    string upperValeu = s.ToUpper ();

    s = 44; //error
}

 

4.3 Usefulness of implicitly typed local variables

Implicit variable is extremely helpful with LINQ technology, as it makes use of query expression that can yield dynamically created result sets based on the format of the query itself. 

public static void Main (string[] args)
{            
    int[] numbers = { 10, 20, 30, 40, 50 };
    //linq query
    var subset = from i in numbers where i < 30 select i;

        foreach (var i in subset) {
        Console.WriteLine ("{0}", i);
    }
}

 

5. C# iteration Construts

5.1 for loop

public static void Main (string[] args)
{    
    for (int i = 0; i < 4; i++) {
        Console.WriteLine ("number is {0}", i);
    }
}

 

5.2 foreach loop

The c# foreach keyword allows you to iterate over all items in a container without the need to test for an upper limit. In addition, unlike for loop, the foreach loop will only walk the contianer in a linear fashion. It is a perfect choice to walk a collection item by item. 

public static void Main (string[] args)
{    
    string[] carTypes = { "Ford", "BMW", "Yugo", "Honda" };

    foreach (string car in carTypes) {
        Console.WriteLine (car);
    }
}

Any class that implements IEnumerable interfaces can be used in foreach loop. 

 

5.3 while/ do while loop

The while looping construct is useful should you wish to execute a block of statements until some terminating condition has been reached. 

public static void Main (string[] args)
{    
    string userIsDone = "";

    while (userIsDone.ToLower () != "yes") {
        Console.WriteLine ("In while loop");
        Console.WriteLine ("Are you done? [yes][no]: ");
        userIsDone = Console.ReadLine ();
    }
}

 

public static void Main (string[] args)
{    
    string userIsDone = "";

    do {
        Console.WriteLine ("In while loop");
        Console.WriteLine ("Are you done? [yes][no]: ");
        userIsDone = Console.ReadLine ();
    } while(userIsDone.ToLower () != "yes");
}

The difference is that do/while loop are guaranteed to exeucte the corresponding block of code at least once. In contrast, it is possible that a simple while loop may never execute if the condition is false from the onset. 

 

6. Decision constructs and the relational/equality operators

6.1 Equality and Relational operators

==	if(age == 30)	age equal 30
!=	if (age != 30)	age not equal 30
<	if (age < 30)	age is less than 30
>	if (age > 30)	age is greater than 30
<=	if (age <=30)	age is less than or equal 30
>=	if (age >= 30)	age is greater or equal 30

 

6.2 Conditional operators

&&	if (age == 30 && name == "tim")	And operator, return true is all expression are ture
||	if (age == 30 || name == "tim")	Or operator, return true is at least one express is ture
!	if (!myBool)	Not operator, return ture if false, or false if true

 

6.3 Switch statement

The Switch statement allows you to handle program flow based on a predefined set of choices. 

public static void Main (string[] args)
{    
    string choice = Console.ReadLine ();
    int n = int.Parse (choice);

    switch (n) {
     case 1:
        Console.WriteLine ("Good choice");
        break;
    case 2:
        Console.WriteLine ("second choice");
        break;
    default:
        Console.WriteLine ("default choice");
        break;
    }
}

one nice feature of the C# switch statement is that you can evaluate string data or enumeration type in addition to numeric data.