C# PROGRAMMING

C# is pronounced "C-Sharp".
It is an object-oriented programming language created by Microsoft that runs
on the .NET Framework.
C# has roots from the C family, and the language is close to other popular
languages like C++ and Java.
C# is used for:
 Mobile applications
 Desktop applications
 Web applications
 Web services
 Web sites
 Games
 Database applications
Why Use C#?
 It is one of the most popular programming language in the world
 It is easy to learn and simple to use
 It has a huge community support
 C# is an object oriented language which gives a clear structure to
programs and allows code to be reused, lowering development costs.
C# Syntax

Line 1: using System means that we can use classes from

the System namespace.

Line 2: A blank line. C# ignores white space. However, multiple lines makes
the code more readable.

1
Line 3: namespace is used to organize your code, and it is a container for
classes and other namespaces.

Line 4: The curly braces {} marks the beginning and the end of a block of code.

Line 5: class is a container for data and methods, which brings functionality to
your program. Every line of code that runs in C# must be inside a class. In our
example, we named the class Program.

Line 7: Another thing that always appear in a C# program, is the Main method.
Any code inside its curly brackets {} will be executed. You don't have to
understand the keywords before and after Main

Line 9: Console is a class of the System namespace, which has

a WriteLine() method that is used to output/print text.

If you omit the using System line, you would have to

write System.Console.WriteLine() to print/output text.

Note: Every C# statement ends with a semicolon ;.

Note: C# is case-sensitive: "MyClass" and "myclass" has different meaning.

WriteLine or Write

The most common method to output something in C# is WriteLine(), but you

can also use Write().

The difference is that WriteLine() prints the output on a new line each time,
while Write() prints on the same line (note that you should remember to add
spaces when needed, for better readability):

C# Variables

Variables are containers for storing data values.

In C#, there are different types of variables (defined with different keywords),
for example:
2
  int - stores integers (whole numbers), without decimals, such as 123 or -
123
 double - stores floating point numbers, with decimals, such as 19.99 or -
19.99
 char - stores single characters, such as 'a' or 'B'. Char values are
surrounded by single quotes
 string - stores text, such as "Hello World". String values are surrounded
by double quotes
 bool - stores values with two states: true or false

Declaring (Creating) Variables

To create a variable, you must specify the type and assign it a value:

Syntax
type variableName = value;

Display Variables

The WriteLine() method is often used to display variable values to the console
window.

C# Identifiers

All C# variables must be identified with unique names.

These unique names are called identifiers.

Identifiers can be short names (like x and y) or more descriptive names (age,
sum, totalVolume).

Note: It is recommended to use descriptive names in order to create

understandable and maintainable code.

The general rules for constructing names for variables (unique identifiers) are:

3
  Names can contain letters, digits and the underscore character (_)
 Names must begin with a letter
 Names should start with a lowercase letter and it cannot contain
