Fundamentals of C#

• The while loop is used to execute a block of code repetitively as long as the condition of the loop remains true. The while loop consists of the while statement, that begins with the while keyword followed by a Boolean condition. If the condition evaluates to true then the block of statements after the while statement is executed.
• After each iteration, the control is transferred back to the while statement and the condition is checked again for another round of execution. When the condition is evaluated to false, the block of statements following the while statement is ignored and the statement appearing after the block is executed by the compiler.
• The condition for the while loop is always checked before executing the loop. Therefore, the while loop is also referred to as the pre-test loop.

Syntax

Demo Program

namespace While_Loop
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 1;
            //Console.Write("Enter Number:-");
            //num = Convert.ToInt32(Console.ReadLine());
            while (num <= 11)
            {
                if ((num % 2) == 0)
                {
                    Console.WriteLine(+num);
                }
                num = num + 1;
            }
            Console.ReadLine();
        }
    }
}

2. The "Do-While" Loop

• The do-while loop is similar to the while loop; however, it is always executed at least once without the condition being checked. The loop starts with the do keyword and is followed by a block of executable statements. The while statement along with the condition appears at the end of this block.
• The statements in the do-while loop are executed as long as the specified condition remains true. When the condition evaluates to false, the block of statements after the do keyword are ignored and the immediate statement after the while statement is executed.
• The statements defined in the do-while loop are executed for the first time and then the specified condition is checked. Therefore, the do-while loop is referred to as the post-test loop.

Syntax

Demo Program

namespace DO_While_Loop
{
    class Program
    {
        static void Main(string[] args)
        {
            int num;
            Console.Write("Enter Number:-");
            num = Convert.ToInt32(Console.ReadLine());
            do
            {
                if ((num % 2) == 0)
                {
                    Console.WriteLine(+num);
                }
                num = num + 1;
            } while (num <= 11);
            Console.ReadLine();
        }
    }
}

3. The "for" Loop

The for statement is similar to the while statement in its function. The statements within the body of the loop are executed as long as the condition is true. Here too, the condition is checked before the statements are executed.

Syntax

Demo Program

namespace For_Loop
{
    class Program
    {
        static void Main(string[] args)
        {
            int num, i;
            Console.Write("Enter Number:-");
            num = Convert.ToInt32(Console.ReadLine());
            for (i = num; i <= 11; i++)
            {
                if ((i % 2) == 0)
                {
                    Console.WriteLine(+i);
                }
            }
            Console.ReadLine();
        }
    }
}

4. Nested "for" Loop

• The nested for loop consists of multiple for statements. When one for loop is enclosed inside another for loop, the loops are said to be nested. The for loop that encloses the other for loop is referred to as the inner for loop.
• The outer for loop determines the number of times the inner for loop will be invoked. For each iteration of the outer for loop, the inner for loop executes all its iterations.

Demo Program

namespace Nested_For_Loop
{
    class Program
    {
        static void Main(string[] args)
        {
            int i, j;
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("Welcome To CCSIT");
                }
            }
            Console.ReadLine();
        }
    }
}

5. The "foreach" Loop

• A Foreach loop iterates through the items in the collection
• The elements of a collection cannot be modified.
• The foreach loop navigates through each value in the specified list and executes the block of statements for each value. The number of values in the list determines how many times the foreach loop will be executed. Each value in the list is referred to as an element. The foreach loop starts with the foreach statements that allows you to specify the identifier that holds a list of values.
• While executing the foreach loop, all the elements specified in the for statement become read-only. Therefore, you cannot change the value of any element during the execution of the foreach loop.

Syntax

Demo Program

namespace foreach_Loop
{
    class Program
    {
        static void Main(string[] args)
        {
            // FOREACH LOOP IS USE FOR STRING
            string[] Names = { "joy", "Mariya", "Jeni", "Wilson" };
            Console.WriteLine("Employee Name");
            foreach (string person in Names)
            {
                Console.WriteLine("{0}", person);
            }
            // FOREACH LOOP IS USE FOR INTEGER
            int[] No = { 1, 2, 3, 4 };
            Console.WriteLine("\nEmployee Number");
            foreach (int Number in No)
            {
                Console.WriteLine("{0}", Number);
            }
            Console.ReadLine();
        }
    }
}

