Welcome to the Introduction to C# lesson!

In this lesson, we will provide an overview of C# and its importance in .NET development.

C# is a modern, object-oriented programming language developed by Microsoft. It is a key component of the .NET framework and is widely used for building web applications, desktop applications, mobile apps, and more.

C# offers many powerful features such as type safety, garbage collection, and support for asynchronous programming. It provides a strong type system, allowing for better code organization and easier debugging.

One of the main advantages of C# is its integration with the .NET framework. This enables developers to leverage a wide range of libraries and tools for building robust and scalable applications.

C# is also cross-platform, which means that you can write code once and run it on different operating systems such as Windows, macOS, and Linux.

Whether you are a beginner or an experienced programmer, learning C# will open up new possibilities in your career as a software developer.

Let's get started and explore the world of C#!

Variables and Data Types

In C#, variables are used to store and manipulate data. Before using a variable, you need to declare it with a specific data type. C# provides several built-in data types to accommodate different kinds of values.

Integer Variables

Integer variables are used to store whole numbers without any decimal places. In C#, you can declare an integer variable using the int keyword. Here's an example:

1int age = 30;

In this example, the variable age is declared as an integer and assigned a value of 30.

Floating-Point Variables

Floating-point variables are used to store numbers with decimal places. In C#, you can declare a floating-point variable using the double keyword. Here's an example:

1double height = 1.75;

In this example, the variable height is declared as a double and assigned a value of 1.75.

String Variables

String variables are used to store sequences of characters, such as names, addresses, or messages. In C#, you can declare a string variable using the string keyword. Here's an example:

1string name = "John";

In this example, the variable name is declared as a string and assigned the value "John".

Boolean Variables

Boolean variables are used to store either true or false values. In C#, you can declare a boolean variable using the bool keyword. Here's an example:

1bool isStudent = true;

In this example, the variable isStudent is declared as a boolean and assigned the value true.

Character Variables

Character variables are used to store single characters. In C#, you can declare a character variable using the char keyword. Characters are enclosed in single quotes. Here's an example:

1char gender = 'M';

In this example, the variable gender is declared as a character and assigned the value 'M'.

By declaring variables with the appropriate data types, you can ensure that the values you store and manipulate are compatible with the operations you want to perform.

Now, let's write some code to see these variable declarations in action:

1using System;
2
3public class Program
4{
5    public static void Main()
6    {
7        // Integer Variables
8        int age = 30;
9        Console.WriteLine("My age is " + age);
10
11        // Floating-Point Variables
12        double height = 1.75;
13        Console.WriteLine("My height is " + height);
14
15        // String Variables
16        string name = "John";
17        Console.WriteLine("My name is " + name);
18
19        // Boolean Variables
20        bool isStudent = true;
21        Console.WriteLine("Am I a student? " + isStudent);
22
23        // Character Variables
24        char gender = 'M';
25        Console.WriteLine("My gender is " + gender);
26    }
27}

xxxxxxxxxx

using System;

​

public class Program

{

    public static void Main()

    {

        // Integer Variables

        int age = 30;

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

​

        // Floating-Point Variables

        double height = 1.75;

        Console.WriteLine("My height is " + height);

​

        // String Variables

        string name = "John";

        Console.WriteLine("My name is " + name);

​

        // Boolean Variables

        bool isStudent = true;

        Console.WriteLine("Am I a student? " + isStudent);

​

        // Character Variables

        char gender = 'M';

        Console.WriteLine("My gender is " + gender);

    }

}

Operators and Expressions

In C#, operators are used to perform various operations on variables and values. They allow you to perform arithmetic calculations, compare values, and perform logical operations.

Arithmetic Operators

Arithmetic operators are used to perform mathematical calculations. C# provides the following arithmetic operators:

• Addition (+)
• Subtraction (-)
• Multiplication (*)
• Division (/)
• Modulus (%)

Here's an example of using arithmetic operators:

1int x = 10;
2int y = 5;
3
4int addition = x + y;
5int subtraction = x - y;
6int multiplication = x * y;
7int division = x / y;
8int modulus = x % y;
9
10Console.WriteLine("Addition: " + addition);
11Console.WriteLine("Subtraction: " + subtraction);
12Console.WriteLine("Multiplication: " + multiplication);
13Console.WriteLine("Division: " + division);
14Console.WriteLine("Modulus: " + modulus);

Comparison Operators

Comparison operators are used to compare two values and determine the relationship between them. C# provides the following comparison operators:

• Equal to (==)
• Not equal to (!=)
• Greater than (>)
• Less than (<)
• Greater than or equal to (>=)
• Less than or equal to (<=)

