C# Functional Console Programming

C# Introduction

C# Hello World - Your First C# Program

In this tutorial, we will learn how to write a simple "Hello World!" program in C#. This will get you familiar with the basic syntax and requirements of a C# program.

The “Hello World!” program is often the first program we see when we dive into a new language. It simply prints Hello World! on the output screen.

The purpose of this program is to get us familiar with the basic syntax and requirements of a programming language.

"Hello World!" in C#

// Hello World! program
namespace HelloWorld
{
    class Hello {         
        static void Main(string[] args)
        {
            System.Console.WriteLine("Hello World!");
        }
    }
}

When you run the program, the output will be:

Hello World!

How the "Hello World!" program in C# works?

Let's break down the program line by line.

1. // Hello World! Program

   // indicates the beginning of a comment in C#. Comments are not executed by the C# compiler.

   They are intended for the developers to better understand a piece of code. To learn more about comments in C#, visit C# comments.

2. namespace HelloWorld{...}

   The namespace keyword is used to define our own namespace. Here we are creating a namespace called HelloWorld.

   Just think of namespace as a container which consists of classes, methods and other namespaces. To get a detailed overview of namespaces, visit C# Namespaces.

3. class Hello{...}

   The above statement creates a class named - Helloin C#. Since, C# is an object-oriented programming language, creating a class is mandatory for the program’s execution.

4. static void Main(string[] args){...}

   Main() is a method of class Hello. The execution of every C# program starts from the Main() method. So it is mandatory for a C# program to have a Main() method.

   The signature/syntax of the Main() method is:

   static void Main(string[] args)
   {
      ...
   }
   

   We’ll learn more about methods in the later chapters.

5. System.Console.WriteLine("Hello World!");

   For now, just remember that this is the piece of code that prints Hello World! to the output screen.You’ll learn more about how it works in the later chapters.

Alternative Hello World! implementation

Here’s an alternative way to write the “Hello World!” program.

// Hello World! program
using System;

namespace HelloWorld
{
    class Hello {         
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Notice in this case, we’ve written using System; at the start of the program. By using this, we can now replace

System.Console.WriteLine("Hello World!");

with

Console.WriteLine("Hello World!");

This is a convenience we’ll be using in our later chapters as well.

Things to remember from this article

• Every C# program must have a class definition.
• The execution of program begins from the Main() method.
• Main() method must be inside a class definition.

This is just a simple program for introducing C# to a newbie. If you did not understand certain things in this article, that's okay (even I did not when I started). As we move on with this tutorial series, everything will start to make sense.

C# Keywords and Identifiers

In this tutorial, we will learn about keywords (reserved words) and identifiers in C# programming language.

C# Keywords

Keywords are predefined sets of reserved words that have special meaning in a program. The meaning of keywords can not be changed, neither can they be directly used as identifiers in a program.

For example,

long mobileNum;

Here, long is a keyword and mobileNum is a variable (identifier). long has a special meaning in C# i.e. it is used to declare variables of type long and this function cannot be changed.

Also, keywords like long, int, char, etc can not be used as identifiers. So, we cannot have something like:

long long;

C# has a total of 79 keywords. All these keywords are in lowercase. Here is a complete list of all C# keywords.

Although keywords are reserved words, they can be used as identifiers if @ is added as prefix. For example,

int @void;

The above statement will create a variable @void of type int.

Contextual Keywords

Besides regular keywords, C# has 25 contextual keywords. Contextual keywords have specific meaning in a limited program context and can be used as identifiers outside that context. They are not reserved words in C#.

If you are interested to know the function of every keywords, I suggest you visit C# keywords (official C# docs).

C# Identifiers

Identifiers are the name given to entities such as variables, methods, classes, etc. They are tokens in a program which uniquely identify an element. For example,

int value;

Here, value is the name of variable. Hence it is an identifier. Reserved keywords can not be used as identifiers unless @ is added as prefix. For example,

int break;

This statement will generate an error in compile time.

To learn more about variables, visit C# Variables.

Rules for Naming an Identifier

• An identifier can not be a C# keyword.
• An identifier must begin with a letter, an underscore or @ symbol. The remaining part of identifier can contain letters, digits and underscore symbol.
• Whitespaces are not allowed. Neither it can have symbols other than letter, digits and underscore.
• Identifiers are case-sensitive. So, getName, GetName and getname represents 3 different identifiers.

Here are some of the valid and invalid identifiers:

Example: Find list of keywords and identifiers in a program

Just to clear the concept, let's find the list of keywords and identifiers in the program we wrote in C# Hello World.

using System;
namespace HelloWorld
{
    class Hello
{         
        static void Main(string[] args)
        {
          Console.WriteLine("Hello World!");
        }
    }
} 

The "Hello World!" inside WriteLine method is a string literal.

C# Variables and (Primitive) Data Types

In this tutorial, we will learn about variables, how to create variables in C# and different data types that C# programming language supports.

A variable is a symbolic name given to a memory location. Variables are used to store data in a computer program.

How to declare variables in C#?

Here's an example to declare a variable in C#.

int age;

In this example, a variable age of type int (integer) is declared and it can only store integer values.

We can assign a value to the variable later in our program like such:

int age;
... ... ...
age = 24;

However, the variable can also be initialized to some value during declaration. For example,

int age = 24;

Here, a variable age of type int is declared and initialized to 24 at the same time.

Since, it’s a variable, we can change the value of variables as well. For example,

int age = 24;
age = 35;

Here, the value of age is changed to 35 from 24.

Variables in C# must be declared before they can be used. This means, the name and type of variable must be known before they can be assigned a value. This is why C# is called a statically-typed language.

Once declared, the datatype of a variable can not be changed within a scope. A scope can be thought as a block of code where the variable is visible or available to use. If you don’t understand the previous statement, don’t worry we’ll learn about scopes in the later chapters.

For now remember,we can not do the following in C#:

int age;
age = 24;
... ... ...
float age;

Implicitly typed variables

Alternatively in C#, we can declare a variable without knowing its type using var keyword. Such variables are called implicitly typed local variables.

Variables declared using var keyword must be initialized at the time of declaration.

var value = 5;

The compiler determines the type of variable from the value that is assigned to the variable. In the above example, value is of type int. This is equivalent to:

int value;
value = 5;

You can learn more about implicitly typed local variables.

Rules for Naming Variables in C#

There are certain rules we need to follow while naming a variable. The rules for naming a variable in C# are:

1. The variable name can contain letters (uppercase and lowercase), underscore( _ ) and digits only.

2. The variable name must start with either letter, underscore or @ symbol. For example,

Rules for naming variables in C#

3. C# is case sensitive. It means age and Age refers to 2 different variables.

4. A variable name must not be a C# keyword. For example, if, for, using can not be a variable name. We will be discussing more about C# keywords in the next tutorial.

Best Practices for Naming a Variable

1. Choose a variable name that make sense. For example, name, age, subject makes more sense than n, a and s.
2. Use camelCase notation (starts with lowercase letter) for naming local variables. For example, numberOfStudents, age, etc.
3. Use PascalCase or CamelCase (starts with uppercase letter) for naming public member variables. For example, FirstName, Price, etc.
4. Use a leading underscore (_) followed by camelCase notation for naming private member variables. For example, _bankBalance, _emailAddress, etc.

You can learn more about naming conventions in C# here.

Don't worry about public and private member variables. We will learn about them in later chapters.

C# Primitive Data Types

Variables in C# are broadly classified into two types: Value types and Reference types. In this tutorial we will be discussing about primitive (simple) data types which is a subclass of Value types.

Reference types will be covered in later tutorials. However, if you want to know more about variable types, visit C# Types and variables (official C# docs).

Boolean (bool)

• Boolean data type has two possible values: true or false
• Default value: false
• Boolean variables are generally used to check conditions such as in if statements, loops, etc.

For Example:

using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}

When we run the program, the output will be:

True

Signed Integral

These data types hold integer values (both positive and negative). Out of the total available bits, one bit is used for sign.

1. sbyte

• Size: 8 bits
• Range: -128 to 127.
• Default value: 0

For example:

using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}

When we run the program, the output will be:

23

Try assigning values out of range i.e. less than -128 or greater than 127 and see what happens.

2. short

• Size: 16 bits
• Range: -32,768 to 32,767
• Default value: 0

For example:

using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}

When we run the program, the output will be:

-1109

3. int

• Size: 32 bits
• Range: -231 to 231-1
• Default value: 0

For example:

using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}

When we run the program, the output will be:

51092

4. long

• Size: 64 bits
• Range: -263 to 263-1
• Default value: 0L [L at the end represent the value is of long type]

For example:

using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}

When we run the program, the output will be:

-7091821871

Unsigned Integral

These data types only hold values equal to or greater than 0. We generally use these data types to store values when we are sure, we won't have negative values.

1. byte

• Size: 8 bits
• Range: 0 to 255.
• Default value: 0

For example:

using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
}

When we run the program, the output will be:

62

2. ushort

• Size: 16 bits
• Range: 0 to 65,535
• Default value: 0

For example:

using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}

When we run the program, the output will be:

42019

3. uint

• Size: 32 bits
• Range: 0 to 232-1
• Default value: 0

For example:

using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}

When we run the program, the output will be:

1151092

4. ulong

• Size: 64 bits
• Range: 0 to 264-1
• Default value: 0

For example:

using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}

When we run the program, the output will be:

17091821871

Floating Point

These data types hold floating point values i.e. numbers containing decimal values. For example, 12.36, -92.17, etc.

1. float

• Single-precision floating point type
• Size: 32 bits
• Range: 1.5 × 10−45 to 3.4 × 1038
• Default value: 0.0F [F at the end represent the value is of float type]

For example:

using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}

When we run the program, the output will be:

43.27

2. double

• Double-precision floating point type. What is the difference between single and double precision floating point?
• Size: 64 bits
• Range: 5.0 × 10−324 to 1.7 × 10308
• Default value: 0.0D [D at the end represent the value is of double type]

For example:

using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}

When we run the program, the output will be:

-11092.53

Character (char)

• It represents a 16 bit unicode character.
• Size: 16 bits
• Default value: '\0'
• Range: U+0000 ('\u0000') to U+FFFF ('\uffff')

For example:

using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}

When we run the program, the output will be:

B
x

The unicode value of 'B' is '\u0042', hence printing ch1 will print 'B'.

Decimal

• Decimal type has more precision and a smaller range as compared to floating point types (double and float). So it is appropriate for monetary calculations.
• Size: 128 bits
• Default value: 0.0M [M at the end represent the value is of decimal type]
• Range: (-7.9 x 1028 to 7.9 x 1028) / (100 to 28)

For example:

using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}

When we run the program, the output will be:

53005.25

The suffix M or m must be added at the end otherwise the value will be treated as a double and an error will be generated.

C# Literals

Let's look at the following statement:

int number = 41;

Here,

• int is a data type
• number is a variable and
• 41 is a literal

Literals are fixed values that appear in the program. They do not require any computation. For example, 5, false, 'w' are literals that appear in a program directly without any computation.

Boolean Literals

• true and false are the available boolean literals.
• They are used to initialize boolean variables.

For example:

bool isValid = true;
bool isPresent = false;

Integer Literals

• Integer literals are used to initialize variables of integer data types i.e. sbyte, short, int, long, byte, ushort, uint and ulong.

• If an integer literal ends with L or l, it is of type long. For best practice use L (not l).

  long value1 = 4200910L;
  long value2 = -10928190L;

• If an integer literal starts with a 0x, it represents hexadecimal value. Number with no prefixes are treated as decimal value. Octal and binary representation are not allowed in C#.

  int decimalValue = 25;
  int hexValue = 0x11c;// decimal value 284

Floating Point Literals

• Floating point literals are used to initialize variables of float and double data types.

• If a floating point literal ends with a suffix f or F, it is of type float. Similarly, if it ends with d or D, it is of type double. If neither of the suffix is present, it is of type double by default.

• These literals contains e or E when expressed in scientific notation.

double number = 24.67;// double by default
float value = -12.29F;
double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Character and String Literals

• Character literals are used to initialize variables of char data types.

• Character literals are enclosed in single quotes. For example, 'x','p', etc.

• They can be represented as character, hexadecimal escape sequence, unicode representation or integral values casted to char.

char ch1 = 'R';// character
char ch2 = '\x0072';// hexadecimal
char ch3 = '\u0059';// unicode
char ch4 = (char)107;// casted from integer

• String literals are the collection of character literals.

• They are enclosed in double quotes. For example, "Hello", "Easy Programming", etc.

string firstName = "Richard";
string lastName = " Feynman";

• C# also supports escape sequence characters such as:

  Character	Meaning
  \'	Single quote
  \"	Double quote
  \\	Backslash
  \n	Newline
  \r	Carriage return
  \t	Horizontal Tab
  \a	Alert
  \b	Backspace