Question 11: Jump Statements

Answer

Jump statements are used to transfer control from one point in a program to another. There will be situations where you need to exit out of a loop prematurely and continue with the program. In such cases, jump statements are used. A Jump statement unconditionally transfers control of a program to a different location. The location to which a jump statement transfers control is called the target of the jump statement.

C# supports four types of jump statements. These are:

1. Break
2. Continue
3. Goto
4. Return

1. Break Statement

The break statement is used in the selection and loop constructs. It is most widely used in the switch .. case construct and in the for and while loops. The break statement is denoted by the break keyword. In the switch .. case construct, it is used to terminate the execution of the construct. In this case, the control passes to the next statement following the loop.

Syntax

Demo Program

namespace Break_Statement
{
    class Program
    {
        static void Main(string[] args)
        {
            int i;
            double no, sum = 0, avg;
            Console.WriteLine("Enter Number One by One:-");
            Console.WriteLine("Enter Zero to stop Entry");
            for (i = 1; i <= 1000; i++)
            {
                no = Convert.ToDouble(Console.ReadLine());
                if (no == 0)
                {
                    break;
                }
                sum = sum + no;
            }
            Console.WriteLine("Sum =>" + sum);
            Console.ReadLine();
        }
    }
}

2. The "continue" Statement

The continue statement is most widely used in loop constructs. This statement is denoted by the continue keyword. The continue statement is used to end the current iteration of the loop and transfer the program control returns back to the beginning of the loop. The statements of the loop following the continue statement are ignored in the current iteration.

Demo Program

namespace Continue_Statement
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Even numbers in the range of 1-10");
            for (int i = 1; i <= 10; i++)
            {
                if (i % 2 != 0)
                {
                    continue;
                }
                Console.Write(i + "\n");
            }
            Console.ReadLine();
        }
    }
}

3. The "goto" Statement

• The goto statement allows you to directly execute a labeled statement or a ladeled block of statements. A labaled is an identifier ending with a colon. A single labeled block can be reffered by more than one goto statements.
• The goto statement is denoted by the goto keyword.
• You cannot use the goto statement for moving inside a block under the for, while or do-while loops.

Demo Program

namespace Goto_Statement
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 0;
        display:
            Console.WriteLine("Hello Word");
            i++;
            if (i < 5)
            {
                goto display;
            }
        }
    }
}

4. The "return" Statement

The return statement returns a value of an expression or transfers control to the method from which the currently executing method was invoked. The return statement is denoted by the return keyword. The return statement must be the last statement in the method block.

Demo Program

namespace Return_Statement
{
    class Program
    {
        static void Main(string[] args)
        {
            int YrsofService = 5;
            double salary = 1250;
            double bonus = 0;
            if (YrsofService <= 5)
            {
                bonus = 50;
                return;
            }
            else
            {
                bonus = salary * 0.2;
            }
            Console.WriteLine("Salary amount:" + salary);
            Console.WriteLine("Bonus amount:" + bonus);
            Console.ReadLine();
        }
    }
}

Question 12: Statements

Answer

• Statements are referred to as logical grouping of variables, operators and C# keywords that perform a specific task. For example, the line that initializes a variable by assigning it a value is a statement.
• In C#, a statement ends with a semicolon. A program is built with multiple statements and these statements are grouped in blocks. A block is a code consisting of related statements enclosed in curly braces. For example, the set of statements included in the main() method of a C# code is a block.
• A method in C# is equivalent to a function in earlier programming languages such as C and C++.

  

• Statements are used to specify the input, the process and the output takes of a program. Statements can consist of:
  • Data types
  • Variables
  • Operators
  • Constants
  • Literals
  • Keywords
  • Escape sequence characters
• Statements help you build a logical flow in the program. with the help of statements, you can:
• Initialize variables and objects
• Take the input
• Call a method of a class
• Perform calculations
• Display the output

Example of Statements

Types of Statements

C# statements are similar to statements in C and C++. C# statements are classified into seven categories depending on the function they perform. These categories are the following.