Here's an example of using comparison operators:

1int x = 10;
2int y = 5;
3
4bool isEqual = x == y;
5bool isNotEqual = x != y;
6bool isGreater = x > y;
7bool isLess = x < y;
8bool isGreaterOrEqual = x >= y;
9bool isLessOrEqual = x <= y;
10
11Console.WriteLine("Is Equal: " + isEqual);
12Console.WriteLine("Is Not Equal: " + isNotEqual);
13Console.WriteLine("Is Greater: " + isGreater);
14Console.WriteLine("Is Less: " + isLess);
15Console.WriteLine("Is Greater or Equal: " + isGreaterOrEqual);
16Console.WriteLine("Is Less or Equal: " + isLessOrEqual);

Logical Operators

Logical operators are used to perform logical operations on boolean values. C# provides the following logical operators:

• AND (&&)
• OR (||)
• NOT (!)

Here's an example of using logical operators:

1bool isTrue = true;
2bool isFalse = false;
3
4bool andResult = isTrue && isFalse;
5bool orResult = isTrue || isFalse;
6bool notResult = !isTrue;
7
8Console.WriteLine("AND Result: " + andResult);
9Console.WriteLine("OR Result: " + orResult);
10Console.WriteLine("NOT Result: " + notResult);

Understanding and using operators correctly is an essential part of writing efficient and logical code in C#.

xxxxxxxxxx

}

using System;

​

public class Program

{

    public static void Main()