whitespace
 Names are case sensitive ("myVar" and "myvar" are different variables)
 Reserved words (like C# keywords, such as int or double) cannot be used
as names

C# Data Types

A data type specifies the size and type of variable values. It is important to use
the correct data type for the corresponding variable; to avoid errors, to save time
and memory, but it will also make your code more maintainable and readable.
The most common data types are:

Numbers

Number types are divided into two groups:

Integer types stores whole numbers, positive or negative (such as 123 or -456),
without decimals. Valid types are int and long. Which type you should use,
depends on the numeric value.

Floating point types represents numbers with a fractional part, containing one
or more decimals. Valid types are float and double.

Integer Types
Int

The int data type can store whole numbers from -2147483648 to 2147483647.

Long

The long data type can store whole numbers from -9223372036854775808 to
9223372036854775807. This is used when int is not large enough to store the
value. Note that you should end the value with an "L":

4
Floating Point Types

You should use a floating point type whenever you need a number with a
decimal, such as 9.99 or 3.14515.

Float

The float data type can store fractional numbers from 3.4e−038 to 3.4e+038.
Note that you should end the value with an "F":

Double

The double data type can store fractional numbers from 1.7e−308 to 1.7e+308.

When to use float or double

The precision of a floating point value indicates how many digits the value can
have after the decimal point. The precision of float is only six or seven decimal
digits, while double variables have a precision of about 15 digits. Therefore it
is safer to use double for most calculations.
Scientific Numbers

A floating point number can also be a scientific number with an "e" to indicate
the power of 10:

Booleans

A boolean data type is declared with the bool keyword and can only take the
values true or false. Boolean values are mostly used for conditional testing.

Characters

The char data type is used to store a single character. The character must be
surrounded by single quotes, like 'A' or 'c':

Strings

5
The string data type is used to store a sequence of characters (text). String
values must be surrounded by double quotes:

C# Type Casting

Type casting is when you assign a value of one data type to another type.

In C#, there are two types of casting:

 Implicit Casting (automatically) - converting a smaller type to a larger

type size
char -> int -> long -> float -> double

 Explicit Casting (manually) - converting a larger type to a smaller size

type

double -> float -> long -> int -> char

Implicit Casting

Implicit casting is done automatically when passing a smaller size type to a

larger size type:

Explicit Casting

Explicit casting must be done manually by placing the type in parentheses in

front of the value:

Type Conversion Methods

It is also possible to convert data types explicitly by using built-in methods,

such as;

Convert.ToBoolean, Convert.ToDouble, Convert.ToString, Convert.ToInt32 (

int) and Convert.ToInt64 (long):

Why Conversion?

6
Many times, there's no need for type conversion, but sometimes you have to.
Get User Input

You have already learned that Console.WriteLine() is used to output (print)

values. Now we will use Console.ReadLine() to get user input.

In the following example, the user can input his or hers username, which is
stored in the variable userName. Then we print the value of userName:

Example

// Type your username and press enter

Console.WriteLine("Enter username:");

// Create a string variable and get user input from the keyboard and store it in
the variable

string userName = Console.ReadLine();

// Print the value of the variable (userName), which will display the input value

Console.WriteLine("Username is: " + userName);

User Input and Numbers

The Console.ReadLine() method returns a string. Therefore, you cannot get

information from another data type, such as int. The following program will
cause an error:

Example

Console.WriteLine("Enter your age:");

int age = Console.ReadLine();

Console.WriteLine("Your age is: " + age);

The error message will be something like this:

Cannot implicitly convert type 'string' to 'int'
7
Like the error message says, you cannot implicitly convert type 'string' to 'int',
but we have just seen how to convert explicitly, so we are going to make use of
that (Convert.To) methods.

Example

Console.WriteLine("Enter your age:");

int age = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("Your age is: " + age);

C# Operators

Operators are used to perform operations on variables and values.

C# Assignment Operators

Assignment operators are used to assign values to variables.

The addition assignment operator (+=) adds a value to a variable:

Operator Example Same As

= x=5 x=5

+= x += 3 x=x+3

-= x -= 3 x=x-3

8
 *= x *= 3 x=x*3

/= x /= 3 x=x/3

%= x %= 3 x=x%3

&= x &= 3 x=x&3

|= x |= 3 x=x|3

^= x ^= 3 x=x^3

>>= x >>= 3 x = x >> 3

<<= x <<= 3 x = x << 3

C# Comparison Operators

Comparison operators are used to compare two values:

Operator Name Exampl

e

9
 == Equal to x == y

!= Not equal x != y

> Greater than x>y

< Less than x<y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

C# Logical Operators

Logical operators are used to determine the logic between variables or values:

Operator Name Description Example

&& Logical and Returns true if both statements are true x < 5 && x < 10

|| Logical or Returns true if one of the statements is true x < 5 || x < 4

10
! Logical not Reverse the result, returns false if the !(x < 5 && x < 10)
result is true

Math.Max(x,y)

The Math.Max(x,y) method can be used to find the highest value of x and y:

Example

Math.Max(5, 10);

Math.Min(x,y)

The Math.Min(x,y) method can be used to find the lowest value of of x and y:

Example

Math.Min(5, 10);

Math.Sqrt(x)

The Math.Sqrt(x) method returns the square root of x:

Example

Math.Sqrt(64);
Math.Abs(x)

The Math.Abs(x) method returns the absolute (positive) value of x:

Example
Math.Abs(-4.7);
Math.Round()

11
Math.Round() rounds a number to the nearest whole number:
Example
Math.Round(9.99);
C# Strings

Strings are used for storing text.

A string variable contains a collection of characters surrounded by double

quotes:

String Length

A string in C# is actually an object, which contain properties and methods that

can perform certain operations on strings. For example, the length of a string
can be found with the Length property:

Example

string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

Console.WriteLine("The length of the txt string is: " + txt.Length);

Other Methods

There are many string methods available, for

example ToUpper() and ToLower(), which returns a copy of the string
converted to uppercase or lowercase:

Example

string txt = "Hello World";

Console.WriteLine(txt.ToUpper()); // Outputs "HELLO WORLD"

Console.WriteLine(txt.ToLower()); // Outputs "hello world"

String Concatenation

12
The + operator can be used between strings to combine them. This is
called concatenation:

Example

string firstName = "John ";

string lastName = "Doe";

string name = firstName + lastName;

You can also use the string.Concat() method to concatenate two strings:

Example

string firstName = "John ";

string lastName = "Doe";

string name = string.Concat(firstName, lastName);

String Interpolation

Another option of string concatenation, is string interpolation, which

substitutes values of variables into placeholders in a string. Note that you do not
have to worry about spaces, like with concatenation:

Example

string firstName = "John";

string lastName = "Doe";

string name = $"My full name is: {firstName} {lastName}";

Access Strings

You can access the characters in a string by referring to its index number inside
square brackets [].

This example prints the first character in myString:

13
Example

string myString = "Hello";

Console.WriteLine(myString[0]); // Outputs "H"

You can also find the index position of a specific character in a string, by using
the IndexOf() method:

Example

string myString = "Hello";

Console.WriteLine(myString.IndexOf("e")); // Outputs "1"

Another useful method is Substring(), which extracts the characters from a

string, starting from the specified character position/index, and returns a new
string. This method is often used together with IndexOf() to get the specific
character position:

Example

// Full name
string name = "John Doe";

// Location of the letter D

int charPos = name.IndexOf("D");

// Get last name

string lastName = name.Substring(charPos);

// Print the result

Console.WriteLine(lastName);

Special Characters

14
Because strings must be written within quotes, C# will misunderstand this
string, and generate an error:

string txt = "We are the so-called "Vikings" from the north.";

The solution to avoid this problem, is to use the backslash escape character.

The backslash (\) escape character turns special characters into string
characters:

Escape character Result Description

\' ' Single quote

\" " Double quote

\\ \ Backslash

The sequence \" inserts a double quote in a string:

Example

string txt = "We are the so-called \"Vikings\" from the north.";

The sequence \' inserts a single quote in a string:

Example

string txt = "It\'s alright.";

The sequence \\ inserts a single backslash in a string:

15
Example

string txt = "The character \\ is called backslash.";

Other useful escape characters in C# are:

Code Result

\n New Line

\t Tab

\b Backspace

C# Booleans

Very often, in programming, you will need a data type that can only have one
of two values, like:

 YES / NO
 ON / OFF
 TRUE / FALSE

For this, C# has a bool data type, which can take the values true or false.

Boolean Values

A boolean type is declared with the bool keyword and can only take the
values true or false:

16
Example

bool isCSharpFun = true;

bool isFishTasty = false;

Console.WriteLine(isCSharpFun); // Outputs True

Console.WriteLine(isFishTasty); // Outputs False

C# Conditions and If Statements

C# supports the usual logical conditions from mathematics:

 Less than: a < b

 Less than or equal to: a <= b
 Greater than: a > b
 Greater than or equal to: a >= b
 Equal to a == b
 Not Equal to: a != b

You can use these conditions to perform different actions for different
decisions.

C# has the following conditional statements:

 Use if to specify a block of code to be executed, if a specified condition

is true
 Use else to specify a block of code to be executed, if the same condition
is false
 Use else if to specify a new condition to test, if the first condition is false
 Use switch to specify many alternative blocks of code to be executed

The if Statement

Use the if statement to specify a block of C# code to be executed if a condition

is True.

17
Syntax

if (condition)

// block of code to be executed if the condition is True

In the example below, we test two values to find out if 20 is greater than 18. If
the condition is True, print some text:

Example

if (20 > 18)

{

Console.WriteLine("20 is greater than 18");

We can also test variables:

Example

int x = 20;
int y = 18;

if (x > y)

Console.WriteLine("x is greater than y");

}
The else Statement

Use the else statement to specify a block of code to be executed if the condition
is False.
18
Syntax

if (condition)
{

// block of code to be executed if the condition is True

else

{
// block of code to be executed if the condition is False
}
Example

int time = 8;
if (time < 6)

Console.WriteLine("Good day.");

else
{
Console.WriteLine("Good evening.");

// Outputs "Good evening."

The else if Statement

Use the else if statement to specify a new condition if the first condition
is False.

19
Syntax

if (condition1)
{

// block of code to be executed if condition1 is True

else if (condition2)

{
// block of code to be executed if the condition1 is false and condition2 is True
}

else

// block of code to be executed if the condition1 is false and condition2 is False

Example

int time = 22;

if (time < 10)

{

Console.WriteLine("Good morning.");

}
else if (time < 20)

Console.WriteLine("Good day.");

20
else
{

Console.WriteLine("Good evening.");

// Outputs "Good evening."

Short Hand If...Else (Ternary Operator)

There is also a short-hand if else, which is known as the ternary

operator because it consists of three operands. It can be used to replace
multiple lines of code with a single line. It is often used to replace simple if else
statements:

Syntax
variable = (condition) ? expressionTrue : expressionFalse;

Instead of writing:
Example
int time = 20;
if (time < 18)

{
Console.WriteLine("Good day.");

else

Console.WriteLine("Good evening.");

21
You can simply write:

Example

int time = 20;

string result = (time < 18) ? "Good day." : "Good evening.";

Console.WriteLine(result);

C# Switch Statements

Use the switch statement to select one of many code blocks to be executed.

Syntax

switch(expression)

case x:
// code block

break;
case y:

// code block
break;

default:

// code block
break;

This is how it works:

22
  The switch expression is evaluated once.
 The value of the expression is compared with the values of each case.
 If there is a match, the associated block of code is executed.
 The break and default keywords will be described later in this chapter

The example below uses the weekday number to calculate the weekday name:

Example

int day = 4;

switch (day)
{
case 1:

Console.WriteLine("Monday");

break;
case 2:

Console.WriteLine("Tuesday");
break;

case 3:
Console.WriteLine("Wednesday");

break;

case 4:

Console.WriteLine("Thursday");
break;

case 5:

Console.WriteLine("Friday");
break;
23
 case 6:
Console.WriteLine("Saturday");
break;

case 7:

Console.WriteLine("Sunday");

break;

// Outputs "Thursday" (day 4)

The break Keyword

When C# reaches a break keyword, it breaks out of the switch block.

This will stop the execution of more code and case testing inside the block.

When a match is found, and the job is done, it's time for a break. There is no
need for more testing.

A break can save a lot of execution time because it "ignores" the execution of
all the rest of the code in the switch block.
The default Keyword

The default keyword is optional and specifies some code to run if there is no
case match:

Example

int day = 4;

switch (day)

{
case 6:

24
 Console.WriteLine("Today is Saturday.");
break;
case 7:

Console.WriteLine("Today is Sunday.");

break;

default:

Console.WriteLine("Looking forward to the Weekend.");

break;
}

// Outputs "Looking forward to the Weekend."

Loops

Loops can execute a block of code as long as a specified condition is reached.

Loops are handy because they save time, reduce errors, and they make code
more readable.

C# While Loop

The while loop loops through a block of code as long as a specified condition
is True:

Syntax

while (condition)
{

// code block to be executed

}

25
In the example below, the code in the loop will run, over and over again, as long
as a variable (i) is less than 5:

Example

int i = 0;

while (i < 5)
{

Console.WriteLine(i);

i++;
}
The Do/While Loop

The do/while loop is a variant of the while loop. This loop will execute the code
block once, before checking if the condition is true, then it will repeat the loop
as long as the condition is true.

Syntax

do

// code block to be executed

while (condition);

The example below uses a do/while loop. The loop will always be executed at
least once, even if the condition is false, because the code block is executed
before the condition is tested:

26
Example

int i = 0;
do

Console.WriteLine(i);

i++;

while (i < 5);

C# For Loop

When you know exactly how many times you want to loop through a block of
code, use the for loop instead of a while loop:

Syntax

for (statement 1; statement 2; statement 3)

// code block to be executed

Statement 1 is executed (one time) before the execution of the code block.

Statement 2 defines the condition for executing the code block.

Statement 3 is executed (every time) after the code block has been executed.

The example below will print the numbers 0 to 4:

Example

for (int i = 0; i < 5; i++)

27
{

Console.WriteLine(i);

The foreach Loop

There is also a foreach loop, which is used exclusively to loop through elements
in an array:

Syntax

foreach (type variableName in arrayName)

// code block to be executed

The following example outputs all elements in the cars array, using
a foreach loop:

Example

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

foreach (string i in cars)

Console.WriteLine(i);

}
Console.WriteLine(i);
}
28
ARRAYS

Arrays are used to store multiple values in a single variable, instead of declaring
separate variables for each value

Create an Array

To declare an array, define the variable type with square brackets:

string[] cars;

We have now declared a variable that holds an array of strings.

To insert values to it, we can use an array literal - place the values in a comma-
separated list, inside curly braces:

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

To create an array of integers, you could write:

int[] myNum = {10, 20, 30, 40};

Access the Elements of an Array

You access an array element by referring to the index number.

This statement accesses the value of the first element in cars:

Example

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Console.WriteLine(cars[0]);

29
// Outputs Volvo

Change an Array Element

To change the value of a specific element, refer to the index number:

Example

cars[0] = "Opel";

Example

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

cars[0] = "Opel";

Console.WriteLine(cars[0]);

// Now outputs Opel instead of Volvo

Array Length

To find out how many elements an array has, use the Length property:

Example

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Console.WriteLine(cars.Length);

// Outputs 4

Loop Through an Array

You can loop through the array elements with the for loop, and use
the Length property to specify how many times the loop should run.

The following example outputs all elements in the cars array:

30
Example

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

for (int i = 0; i < cars.Length; i++)

Console.WriteLine(cars[i]);

The foreach Loop

There is also a foreach loop, which is used exclusively to loop through elements
in an array:

Syntax

foreach (type variableName in arrayName)

// code block to be executed

The following example outputs all elements in the cars array, using
a foreach loop:

Example

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

foreach (string i in cars)

Console.WriteLine(i);

31
The example above can be read like this: for each string element (called i - as
in index) in cars, print out the value of i.

If you compare the for loop and foreach loop, you will see that
the foreach method is easier to write, it does not require a counter (using
the Length property), and it is more readable.

Sort Arrays

There are many array methods available, for example Sort(), which sorts an
array alphabetically or in an ascending order:

Example

// Sort a string

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Array.Sort(cars);
foreach (string i in cars)

Console.WriteLine(i);
}

// Sort an int
int[] myNumbers = {5, 1, 8, 9};

Array.Sort(myNumbers);

foreach (int i in myNumbers)

32
{
Console.WriteLine(i);
}

System.Linq Namespace

Other useful array methods, such as Min, Max, and Sum, can be found in
the System.Linq namespace:

Example

using System;

using System.Linq;

namespace MyApplication

{
class Program

{
static void Main(string[] args)

int[] myNumbers = {5, 1, 8, 9};

Console.WriteLine(myNumbers.Max()); // returns the largest value

Console.WriteLine(myNumbers.Min()); // returns the smallest value

Console.WriteLine(myNumbers.Sum()); // returns the sum of elements

}
33
 }
}

Other Ways to Create an Array

If you are familiar with C#, you might have seen arrays created with
the new keyword, and perhaps you have seen arrays with a specified size as
well. In C#, there are different ways to create an array:

// Create an array of four elements, and add values later

string[] cars = new string[4];

// Create an array of four elements and add values right away

string[] cars = new string[4] {"Volvo", "BMW", "Ford", "Mazda"};

// Create an array of four elements without specifying the size

string[] cars = new string[] {"Volvo", "BMW", "Ford", "Mazda"};

// Create an array of four elements, omitting the new keyword, and without
specifying the size
string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Method

A method is a block of code which only runs when it is called.

You can pass data, known as parameters, into a method.

34
Methods are used to perform certain actions, and they are also known
as functions.

Why use methods? To reuse code: define the code once, and use it many times.

Create a Method

A method is defined with the name of the method, followed by parentheses ().
C# provides some pre-defined methods, which you already are familiar with,
such as Main(), but you can also create your own methods to perform certain
actions:

Example

static void MyMethod()

// code to be executed

Example Explained

 MyMethod() is the name of the method

 static is an "access modifier", and it specifies the visibility of the method
 void means that this method does not have a return value.
 Note: In C#, it is good practice to start with an uppercase letter when
naming methods, as it makes the code easier to read.

Call a Method

To call (execute) a method, write the method's name followed by two

parentheses () and a semicolon;

35
In the following example, MyMethod() is used to print a text (the action), when
it is called:

Example

Inside Main(), call the myMethod() method:

static void MyMethod()

{

Console.WriteLine("I just got executed!");

}
static void Main(string[] args)

{
MyMethod();

// Outputs "I just got executed!"

Parameters and Arguments

Information can be passed to methods as parameter. Parameters act as variables

inside the method.

They are specified after the method name, inside the parentheses. You can add
as many parameters as you want, just separate them with a comma.

The following example has a method that takes a string called fname as
parameter. When the method is called, we pass along a first name, which is used
inside the method to print the full name:

36
Example

static void MyMethod(string fname)

{

Console.WriteLine(fname + " Refsnes");

static void Main(string[] args)

{
MyMethod("Liam");
MyMethod("Jenny");

MyMethod("Anja");

// Liam Refsnes

// Jenny Refsnes
// Anja Refsnes
When a parameter is passed to the method, it is called an argument. So, from
the example above: fname is a parameter,
while Liam, Jenny and Anja are arguments.
Default Parameter Value

You can also use a default parameter value, by using the equals sign (=). If we
call the method without an argument, it uses the default value ("Norway"):

37
Example

static void MyMethod(string country = "Norway")

{

Console.WriteLine(country);

static void Main(string[] args)

{
MyMethod("Sweden");

MyMethod("India");

MyMethod();

MyMethod("USA");

// Sweden
// India
// Norway

// USA
A parameter with a default value, is often known as an "optional parameter".
From the example above, country is an optional parameter and "Norway" is the
default value.
Multiple Parameters

You can have as many parameters as you like:

38
Example

static void MyMethod(string fname, int age)

{

Console.WriteLine(fname + " is " + age);

static void Main(string[] args)

{
MyMethod("Liam", 5);
MyMethod("Jenny", 8);

MyMethod("Anja", 31);

// Liam is 5

// Jenny is 8
// Anja is 31
Note that when you are working with multiple parameters, the method call must
have the same number of arguments as there are parameters, and the arguments
must be passed in the same order.
Return Values

The void keyword, used in the examples above, indicates that the method
should not return a value. If you want the method to return a value, you can use
a primitive data type (such as int or double) instead of void, and use
the return keyword inside the method:

39
Example

static int MyMethod(int x)

{

return 5 + x;

static void Main(string[] args)

{
Console.WriteLine(MyMethod(3));
}

// Outputs 8 (5 + 3)

This example returns the sum of a method's two parameters:

Example

static int MyMethod(int x, int y)

{

return x + y;

static void Main(string[] args)

Console.WriteLine(MyMethod(5, 3));

// Outputs 8 (5 + 3)

You can also store the result in a variable (recommended, as it is easier to read
and maintain):

40
Example

static int MyMethod(int x, int y)

{

return x + y;

static void Main(string[] args)

{
int z = MyMethod(5, 3);
Console.WriteLine(z);

// Outputs 8 (5 + 3)
Named Arguments

It is also possible to send arguments with the key: value syntax.

That way, the order of the arguments does not matter:

Example

static void MyMethod(string child1, string child2, string child3)

{

Console.WriteLine("The youngest child is: " + child3);

static void Main(string[] args)

{
MyMethod(child3: "John", child1: "Liam", child2: "Liam");
}
41
// The youngest child is: John

Named arguments are especially useful when you have multiple parameters
with default values, and you only want to specify one of them when you call it:

Example

static void MyMethod(string child1 = "Liam", string child2 = "Jenny", string

child3 = "John")

Console.WriteLine(child3);
}
static void Main(string[] args)

{
MyMethod("child3");

// John

Method Overloading

With method overloading, multiple methods can have the same name with
different parameters:

Example

int MyMethod(int x)

float MyMethod(float x)

double MyMethod(double x, double y)

42
Consider the following example, which have two methods that add numbers of
different type:

Example

static int PlusMethodInt(int x, int y)

{
return x + y;

static double PlusMethodDouble(double x, double y)

{

return x + y;
}

static void Main(string[] args)

{
int myNum1 = PlusMethodInt(8, 5);
double myNum2 = PlusMethodDouble(4.3, 6.26);

Console.WriteLine("Int: " + myNum1);

Console.WriteLine("Double: " + myNum2);

Instead of defining two methods that should do the same thing, it is better to
overload one.

In the example below, we overload the PlusMethod method to work for

both int and double:

Example

static int PlusMethod(int x, int y)

43
{
return x + y;
}

static double PlusMethod(double x, double y)

return x + y;

static void Main(string[] args)

{

int myNum1 = PlusMethod(8, 5);

double myNum2 = PlusMethod(4.3, 6.26);

Console.WriteLine("Int: " + myNum1);

Console.WriteLine("Double: " + myNum2);

}

44
C# CLASSES
C# - What is OOP?

OOP stands for Object-Oriented Programming.

Procedural programming is about writing procedures or methods that perform

operations on the data, while object-oriented programming is about creating
objects that contain both data and methods.

Object-oriented programming has several advantages over procedural

programming:

 OOP is faster and easier to execute

 OOP provides a clear structure for the programs
 OOP helps to keep the C# code DRY "Don't Repeat Yourself", and makes
the code easier to maintain, modify and debug
 OOP makes it possible to create full reusable applications with less code
and shorter development time

Note: The "Don't Repeat Yourself" (DRY) principle is about reducing the
repetition of code. You should extract out the codes that are common for the
application, and place them at a single place and reuse them instead of repeating
it.

C# Classes and Objects?

Classes and objects are the two main aspects of object-oriented programming.
A class is a template for objects, and an object is an instance of a class.

When the individual objects are created, they inherit all the variables and
methods from the class.

C# is an object-oriented programming language. Everything in C# is associated

with classes and objects, along with its attributes and methods. For example: in
real life, a car is an object. The car has attributes, such as weight and color,
and methods, such as drive and brake.

45
Create a Class

To create a class, use the class keyword:

Create a class named "Car" with a variable color:

class Car

string color = "red";

When a variable is declared directly in a class, it is often referred to as a field (or

attribute).
It is not required, but it is a good practice to start with an uppercase first letter
when naming classes. Also, it is common that the name of the C# file and the
class matches, as it makes our code organized. However it is not required (like
in Java).
Create an Object

An object is created from a class. We have already created the class named Car,
so now we can use this to create objects.

To create an object of Car, specify the class name, followed by the object name,
and use the keyword new:

Example

Create an object called "myObj" and use it to print the value of color:

class Car

string color = "red";

static void Main(string[] args)

46
 {
Car myObj = new Car();
Console.WriteLine(myObj.color);

Note that we use the dot syntax (.) to access variables/fields inside a class
(myObj.color).

Multiple Objects

You can create multiple objects of one class:

Example

Create two objects of Car:

class Car

string color = "red";

static void Main(string[] args)
{

Car myObj1 = new Car();

Car myObj2 = new Car();

Console.WriteLine(myObj1.color);

Console.WriteLine(myObj2.color);
}

}
Using Multiple Classes

47
You can also create an object of a class and access it in another class. This is
often used for better organization of classes (one class has all the fields and
methods, while the other class holds the Main() method (code to be executed)).

class Car

{
public string color = "red";

class Program
{

static void Main(string[] args)

{

Car myObj = new Car();

Console.WriteLine(myObj.color);

}}
The public keyword is called an access modifier, which specifies that
the color variable/field of Car is accessible for other classes as well, such
as Program.

Object Methods

Methods normally belongs to a class, and they define how an object of a class
behaves.

Just like with fields, you can access methods with the dot syntax. However, note
that the method must be public. And remember that we use the name of the
method followed by two parantheses () and a semicolon ; to call (execute) the
method:

48
Example

class Car
{

string color; // field

int maxSpeed; // field

public void fullThrottle() // method

{
Console.WriteLine("The car is going as fast as it can!");
}

static void Main(string[] args)

Car myObj = new Car();

myObj.fullThrottle(); // Call the method

}

}
Why did we declare the method as public, and not static? The reason is simple:
a static method can be accessed without creating an object of the class,
while public methods can only be accessed by objects.
Constructors

A constructor is a special method that is used to initialize objects. The

advantage of a constructor, is that it is called when an object of a class is created.
It can be used to set initial values for fields:

Example

Create a constructor:

49
// Create a Car class
class Car
{

public string model; // Create a field

// Create a class constructor for the Car class

public Car()

model = "Mustang"; // Set the initial value for model

}

static void Main(string[] args)

{

Car Ford = new Car(); // Create an object of the Car Class (this will call the
constructor)

Console.WriteLine(Ford.model); // Print the value of model

}
}

// Outputs "Mustang"
Note that the constructor name must match the class name, and it cannot have
a return type (like void or int).
Also note that the constructor is called when the object is created.
Constructors Save Time

They help in reducing the amount of code:

Access Modifiers

50
 By now, you are quite familiar with the public keyword that appears in many of
our examples:

public string color;

The public keyword is an access modifier, which is used to set the access
level/visibility for classes, fields, methods and properties.

C# has the following access modifiers:

Modifier Description

public The code is accessible for all classes

private The code is only accessible within the same class

protected The code is accessible within the same class, or in a class that is
inherited from that class.

internal The code is only accessible within its own assembly, but not from
another assembly.

Private Modifier

If you declare a field with a private access modifier, it can only be accessed
within the same class:

51
Example

class Car
{

private string model;

static void Main(string[] args)

{
Car Ford = new Car("Mustang");
Console.WriteLine(Ford.model);

The output will be:

Mustang

If you try to access it outside the class, an error will occur:

Example

class Car
{

private string model = "Mustang";

}
class Program

static void Main(string[] args)

52
 {
Car myObj = new Car();
Console.WriteLine(myObj.model);

The output will be:

'Car.model' is inaccessible due to its protection level

The field 'Car.model' is assigned but its value is never used

Public Modifier

If you declare a field with a public access modifier, it is accessible for all
classes:

Example

class Car
{
public string model = "Mustang";
}

class Program

static void Main(string[] args)

{

Car myObj = new Car();

Console.WriteLine(myObj.model);

53
 }
}
The output will be:

Mustang

Why are Access Modifiers important?

To control the visibility of class members (the security level of each individual
class and class member).
To achieve "Encapsulation" - which is the process of making sure that
"sensitive" data is hidden from users. This is done by declaring fields as private.
Note: By default, all members of a class are private if you don't specify an
access modifier:
Encapsulation

The meaning of Encapsulation, is to make sure that "sensitive" data is hidden

from users. To achieve this, you must:

 declare fields/variables as private

 provide public get and set methods, through properties, to access and
update the value of a private field

Properties

You have already learned that private variables can only be accessed within the
same class (an outside class has no access to it). However, sometimes we need
to access them - and it can be done with properties.

A property is like a combination of a variable and a method, and it has two

methods: a get and a set method:
54
Example

class Person
{

private string name; // field

public string Name // property

{
get { return name; } // get method
set { name = value; } // set method

}
Example explained

The Name property is associated with the name field. It is a good practice to use
the same name for both the property and the private field, but with an uppercase
first letter.

The get method returns the value of the variable name.

The set method assigns a value to the name variable. The value keyword
represents the value we assign to the property.

Now we can use the Name property to access and update the private field of
the Person class:

Example

class Person

{
private string name; // field
55
 public string Name // property
{
get { return name; }

set { name = value; }

class Program

{
static void Main(string[] args)

{
Person myObj = new Person();

myObj.Name = "Liam";

Console.WriteLine(myObj.Name);
}

}
The output will be:
Liam
Why Encapsulation?

 Better control of class members (reduce the possibility of yourself (or

others) to mess up the code)
 Fields can be made read-only (if you only use the get method), or write-
only (if you only use the set method)
 Flexible: the programmer can change one part of the code without
affecting other parts
 Increased security of data

56
Inheritance (Derived and Base Class)

In C#, it is possible to inherit fields and methods from one class to another. We
group the "inheritance concept" into two categories:

 Derived Class (child) - the class that inherits from another class
 Base Class (parent) - the class being inherited from

To inherit from a class, use the : symbol.

In the example below, the Car class (child) inherits the fields and methods from
the Vehicle class (parent):

Example

class Vehicle // base class (parent)

{

public string brand = "Ford"; // Vehicle field

public void honk() // Vehicle method

{
Console.WriteLine("Tuut, tuut!");
}

class Car : Vehicle // derived class (child)

public string modelName = "Mustang"; // Car field

}

class Program
{

57
 static void Main(string[] args)
{
// Create a myCar object

Car myCar = new Car();

// Call the honk() method (From the Vehicle class) on the myCar object

myCar.honk();

// Display the value of the brand field (from the Vehicle class) and the value
of the modelName from the Car class
Console.WriteLine(myCar.brand + " " + myCar.modelName);

}
}
Why And When To Use "Inheritance"?
- It is useful for code reusability: reuse fields and methods of an existing class
when you create a new class.
The sealed Keyword

If you don't want other classes to inherit from a class, use the sealed keyword:

If you try to access a sealed class, C# will generate an error:

sealed class Vehicle

{

...

}
class Car : Vehicle

{
...

58
}
The error message will be something like this:

'Car': cannot derive from sealed type 'Vehicle'

Polymorphism and Overriding Methods

Polymorphism means "many forms", and it occurs when we have many classes
that are related to each other by inheritance.

Inheritance means inheriting fields and methods from another

class. Polymorphism uses those methods to perform different tasks. This
allows us to perform a single action in different ways.

For example, think of a base class called Animal that has a method
called animalSound(). Derived classes of Animals could be Pigs, Cats, Dogs,
Birds - And they also have their own implementation of an animal sound (the
pig oinks, and the cat meows, etc.):

Example

class Animal // Base class (parent)

{

public void animalSound()

{

Console.WriteLine("The animal makes a sound");

class Pig : Animal // Derived class (child)

{

59
 public void animalSound()
{
Console.WriteLine("The pig says: wee wee");

class Dog : Animal // Derived class (child)

public void animalSound()

{

Console.WriteLine("The dog says: bow wow");

}

Now we can create Pig and Dog objects and call the animalSound() method on
both of them:

Example

class Animal // Base class (parent)

{

public void animalSound()

Console.WriteLine("The animal makes a sound");

}
}

class Pig : Animal // Derived class (child)

60
{
public void animalSound()
{

Console.WriteLine("The pig says: wee wee");

class Dog : Animal // Derived class (child)

{
public void animalSound()

{
Console.WriteLine("The dog says: bow wow");

}
class Program

{
static void Main(string[] args)

{
Animal myAnimal = new Animal(); // Create a Animal object

Animal myPig = new Pig(); // Create a Pig object

Animal myDog = new Dog(); // Create a Dog object

myAnimal.animalSound();
myPig.animalSound();
myDog.animalSound();

61
 }}
The output will be:
The animal makes a sound
The animal makes a sound
The animal makes a sound
The output from the example above was probably not what was expected. That
is because the base class method overrides the derived class method, when they
share the same name.
However, C# provides an option to override the base class method, by adding
the virtual keyword to the method inside the base class, and by using
the override keyword for each derived class methods:
Example

class Animal // Base class (parent)

{
public virtual void animalSound()

{
Console.WriteLine("The animal makes a sound");
}

}
class Pig : Animal // Derived class (child)

public override void animalSound()

{

Console.WriteLine("The pig says: wee wee");

}
}
62
class Dog : Animal // Derived class (child)
{
public override void animalSound()

Console.WriteLine("The dog says: bow wow");

class Program
{

static void Main(string[] args)

{

Animal myAnimal = new Animal(); // Create a Animal object

Animal myPig = new Pig(); // Create a Pig object

Animal myDog = new Dog(); // Create a Dog object

myAnimal.animalSound();
myPig.animalSound();

myDog.animalSound();
}

The output will be:

The animal makes a sound

The pig says: wee wee
The dog says: bow wow
Why And When To Use "Inheritance" and "Polymorphism"?
63
- It is useful for code reusability: reuse fields and methods of an existing class
when you create a new class.
Multiple Interfaces

To implement multiple interfaces, separate them with a comma:

Example

interface IFirstInterface

void myMethod(); // interface method

}

interface ISecondInterface

{
void myOtherMethod(); // interface method

}
// Implement multiple interfaces

class DemoClass : IFirstInterface, ISecondInterface

{

public void myMethod()

{

Console.WriteLine("Some text..");

}
public void myOtherMethod()

Console.WriteLine("Some other text...");

64
 }
}
class Program

static void Main(string[] args)

DemoClass myObj = new DemoClass();

myObj.myMethod();
myObj.myOtherMethod();

}
}

Files

The File class from the System.IO namespace, allows us to work with files:

Example

using System.IO; // include the System.IO namespace

File.SomeFileMethod(); // use the file class with methods

The File class has many useful methods for creating and getting information
about files. For example:

Method Description

65
AppendText() Appends text at the end of an existing file

Copy() Copies a file

Create() Creates or overwrites a file

Delete() Deletes a file

Exists() Tests whether the file exists

ReadAllText() Reads the contents of a file

Replace() Replaces the contents of a file with the contents

of another file

WriteAllText() Creates a new file and writes the contents to it.

If the file already exists, it will be overwritten.

Write To a File and Read It

66
In the following example, we use the WriteAllText() method to create a file
named "filename.txt" and write some content to it. Then we use
the ReadAllText() method to read the contents of the file:

Example

using System.IO; // include the System.IO namespace

string writeText = "Hello World!"; // Create a text string

File.WriteAllText("filename.txt", writeText); // Create a file and write the
content of writeText to it

string readText = File.ReadAllText("filename.txt"); // Read the contents of the

file

Console.WriteLine(readText); // Output the content

The output will be:
Hello World!

C# Exceptions

When executing C# code, different errors can occur: coding errors made by the
programmer, errors due to wrong input, or other unforeseeable things.

When an error occurs, C# will normally stop and generate an error message.
The technical term for this is: C# will throw an exception (throw an error).

C# try and catch

The try statement allows you to define a block of code to be tested for errors
while it is being executed.

The catch statement allows you to define a block of code to be executed, if an

error occurs in the try block.

The try and catch keywords come in pairs:

67
Syntax

try
{

// Block of code to try

catch (Exception e)

{
// Block of code to handle errors
}

Consider the following example, where we create an array of three integers:

This will generate an error, because myNumbers[10] does not exist.

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

Console.WriteLine(myNumbers[10]); // error!

The error message will be something like this:

System.IndexOutOfRangeException: 'Index was outside the bounds of the

array.'

If an error occurs, we can use try...catch to catch the error and execute some
code to handle it.

In the following example, we use the variable inside the catch block (e) together
with the built-in Message property, which outputs a message that describes the
exception:

Example

try

68
{
int[] myNumbers = {1, 2, 3};
Console.WriteLine(myNumbers[10]);

catch (Exception e)

Console.WriteLine(e.Message);

}
The output will be:

Index was outside the bounds of the array.

You can also output your own error message:

Example

try
{

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

Console.WriteLine(myNumbers[10]);
}

catch (Exception e)

{
Console.WriteLine("Something went wrong.");

The output will be:

69
Something went wrong.
Finally

The finally statement lets you execute code, after try...catch, regardless of the
result:

Example

try

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

Console.WriteLine(myNumbers[10]);

catch (Exception e)
{

Console.WriteLine("Something went wrong.");

}
finally

{
Console.WriteLine("The 'try catch' is finished.");
}

The output will be:

Something went wrong.

The 'try catch' is finished.
The throw keyword

The throw statement allows you to create a custom error.

70
The throw statement is used together with an exception class. There are many
exception classes available in
C#: ArithmeticException, FileNotFoundException, IndexOutOfRangeExcepti
on, TimeOutException, etc:

71
Example

static void checkAge(int age)

{

if (age < 18)

throw new ArithmeticException("Access denied - You must be at least 18

years old.");

}
else

Console.WriteLine("Access granted - You are old enough!");

}
}

static void Main(string[] args)

{
checkAge(15);
}

The error message displayed in the program will be:

System.ArithmeticException: 'Access denied - You must be at least 18 years

old.'

If age was 20, you would not get an exception:

72