C# Operators

In this article, we will learn everything about different types of operators in C# programming language and how to use them.

Operators are symbols that are used to perform operations on operands. Operands may be variables and/or constants.

For example, in 2+3, + is an operator that is used to carry out addition operation, while 2 and 3 are operands.

Operators are used to manipulate variables and values in a program. C# supports a number of operators that are classified based on the type of operations they perform.

1. Basic Assignment Operator

Basic assignment operator (=) is used to assign values to variables. For example,

double x;
x = 50.05;

Here, 50.05 is assigned to x.

Example 1: Basic Assignment Operator

using System;

namespace Operator
{
    class AssignmentOperator
    {
        public static void Main(string[] args)
        {
            int firstNumber, secondNumber;
            // Assigning a constant to variable
            firstNumber = 10;
            Console.WriteLine("First Number = {0}", firstNumber);

            // Assigning a variable to another variable
            secondNumber = firstNumber;
            Console.WriteLine("Second Number = {0}", secondNumber);
        }
    }
}

When we run the program, the output will be:

First Number = 10
Second Number = 10

This is a simple example that demonstrates the use of assignment operator.

You might have noticed the use of curly brackets { } in the example. We will discuss about them in string formatting. For now, just keep in mind that {0} is replaced by the first variable that follows the string, {1} is replaced by the second variable and so on.

2. Arithmetic Operators

Arithmetic operators are used to perform arithmetic operations such as addition, subtraction, multiplication, division, etc.

For example,

int x = 5;
int y = 10;
int z = x + y;// z = 15

C# Arithmetic Operators

Example 2: Arithmetic Operators

using System;

namespace Operator
{
    class ArithmeticOperator
    {
        public static void Main(string[] args)
        {
            double firstNumber = 14.40, secondNumber = 4.60, result;
            int num1 = 26, num2 = 4, rem;

            // Addition operator
            result = firstNumber + secondNumber;
            Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

            // Subtraction operator
            result = firstNumber - secondNumber;
            Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

            // Multiplication operator
            result = firstNumber * secondNumber;
            Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

            // Division operator
            result = firstNumber / secondNumber;
            Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

            // Modulo operator
            rem = num1 % num2;
            Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
        }
    }
}

When we run the program, the output will be:

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

Arithmetic operations are carried out in the above example. Variables can be replaced by constants in the statements. For example,

result = 4.5 + 2.7 ; // result will hold 7.2
result = firstNumber - 3.2; // result will hold 11.2

3. Relational Operators

Relational operators are used to check the relationship between two operands. If the relationship is true the result will be true, otherwise it will result in false.

Relational operators are used in decision making and loops.

C# Relational Operators

Example 3: Relational Operators

using System;

namespace Operator
{
    class RelationalOperator
    {
        public static void Main(string[] args)
        {
            bool result;
            int firstNumber = 10, secondNumber = 20;

            result = (firstNumber==secondNumber);
            Console.WriteLine("{0} == {1} returns {2}",firstNumber, secondNumber, result);

            result = (firstNumber > secondNumber);
            Console.WriteLine("{0} > {1} returns {2}",firstNumber, secondNumber, result);

            result = (firstNumber < secondNumber);
            Console.WriteLine("{0} < {1} returns {2}",firstNumber, secondNumber, result);

            result = (firstNumber >= secondNumber);
            Console.WriteLine("{0} >= {1} returns {2}",firstNumber, secondNumber, result);

            result = (firstNumber <= secondNumber);
            Console.WriteLine("{0} <= {1} returns {2}",firstNumber, secondNumber, result);

            result = (firstNumber != secondNumber);
            Console.WriteLine("{0} != {1} returns {2}",firstNumber, secondNumber, result);
        }
    }
}

When we run the program, the output will be:

10 == 20 returns False
10 > 20 returns False
10 < 20 returns True
10 >= 20 returns False
10 <= 20 returns True
10 != 20 returns True

4. Logical Operators

• Logical operators are used to perform logical operation such as and, or. Logical operators operates on boolean expressions (true and false) and returns boolean values. Logical operators are used in decision making and loops.
• Here is how the result is evaluated for logical AND and OR operators.
• C# Logical operators

In simple words, the table can be summarized as:

• If one of the operand is true, the OR operator will evaluate it to true.
• If one of the operand is false, the AND operator will evaluate it to false.

Example 4: Logical Operators

using System;

namespace Operator
{
    class LogicalOperator
    {
        public static void Main(string[] args)
        {
            bool result;
            int firstNumber = 10, secondNumber = 20;

            // OR operator
            result = (firstNumber == secondNumber) || (firstNumber > 5);
            Console.WriteLine(result);

            // AND operator
            result = (firstNumber == secondNumber) && (firstNumber > 5);
            Console.WriteLine(result);
        }
    }
}

When we run the program, the output will be:

True
False

5. Unary Operators

Unlike other operators, the unary operators operates on a single operand.
C# unary operators

Example 5: Unary Operators

using System;

namespace Operator
{
    class UnaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10, result;
            bool flag = true;

            result = +number;
            Console.WriteLine("+number = " + result);

            result = -number;
            Console.WriteLine("-number = " + result);

            result = ++number;
            Console.WriteLine("++number = " + result);

            result = --number;
            Console.WriteLine("--number = " + result);

            Console.WriteLine("!flag = " + (!flag));
        }
    }
}

When we run the program, the output will be:

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

The increment (++) and decrement (--) operators can be used as prefix and postfix. If used as prefix, the change in value of variable is seen on the same line and if used as postfix, the change in value of variable is seen on the next line. This will be clear by the example below.

Example 6: Post and Pre Increment operators in C#

using System;

namespace Operator
{
    class UnaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;

            Console.WriteLine((number++));
            Console.WriteLine((number));

            Console.WriteLine((++number));
            Console.WriteLine((number));
        }
    }
}

When we run the program, the output will be:

10
11
12
12

We can see the effect of using ++ as prefix and postfix. When ++ is used after the operand, the value is first evaluated and then it is incremented by 1. Hence the statement

Console.WriteLine((number++));

prints 10 instead of 11. After the value is printed, the value of number is incremented by 1.

The process is opposite when ++ is used as prefix. The value is incremented before printing. Hence the statement

Console.WriteLine((++number));

prints 12.

The case is same for decrement operator (--).

6. Ternary Operator

The ternary operator ? : operates on three operands. It is a shorthand for if-then-else statement. Ternary operator can be used as follows:

variable = Condition? Expression1 : Expression2;

The ternary operator works as follows:

• If the expression stated by Condition is true, the result of Expression1 is assigned to variable.
• If it is false, the result of Expression2 is assigned to variable.

Example 7: Ternary Operator

using System;

namespace Operator
{
    class TernaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            string result;

            result = (number % 2 == 0)? "Even Number" : "Odd Number";
            Console.WriteLine("{0} is {1}", number, result);
        }
    }
}

When we run the program, the output will be:

10 is Even Number

To learn more, visit C# ternary operator.

7. Bitwise and Bit Shift Operators

Bitwise and bit shift operators are used to perform bit manipulation operations.

C# Bitwise and Bit Shift operators

Example 8: Bitwise and Bit Shift Operator

using System;

namespace Operator
{
    class BitOperator
    {
        public static void Main(string[] args)
        {
            int firstNumber = 10;
            int secondNumber = 20;
            int result;

            result = ~firstNumber;
            Console.WriteLine("~{0} = {1}", firstNumber, result);

            result = firstNumber & secondNumber;
            Console.WriteLine("{0} & {1} = {2}", firstNumber,secondNumber, result);

            result = firstNumber | secondNumber;
            Console.WriteLine("{0} | {1} = {2}", firstNumber,secondNumber, result);

            result = firstNumber ^ secondNumber;
            Console.WriteLine("{0} ^ {1} = {2}", firstNumber,secondNumber, result);

            result = firstNumber << 2;
            Console.WriteLine("{0} << 2 = {1}", firstNumber, result);

            result = firstNumber >> 2;
            Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
        }
    }
}

When we run the program, the output will be:

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

To learn more, visit C# Bitwise and Bit Shift operator.

8. Compound Assignment Operators

• C# Compound Assignment Operators

Example 9: Compound Assignment Operator

using System;

namespace Operator
{
    class BitOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;

            number += 5;
            Console.WriteLine(number);

            number -= 3;
            Console.WriteLine(number);

            number *= 2;
            Console.WriteLine(number);

            number /= 3;
            Console.WriteLine(number);

            number %= 3;
            Console.WriteLine(number);

            number &= 10;
            Console.WriteLine(number);

            number |= 14;
            Console.WriteLine(number);

            number ^= 12;
            Console.WriteLine(number);

            number <<= 2;
            Console.WriteLine(number);

            number >>= 3;
            Console.WriteLine(number);
        }
    }
}

When we run the program, the output will be:

15
12
24
8
2
2
14
2
8
1

We will discuss about Lambda operators in later tutorial.

C# Operator Precedence and Associativity

In this tutorial we you will learn about operator precedence and associativity in C#. This will give us an idea of how an expression is evaluated by the C# compiler.

C# Operator Precedence

Operator precedence is a set of rules which defines how an expression is evaluated. In C#, each C# operator has an assigned priority and based on these priorities, the expression is evaluated.

For example, the precedence of multiplication (*) operator is higher than the precedence of addition (+) operator. Therefore, operation involving multiplication is carried out before addition.

Take a look at the statement below.

int x = 4 + 3 * 5;

What will be the value of x after executing this statement?

The operand 3 is associated with + and *. As stated earlier, multiplication has a higher precedence than addition. So, the operation 3 * 5 is carried out instead of 4 + 3. The value of variable x will be 19.

If addition would have a higher precedence, 4 + 3 would be evaluated first and the value of x would be 35.

Operator Precedence Table

The higher the precedence of operator is, the higher it appears in the table

C# Operator Precedence

The assignment operators have the lowest precedence while the postfix increment and decrement operators have the highest precedence.

Example 1: Operator Precedence

using System;

namespace Operator
{
    class OperatorPrecedence
    {
        public static void Main(string[] args)
        {
            int result1;
            int a = 5, b = 6, c = 4;
            result1 = --a * b - ++c;
            Console.WriteLine(result1);

            bool result2;
            result2 = b >= c + a;
            Console.WriteLine(result2);
        }
    }
}

When we run the program, the output will be:

19
False

Let's understand how the expression is evaluated in the program.

The precedence of -- and ++ is higher than *, and precedence of * is higher than -. Hence the statement,

result1 = --a * b - ++c;

is equivalent to

result1 = ((--a)*b)-(++c);

The expression inside parentheses is always evaluated first no matter what the precedence of operators outside it is.

• At first, (--a) is evaluated resulting into 4.

  

• Then (++c) is evaluated resulting into 5.

  

• Now, (a * b) is evaluated resulting into 24.

  

• Finally, the subtraction is carried out resulting into 19.
• Hence the final value of result1 will be 19.

In the next expression, the precedence of + is higher than >=. So, c and a is added first and the sum is compared with b to produce false.

Associativity of Operators in C#

In the previous section, we discussed about operator precedence. If two operators with different precedence are used, the operator with higher precedence is evaluated first.

But what if both the operators have same precedence?

In such case, the expression is evaluated based on the associativity of operator (left to right or right to left).

For example:

int a = 5, b = 6, c = 3;
int result = a * b / c;

Here, both * and / have the same precedence. But since the associativity of these operators is from left to right, a * b is evaluated first and then division is carried out. The final result of this expression will be 10.

In this particular example, the associativity does not really matter. Because even if division was carried out before multiplication, the result would be unaffected.

Let's take a look at another example.

int a = 5, b = 6, c = 3;
a = b = c;

The associativity of = operator is from right to left. So the value of c (i.e. 3) is assigned to b, and then the value of b is assigned to a. So after executing this statement, the values of a, b and c will be 3.

The table below shows the associativity of C# operators:
C# Associativity of operators

Almost all the operators have associativity from left to right. The operators having associativity from right to left are:

• Unary operators
• Prefix Increment and Decrement Operators
• Ternary Operator
• Assignment Operators

Example 2: Associativity of Operators

using System;

namespace Operator
{
    class OperatorPrecedence
    {
        public static void Main(string[] args)
        {
            int a = 5, b = 6, c = 3;
            int result = a * b / c;
            Console.WriteLine(result);

            a = b = c;
            Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
        }
    }
}

When we run the program, the output will be:

10
a = 3, b = 3, c = 3

C# Bitwise and Bit Shift Operators

In this tutorial, we will learn in detail about bitwise and bit shift operators in C#. C# provides 4 bitwise and 2 bit shift operators.

Bitwise and bit shift operators are used to perform bit level operations on integer (int, long, etc) and boolean data. These operators are not commonly used in real life situations.