Selection statements

A selection statement is a decision-making statement that checks whether a specific condition is true or false. The keyword associated with this statement are: if, else, switch and case.

Iteration statements

An iteration statement helps you to repeatedly execute a block of code. The keywords with this statement are: do, for, foreach, and while.

Jump statements

A jump statement helps you transfer the flow from one block to another block in the program. The keywords associated with this statement are: break, continue, default, goto, return.

Exception handling statements

An exception handling statement manages unexpected situations that hinder the normal execution of the program. For example, if the code is dividing a number by zero, the program will not execute properly. To avoid this situation, you can use the following exception handling statements: throw, try-catch, try-finally and try-catch-finally.

Checked and unchecked statements

The checked and unchecked statements manage arithmetic overflows. An arithmetic overflow occurs if the resultant value is greater than the range of the target variable's data type. The checked statement halts the execution of the program whereas the unchecked statement assigns junk data to the target variable. The keywords associated with these statements are: checked and unchecked.

Fixed statement

The fixed statement is required to tell the garbage collector not to move that object during execution. The keywords associated with this statement are: fixed and unsafe.

Lock statement

A lock statement in locking the critical code blocks. This ensures that no locking the critical code. These statements ensure security and only work with reference statements ensure security and only work with reference types. The keyword associated with this statement is: - lock.

Question 13: Expressions

Answer

Expressions are used to manipulation data. Like in mathematics, expressions in programming languages, including C#, are constructed from the operands and operators. An expression statement in C# ends with a semicolon (;).

Expressions are used to:

• Produce values.
• Produce a result from an evaluation.
• From part of anther expression or a statement.

Question 14: Difference between Statements andExpressions

Answer

Question 15: Introduction to Arrays

Answer

An array is a collection of related data with similar data types.

Consider a program that stores the names of 100 students. To store the names, the programmer would create 100 variables of the string type.

Creating and managing these 100 variables is very difficult but the programmer can create an array for storing the 100 names.

An array is a collection of related values placed in a contiguous memory location and these values are referred to using a common array name. This simplifies the maintanance of these values.

An array always stores values of a single data type. Each value is referred to as an element. These elements are accessed using subscripts or index numbers that determine the position of the element in the array list.

C# supports zero-based index values in an array. This means that the first array element has index number zero while the last element has index number n-1, where n stands for the total number of elements in the array.

This arrangement of sorting values helps in efficient storage of data, easy sorting of data and easy tracking of the data length.

Declaration of array

• Arrays are reference type variables whose creation involves two steps: declaration and memory allocation.
• An array declaration specifies the type of data that it can hold and identifier. This identifier is basically an array name and is used with a subscript to retrieve or set the data value at that location. Declaring an array does not allocate memory to the array.

Initializing Arrays

• An array can be created using the new keyword and then initialized. Alternatively, an array can be initialized at the time of declaration itself, in which case the new keyword is not used. Creating and initializing an array with the new keyword involves specifying the size of array. The number of elements stored in an array depends upon the specified size. The new keyword allocates memory to the array and values can be assigned to the array.
• If the elements are not explicitly assigned then default values are stored in the array. The table shown alongside lists the default values for some of the widely used data types.

Syntax

Demo Program

namespace Simple_Array
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] count = new int[10];
            int counter = 0, i;
            for (i = 0; i < 10; i++)
            {
                count[i] = counter++;
                Console.WriteLine("The Count value is:-" + count[i]);
            }
            Console.ReadLine();
        }
    }
}

Types of Arrays

C# .Net mainly has three types of arrays, these are:

1. Single-Dimension Array.
2. Multi-Dimension Array.

1. Single-Dimension Array

• The elements of a single-dimensional array are stored in a single row in the allocated memory. The declaration and initialization of single-dimensional arrays are the same as the standard declaration and initialization of arrays.
• In a single-dimensional array, the elements are indexed from 0 to (n-1), where n is the total number of elements in the array. For example, an array of 5 elements will have the elments indexed from 0 to 4 such that the first element is indexed 0 and the last element is indexed

Syntax

Demo Program