    {

        // Arithmetic operators

        int x = 10;

        int y = 5;

        int addition = x + y;

        int subtraction = x - y;

        int multiplication = x * y;

        int division = x / y;

        int modulus = x % y;

​

        Console.WriteLine("Addition: " + addition);

        Console.WriteLine("Subtraction: " + subtraction);

        Console.WriteLine("Multiplication: " + multiplication);

        Console.WriteLine("Division: " + division);

        Console.WriteLine("Modulus: " + modulus);

​

        // Comparison operators

        bool isEqual = x == y;

        bool isNotEqual = x != y;

        bool isGreater = x > y;

        bool isLess = x < y;

        bool isGreaterOrEqual = x >= y;

        bool isLessOrEqual = x <= y;

​

Control Flow

Control flow is the order in which statements and instructions are executed in a program. In C#, control flow is managed using if statements, switch statements, and loops.

If Statements

If statements are used to execute a block of code only if a certain condition is true. Here's an example:

1int x = 10;
2if (x > 5)
3{
4    Console.WriteLine("x is greater than 5");
5}

In this example, the code inside the if statement will only be executed if the value of x is greater than 5.

Switch Statements

Switch statements are used to perform different actions based on different conditions. Here's an example:

1string day = "Monday";
2switch (day)
3{
4    case "Monday":
5        Console.WriteLine("It's Monday");
6        break;
7    case "Tuesday":
8        Console.WriteLine("It's Tuesday");
9        break;
10    default:
11        Console.WriteLine("It's another day");
12        break;
13}

In this example, the code will check the value of the day variable and execute the corresponding block of code.

Loops

Loops are used to repeatedly execute a block of code until a certain condition is met. Here's an example of a for loop:

1for (int i = 0; i < 5; i++)
2{
3    Console.WriteLine("Iteration: " + i);
4}

This loop will execute the code inside the curly braces for each iteration, starting from 0 and incrementing i by 1 each time, until i is no longer less than 5.

Understanding control flow is essential in programming as it allows you to control the execution of your code based on different conditions and perform repetitive tasks efficiently.

xxxxxxxxxx

// Example of if statement

int x = 10;

if (x > 5)

{

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

}

​

// Example of switch statement

string day = "Monday";

switch (day)

{

    case "Monday":

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

        break;

    case "Tuesday":

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

        break;

    default:

        Console.WriteLine("It's another day");

        break;

}

​

// Example of loop

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

{

    Console.WriteLine("Iteration: " + i);

}

Arrays

In the world of programming, arrays are like a container that can hold multiple values of the same data type. Imagine arrays as a row of numbered boxes, where each box can store a value.

Arrays in C# are fixed in size, meaning you need to specify the size of the array when declaring it. Once the array is created, you can access and modify the elements by their index.

To declare an array in C#, you need to specify the data type followed by square brackets [], and then the name of the array. Here's an example:

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

In this example, we declared an array called numbers that can store integers. We also assigned values to the array using the array initializer syntax.

To access an element in an array, you can use the index of the element. Remember that the index starts from 0. Here's an example:

1int firstElement = numbers[0];
2Console.WriteLine("The first element is: " + firstElement);

This code will output The first element is: 1.

Arrays also have a Length property that gives you the number of elements in the array. Here's an example:

1Console.WriteLine("The size of the array is: " + numbers.Length);

This code will output The size of the array is: 5.

You can also loop over the elements in an array using the foreach loop. Here's an example:

1Console.WriteLine("The elements in the array are:");
2foreach (int num in numbers)
3{
4    Console.WriteLine(num);
5}

This code will output each element of the numbers array on a new line.

Arrays are a powerful tool in programming as they allow you to store and manipulate multiple values in a single variable. They are commonly used in various algorithms and data structures.

xxxxxxxxxx

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

Console.WriteLine("The size of the array is: " + numbers.Length);

Console.WriteLine("The elements in the array are:");

foreach (int num in numbers)

{

    Console.WriteLine(num);

}

Methods

In programming, methods are blocks of code that perform a specific task. They are like a reusable recipe that you can call whenever you need to perform that task.

In C#, you can define your own methods to encapsulate a set of instructions. Methods can take in parameters and return a value, or they can be void, meaning they don't return anything.

Here's a simple example that defines a method called Greet and calls it:

1class Program
2{
3    static void Main(string[] args)
4    {
5        // Calling the Greet method
6        Greet();
7    }
8
9    // Define a method called Greet
10    static void Greet()
11    {
12        Console.WriteLine("Hello, world!");
13    }
14}

In this example, we defined a method called Greet that doesn't take any parameters or return any value. We then called this method from the Main method.

Methods can also take in parameters, which are values passed to the method when it's called. Here's an example:

1static void Sum(int a, int b)
2{
3    int result = a + b;
4    Console.WriteLine("The sum of " + a + " and " + b + " is " + result);
5}
6
7static void Main(string[] args)
8{
9    Sum(3, 5);
10}

In this example, we defined a method called Sum that takes in two integers as parameters (a and b). The method calculates the sum of a and b and prints the result.

Methods are an essential part of organizing code and making it more modular. They allow you to break down complex tasks into smaller, more manageable parts. By using methods, you can write clean and reusable code.

xxxxxxxxxx

class Program

{

    static void Main(string[] args)

    {

        // Calling the Greet method

        Greet();

    }

​

    // Define a method called Greet

    static void Greet()

    {

        Console.WriteLine("Hello, world!");

    }

}

Classes and Objects

In C#, a class is a blueprint for creating objects. It defines the structure and behavior of the objects that can be created from it.

An object is an instance of a class. It represents a real-world entity and has properties to store data and methods to perform actions.

Let's look at an example:

1// Creating a class called Person
2public class Person
3{
4    // Properties
5    public string Name { get; set; }
6    public int Age { get; set; }
7
8    // Method
9    public void Introduce()
10    {
11        Console.WriteLine("My name is " + Name + " and I am " + Age + " years old.");
12    }
13}
14
15// Creating an instance of the Person class
16Person person = new Person();
17
18// Accessing and setting the properties
19person.Name = "John Doe";
20person.Age = 30;
21
22// Calling the method
23person.Introduce();

In this example, we defined a class called Person with properties Name and Age. We also defined a method called Introduce that prints the person's name and age. We then created an instance of the Person class, set the properties, and called the Introduce method.

Classes and objects are fundamental concepts in object-oriented programming. They allow us to organize and structure our code by representing real-world entities as objects with properties and methods.

xxxxxxxxxx

class Program

{

    static void Main(string[] args)

    {

        // Creating an instance of the Person class

        Person person = new Person();

​

        // Accessing and setting the properties

        person.Name = "John Doe";

        person.Age = 30;

​

        // Calling the method

        person.Introduce();

    }

}

​

public class Person

{

    // Properties

    public string Name { get; set; }

    public int Age { get; set; }

​

    // Method

    public void Introduce()

    {

        Console.WriteLine("My name is " + Name + " and I am " + Age + " years old.");

    }

}

Inheritance and Polymorphism

Inheritance and polymorphism are important concepts in object-oriented programming. In C#, inheritance allows a class to inherit the properties and methods of another class, while polymorphism allows an object to take on different forms.

Inheritance

Inheritance provides a way to create a new class based on an existing class. The new class, called the derived class or subclass, inherits the properties and methods of the existing class, called the base class or superclass. This enables code reuse and promotes the principle of DRY (Don't Repeat Yourself).

1// Base class
2public class Animal
3{
4    public virtual void MakeSound()
5    {
6        Console.WriteLine("The animal makes a sound.");
7    }
8}
9
10// Derived class
11public class Dog : Animal
12{
13    public override void MakeSound()
14    {
15        Console.WriteLine("The dog barks.");
16    }
17}

In this example, we have a base class called Animal with a method MakeSound(). We also have a derived class called Dog that inherits from the Animal class and overrides the MakeSound() method to make the dog bark. By creating a new instance of the derived class, we can access both the inherited methods from the base class and the overridden methods specific to the derived class.

Polymorphism

Polymorphism allows an object to take on many forms. In the context of inheritance, it means that a variable of a base class type can refer to an object of a derived class type. This allows us to write code that works with objects of different derived classes through a common base class interface.

1// Using inheritance and polymorphism
2Animal animal = new Animal();
3animal.MakeSound(); // Output: The animal makes a sound.
4
5Animal dog = new Dog();
6dog.MakeSound(); // Output: The dog barks.

In this example, we create an instance of the Animal class and call the MakeSound() method. The output is "The animal makes a sound." Then, we create an instance of the Dog class and assign it to a variable of type Animal. When we call the MakeSound() method on the dog variable, the output is "The dog barks." This is possible because the dog variable, although of type Animal, actually refers to an object of type Dog, and the overridden method in the Dog class is called.

In summary, inheritance allows classes to inherit properties and methods from other classes, promoting code reuse. Polymorphism allows objects to take on different forms, enabling flexibility and extensibility in object-oriented programming.

xxxxxxxxxx

// Base class

public class Animal

{

    public virtual void MakeSound()

    {

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

    }

}

​

// Derived class

public class Dog : Animal

{

    public override void MakeSound()

    {

        Console.WriteLine("The dog barks.");

    }

}

​

// Using inheritance and polymorphism

Animal animal = new Animal();

animal.MakeSound(); // Output: The animal makes a sound.

​

Animal dog = new Dog();

dog.MakeSound(); // Output: The dog barks.

Exception Handling

Exception handling is an important aspect of programming to handle unexpected or exceptional situations that may occur during the execution of a program. In C#, exception handling is done using try, catch, finally, and throw statements.

The basic syntax of exception handling in C# is as follows:

1try
2{
3    // Code that might throw an exception
4}
5catch (Exception ex)
6{
7    // Code to handle the exception
8    Console.WriteLine("An exception occurred: " + ex.Message);
9}

xxxxxxxxxx

try

{

    // Code that might throw an exception

}

catch (Exception ex)

{

    // Code to handle the exception

    Console.WriteLine("An exception occurred: " + ex.Message);

}

File Input and Output

File input and output is a fundamental topic in programming, allowing you to read and write data to files. In C#, you can use the StreamReader and StreamWriter classes from the System.IO namespace to perform file input and output operations.

Writing to a File

To write data to a file, you can use the StreamWriter class. First, specify the filepath where you want to create or overwrite the file. Then, use the StreamWriter to write data to the file. Here's an example:

1string filePath = "data.txt";
2
3// Writing to a file
4using (StreamWriter writer = new StreamWriter(filePath))
5{
6    writer.WriteLine("Hello, World!");
7    writer.WriteLine("This is a test file.");
8}

In this example, we create a StreamWriter object and pass the filepath to the constructor. We can then use the WriteLine method to write lines of text to the file.

Reading from a File

To read data from a file, you can use the StreamReader class. First, specify the filepath of the file you want to read from. Then, use the StreamReader to read data from the file. Here's an example:

1string filePath = "data.txt";
2
3// Reading from a file
4using (StreamReader reader = new StreamReader(filePath))
5{
6    string line;
7    while ((line = reader.ReadLine()) != null)
8    {
9        Console.WriteLine(line);
10    }
11}

In this example, we create a StreamReader object and pass the filepath to the constructor. We can then use the ReadLine method to read each line of the file and print it to the console.

File input and output is a powerful tool that allows you to store and retrieve data from external files, making your programs more flexible and versatile.

xxxxxxxxxx

using System;

using System.IO;

​

class Program

{

    static void Main()

    {

        string filePath = "data.txt";

​

        // Writing to a file

        using (StreamWriter writer = new StreamWriter(filePath))

        {

            writer.WriteLine("Hello, World!");

            writer.WriteLine("This is a test file.");

        }

​

        // Reading from a file

        using (StreamReader reader = new StreamReader(filePath))

        {

            string line;

            while ((line = reader.ReadLine()) != null)

            {

                Console.WriteLine(line);

            }

        }

    }

}