If you are interested to explore more, visit practical applications of bitwise operations.

The bitwise and bit shift operators available in C# are listed below.

List of C# Bitwise Operators

Bitwise OR

• Bitwise OR operator is represented by |.
• It performs bitwise OR operation on the corresponding bits of two operands.
• If either of the bits is 1, the result is 1. Otherwise the result is 0.
• If the operands are of type bool, the bitwise OR operation is equivalent to logical OR operation between them.

For Example,

14 = 00001110 (In Binary)
11 = 00001011 (In Binary)

Bitwise OR operation between 14 and 11:

00001110
00001011
-------- XOR
00001111 = 15 (In Decimal)

Example 1: Bitwise OR

using System;

namespace Operator
{
    class BitWiseOR
    {
        public static void Main(string[] args)
        {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber | secondNumber;
            Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

When we run the program, the output will be:

14 | 11 = 15

Bitwise AND

• Bitwise AND operator is represented by &.
• It performs bitwise AND operation on the corresponding bits of two operands.
• If either of the bits is 0, the result is 0.
• Otherwise the result is 1.
• If the operands are of type bool, the bitwise AND operation is equivalent to logical AND operation between them.

For Example,

14 = 00001110 (In Binary)
11 = 00001011 (In Binary)

Bitwise AND operation between 14 and 11:

00001110
00001011
-------- AND
00001010 = 10 (In Decimal)

Example 2: Bitwise AND

using System;

namespace Operator
{
    class BitWiseAND
    {
        public static void Main(string[] args)
        {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber & secondNumber;
            Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

When we run the program, the output will be:

14 & 11 = 10

Bitwise XOR

• Bitwise XOR operator is represented by ^.
• It performs bitwise XOR operation on the corresponding bits of two operands.
• If the corresponding bits are same, the result is 0.
• If the corresponding bits are different, the result is 1.
• If the operands are of type bool, the bitwise XOR operation is equivalent to logical XOR operation between them.

For Example,

14 = 00001110 (In Binary)
11 = 00001011 (In Binary)

Bitwise XOR operation between 14 and 11:

00001110
00001011
-------- B-XOR
00000101 = 5 (In Decimal)

If you want to more about the usage of Bitwise XOR, visit The Magic of XOR

Example 3: Bitwise XOR

using System;

namespace Operator
{
    class BitWiseXOR
    {
        public static void Main(string[] args)
        {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber^secondNumber;
            Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

When we run the program, the output will be:

14 ^ 11 = 5

Bitwise Complement

Bitwise Complement operator is represented by ~. It is a unary operator, i.e. operates on only one operand. The ~ operator inverts each bits i.e. changes 1 to 0 and 0 to 1.

For Example,

26 = 00011010 (In Binary)

Bitwise Complement operation on 26:

~ 00011010 = 11100101 = 229 (In Decimal)

Example 4: Bitwise Complement

using System;

namespace Operator
{
    class BitWiseComplement
    {
        public static void Main(string[] args)
        {
            int number = 26, result;
            result = ~number;
            Console.WriteLine("~{0} = {1}", number, result);
        }
    }
}

When we run the program, the output will be:

~26 = -27

We got -27 as output when we were expecting 229. Why did this happen?

It happens because the binary value 11100101 which we expect to be 229 is actually a 2's complement representation of -27. Negative numbers in computer are represented in 2's complement representation.

For any integer n, 2's complement of n will be -(n+1).

2's complement

Overflow values are ignored in 2's complement.

The bitwise complement of 26 is 229 (in decimal) and the 2's complement of 229 is -27. Hence the output is -27 instead of 229.

Bitwise Left Shift

Bitwise left shift operator is represented by <<. The << operator shifts a number to the left by a specified number of bits. Zeroes are added to the least significant bits.

In decimal, it is equivalent to

num * 2bits

For Example,

42 = 101010 (In Binary)

Bitwise Lift Shift operation on 42:

42 << 1 = 84 (In binary 1010100)
42 << 2 = 168 (In binary 10101000)
42 << 4 = 672 (In binary 1010100000)

Example 5: Bitwise Left Shift

using System;

namespace Operator
{
    class LeftShift
    {
        public static void Main(string[] args)
        {
            int number = 42;

            Console.WriteLine("{0}<<1 = {1}", number, number<<1);
            Console.WriteLine("{0}<<2 = {1}", number, number<<2);
            Console.WriteLine("{0}<<4 = {1}", number, number<<4);
        }
    }
}

When we run the program, the output will be:

42<<1 = 84
42<<2 = 168
42<<4 = 672

Bitwise Right Shift

Bitwise right shift operator is represented by >>. The >> operator shifts a number to the right by a specified number of bits. The first operand is shifted to right by the number of bits specified by second operand.

In decimal, it is equivalent to

floor(num / 2bits)

For Example,

42 = 101010 (In Binary)

Bitwise Lift Shift operation on 42:

42 >> 1 = 21 (In binary 010101)
42 >> 2 = 10 (In binary 001010)
42 >> 4 = 2 (In binary 000010)

Example 6: Bitwise Right Shift

using System;

namespace Operator
{
    class LeftShift
    {
        public static void Main(string[] args)
        {
            int number = 42;

            Console.WriteLine("{0}>>1 = {1}", number, number>>1);
            Console.WriteLine("{0}>>2 = {1}", number, number>>2);
            Console.WriteLine("{0}>>4 = {1}", number, number>>4);
        }
    }
}

When we run the program, the output will be:

42>>1 = 21
42>>2 = 10
42>>4 = 2

C# Basic Input and Output

In this tutorial, we will learn how to take input from user and and display output in C# using various methods

C# Output

In order to output something in C#, we can use

System.Console.WriteLine() OR
System.Console.Write()

Here, System is a namespace, Console is a class within namespace System and WriteLine and Write are methods of class Console.

Let's look at a simple example that prints a string to output screen.

Example 1: Printing String using WriteLine()

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("C# is cool");
        }
    }
}

When we run the program, the output will be

C# is cool

Difference between WriteLine() and Write() method

The main difference between WriteLine() and Write() is that the Write() method only prints the string provided to it, while the WriteLine() method prints the string and moves to the start of next line as well.

Let's take at a look at the example below to understand the difference between these methods.

Example 2: How to use WriteLine() and Write() method?

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Prints on ");
            Console.WriteLine("New line");

            Console.Write("Prints on ");
            Console.Write("Same line");
        }
    }
}

When we run the program, the output will be

Prints on
New line
Prints on Same line

Printing Variables and Literals using WriteLine() and Write()

The WriteLine() and Write() method can be used to print variables and literals. Here's an example.

Example 3: Printing Variables and Literals

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            int value = 10;

            // Variable
            Console.WriteLine(value);
            // Literal
            Console.WriteLine(50.05);
        }
    }
}

When we run the program, the output will be

10
50.05

Combining (Concatenating) two strings using + operator and printing them

Strings can be combined/concatenated using the + operator while printing.

Example 4: Printing Concatenated String using + operator

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            int val = 55;
            Console.WriteLine("Hello " + "World");
            Console.WriteLine("Value = " + val);
        }
    }
}

When we run the program, the output will be

Hello World
Value = 55

Printing concatenated string using Formatted String [Better Alternative]

A better alternative for printing concatenated string is using formatted string. Formatted string allows programmer to use placeholders for variables.

For example, The following line,

Console.WriteLine("Value = " + val);

can be replaced by,

Console.WriteLine("Value = {0}", val);

{0} is the placeholder for variable val which will be replaced by value of val. Since only one variable is used so there is only one placeholder.

Multiple variables can be used in the formatted string. We will see that in the example below.

Example 5: Printing Concatenated string using String formatting

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            int firstNumber = 5, secondNumber = 10, result;
            result = firstNumber + secondNumber;
            Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

When we run the program, the output will be

5 + 10 = 15

Here, {0} is replaced by firstNumber, {1} is replaced by secondNumber and {2} is replaced by result. This approach of printing output is more readable and less error prone than using + operator.

To know more about string formatting, visit C# string formatting.

C# Input

In C#, the simplest method to get input from the user is by using the ReadLine() method of the Console class. However, Read() and ReadKey() are also available for getting input from the user. They are also included in Console class.

Example 6: Get String Input From User

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            string testString;
            Console.Write("Enter a string - ");
            testString = Console.ReadLine();
            Console.WriteLine("You entered '{0}'", testString);
        }
    }
}

When we run the program, the output will be:

Enter a string - Hello World
You entered 'Hello World'

Difference between ReadLine(), Read() and ReadKey() method:

The difference between ReadLine(), Read() and ReadKey() method is:

• ReadLine(): The ReadLine() method reads the next line of input from the standard input stream. It returns the same string.
• Read(): The Read() method reads the next character from the standard input stream. It returns the ascii value of the character.
• ReadKey(): The ReadKey() method obtains the next key pressed by user. This method is usually used to hold the screen until user press a key.

If you want to know more about these methods, here is an interesting discussion on StackOverflow on: Difference between Console.Read() and Console.ReadLine()?.

Example 7: Difference between Read() and ReadKey() method

using System;

namespace Sample
{
    class Test
    {
        public static void Main(string[] args)
        {
            int userInput;

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
            Console.WriteLine();

            Console.Write("Input using Read() - ");
            userInput = Console.Read();
            Console.WriteLine("Ascii Value = {0}",userInput);
        }
    }
}

When we run the program, the output will be

Press any key to continue...
x
Input using Read() - Learning C#
Ascii Value = 76

From this example, it must be clear how ReadKey() and Read() method works. While using ReadKey(), as soon as the key is pressed, it is displayed on the screen.

When Read() is used, it takes a whole line but only returns the ASCII value of first character. Hence, 76 (ASCII value of L) is printed.

Reading numeric values (integer and floating point types)

Reading a character or string is very simple in C#. All you need to do is call the corresponding methods as required.

But, reading numeric values can be slightly tricky in C#. We’ll still use the same ReadLine() method we used for getting string values. But since the ReadLine() method receives the input as string, it needs to be converted into integer or floating point type.

One simple approach for converting our input is using the methods of Convert class.

Example 8: Reading Numeric Values from User using Convert class

using System;

namespace UserInput
{
    class MyClass
    {
        public static void Main(string[] args)
        {
            string userInput;
            int intVal;
            double doubleVal;

            Console.Write("Enter integer value: ");
            userInput = Console.ReadLine();
            /* Converts to integer type */
            intVal = Convert.ToInt32(userInput);
            Console.WriteLine("You entered {0}",intVal);

            Console.Write("Enter double value: ");
            userInput = Console.ReadLine();
            /* Converts to double type */
            doubleVal = Convert.ToDouble(userInput);
            Console.WriteLine("You entered {0}",doubleVal);
        }
    }
}

When we run the program, the output will be

Enter integer value: 101
You entered 101
Enter double value: 59.412
You entered 59.412

The ToInt32() and ToDouble() method of Convert class converts the string input to integer and double type respectively. Similarly we can convert the input to other types. Here is a complete list of available methods for Convert class.

There are other ways to get numeric inputs from user. To learn more, visit Reading an integer from user input.

C# Expressions, Statements and Blocks (With Examples)

In this article, we will learn about C# expressions, C# statements, difference between expression and statement, and C# blocks.

Expressions, statements and blocks are the building block of a C# program. We have been using them since our first "Hello World" program.

C# Expressions

An expression in C# is a combination of operands (variables, literals, method calls) and operators that can be evaluated to a single value. To be precise, an expression must have at least one operand but may not have any operator.

Let's look at the example below:

double temperature;
temperature = 42.05;

Here, 42.05 is an expression. Also, temperature = 42.05 is an expression too.

int a, b, c, sum;
sum = a + b + c;

Here, a + b + c is an expression.

if (age>=18 && age<58)
    Console.WriteLine("Eligible to work");

Here, (age>=18 && age<58) is an expression that returns a boolean value. "Eligible to work" is also an expression.

C# Statements

A statement is a basic unit of execution of a program. A program consists of multiple statements.

For example:

int age = 21;
Int marks = 90;

In the above example, both lines above are statements.

There are different types of statements in C#. In this tutorial, we’ll mainly focus on two of them:

1. Declaration Statement
2. Expression Statement

Declaration Statement

Declaration statements are used to declare and initialize variables.

For example:

char ch;
int maxValue = 55;

Both char ch; and int maxValue = 55; are declaration statements.

Expression Statement

An expression followed by a semicolon is called an expression statement.

For example:

/* Assignment */
area = 3.14 * radius * radius;
/* Method call is an expression*/
System.Console.WriteLine("Hello");

Here, 3.14 * radius * radius  is an expression and area = 3.14 * radius * radius; is an expression statement.