namespace Simple_Array
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] students = new string[3] { "Jems", "Alex", "Joy" };
            int i;
            for (i = 0; i < students.Length; i++)
            {
                Console.WriteLine(students[i]);
            }
            Console.ReadLine();
        }
    }
}

2. Multi-Dimension Array

• Consider a scenario where you need to store the roll number of 50 students and their marks in three exams. Using a single-dimensional array, you require two separate arrays for storing roll numbers and marks respectively. However, using a multi-dimension array, you just need one array to store both, roll numbers as well as marks.
• A multi-dimensional array allows you to store combinations of values of a single type in two or more dimensions. The dimensions of the array are represented as rows and columns similar to the rows and columns of a Microsoft Excel sheet.
• A multi-dimensional array can have a maximum of eight dimensions.

There are two types of multi-dimensional array, these are:

1. Rectangular Array.

2. Jagged Array.

1. Rectangular Array

A rectangular array is a multi-dimensional array where all the specified dimensions have constant values. A rectangular array will always have the same number of columns for each row.

Syntax

Demo Program

namespace Multi_Dimensional_array
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] dimension = new int[4, 5];
            int numOne = 0;
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    dimension[i, j] = numOne;
                    numOne++;
                }
            }
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    Console.Write(dimension[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

2. Jagged Array

• A jagged array is a multidimensional array where one of the specified dimensions can have varying sizes. Jagged arrays can have unequal number of columns for each row.
• A jagged array is a multi-dimensional array and is referred to as an array of arrays. It consists of multiple arrays where the number of elements within each array can be different. Thus, rows of jagged arrays can have different number of columns.
• A jagged array optimizes the memory utilization and performance because navigating and accessing elements in a jagged array is quicker as compared to other multi-dimensional arrays.
• For example, consider a class of 500 students where each student has opted for a different number of subjects. Here, you can create a jagged array because the number of subjects for each student varies.

Demo Program

namespace Jagged_Arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            string[][] companies = new string[3][];
            companies[0] = new string[] { "Intel", "AMD" };
            companies[1] = new string[] { "IBM", "Microsoft", "Sun" };
            companies[2] = new string[] { "HP", "Canon", "Lexmark", "Epson" };
            for (int i = 0; i < companies.GetLength(0); i++)
            {
                Console.Write("List of companies in group" + (i + 1) + ":\t");
                for (int j = 0; j < companies[i].GetLength(0); j++)
                {
                    Console.Write(companies[i][j] + " ");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

3. Using the "foreach"Loop for Arrays

The foreach loop in C# is anextension of the for loop. This loop is used to perform specific actions on collections, such as arrays. The loop reads every element in the specified array and allows you to execute a block of code for each element in the array. This is particularly useful for reference types, such as strings.

Syntax

Demo Program

namespace Foreach_Loop_For_Array
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] studentNames = new string[3] { "JAY", "MAHESH", "RAJ" };
            foreach (string studName in studentNames)
            {
                Console.WriteLine("Congratulations!! " + studName + " You Have Selected for This Job");
            }
            Console.ReadLine();
        }
    }
}

Question 16: Type Casting

Answer

• Consider the payroll system of an organization. The gross salary of an employee is calculated and stored in a variable of float type. Currently, the output is shown as float values. The payrll department wants the salary amount as a whole number and thus wants any digits after the decimal point of the calculated salary to be ignored. The programmer is able to do this using the typecasting feature of C#. Typecasting allows you to change the data type of a variable.
• C# supports two types of casting, namely implicit and explicit. Type casting is mainly used to:
• Convert a data type to another data type belonging to the same or a different hierarchy. For example, the numaric hierarchy includes int, float and double. You can convert the char type into int type to display the ASCII value.
• Display the exact numeric output. For example, you can display exact quotionts during mathematical divisions.
• Prevent loss of numaric data if the resultant value exceeds the range of its variable's data type.

1. Implicit Conversions for C# Data Types

Implicit typecasting refers to an automatic conversion of data types. This is done by the C# compiler. Implicitly typecasting is done only when the destination and source data types belong to the same hierarchy. In addition, the destination data type must hold a larger range of values than the source data type. Implicit conversion prevents the loss of data as the destination data type is always larger than the source data type. For example, if you have a value of int type then you can assign that value to the variable of long type.

Snippet

Demo Program

namespace Implicit_TypeCasting
{
    class Program
    {
        static void Main(string[] args)
        {
            int valOne = 20;
            int valTwo = 30;
            float valThree;
            valThree = valOne + valTwo;
            Console.WriteLine("Addition of Two variables:-" + valThree);
            Console.ReadLine();
        }
    }
}

Rules

• Implicit typecasting is done automatically by the compiler. The C# compiler automatically converts a lower precision data type into a higher precision data when the target variable is of a higher precision than the source variable.
• The graphic illustrates the various data types and the data types of higher precision to which they can be converted.

2. Explicit Conversions for C# Data Types

Explicit typecasting refers to changing a data type of higher precision into a data type of lower precision. For example, using explicit type casting, you can manually convert the value of float type into int type. This typecasting might result in loss of data. This is because when you convert the float data type into the int data type, the digits after the decimal point are lost.

Syntax

Demo Program

namespace Implicit_Typecasting
{
    class Program
    {
        static void Main(string[] args)
        {
            float side = 10.5F;
            int area;
            area = (int)(side * side);
            Console.WriteLine("Area of the Squre = {0}", area);
            Console.ReadLine();
        }
    }
}

Question 17: Boxing and Unboxing

Answer

Boxing and unboxing are concepts of C# data type system. Using these concepts, a value of any value type can be converted to a reference type and a value of any refeerance type can be converted to a value type.

Boxing

• Boxing is a process for converting a value type, like integer, to its reference type, like objects. This convertion is useful to reduce the overhead on the system during execution. This is because all value types are implicitly of object type.
• To implement boxing, assign the value type to an object. While boxing, the variabe of the value type variable. This means that the object type has the copy of the value instead of its reference.
• Boxing is done implicitly when a value type is provided instead of the expected reference type.

Syntax

Demo Program

namespace Boxing_Type
{
    class Program
    {
        static void Main(string[] args)
        {
            // Demo-1
            int radious = 10;
            double area;
            area = 3.14 * radious * radious;
            object boxed = area;
            Console.WriteLine("DEMO-1 OUTPUT\n");
            Console.WriteLine("Area of the circule= {0}\n", area);
            //Demo-2
            double bonus = 0.0;
            double salary;
            Console.WriteLine("DEMO-2 OUTPUT\n");
            Console.WriteLine("Enter Salary:-");
            salary = Convert.ToDouble(Console.ReadLine());
            bonus = salary * 0.1;
            object any = bonus;
            Console.WriteLine("Bonus of Rs.{0} is Rs.{1}", salary, bonus);
            Console.ReadLine();
        }
    }
}

Unboxing

• Unboxing is a process for converting a reference type, like objects, to its value type, like integer. This conversion is useful to reduce the overhead on the system during execution. This is object type because all are implicitly of value types.
• To implement unboxing, assign the reference type to an value type. While unboxing, the reference is of the reference type variable. This means that the value type has the copy of the value instead of its value.
• Unboxing is done implicitly when a reference type is provided instead of the expected value type.

Syntax

Demo Program

namespace UnBoxing_Type
{
    class Program
    {
        static void Main(string[] args)
        {
            //Demo-1
            int length = 10;
            int breadth = 20;
            int area;
            area = length * breadth;
            object boxed = area;
            int num = (int)boxed;
            Console.WriteLine("DEMO-1 OUTPUT\n");
            Console.WriteLine("Area of the Rectangle={0}\n", num);

            //Demo-2
            double bonus = 0.0;
            double salary;
            Console.WriteLine("DEMO-2 OUTPUT\n");
            Console.WriteLine("Enter Salary:-");
            salary = Convert.ToDouble(Console.ReadLine());
            bonus = salary * 0.1;
            object any = bonus;
            double num2 = (double)bonus;
            Console.WriteLine("Bonus of Rs.{0} is Rs.{1}", salary, bonus);
            Console.ReadLine();
        }
    }
}