Likewise, System.Console.WriteLine("Hello"); is both an expression and a statement.

Beside declaration and expression statement, there are:

• Selection Statements (if...else, switch)
• Iteration Statements (do, while, for, foreach)
• Jump Statements (break, continue, goto, return, yield)
• Exception Handling Statements (throw, try-catch, try-finally, try-catch-finally)

These statements will be discussed in later tutorials.

If you want to learn more about statements, visit C# Statements ( C# reference)

C# Blocks

A block is a combination of zero or more statements that is enclosed inside curly brackets { }.

For example:

Example 1: C# Blocks with statements

using System;

namespace Blocks
{
    class BlockExample
    {
        public static void Main(string[] args)
        {
            double temperature = 42.05;
            if (temperature > 32)
            {    // Start of block
                Console.WriteLine("Current temperature = {0}", temperature);
                Console.WriteLine("It's hot");
            }    // End of block
        }
    }
}

When we run the program, the output will be:

Current temperature = 42.05
It's hot

Here, the two statements inside { }:

Console.WriteLine("Current temperature = {0}", temperature);

and

Console.WriteLine("It's hot");

forms a block.

Example 2: C# Blocks without statements

A block may not have any statements within it as shown in the below example.

using System;

namespace Blocks
{
    class BlockExample
    {
        public static void Main(string[] args)
        {
            double temperature = 42.05;
            if (temperature > 32)
            {    // Start of block
                // No statements
            }    // End of block
        }
    }
}

Here, the curly braces { } after if(temperature > 32) contains only comments and no statements.

C# Comments

In this article, we will learn about C# comments, different style of comments, and why and how to use them in a program.

Comments are used in a program to help us understand a piece of code. They are human readable words intended to make the code readable. Comments are completely ignored by the compiler.

In C#, there are 3 types of comments:

1. Single Line Comments ( // )
2. Multi Line Comments (/* */)
3. XML Comments ( /// )

Single Line Comments

Single line comments start with a double slash //. The compiler ignores everything after // to the end of the line. For example,

int a = 5 + 7; // Adding 5 and 7

Here, Adding 5 and 7 is the comment.

Example 1: Using single line comment

// Hello World Program
using System;

namespace HelloWorld
{
    class Program
    {
        public static void Main(string[] args)  // Execution Starts from Main method
        {
            // Prints Hello World
            Console.WriteLine("Hello World!");
        }
    }
}

The above program contains 3 single line comments:

// Hello World Program
// Execution Starts from Main method

and

// Prints Hello World

Single line comments can be written in a separate line or along with the codes in same line. However, it is recommended to use comments in a separate line.

Multi Line Comments

Multi line comments start with /* and ends with */. Multi line comments can span over multiple lines.

Example 2: Using multi line comment

/*    This is a Hello World Program in C#.    This program prints Hello World.*/
using System;

namespace HelloWorld
{
    class Program
    {
        public static void Main(string[] args)
        {
            /* Prints Hello World     */
            Console.WriteLine("Hello World!");
        }
    }
}

The above program contains 2 multi line comments:

/*
This is a Hello World Program in C#.
This program prints Hello World.
*/

and

/* Prints Hello World */

Here, we may have noticed that it is not compulsory for a multi line comment to span over multiple lines./* … */ can be used instead of single line comments.

XML Documentation Comments

XML documentation comment is a special feature in C#. It starts with a triple slash /// and is used to categorically describe a piece of code.. This is done using XML tags within a comment. These comments are then, used to create a separate XML documentation file.

If you are not familiar with XML, see What is XML?

Example 3: Using XML documentation comment

/// <summary>
///  This is a hello world program.
/// </summary>

using System;

namespace HelloWorld
{
    class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

The XML comment used in the above program is

/// <summary>
/// This is a hello world program.
/// </summary>

The XML documentation (.xml file) generated will contain:

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>HelloWorld</name>
    </assembly>
    <members>
    </members>
</doc>

Visit XML Documentation Comments if you are interested in learning more.

Use Comments the Right Way

Comments are used to explain parts of code but they should not be overused .

For example:

// Prints Hello World
Console.WriteLine("Hello World");

Using comment in the above example is not necessary. It is obvious that the line will print Hello World. Comments should be avoided in such cases.

• Instead comments should be used in the program to explain complex algorithms and techniques.
• Comments should be short and to the point instead of a long description.
• As a rule of thumb, it is better to explain why instead of how, using comments.

Flow Control

C# if, if...else, if...else if and Nested if Statement

In this article, we will learn how to use if, if...else, if...else if statement in C# to control the flow of our program’s execution.

Testing a condition is inevitable in programming. We will often face situations where we need to test conditions (whether it is true or false) to control the flow of program. These conditions may be affected by user's input, time factor, current environment where the program is running, etc.

In this article, we'll learn to test conditions using if statement in C#.

C# if (if-then) Statement

C# if-then statement will execute a block of code if the given condition is true. The syntax of if-then statement in C# is:

if (boolean-expression)
{
    // statements executed if boolean-expression is true
}

• The boolean-expression will return either true or false.
• If the boolean-expression returns true, the statements inside the body of if ( inside {...} ) will be executed.
• If the boolean-expression returns false, the statements inside the body of if will be ignored.

For example,

if (number < 5)
{
    number += 5;
}

In this example, the statement

number += 5;

will be executed only if the value of number is less than 5.

Remember the += operator?

How if statement works?

Example 1: C# if Statement

using System;

namespace Conditional
{
    class IfStatement
    {
        public static void Main(string[] args)
        {
            int number = 2;
            if (number < 5)
            {
                Console.WriteLine("{0} is less than 5", number);
            }

            Console.WriteLine("This statement is always executed.");
        }
    }
}

When we run the program, the output will be:

2 is less than 5
This statement is always executed.

The value of number is initialized to 2. So the expression number < 5 is evaluated to true. Hence, the code inside the if block are executed. The code after the if statement will always be executed irrespective to the expression.

Now, change the value of number to something greater than 5, say 10. When we run the program the output will be:

This statement is always executed.

The expression number < 5 will return false, hence the code inside if block won't be executed.

C# if...else (if-then-else) Statement

The if statement in C# may have an optional else statement. The block of code inside the else statement will be executed if the expression is evaluated to false.

The syntax of if...else statement in C# is:

if (boolean-expression)
{
    // statements executed if boolean-expression is true
}
else
{
    // statements executed if boolean-expression is false
}

For example,

if (number < 5)
{
    number += 5;
}
else
{
    number -= 5;
}

In this example, the statement

number += 5;

will be executed only if the value of number is less than 5.

The statement

number -= 5;

will be executed if the value of number is greater than or equal to 5.

How if...else Statement works?

Working of if...else Statement

Example 2: C# if...else Statement

using System;

namespace Conditional
{
    class IfElseStatement
    {
        public static void Main(string[] args)
        {
            int number = 12;

            if (number < 5)
            {
                Console.WriteLine("{0} is less than 5", number);
            }
            else
            {
                Console.WriteLine("{0} is greater than or equal to 5", number);
            }

            Console.WriteLine("This statement is always executed.");
        }
    }
}

When we run the program, the output will be:

12 is greater than or equal to 5
This statement is always executed.

Here, the value of number is initialized to 12. So the expression number < 5 is evaluated to false. Hence, the code inside the else block are executed. The code after the if..else statement will always be executed irrespective to the expression.

Now, change the value of number to something less than 5, say 2. When we run the program the output will be:

2 is less than 5
This statement is always executed.

The expression number < 5 will return true, hence the code inside if block will be executed.

Ternary operator in C# provides a shortcut for C# if...else statement.

C# if...else if (if-then-else if) Statement

When we have only one condition to test, if-then and if-then-else statement works fine. But what if we have a multiple condition to test and execute one of the many block of code.

For such case, we can use if..else if statement in C#. The syntax for if...else if statement is:

if (boolean-expression-1)
{
    // statements executed if boolean-expression-1 is true
}
else if (boolean-expression-2)
{
    // statements executed if boolean-expression-2 is true
}
else if (boolean-expression-3)
{
    // statements executed if boolean-expression-3 is true
}
.
.
.
else
{
    // statements executed if all above expressions are false
}

The if...else if statement is executed from the top to bottom. As soon as a test expression is true, the code inside of that if ( or else if ) block is executed. Then the control jumps out of the if...else if block.

If none of the expression is true, the code inside the else block is executed.

Alternatively, we can use switch statement in such condition.

Example 3: C# if...else if Statement

using System;

namespace Conditional
{
    class IfElseIfStatement
    {
        public static void Main(string[] args)
        {
            int number = 12;

            if (number < 5)
            {
                Console.WriteLine("{0} is less than 5", number);
            }
            else if (number > 5)
            {
                Console.WriteLine("{0} is greater than 5", number);
            }
            else
            {
                Console.WriteLine("{0} is equal to 5");
            }
        }
    }
}

When we run the program, the output will be:

12 is greater than 5

The value of number is initialized to 12. The first test expression number < 5 is false, so the control will move to the else if block. The test expression number > 5 is true hence the block of code inside else if will be executed.

Similarly, we can change the value of number to alter the flow of execution.

Nested if...else Statement

An if...else statement can exist within another if...else statement. Such statements are called nested if...else statement.

The general structure of nested if...else statement is:

if (boolean-expression){
    if (nested-expression-1){
        // code to be executed
    }else{
    // code to be executed
    }
}else{
    if (nested-expression-2){
        // code to be executed
    }else{
        // code to be executed
    }
}

Nested if statements are generally used when we have to test one condition followed by another. In a nested if statement, if the outer if statement returns true, it enters the body to check the inner if statement.

Example 4: Nested if...else Statement

The following program computes the largest number among 3 numbers using nested if...else statement.

using System;

namespace Conditional{
    class Nested{
        public static void Main(string[] args){
            int first = 7, second = -23, third = 13;
            if (first > second){
                if (firstNumber > third){
                    Console.WriteLine("{0} is the largest", first);
                }else{
                    Console.WriteLine("{0} is the largest", third);
                }
            }else{
                  if (second > third){
                    Console.WriteLine("{0} is the largest", second);
                    }else{
                    Console.WriteLine("{0} is the largest", third);
                    }
            }
        }
    }
}

When we run the program, the output will be:

13 is the largest

C# switch Statement

In this article, we will learn about switch statement in C# and how to use them with examples.

Switch statement can be used to replace the if...else if statement in C#. The advantage of using switch over if...else if statement is the codes will look much cleaner and readable with switch.

The syntax of switch statement is:

switch (variable/expression)
{
    case value1:
        // Statements executed if expression(or variable) = value1
        break;
    case value2:
        // Statements executed if expression(or variable) = value1
        break;
    ... ... ... 
    ... ... ... 
    default:
        // Statements executed if no case matches
}

The switch statement evaluates the expression (or variable) and compare its value with the values (or expression) of each case (value1, value2, …). When it finds the matching value, the statements inside that case are executed.

But, if none of the above cases matches the expression, the statements inside default block is executed. The default statement at the end of switch is similar to the else block in if else statement.

However a problem with the switch statement is, when the matching value is found, it executes all statements after it until the end of switch block.

To avoid this, we use break statement at the end of each case. The break statement stops the program from executing non-matching statements by terminating the execution of switch statement.

To learn more about break statement, visit C# break statement.

Example 1: C# switch Statement

using System;

namespace Conditional
{
    class SwitchCase
    {
        public static void Main(string[] args)
        {
            char ch;
            Console.WriteLine("Enter an alphabet");
            ch = Convert.ToChar(Console.ReadLine());

            switch(Char.ToLower(ch))
            {
                case 'a':
                    Console.WriteLine("Vowel");
                    break;
                case 'e':
                    Console.WriteLine("Vowel");
                    break;
                case 'i':
                    Console.WriteLine("Vowel");
                    break;
                case 'o':
                    Console.WriteLine("Vowel");
                    break;
                case 'u':
                    Console.WriteLine("Vowel");
                    break;
                default:
                    Console.WriteLine("Not a vowel");
                    break;
            }
        }
    }
}

When we run the program, the output will be:

Enter an alphabet
X
Not a vowel

In this example, the user is prompted to enter an alphabet. The alphabet is converted to lowercase by using ToLower() method if it is in uppercase.

Then, the switch statement checks whether the alphabet entered by user is any of a, e, i, o or u.

If one of the case matches, Vowel is printed otherwise the control goes to default block and Not a vowel is printed as output.

Since, the output for all vowels are the same, we can join the cases as:

Example 2: C# switch Statement with grouped cases

using System;

namespace Conditional
{
    class SwitchCase
    {
        public static void Main(string[] args)
        {
            char ch;
            Console.WriteLine("Enter an alphabet");
            ch = Convert.ToChar(Console.ReadLine());

            switch(Char.ToLower(ch))
            {
                case 'a':
                case 'e':
                case 'i':
                case 'o':
                case 'u':
                    Console.WriteLine("Vowel");
                    break;
                default:
                    Console.WriteLine("Not a vowel");
                    break;
            }
        }
    }
}

The output of both programs is same. In the above program, all vowels print the output Vowel and breaks from the switch statement.

Although switch statement makes the code look cleaner than if...else if statement, switch is restricted to work with limited data types. Switch statement in C# only works with:

• Primitive data types: bool, char and integral type
• Enumerated Types (Enum)
• String Class
• Nullable types of above data types

Example 3: Simple calculator program using C# switch Statement

using System;

namespace Conditional
{
    class SwitchCase
    {
        public static void Main(string[] args)
        {
            char op;
            double first, second, result;

            Console.Write("Enter first number: ");
            first = Convert.ToDouble(Console.ReadLine());
            Console.Write("Enter second number: ");
            second = Convert.ToDouble(Console.ReadLine());
            Console.Write("Enter operator (+, -, *, /): ");
            op = (char)Console.Read();

            switch(op)
            {
                case '+':
                    result = first + second;
                    Console.WriteLine("{0} + {1} = {2}", first, second, result);
                    break;

                case '-':
                    result = first - second;
                    Console.WriteLine("{0} - {1} = {2}", first, second, result);
                    break;

                case '*':
                    result = first * second;
                    Console.WriteLine("{0} * {1} = {2}", first, second, result);
                    break;

                case '/':
                    result = first / second;
                    Console.WriteLine("{0} / {1} = {2}", first, second, result);
                    break;

                default:
                    Console.WriteLine("Invalid Operator");
                    break;

            }
        }
    }
}

When we run the program, the output will be:

Enter first number: -13.11
Enter second number: 2.41
Enter operator (+, -, *, /): *
-13.11 * 2.41 = -31.5951

The above program takes two operands and an operator as input from the user and performs the operation based on the operator.

The inputs are taken from the user using the ReadLine() and Read() method. To learn more, visit C# Basic Input and Output.

The program uses switch case statement for decision making. Alternatively, we can use if-else if ladder to perform the same operation.

C# ternary (? :) Operator

In this article, we will learn about C# ternary operator and how to use it to control the flow of program.

Ternary operator are a substitute for if...else statement. So before you move any further in this tutorial, go through C# if...else statement (if you haven't).

The syntax of ternary operator is:

Condition ? Expression1 : Expression2;

The ternary operator works as follows:

• If the expression stated by Condition is true, the result of Expression1 is returned by the ternary operator.
• If it is false, the result of Expression2 is returned.

For example, we can replace the following code

if (number % 2 == 0){
    isEven = true;
}else{
    isEven = false;
}

with

isEven = (number % 2 == 0) ? true : false ;

Why is it called ternary operator?

This operator takes 3 operand, hence called ternary operator.

Example 1: C# Ternary Operator

using System;

namespace Conditional
{
    class Ternary
    {
        public static void Main(string[] args)
        {
            int number = 2;
            bool isEven;

            isEven = (number % 2 == 0) ? true : false ;  
            Console.WriteLine(isEven);
        }
    }
}

When we run the program, the output will be:

True

In the above program, 2 is assigned to a variable number. Then, the ternary operator is used to check if number is even or not.

Since, 2 is even, the expression (number % 2 == 0) returns true. We can also use ternary operator to return numbers, strings and characters.

Instead of storing the return value in variable isEven, we can directly print the value returned by ternary operator as,

Console.WriteLine((number % 2 == 0) ? true : false);

When to use ternary operator?

Ternary operator can be used to replace multi lines of code with a single line. However, we shouldn't overuse it.

For example, we can replace the following if..else if code

if (a > b){
    result = "a is greater than b";
}else if (a < b){
    result = "b is greater than a";
}else{
    result = "a is equal to b";
}

with a single line of code

result = a > b ? "a is greater than b" : a < b ? "b is greater than a" : "a is equal to b";

As we can see, the use of ternary operator may decrease the length of code but it makes us difficult to understand the logic of the code.

Hence, it's better to only use ternary operator to replace simple if else statement

C# for loop

In this article, we will learn about for loop in C# and different ways to use them in a program.

In programming, it is often desired to execute certain block of statements for a specified number of times. A possible solution will be to type those statements for the required number of times. However, the number of repetition may not be known in advance (during compile time) or maybe large enough (say 10000).

The best solution to such problem is loop. Loops are used in programming to repeatedly execute a certain block of statements until some condition is met.

In this article, we’ll look at for loop in C#.

C# for loop

The for keyword is used to create for loop in C#. The syntax for for loop is:

for (initialization; condition; iterator)
{
    // body of for loop
}

How for loop works?

1. C# for loop has three statements: initialization, condition and iterator.

2. The initialization statement is executed at first and only once. Here, the variable is usually declared and initialized.

3. Then, the condition is evaluated. The condition is a boolean expression, i.e. it returns either true or false.

4. If the condition is evaluated to true:
   1. The statements inside the for loop are executed.
   2. Then, the iterator statement is executed which usually changes the value of the initialized variable.
   3. Again the condition is evaluated.
   4. The process continues until the condition is evaluated to false.

5. If the condition is evaluated to false, the for loop terminates.

for Loop Flowchart

Working of C# for loop

Example 1: C# for Loop

using System;

namespace Loop
{
    class ForLoop
    {
        public static void Main(string[] args)
        {
            for (int i=1; i<=5; i++)
            {
                Console.WriteLine("C# For Loop: Iteration {0}", i);
            }
        }
    }    
}

When we run the program, the output will be:

C# For Loop: Iteration 1
C# For Loop: Iteration 2
C# For Loop: Iteration 3
C# For Loop: Iteration 4
C# For Loop: Iteration 5

In this program,

• initialization statement is int i=1
• condition statement is i<=5
• iterator statement is i++

When the program runs,

• First, the variable i is declared and initialized to 1.

• Then, the condition (i<=5) is evaluated.

• Since, the condition returns true, the program then executes the body of the for loop. It prints the given line with Iteration 1 (Iteration simply means repetition).

• Now, the iterator (i++) is evaluated. This increments the value of i to 2.

• The condition (i<=5) is evaluated again and at the end, the value of i is incremented by 1. The condition will evaluate to true for the first 5 times.

• When the value of i will be 6 and the condition will be false, hence the loop will terminate.

Example 2: for loop to compute sum of first n natural numbers

using System;

namespace Loop
{
    class ForLoop
    {
        public static void Main(string[] args)
        {
            int n = 5,sum = 0;

            for (int i=1; i<=n; i++)
            {
                // sum = sum + i;
                sum += i;
            }

            Console.WriteLine("Sum of first {0} natural numbers = {1}", n, sum);
        }
    }
}

When we run the program, the output will be:

Sum of first 5 natural numbers = 15

Here, the value of sum and n are initialized to 0 and 5 respectively. The iteration variable i is initialized to 1 and incremented on each iteration.

Inside the for loop, value of sum is incremented by i i.e. sum = sum + i. The for loop continues until i is less than or equal to n (user's input).

Let's see what happens in the given program on each iteration.

Initially, i = 1, sum = 0 and n = 3

So, the final value of sum will be 15 when n = 5.

Multiple expressions inside a for loop

We can also use multiple expressions inside a for loop. It means we can have more than one initialization and/or iterator statements within a for loop. Let's see the example below.

Example 3: for loop with multiple initialization and iterator expressions

using System;

namespace Loop
{
    class ForLoop
    {
        public static void Main(string[] args)
        {
            for (int i=0, j=0; i+j<=5; i++, j++)
            {
                Console.WriteLine("i = {0} and j = {1}", i,j);
            }         
        }
    }
}

When we run the program, the output will be:

i = 0 and j = 0
i = 1 and j = 1
i = 2 and j = 2

In this program, we have declared and initialized two variables: i and j in the initialization statement.

Also, we have two expressions in the iterator part. That means both i and j are incremented by 1 on each iteration.

For loop without initialization and iterator statements

The initialization, condition and the iterator statement are optional in a for loop. It means we can run a for loop without these statements as well.

In such cases, for loop acts as a while loop. Let's see the example below.

Example 4: for loop without initialization and iterator statement

using System;

namespace Loop
{
    class ForLoop
    {
        public static void Main(string[] args)
        {
            int i = 1;
            for ( ; i<=5; )
            {
                Console.WriteLine("C# For Loop: Iteration {0}", i);
                i++;
            }
        }
    }
}

When we run the program, the output will be:

C# For Loop: Iteration 1
C# For Loop: Iteration 2
C# For Loop: Iteration 3
C# For Loop: Iteration 4
C# For Loop: Iteration 5

In this example, we haven't used the initialization and iterator statement.

The variable i is initialized above the for loop and its value is incremented inside the body of loop. This program is same as the one in Example 1.

Similarly, the condition is also an optional statement. However if we don't use test expression, the for loop won't test any condition and will run forever (infinite loop).

Infinite for loop

If the condition in a for loop is always true, for loop will run forever. This is called infinite for loop.

Example 5: Infinite for loop

using System;

namespace Loop
{
    class ForLoop
    {
        public static void Main(string[] args)
        {
            for (int i=1 ; i>0; i++)
            {
                Console.WriteLine("C# For Loop: Iteration {0}", i);
            }
        }
    }
}

Here, i is initialized to 1 and the condition is i>0. On each iteration we are incrementing the value of i by 1, so the condition will never be false. This will cause the loop to execute infinitely.

We can also create an infinite loop by replacing the condition with a blank. For example,

for ( ; ; )
{
    // body of for loop
}

or

for (initialization ; ; iterator){
    // body of for loop
}

C# while and do...while loop

In this article, we will learn about while and do...while loop in C#, how to use them and difference between them.

In programming, it is often desired to execute certain block of statements for a specified number of times. A possible solution will be to type those statements for the required number of times. However, the number of repetition may not be known in advance (during compile time) or maybe large enough (say 10000).

The best solution to such problem is loop. Loops are used in programming to repeatedly execute a certain block of statements until some condition is met.

In this article, we'll learn to use while loops in C#.

C# while loop

The while keyword is used to create while loop in C#. The syntax for while loop is:

while (test-expression){
    // body of while
}

How while loop works?

1. C# while loop consists of a test-expression.
2. If the test-expression is evaluated to true,
   1. statements inside the while loop are executed.
   2. after execution, the test-expression is evaluated again.
3. If the test-expression is evaluated to false, the while loop terminates.

while loop Flowchart

Example 1: while Loop

using System;

namespace Loop
{
    class WhileLoop
    {
        public static void Main(string[] args)
        {
            int i=1;
            while (i<=5)
            {
                Console.WriteLine("C# For Loop: Iteration {0}", i);
                i++;
            }
        }
    }
}

When we run the program, the output will be:

C# For Loop: Iteration 1
C# For Loop: Iteration 2
C# For Loop: Iteration 3
C# For Loop: Iteration 4
C# For Loop: Iteration 5

Initially the value of i is 1.

When the program reaches the while loop statement,

• the test expression i <=5 is evaluated. Since i is 1 and 1 <= 5 is true, it executes the body of the while loop. Here, the line is printed on the screen with Iteration 1, and the value of i is increased by 1 to become 2.
• Now, the test expression (i <=5) is evaluated again. This time too, the expression returns true (2 <= 5), so the line is printed on the screen and the value of i is now incremented to 3..
• This goes and the while loop executes until i becomes 6. At this point, the test-expression will evaluate to false and hence the loop terminates.

Example 2: while loop to compute sum of first 5 natural numbers

using System;

namespace Loop
{
    class WhileLoop
    {
        public static void Main(string[] args)
        {
            int i=1, sum=0;

            while (i<=5)
            {
                sum += i;
                i++;
            }
            Console.WriteLine("Sum = {0}", sum);
        }
    }
}

When we run the program, the output will be:

Sum = 15

This program computes the sum of first 5 natural numbers.

• Initially the value of sum is initialized to 0.
• On each iteration, the value of sum is updated to sum+i and the value of i is incremented by 1.
• When the value of i reaches 6, the test expression i<=5 will return false and the loop terminates.

Let's see what happens in the given program on each iteration.

Initially, i = 1, sum = 0, While loop execution steps

So, the final value of sum will be 15.

C# do...while loop

The do and while keyword is used to create a do...while loop. It is similar to a while loop, however there is a major difference between them.

In while loop, the condition is checked before the body is executed. It is the exact opposite in do...while loop, i.e. condition is checked after the body is executed.

This is why, the body of do...while loop will execute at least once irrespective to the test-expression.

The syntax for do...while loop is:

do
{
    // body of do while loop
} while (test-expression);

How do...while loop works?

1. The body of do...while loop is executed at first.
2. Then the test-expression is evaluated.
3. If the test-expression is true, the body of loop is executed.
4. When the test-expression is false, do...while loop terminates.

do...while loop Flowchart

Example 3: do...while loop

using System;

namespace Loop
{
    class DoWhileLoop
    {
        public static void Main(string[] args)
        {
            int i = 1, n = 5, product;

            do
            {
                product = n * i;
                Console.WriteLine("{0} * {1} = {2}", n, i, product);
                i++;
            } while (i <= 10);
        }
    }
}

When we run the program, the output will be:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

As we can see, the above program prints the multiplication table of a number (5).

• Initially, the value of i is 1. The program, then enters the body of do..while loop without checking any condition (as opposed to while loop).
• Inside the body, product is calculated and printed on the screen. The value of i is then incremented to 2.
• After the execution of the loop’s body, the test expression i <= 10 is evaluated. In total, the do...while loop will run for 10 times.
• Finally, when the value of i is 11, the test-expression evaluates to false and hence terminates the loop.

Infinite while and do...while loop

If the test expression in the while and do...while loop never evaluates to false, the body of loop will run forever. Such loops are called infinite loop.

For example:

Infinite while loop

while (true)
{
    // body of while loop
}

Infinite do...while loop

do
{
    // body of while loop
} while (true);

The infinite loop is useful when we need a loop to run as long as our program runs.

For example, if your program is an animation, you will need to constantly run it until it is stopped. In such cases, an infinite loop is necessary to keep running the animation repeatedly.

Nested Loops in C#: for, while, do-while

In this article, we will learn about nested loops in C#. We'll learn to use nested for, while and do-while loops in a program.

A loop within another loop is called nested loop. This is how a nested loop looks like:

Outer-Loop 
{
    // body of outer-loop
    Inner-Loop
    {
        // body of inner-loop
    }
... ... ...
}

As you can see, the outer loop encloses the inner loop. The inner loop is a part of the outer loop and must start and finish within the body of outer loop.

On each iteration of outer loop, the inner loop is executed completely.

Nested for loop

A for loop inside another for loop is called nested for loop.

For example:

for (int i=0; i<5; i++)
{
    // body of outer for loop
    for (int j=0; j<5; j++)
    {
        // body of inner for loop
    }
    // body of outer for loop
}

Example 1: Nested for Loop

using System;

namespace Loop
{
    class NestedForLoop
    {
        public static void Main(string[] args)
        {
            int outerLoop = 0, innerLoop = 0;
            for (int i=1; i<=5; i++)
            {
                outerLoop ++;
                for (int j=1; j<=5; j++)
                {
                    innerLoop++;
                }
            }
            Console.WriteLine("Outer Loop runs {0} times", outerLoop);
            Console.WriteLine("Inner Loop runs {0} times", innerLoop);
        }
    }
}

When we run the program, the output will be:

Outer Loop runs 5 times
Inner Loop runs 25 times

In this program, the outer loop runs for 5 times. Each time the outer loop runs, the inner loop runs for 5 times making it run 25 times altogether.

Example 2: Nested for Loop to Print Pattern

using System;

namespace Loop{
    class NestedForLoop{
        public static void Main(string[] args){
            for (int i=1; i<=5; i++){
                for (int j=1; j<=i; j++){
                  Console.Write(j + " ");
                }
              Console.WriteLine();
            }
        }
    }
}

When we run the program, the output will be:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Nested while loop

A while loop inside another while loop is called nested while loop.

For example:

while (condition-1)
{
    // body of outer while loop
    while (condition-2)
    {
        // body of inner while loop
    }
    // body of outer while loop
}

Example 3: Nested while Loop

using System;

namespace Loop
{
    class NestedWhileLoop
    {
        public static void Main(string[] args)
        {
            int i=0;
            while (i<2)
            {
                int j=0;
                while (j<2)
                {
                    Console.Write("({0},{1}) ", i,j);
                    j++;
                }
                i++;
                Console.WriteLine();
            }
        }
    }
}

When we run the program, the output will be:

(0,0) (0,1)
(1,0) (1,1)

Nested do-while loop

A do-while loop inside another do-while loop is called nested do-while loop.

For example:

do
{
    // body of outer while loop
    do
    {
        // body of inner while loop
    } while (condition-2);
    // body of outer while loop
} while (condition-1);

Example 4: Nested do-while Loop

using System;

namespace Loop
{
    class NestedWhileLoop
    {
        public static void Main(string[] args)
        {
            int i=0;
            do
            {
                int j=0;
                do
                {
                    Console.Write("({0},{1}) ", i,j);
                    j++;
                } while (j<2);
                i++;
                Console.WriteLine();

            } while (i<2);
        }
    }
}

When we run the program, the output will be:

(0,0) (0,1)
(1,0) (1,1)

Different inner and outer nested loops

It is not mandatory to nest same type of loop. We can put a for loop inside a while loop or a do-while loop inside a for loop.

Example 5: C# Nested Loop: Different inner and outer loops

using System;

namespace Loop
{
    class NestedLoop
    {
        public static void Main(string[] args)
        {
            int i=1;
            while (i<=5)
            {
                for (int j=1; j<=i; j++)
                {
                    Console.Write(i + " ");
                }

                Console.WriteLine();
                i++;
            }
        }
    }
}

When we run the program, the output will be:

1
2 2
3 3 3
4 4 4 4
5 5 5 5 5

In the above program, a for loop is placed within a while loop. We can use different types of loop inside a loop.

C# break Statement

In this tutorial, you will learn about the working C# break statement with the help of examples.

In C#, we use the break statement to terminate the loop.

As we know, loops iterate over a block of code until the test expression is false. However, sometimes we may need to terminate the loop immediately without checking the test expression.

In such cases, the break statement is used. The syntax of break statement is,

break;

Before we learn about break, make sure to learn about

• for loop
• if...else
• while loop

Example: C# break statement with for loop

using System;

namespace CSharpBreak {

  class Program {
    static void Main(string[] args) {

      for (int i = 1; i <= 4; ++i) {

        // terminates the loop
        if (i == 3) {
          break; 
        }

        Console.WriteLine(i);
      }

      Console.ReadLine();

    }
  }
}

Output

1
2

In the above program, our for loop runs 4 times from i = 1 to 4. However, when i is equal to 3, the break statement is encountered.

if (i == 3) {
  break;
}

Now, the loop is terminated suddenly. So, we only get 1 and 2 as output.

Note: The break statement is used with decision-making statements like if..else.

Example: C# break statement with while loop

using System;

namespace WhileBreak {

  class Program {
    static void Main(string[] args) {
      int i = 1;
      while (i <= 5) {
        Console.WriteLine(i);
         i++;
           if (i == 4) {
             // terminates the loop
             break; 
           }
      }
      Console.ReadLine();
    }
  }
}

Output

1
2
3

In the above example, we have created a while loop that is supposed to run from i = 1 to 5.

However, when i is equal to 4, the break statement is encountered.

if (i == 4) {
  break;
}

Now, the while loop is terminated.

Working of break statement in C#

break Statement with Nested Loop

We can also use the break statement with nested loops. For example,

using System;

namespace NestedBreak {
  class Program {
    static void Main(string[] args) {
      int sum = 0;
      for(int i = 1; i <= 3; i++) { //outer loop
      // inner loop
      for(int j = 1; j <= 3; j++) { 
        if (i == 2) {
          break;
        }
      Console.WriteLine("i = " + i + " j = " +j);
      }
    }
    Console.ReadLine();
    }
  }
}

Output

i = 1 j = 1
i = 1 j = 2
i = 1 j = 3
i = 3 j = 1
i = 3 j = 2
i = 3 j = 3

In the above example, we have used the break statement inside the inner for loop. Here, the break statement is executed when i == 2.

Hence, the value of i = 2 is never printed.

Note: The break statement only terminates the inner for loop. This is because we have used the break statement inside the inner loop.

If you want to learn the working of nested loops, visit C# Nested Loops.

break with foreach Loop

We can also use the break statement with foreach loops. For example,

using System;

namespace ForEachBreak {
  class Program {
    static void Main(string[] args) {
      int[] num = { 1, 2, 3, 4, 5 };

      // use of for each loop
      foreach(int number in num) {

        // terminates the loop
         if(number==3) {
           break; 
           }

      Console.WriteLine(number);
        }
    }
  }
}

Output

1
2

In the above example, we have created an array with values: 1, 2, 3, 4, 5. Here, we have used the foreach loop to print each element of the array.

However, the loop only prints 1 and 2. This is because when the number is equal to 3, the break statement is executed.

if (number == 3) {
  break;
}

This immediately terminates the foreach loop.

break with Switch Statement

We can also use the break statement inside a switch case statement. For example,

using System;

namespace ConsoleApp1 {

  class Program {
    static void Main(string[] args) {
      char ch='e';

       switch (ch) {
         case 'a':
           Console.WriteLine("Vowel");
           break;

         case 'e':
           Console.WriteLine("Vowel");
           break;

         case 'i':
           Console.WriteLine("Vowel");
           break;

         case 'o':
           Console.WriteLine("Vowel");
           break;

         case 'u':
           Console.WriteLine("Vowel");
           break;

         default:
           Console.WriteLine("Not a vowel");
       }
    }
  }
}

Output

Vowel

Here, we have used the break statement inside each case. It helps us to terminate the switch statement when a matching case is found.

To learn more, visit C# switch statement.

C# continue Statement

In this tutorial, you will learn about the working of C# continue statement with the help of examples.

In C#, we use the continue statement to skip a current iteration of a loop.

When our program encounters the continue statement, the program control moves to the end of the loop and executes the test condition (update statement in case of for loop).

The syntax for continue is:

continue;

Before we learn about continue, make sure to learn about

• for loop
• while loop
• if...else

Example1: C# continue with for loop

using System;

namespace ContinueLoop {

  class Program {
    static void Main(string[] args){
      for (int i = 1; i <= 5; ++i{
        if (i == 3) {
          continue;
        }
        Console.WriteLine(i);
      }
    }
  }
}

Output

1
2
4
5

In the above example, we have used the for loop to print numbers from i = 1 to 5. However, the number 3 is not printed.

This is because when the value of i is 3, the continue statement is executed.

// skips the condition
if (i == 3) {
  continue;  
}

This skips the current iteration of loop and moves the program control to the update statement. Hence, the value 3 is not printed.

Note: The continue statement is usually used with the if...else statement.

Example: C# continue with while loop

using System;

namespace ContinueWhile {
  class Program{
    static void Main(string[] args) {
      int i = 0;
      while (i < 5) {
        i++;

        if (i == 3) {
          continue;
        }

        Console.WriteLine(i);
      }
    }
  }
}

Output

1
2
4
5

Here, we have used the continue statement inside the while loop. Similar to the earlier program, when the value of i is 3, the continue statement is executed.

Hence, 3 is not printed on the screen.

Working of C# continue Statement

continue with Nested Loop

We use the continue statement with nested as well. For example:

using System;

namespace ContinueNested {
    class Program {
       static void Main(string[] args) {

      int sum = 0;

      // outer loop
      for(int i = 1; i <= 3; i++) { 

      // inner loop
      for(int j = 1; j <= 3; j++) { 
        if (j == 2) {
          continue;
        }

      Console.WriteLine("i = " + i + " j = " +j);
      }
     }
    }
   }
}

Output

i = 1 j = 1
i = 1 j = 3
i = 2 j = 1
i = 2 j = 3
i = 3 j = 1
i = 3 j = 3

In the above example, we have used the continue statement inside the inner for loop. Here, the continue statement is executed when j == 2.

Hence, the value of j = 2 is ignored.

If you want to learn the working of nested loops, visit C# Nested Loops.

C# continue with foreach Loop

We can also use the continue statement with foreach loops. For example,

using System;

namespace ContinueForeach {
  class Program {
    static void Main(string[] args) {

      int[] num = { 1, 2, 3, 4, 5 };
      foreach(int number in num) {

        // skips the iteration
        if(number==3) {
          continue; 
         }

        Console.WriteLine(number);
      }
    }
  }
}

Output

1
2
4
5 

In the above example, we have created an array with values: 1, 2, 3, 4, 5. Here, we have used the foreach loop to print each element of the array.

However, the loop doesn't print the value 3. This is because when the number is equal to 3, the continue statement is executed.

if (number == 3) {
  continue;
}

Hence, the print statement for this iteration is skipped.

Arrays

C# Arrays

In this tutorial, we will learn about C# arrays. We will learn to create, initialize, and access array with the help of examples.

An array is a collection of similar types of data.

For example, Suppose we need to record the age of 5 students. Instead of creating 5 separate variables, we can simply create an array:

Elements of an Array

1. C# Array Declaration

In C#, here is how we can declare an array.

datatype[] arrayName;

Here,

• dataType - data type like int, string, char, etc
• arrayName - it is an identifier

Let's see an example,

int[] age;

Here, we have created an array named age. It can store elements of int type.

But how many elements can it store?

To define the number of elements that an array can hold, we have to allocate memory for the array in C#. For example,

// declare an array
int[] age;

// allocate memory for array
age = new int[5];

Here, new int[5] represents that the array can store 5 elements. We can also say the size/length of the array is 5.

Note: We can also declare and allocate the memory of an array in a single line. For example,

int[] age = new int[5];

2. Array initialization in C#

In C#, we can initialize an array during the declaration.

For example,

int [] numbers = {1, 2, 3, 4, 5};

Here, we have created an array named numbers and initialized it with values 1, 2, 3, 4, and 5 inside the curly braces.

Note that we have not provided the size of the array. In this case, the C# automatically specifies the size by counting the number of elements in the array (i.e. 5).

In an array, we use an index number to determine the position of each array element. We can use the index number to initialize an array in C#.

For example,

// declare an array
int[] age = new int[5];

//initializing array
age[0] = 12;
age[1] = 4;
age[2] = 5;
...

C# Array Initialization

Note:

• An array index always starts at 0. That is, the first element of an array is at index 0.
• If the size of an array is 5, the index of the last element will be at 4 (5 - 1).

3. Access Array Elements

We can access the elements in the array using the index of the array. For example,

// access element at index 2
array[2];

// access element at index 4
array[4];

Here,

• array[2] - access the 3rd element
• array[4] - access the 5th element

Example: C# Array

using System;

namespace AccessArray {
  class Program  {
    static void Main(string[] args) {

      // create an array
      int[] numbers = {1, 2, 3};

      //access first element
      Console.WriteLine("Element in first index : " + numbers[0]);

      //access second element
      Console.WriteLine("Element in second index : " + numbers[1]);

      //access third element
      Console.WriteLine("Element in third index : " + numbers[2]);

      Console.ReadLine();

    }
  }
}

Output

Element in first index : 1
Element in second index : 2
Element in third index : 3

In the above example, we have created an array named numbers with elements 1, 2, 3. Here, we are using the index number to access elements of the array.

• numbers[0] - access first element, 1
• numbers[1] - access second element, 2
• numbers[3] - access third element, 3

4. Change Array Elements

We can also change the elements of an array. To change the element, we simply assign a new value to that particular index. For example,

using System;

namespace ChangeArray {
  class Program {
    static void Main(string[] args) {
      // create an array
      int[] numbers = {1, 2, 3};
      Console.WriteLine("Old Value at index 0: " + numbers[0]);
      // change the value at index 0
      numbers[0] = 11;
      //print new value
      Console.WriteLine("New Value at index 0: " + numbers[0]);
      Console.ReadLine();
    }
  }
}

Output

Old Value at index 0: 1
New Value at index 0: 11

In the above example, the initial value at index 0 is 1. Notice the line,

//change the value at index 0
numbers[0] = 11;

Here, we are assigning a new value of 11 to the index 0. Now, the value at index 0 is changed from 1 to 11.

5. Iterating C# Array using Loops

In C#, we can use loops to iterate through each element of an array. For example,

Example: Using for loop

using System;

namespace AccessArrayFor {
  class Program {
    static void Main(string[] args) {

      int[] numbers = { 1, 2, 3};

      for(int i=0; i < numbers.Length; i++) {
        Console.WriteLine("Element in index " + i + ": " + numbers[i]);
      }

      Console.ReadLine();
    }
  }
}

Output

Element in index 0: 1
Element in index 1: 2
Element in index 2: 3

In the above example, we have used a for loop to iterate through the elements of the array, numbers. Notice the line,

numbers.Length

Here, the Length property of the array gives the size of the array.

We can also use a foreach loop to iterate through the elements of an array. For example,

Example: Using foreach loop

using System;

namespace AccessArrayForeach {
  class Program {
    static void Main(string[] args) {
      int[] numbers = {1, 2, 3};

      Console.WriteLine("Array Elements: ");

      foreach(int num in numbers) {
        Console.WriteLine(num);
      }

      Console.ReadLine();
    }
  }
}

Output

Array Elements:
1
2
3

6. C# Array Operations using System.Linq

In C#, we have the System.Linq namespace that provides different methods to perform various operations in an array. For example,

Example: Find Minimum and Maximum Element

using System;

 // provides us various methods to use in an array
using System.Linq;

namespace ArrayMinMax {
  class Program  {
    static void Main(string[] args) {

      int[] numbers = {51, 1, 3, 4, 98};

      // get the minimum element
      Console.WriteLine("Smallest  Element: " + numbers.Min());  

      // Max() returns the largest number in array
      Console.WriteLine("Largest Element: " + numbers.Max());  

      Console.ReadLine();
    }
  }
}

Output

Smallest Element: 1
Largest Element: 98

In the above example,

• numbers.Min() - returns the smallest number in an array, 1
• numbers.Max() - returns the largest number in an array, 98

Example: Find the Average of an Array

using System;
// provides us various methods to use in an array
using System.Linq;

namespace ArrayFunction {
  class Program  {
    static void Main(string[] args) {

      int[] numbers = {30, 31, 94, 86, 55};

      // get the sum of all array elements
      float sum = numbers.Sum();

      // get the total number of elements present in the array
      int count = numbers.Count();

      float average = sum/count;

      Console.WriteLine("Average : " + average);

      // compute the average
      Console.WriteLine("Average using Average() : " + numbers.Average());

      Console.ReadLine();
    }
  }
}

Output

Average : 59.2
Average using Average() : 59.2

In the above example, we have used

• numbers.Sum() to get the sum of all the elements of the array
• numbers.Count() to get the total number of element present inside the array

We then divide the sum by count to get the average.

float average = sum / count;

Here, we have also used the numbers.Average() method of the System.Linq namespace to get the average directly.

Note: It is compulsory to use the System.Linq namespace while using Min(), Max(), Sum(), Count(), and Average() methods.

C# Multidimensional Array

In this tutorial, we will learn about the multidimensional array in C# using the example of two-dimensional array.

Before we learn about the multidimensional arrays, make sure to know about the single-dimensional array in C#.

In a multidimensional array, each element of the array is also an array. For example,

int[ , ] x = { { 1, 2 ,3}, { 3, 4, 5 } };

Here, x is a multidimensional array which has two elements: {1, 2, 3} and {3, 4, 5}. And, each element of the array is also an array with 3 elements.

Two-dimensional array in C#

A two-dimensional array consists of single-dimensional arrays as its elements. It can be represented as a table with a specific number of rows and columns.

C# Two-dimensional array

Here, rows {1, 2, 3} and {3, 4, 5} are elements of a 2D array.

1. Two-Dimensional Array Declaration

Here's how we declare a 2D array in C#.

int[ , ] x = new int [2, 3];

Here, x is a two-dimensional array with 2 elements. And, each element is also an array with 3 elements.

So, all together the array can store 6 elements (2 * 3).

Note: The single comma [ , ] represents the array is 2 dimensional.

2. Two-Dimensional Array initialization

In C#, we can initialize an array during the declaration. For example,

int[ , ] x = { { 1, 2 ,3}, { 3, 4, 5 } };

Here, x is a 2D array with two elements {1, 2, 3} and {3, 4, 5}. We can see that each element of the array is also an array.

We can also specify the number of rows and columns during the initialization. For example,

int [ , ] x = new int[2, 3]{ {1, 2, 3}, {3, 4, 5} };

3. Access Elements from 2D Array

We use the index number to access elements of a 2D array.

For example,

// a 2D array
int[ , ] x = { { 1, 2 ,3}, { 3, 4, 5 } };

// access first element from first row
x[0, 0];  // returns 1

// access third element from second row
x[1, 2];  // returns 5

// access third element from first row
x[0, 2];  // returns 3

Elements of Two-Dimensional array in C#

Example: C# 2D Array

using System;

namespace MultiDArray {
  class Program {
    static void Main(string[] args) {

        //initializing 2D array
       int[ , ] numbers = {{2, 3}, {4, 5}};

        // access first element from the first row
       Console.WriteLine("Element at index [0, 0] : "+numbers[0, 0]);

        // access first element from second row
       Console.WriteLine("Element at index [1, 0] : "+numbers[1, 0]);
    }
  }
}

Output

Element at index [0, 0] : 2
Element at index [1, 0] : 4

In the above example, we have created a 2D array named numbers with rows {2, 3} and {4, 5}.

Here, we are using the index numbers to access elements of the 2D array.

• numbers[0, 0] - access the first element from the first row (2)
• numbers[1, 0] - access the first element from the second row (4)

Change Array Elements

We can also change the elements of a two-dimensional array. To change the element, we simply assign a new value to that particular index. For example,

using System;

namespace MultiDArray {
  class Program {
    static void Main(string[] args) {

    int[ , ] numbers = {{2, 3}, {4, 5}};
     // old element
    Console.WriteLine("Old element at index [0, 0] : "+numbers[0, 0]);
      // assigning new value
    numbers[0, 0] = 222;
      // new element
    Console.WriteLine("New element at index [0, 0] : "+numbers[0, 0]);
    }
  }
}

Output

Old element at index [0, 0] : 2
New element at index [0, 0] : 222

In the above example, the initial value at index [0, 0] is 2. Notice the line,

// assigning new value
numbers[0, 0] = 222;

Here, we are assigning a new value 222 at index [0, 0]. Now, the value at index [0, 0] is changed from 2 to 222.

Iterating C# Array using Loop

using System;

namespace MultiDArray {
  class Program  {
    static void Main(string[] args)  {

      int[ , ] numbers = { {2, 3, 9}, {4, 5, 9} };

      for(int i = 0; i < numbers.GetLength(0); i++)  { 
        Console.Write("Row "+ i+": ");
        for(int j = 0; j < numbers.GetLength(1); j++)  { 
          Console.Write(numbers[i, j]+" ");
        }
        Console.WriteLine(); 
      }  
    }
  }
}

Output

Row 0: 2 3 9
Row 1: 4 5 9

In the above example, we have used a nested for loop to iterate through the elements of a 2D array. Here,

• numbers.GetLength(0) - gives the number of rows in a 2D array
• numbers.GetLength(1) - gives the number of elements in the row

Note: We can also create a 3D array. Technically, a 3D array is an array that has multiple two-dimensional arrays as its elements. For example,

int[ , , ] numbers = { { { 1, 3, 5 }, { 2, 4, 6 } },
                       { { 2, 4, 9 }, { 5, 7, 11 } } };

Here, [ , , ] (2 commas) denotes the 3D array.

C# Jagged Array

In this tutorial, we will learn about the C# jagged array. We will learn to declare, initialize, and access the jagged array with the help of examples.

In C#, a jagged array consists of multiple arrays as its element. However, unlike multidimensional arrays, each array inside a jagged array can be of different sizes.

Before you learn about jagged array, make sure to know about

• C# Arrays
• C# Multidimensional Arrays

C# Jagged Array Declaration

Here's a syntax to declare a jagged array in C#.

dataType[ ][ ] nameOfArray = new dataType[rows][ ];

Let's see an example,

// declare jagged array
int[ ][ ] jaggedArray = new int[2][ ];

Here,

• int - data type of the array
• [][] - represents jagged array
• jaggedArray - name of the jagged array
• [2][] - represents the number of elements (arrays) inside the jagged array

Since we know each element of a jagged array is also an array, we can set the size of the individual array.

For example,

// set size of the first array as 3
jaggedArray[0] = new int[3];

// set size of second array as 2
jaggedArray[1] = new int[2];

Initializing Jagged Array

There are different ways to initialize a jagged array. For example,

1. Using the index number

Once we declare a jagged array, we can use the index number to initialize it. For example,

// initialize the first array
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;

// initialize the second array
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

Here,

• index at the first square bracket represents the index of the jagged array element
• index at the second square bracket represents the index of the element inside each element of the jagged array

2. Initialize without setting size of array elements

// declaring string jagged array
int[ ][ ] jaggedArray = new int[2] [ ];

// initialize each array
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. Initialize while declaring Jagged Array

int[ ][ ] jaggedArray = {
    new int[ ] {10, 20, 30},
    new int[ ] {11, 22},
    new int[ ] {88, 99}
};

Accessing elements of a jagged array

We can access the elements of the jagged array using the index number. For example,

// access first element of second array
jaggedArray[1][0];

// access second element of the second array
jaggedArray[1][1];

// access second element of the first array
jaggedArray[0][1];

Example: C# Jagged Array

using System;

namespace JaggedArray {
  class Program {
    static void Main(string[] args) {

     // create a jagged array
     int[ ][ ] jaggedArray = {
         new int[] {1, 3, 5},
         new int[] {2, 4},
      };

     // print elements of jagged array
     Console.WriteLine("jaggedArray[1][0]: " + jaggedArray[1][0]);
     Console.WriteLine("jaggedArray[1][1]: " + jaggedArray[1][1]);

     Console.WriteLine("jaggedArray[0][2]: " + jaggedArray[0][2]);

     Console.ReadLine();
    }    
  }
}

Output

jaggedArray[1][0]: 2
jaggedArray[1][1]: 4
jaggedArray[0][2]: 5

Here, inside a jagged array,

• jaggedArray[1][0] - first element of the second array
• jaggedArray[1][1] - second element of the second array
• jaggedArray[0][2] - third element of the first array

Iterating through a jagged array

In C#, we can use loops to iterate through each element of the jagged array. For example,

using System;

namespace JaggedArray {
  class Program {
    static void Main(string[] args) {

      // declare a jagged array
      int[][] jaggedArray = new int[2][];

      // set size of Jagged Array Elements
      jaggedArray[0] = new int[3];
      jaggedArray[1] = new int[2];

      // initialize the first array
      jaggedArray[0][0] = 1;
      jaggedArray[0][1] = 3;
      jaggedArray[0][2] = 5;

      // initialize the second array
      jaggedArray[1][0] = 2;
      jaggedArray[1][1] = 2;

      // outer for loop
      for (int i = 0; i < jaggedArray.Length; i++) {

        Console.Write("Element "+ i +": ");
        // inner for loop
        for (int j = 0; j < jaggedArray[i].Length; j++) {
          Console.Write(jaggedArray[i][j] + " ");
         }
      Console.WriteLine();
      }
      Console.ReadLine();
    } 
  }
}

Output

Element 0: 1 3 5
Element 1: 2 2

In the above example, we have used a nested for loop to iterate through the jagged array. Here,

1. Outer for loop

• to access the elements (arrays) of the jagged array
• jaggedArray.Length - gives the size of jagged array

2. Inner for loop

• to access the elements of the individual array inside the jagged array.
• jaggedArray[i].Length - gives the size of elements of the ith array inside the jagged array

Jagged Array with Multidimensional Array

In C#, we can also use multidimensional arrays as Jagged Array Elements. For example,

int[ ][ , ] jaggedArrayTwoD = new int[2][ , ] {
        new int[,] { {1, 8}, {6, 7} },
        new int[,] { {0, 3}, {5, 6}, {9, 10} }
};

Here, each element of the jagged array is a multidimensional array:

• new int[,] { {1, 8}, {6, 7} } - 2D array with 2 elements
• new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - 2D array with 3 elements

Let's see an example,

using System;

namespace JaggedArray  {
  class Program {
    static void Main(string[] args)  {

      // declare and initialize jagged array with 2D array
      int[][,] jaggedArray = new int[3][ , ]  {
          new int[ , ] { {1, 8}, {6, 7} },
          new int[ , ] { {0, 3}, {5, 6}, {9, 10} },
          new int[ , ] { {11, 23}, {100, 88}, {0, 10} }
      };

      Console.WriteLine(jaggedArray[0][0, 1]);
      Console.WriteLine(jaggedArray[1][2, 1]);
      Console.WriteLine(jaggedArray[2][1, 0]);

      Console.ReadLine();
    }    
  }
}

Output

8
10
100

In the above example, notice the code,

jaggedArray[0][0, 1]

Here,

• [0] - represents the first element (2D array) of the jagged array
• [0, 1] - represents the second element of the first array inside the 2D array

C# foreach loop

In this tutorial, we will learn about foreach loops (an alternative to for loop) and how to use them with arrays and collections.

C# provides an easy to use and more readable alternative to for loop, the foreach loop when working with arrays and collections to iterate through the items of arrays/collections. The foreach loop iterates through each item, hence called foreach loop.

Before moving forward with foreach loop, visit:

• C# for loop
• C# arrays
• C# collections

Syntax of foreach loop

foreach (element in iterable-item)
{
    // body of foreach loop
}

Here iterable-item can be an array or a class of collection.

How foreach loop works?

The in keyword used along with foreach loop is used to iterate over the iterable-item. The in keyword selects an item from the iterable-item on each iteration and store it in the variable element.

On first iteration, the first item of iterable-item is stored in element. On second iteration, the second element is selected and so on.

The number of times the foreach loop will execute is equal to the number of elements in the array or collection.

Here is an example of iterating through an array using the for loop:

Example 1: Printing array using for loop

using System;

namespace Loop
{
    class ForLoop
    {
        public static void Main(string[] args)
        {
            char[] myArray = {'H','e','l','l','o'};

            for(int i = 0; i < myArray.Length; i++)
            {
                Console.WriteLine(myArray[i]);
            }
        }
    }
}

The same task can be done using the foreach loop.

Example 2: Printing array using foreach loop

using System;

namespace Loop
{
    class ForEachLoop
    {
        public static void Main(string[] args)
        {
            char[] myArray = {'H','e','l','l','o'};

            foreach(char ch in myArray)
            {
                Console.WriteLine(ch);
            }
        }
    }
}

When we run the both program, the output will be:

H
e
l
l
o

In the above program, the foreach loop iterates over the array, myArray.
On first iteration, the first element i.e. myArray[0] is selected and stored in ch.
Similarly on the last iteration, the last element i.e. myArray[4] is selected.
Inside the body of loop, the value of ch is printed.

When we look at both programs, the program that uses foreach loop is more readable and easy to understand.
This is because of its simple and expressive syntax.
Hence, foreach loop is preferred over for loop when working with arrays and collections.

Example 3: Traversing an array of gender using foreach loop

This program computes the number of male and female candidates.

using System;

namespace Loop{
    class ForEachLoop{
        public static void Main(string[] args){
            char[] gender = {'m','f','m','m','m','f','f','m','m','f'};
            int male = 0, female = 0;
            foreach (char g in gender)  {
                if (g == 'm')
                  male++;
                else if (g =='f')
                  female++;
            }
            Console.WriteLine("Number of male = {0}", male);
            Console.WriteLine("Number of female = {0}", female);
        }
    }
}

When we run the program, the output will be:

Number of male = 6
Number of female = 4

Example 4: foreach loop with List (Collection)

This program computes the sum of elements in a List.

using System;
using System.Collections.Generic;
namespace Loop {
  class ForEachLoop {
    public static void Main(string[] args) {
      var numbers = new List<int>() { 5, -8, 3, 14, 9, 17, 0, 4 };
      int sum = 0;
      foreach (int number in numbers) {
        sum += number;
      }
      Console.WriteLine("Sum = {0}", sum);
      Console.ReadLine();
    }
  }
}

When we run the program, the output will be:

Sum = 44

In this program, foreach loop is used to traverse through a collection. Traversing a collection is similar to traversing through an array.

The first element of collection is selected on the first iteration, second element on second iteration and so on till the last element.

C# Class and Object - OOP (I)

C# Class and Object

In this tutorial, you will learn about the concept of classes and objects in C# with the help of examples.

C# is an object-oriented program.
In object-oriented programming(OOP),
we solve complex problems by dividing them into objects.

To work with objects, we need to perform the following activities:

• create a class
• create objects from the class

C# Class

Before we learn about objects,
we need to understand the working of classes.
Class is the blueprint for the object.

We can think of the class as a sketch (prototype) of a house.
It contains all the details about the floors, doors, windows, etc.
We can build a house based on these descriptions. 
House is the object.

Like many houses can be made from the sketch, we can create many objects from a class.

Create a class in C#

We use the class keyword to create an object. For example,

class ClassName {

}

Here, we have created a class named ClassName. A class can contain

• fields - variables to store data
• methods - functions to perform specific tasks

Let's see an example,

class Dog {

  //field
  string breed;

  //method
  public void bark() {

  }

}

In the above example,

• Dog - class name
• breed - field
• bark() - method

Note: In C#, fields and methods inside a class are called members of a class.

C# Objects

An object is an instance of a class. Suppose, we have a class Dog. Bulldog, German Shepherd, Pug are objects of the class.

Creating an Object of a class

In C#, here's how we create an object of the class.

ClassName obj = new ClassName();

Here, we have used the new keyword to create an object of the class. And, obj is the name of the object. Now, let us create an object from the Dog class.

Dog bullDog = new Dog();

Now, the bullDog object can access the fields and methods of the Dog class.

Access Class Members using Object

We use the name of objects along with the . operator to access members of a class. For example,

using System;

namespace ClassObject {
  class Dog {
    string breed;
    public void bark() {
      Console.WriteLine("Bark Bark !!");
    }

    static void Main(string[] args) {
      // create Dog object 
      Dog bullDog = new Dog();
      // access breed of the Dog 
      bullDog.breed = "Bull Dog";
      Console.WriteLine(bullDog.breed);
      // access method of the Dog
      bullDog.bark();   
      Console.ReadLine();
    }
  }
}

--

Output

Bull Dog
Bark Bark !!

In the above program, we have created an object named bullDog from the Dog class. Notice that we have used the object name and the . (dot operator) to access the breed field

// access breed of the Dog
bullDog.breed = "Bull Dog";

and the bark() method

// access method of the Dog
bullDog.bark();

Creating Multiple Objects of a Class

We can create multiple objects from the same class. For example,

using System;

namespace ClassObject {

  class Employee {

    string department;

    static void Main(string[] args) {

      // create Employee object 
      Employee sheeran = new Employee();

      // set department for sheeran
      sheeran.department = "Development";
      Console.WriteLine("Sheeran: " + sheeran.department);

      // create second object of Employee
      Employee taylor = new Employee();

      // set department for taylor
      taylor.department = "Content Writing";
      Console.WriteLine("Taylor: " + taylor.department);

      Console.ReadLine();
    }
  }
}

Output

Sheeran: Development
Taylor: Content Writing

In the above example, we have created two objects: sheeran and taylor from the Employee class.

Here, you can see both the objects have their own version of the department field with different values.

Creating objects in a different class

In C#, we can also create an object of a class in another class.

For example,

using System;

namespace ClassObject {

  class Employee {
    public string name;

    public void work(string work) {
      Console.WriteLine("Work: " + work);

    }
  }

  class EmployeeDrive {
    static void Main(string[] args) {

      // create Employee object 
      Employee e1= new Employee();

      Console.WriteLine("Employee 1");

      // set name of the Employee 
      e1.name="Gloria";
      Console.WriteLine("Name: " + e1.name);

      //call method of the Employee
      e1.work("Coding"); 

      Console.ReadLine();

    }
  }
}

Output

Employee 1
Name: Gloria
Work: Coding

In the above example, we have two classes: Employee and EmployeeDrive. Here, we are creating an object e1 of the Employee class in the EmployeeDrive class.

We have used the e1 object to access the members of the Employee class from EmployeeDrive. This is possible because the members in the Employee class are public.

Here, public is an access specifier that means the class members are accessible from any other classes. To learn more, visit C# Access Modifiers.

Why Objects and Classes?

Objects and classes help us to divide a large project into smaller sub-problems.

Suppose you want to create a game that has hundreds of enemies and each of them has fields like health, ammo, and methods like shoot() and run().

With OOP we can create a single Enemy class with required fields and methods.

Then, we can create multiple enemy objects from it.

Each of the enemy objects will have its own version of health and ammo fields. And, they can use the common shoot() and run() methods.

Now, instead of thinking of projects in terms of variables and methods, we can think of them in terms of objects.

This helps to manage complexity as well as make our code reusable.

C# Method

In this tutorial, we will learn about the C# method with the help of examples.

A method is a block of code that performs a specific task. Suppose you need to create a program to create a circle and color it. You can create two methods to solve this problem:

• a method to draw the circle
• a method to color the circle

Dividing a complex problem into smaller chunks makes your program easy to understand and reusable.

Declaring a Method in C#

Here's the syntax to declare a method in C#.

returnType methodName() {
  // method body
}

Here,

• returnType - It specifies what type of value a method returns. For example, if a method has an int return type then it returns an int value.

If the method does not return a value, its return type is void.

• methodName - It is an identifier that is used to refer to the particular method in a program.

• method body - It includes the programming statements that are used to perform some tasks. The method body is enclosed inside the curly braces { }

Let's see an example,

void display() {
// code
}

Here, the name of the method is display(). And, the return type is void.

Calling a Method in C#

In the above example, we have declared a method named display(). Now, to use the method, we need to call it.

Here's how we can call the display() method.

// calls the method
display();

Working of C# method call

Example: C# Method

using System;

namespace Method {

  class Program {  

    // method declaration
    public void display() {
      Console.WriteLine("Hello World");   
    }

    static void Main(string[] args) {

      // create class object 
      Program p1 = new Program();

      //call method 
      p1.display();   

      Console.ReadLine();

    }
  }
}