Introduction to C# Programming

Welcome to the world of C# programming! In this lesson, we will provide an overview of the C# programming language and its features.

C# (pronounced C sharp) is a modern, object-oriented programming language developed by Microsoft. It is widely used for developing Windows desktop applications, web applications, and games.

C# is part of the .NET framework, a powerful and versatile platform for building all kinds of applications. The .NET framework provides a rich set of libraries and tools for developers to create robust and efficient software solutions.

One of the key features of C# is its simplicity and ease of use. It has a clean and readable syntax that makes it easy for beginners to learn and understand. However, C# is also a powerful language with advanced features and capabilities that allow experienced developers to build complex and sophisticated applications.

Let's start by looking at a simple C# program:

1class Program {
2    static void Main(string[] args) {
3        Console.WriteLine("Hello, world!");
4    }
5}

In this program, we define a class called Program with a Main method. The Main method is the entry point of a C# program, and it is where the program execution begins. Inside the Main method, we use the Console.WriteLine method to output the message "Hello, world!" to the console.

Now that you have a basic understanding of C# programming, let's dive deeper into the language and explore its various features and concepts.

xxxxxxxxxx

class Program {

    static void Main(string[] args) {

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

    }

}

Variables and Data Types

In C#, variables are used to store and manipulate data. Before using a variable, you need to declare its type and assign a value to it.

C# provides various data types to represent different kinds of information. Some of the commonly used data types are:

• int (integer): used for storing whole numbers.
• double (floating-point): used for storing decimal numbers with floating-point precision.
• string: used for storing text.
• bool (boolean): used for storing boolean values (true or false).

Here's an example of declaring and initializing variables of different data types:

1int age = 30;
2string name = "John Doe";
3double salary = 50000.50;
4bool isMarried = false;

xxxxxxxxxx

}

using System;

​

namespace DataTypesExample

{

    class Program

    {

        static void Main(string[] args)

        {

            // Declaring and Initializing Variables

            int age = 30;

            string name = "John Doe";

            double salary = 50000.50;

            bool isMarried = false;

​

            // Outputting Variables

            Console.WriteLine("Name: " + name);

            Console.WriteLine("Age: " + age);

            Console.WriteLine("Salary: " + salary);

            Console.WriteLine("Married: " + isMarried);

​

            // Data Type Conversion

            int num1 = 10;

            double num2 = 5.5;

​

            // Implicit Conversion

            double result1 = num1;

            Console.WriteLine("Implicit Conversion: " + result1);

​

            // Explicit Conversion

Control Flow and Loops

Control flow statements and loops are essential tools in programming to control the flow of execution and perform repetitive tasks.

Control Flow Statements

Control flow statements allow you to execute different code blocks based on specified conditions. One commonly used control flow statement is the if statement.

1int age = 25;
2
3if (age >= 18)
4{
5    Console.WriteLine("You are an adult.");
6}
7else
8{
9    Console.WriteLine("You are a minor.");
10}

In this example, the if statement checks if the age variable is greater than or equal to 18. If the condition evaluates to true, the program will execute the code block inside the if statement. Otherwise, the program will execute the code block inside the else statement.

Loops

Loops allow you to repeat a set of statements multiple times. One common type of loop is the for loop.

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

In this example, the for loop is used to print the numbers from 1 to 5. The loop starts with initializing a counter variable i with 1, then it checks the condition i <= 5, and if the condition is true, it executes the code block inside the loop, which in this case prints the value of i. After each iteration, the loop updates the counter variable i by incrementing it by 1.

By using control flow statements and loops, you can create more complex programs that can make decisions based on conditions and perform repetitive tasks.

xxxxxxxxxx

using System;

​

class Program

{

    static void Main()

    {

        // Control Flow

        int age = 25;

​

        if (age >= 18)

        {

            Console.WriteLine("You are an adult.");

        }

        else

        {

            Console.WriteLine("You are a minor.");

        }

​

        // Loops

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

        {

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

        }

​

        Console.ReadLine();

    }

}

Arrays and Collections

Arrays and collections are used in C# to store and manipulate data. They provide a way to organize and access multiple elements of the same type.

Arrays

An array is a fixed-size collection of elements of the same type. You can think of it as a container that holds multiple values. Each value in an array is called an element, and is accessed using its index.

Here's an example of an array in C#:

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

In this example, numbers is an array that holds 5 integers. The elements of the array can be accessed using their index. For example, numbers[0] represents the first element of the array.

You can iterate through an array using a for loop, like this:

1for (int i = 0; i < numbers.Length; i++)
2{
3    Console.WriteLine(numbers[i]);
4}

This will print each element of the array.

Collections

Collections are similar to arrays, but they have dynamic size and can hold elements of different types. The .NET framework provides various collection classes that you can use in your C# programs.

One commonly used collection class is the List<T> class, which provides a way to store and manipulate a collection of objects of type T.

Here's an example of using a List<int> to store a collection of integers:

1List<int> numbersList = new List<int>();
2numbersList.Add(1);
3numbersList.Add(2);
4numbersList.Add(3);
5
6foreach (int number in numbersList)
7{
8    Console.WriteLine(number);
9}

In this example, numbersList is a List<int> that holds 3 integers. The Add() method is used to add elements to the list, and the foreach loop is used to iterate through the elements and print them.

Arrays and collections are powerful tools in C# that allow you to store and manipulate data in your programs.

xxxxxxxxxx

// Example of an array

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

​

// Iterate through the array using a for loop

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

{

    Console.WriteLine(numbers[i]);

}

Methods and Functions

Methods and functions are important tools in programming that allow you to organize your code and make it reusable. In C#, a method is a code block that contains a series of statements. It can perform a specific task and can be called multiple times throughout the program.

Defining a Method

To define a method in C#, you use the static keyword followed by the return type of the method. Here's an example:

1static void SayHello()
2{
3    Console.WriteLine("Hello, world!");
4}

In this example, SayHello is the name of the method, and the void keyword indicates that the method does not return a value.

Calling a Method

To call a method in C#, you simply write its name followed by parentheses. Here's an example:

1SayHello();

This will call the SayHello method and execute the code inside it.

Method Parameters

Methods can also have parameters, which are values that are passed into the method. Parameters allow you to pass data from the calling code to the method. Here's an example:

1static int AddNumbers(int num1, int num2)
2{
3    return num1 + num2;
4}

In this example, AddNumbers is a method that takes two parameters of type int and returns their sum.

To call a method with parameters, you pass the values you want to use for the parameters inside the parentheses. Here's an example:

1int sum = AddNumbers(5, 7);
2Console.WriteLine("The sum is: " + sum);

This will call the AddNumbers method with the values 5 and 7 and store the result in the sum variable.

Methods and functions are essential in C# programming as they allow you to break down your code into logical units and make it easier to understand and maintain. They also promote code reusability, as you can call a method multiple times throughout your program. As you continue to learn C#, you'll explore more advanced concepts and techniques related to methods and functions.

Keep it up! You're one step closer to becoming a skilled C# programmer!

xxxxxxxxxx

using System;

​

class Program

{

    // Define a method with void return type

    static void SayHello()

    {

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

    }

​

    // Define a method with int return type

    static int AddNumbers(int num1, int num2)

    {

        return num1 + num2;

    }

​

    static void Main()

    {

        // Call the SayHello method

        SayHello();

​

        // Call the AddNumbers method and store the result in a variable

        int sum = AddNumbers(5, 7);

        Console.WriteLine("The sum is: " + sum);

    }

}

Object-Oriented Programming

Object-oriented programming (OOP) is a programming paradigm that organizes code into objects, which are instances of classes. In C#, every piece of code you write is inside a class.

Classes and Objects

A class is a blueprint for creating objects. It defines the properties and behaviors that an object of that class will have. For example, you can have a Person class that represents a person with properties like Name and Age.

1class Person
2{
3    public string Name { get; set; }
4    public int Age { get; set; }
5}

To create an object of a class, you use the new keyword followed by the class name and parentheses.

1Person person = new Person();

In this example, person is an object of the Person class.

Properties

Properties are used to encapsulate data and provide a way to access and modify it. They define the characteristics of an object. In the Person class example above, Name and Age are properties.

Constructors

A constructor is a special method that is called when an object is created. It initializes the object's state and sets its initial values. In the Person class example, there is a constructor that takes two parameters (name and age) and sets the Name and Age properties of the object.

Methods

Methods are functions that define the behavior of an object. They can perform specific actions and can be called on objects of the class. In the Person class example, there is a Greet method that prints a greeting message using the Name and Age properties.

Example

Here's an example that demonstrates the concepts of classes, objects, properties, constructors, and methods in C#:

1class Person
2{
3    // Properties
4    public string Name { get; set; }
5    public int Age { get; set; }
6
7    // Constructor
8    public Person(string name, int age)
9    {
10        Name = name;
11        Age = age;
12    }
13
14    // Method
15    public void Greet()
16    {
17        Console.WriteLine($"Hello, my name is {Name} and I'm {Age} years old.");
18    }
19}
20
21// Create an instance of Person
22Person person = new Person("John", 25);
23
24// Call the Greet method
25person.Greet();

In this example, we define a Person class with Name and Age properties, a constructor that initializes the properties, and a Greet method that prints a greeting message. We then create an instance of the Person class named person with the name "John" and age 25, and call the Greet method to print the greeting message.

Object-oriented programming is a powerful concept that allows you to create reusable and modular code. It provides a way to model real-world entities and interactions in your programs.

Keep coding and exploring the world of object-oriented programming!

xxxxxxxxxx

class Person

{

    // Properties

    public string Name { get; set; }

    public int Age { get; set; }

​

    // Constructor

    public Person(string name, int age)

    {

        Name = name;

        Age = age;

    }

​

    // Method

    public void Greet()

    {

        Console.WriteLine($"Hello, my name is {Name} and I'm {Age} years old.");

    }

}

​

// Create an instance of Person

Person person = new Person("John", 25);

​

// Call the Greet method

person.Greet();

Exception Handling

Exception handling is a mechanism in C# that allows you to handle and manage runtime errors in your programs. When an error occurs during program execution, an exception is thrown, which can be caught and handled using the try-catch statement.

The try block contains the code that may throw an exception. If an exception occurs within the try block, it is caught by the corresponding catch block. The catch block is used to handle the exception and perform necessary actions.

Here's an example that demonstrates exception handling in C#:

1try
2{
3    int result = 10 / 0;
4}
5catch (DivideByZeroException ex)
6{
7    Console.WriteLine("Error: Division by zero!");
8}

In this example, we try to divide the number 10 by 0. Since dividing by zero is not allowed, a DivideByZeroException is thrown. The catch block catches the exception and prints an error message, "Error: Division by zero!".

Exception handling is an important aspect of writing reliable and robust code. It allows you to gracefully handle errors and take appropriate actions to handle them.

xxxxxxxxxx

try

{

    int result = 10 / 0;

}

catch (DivideByZeroException ex)

{

    Console.WriteLine("Error: Division by zero!");

}

File Handling in C

File handling is a crucial aspect of any programming language, as it allows you to read from and write to files on your computer. In C#, you can utilize the System.IO namespace to perform file handling operations.

To create a file and write content to it, you can use the File.WriteAllText() method. For example, let's create a file named example.txt and write the text Hello, World! to it:

1File.WriteAllText("./example.txt", "Hello, World!");

To read the entire content of a file, you can use the File.ReadAllText() method. This method returns the contents of the specified file as a string. For example, let's read the content of example.txt and print it to the console:

1string content = File.ReadAllText("./example.txt");
2Console.WriteLine(content);

If you want to append content to an existing file, you can use the File.AppendAllText() method. This method appends the specified string to the file.

Let's append the text Goodbye, World! to the example.txt file:

1File.AppendAllText("./example.txt", "\nGoodbye, World!");

Finally, let's read the updated content of example.txt and print it to the console:

1content = File.ReadAllText("./example.txt");
2Console.WriteLine(content);

File handling in C# allows you to store and retrieve data from files, which is vital for many real-world applications. Whether you need to read configuration files, log data, or process large input files, understanding file handling is an essential skill in C# programming.

xxxxxxxxxx

using System;

using System.IO;

​

class Program

{

    static void Main()

    {

        // Creating a file

        File.WriteAllText("./example.txt", "Hello, World!");

​

        // Reading from a file

        string content = File.ReadAllText("./example.txt");

        Console.WriteLine(content);

​

        // Appending to a file

        File.AppendAllText("./example.txt", "\nGoodbye, World!");

​

        content = File.ReadAllText("./example.txt");

        Console.WriteLine(content);

    }

}

Windows Forms in C

Windows Forms is a powerful framework in C# that allows you to create interactive graphical user interfaces (GUI) for desktop applications. It provides a wide range of controls and components that you can use to design and build your application's user interface.

Whether you're creating a calculator, a text editor, or a game, Windows Forms provides the necessary tools to make it happen. You can add buttons, textboxes, labels, checkboxes, radio buttons, and many more controls to your forms to create a visually appealing and functional user interface.

To get started with Windows Forms, you'll need to create a new Windows Forms Application project in your preferred C# Integrated Development Environment (IDE), such as Visual Studio or Visual Studio Code. Once you have your project set up, you can start designing your form by dragging and dropping controls from the Toolbox onto the form.

Here's an example of how to create a simple Windows Forms application that displays a message box when a button is clicked:

1using System;
2using System.Windows.Forms;
3
4public class HelloWorldForm : Form
5{
6    public HelloWorldForm()
7    {
8        Button button = new Button
9        {
10            Text = "Say Hello",
11            Location = new System.Drawing.Point(100, 100)
12        };
13        button.Click += (sender, e) => MessageBox.Show("Hello, World!");
14        Controls.Add(button);
15    }
16
17    public static void Main()
18    {
19        Application.Run(new HelloWorldForm());
20    }
21}

In this example, we create a new class HelloWorldForm that inherits from the Form class provided by Windows Forms. Inside the constructor of HelloWorldForm, we create a Button control with the text "Say Hello" and a location on the form. We also attach an event handler to the button.Click event, which displays a message box with the text "Hello, World!" when the button is clicked.

To run the Windows Forms application, we create a Main method that calls Application.Run(new HelloWorldForm()), which starts the application and displays the form on the screen.

Windows Forms provides a rich set of features and controls that you can explore to create visually appealing and interactive desktop applications with C#. So, if you're interested in creating desktop applications with a graphical user interface, Windows Forms is a great choice!

Event Handling in C

Event handling is an essential aspect of developing interactive Windows Forms applications in C#. It allows you to respond to user actions, such as clicking a button or pressing a key, by executing specific code.

To handle events in C#, you can use event handlers. An event handler is a method that gets executed when a specific event occurs. In Windows Forms applications, you can attach event handlers to controls, such as buttons, checkboxes, or textboxes.

Let's take a look at an example:

1using System;
2using System.Windows.Forms;
3
4public class EventHandlingForm : Form
5{
6    public EventHandlingForm()
7    {
8        Button button = new Button
9        {
10            Text = "Click Me",
11            Location = new System.Drawing.Point(100, 100)
12        };
13        button.Click += (sender, e) =>
14        {
15            MessageBox.Show("Button Clicked!");
16        };
17        Controls.Add(button);
18    }
19
20    public static void Main()
21    {
22        Application.Run(new EventHandlingForm());
23    }
24}

In this example, we create a class EventHandlingForm that inherits from the Form class provided by Windows Forms. Inside the constructor of EventHandlingForm, we create a Button control with the text "Click Me" and a location on the form.

We then attach an event handler to the button.Click event using an anonymous function. When the button is clicked, the event handler displays a message box with the text "Button Clicked!".

Finally, we add the button to the form using the Controls.Add method, and we start the application by calling Application.Run(new EventHandlingForm()).

Event handling is a powerful concept that enables you to create dynamic and interactive user interfaces in your Windows Forms applications. By attaching event handlers to controls, you can define custom behavior for your application's user interface based on user actions.

Try running the example code and clicking the button to see the event handling in action! Feel free to explore different events and attach event handlers to other controls to enhance the interactivity of your Windows Forms applications.

xxxxxxxxxx

using System;

using System.Windows.Forms;

​

public class EventHandlingForm : Form

{

    public EventHandlingForm()

    {

        Button button = new Button

        {

            Text = "Click Me",

            Location = new System.Drawing.Point(100, 100)

        };

        button.Click += (sender, e) =>

        {

            MessageBox.Show("Button Clicked!");

        };

        Controls.Add(button);

    }

​

    public static void Main()

    {

        Application.Run(new EventHandlingForm());

    }

}

Database Access

Database access is a fundamental aspect of many applications, including desktop applications. It allows you to connect to databases, retrieve data, and perform various operations such as inserting, updating, and deleting records.

In C#, you can use the ADO.NET library to interact with databases. ADO.NET provides a set of classes that enable database access and manipulation.

To connect to a database, you need to provide the connection string, which includes information such as the server name, database name, and authentication credentials. Here's an example of connecting to a SQL Server database using the SqlConnection class:

1using System;
2using System.Data.SqlClient;
3
4public class DatabaseAccessExample
5{
6    public static void Main()
7    {
8        string connectionString = "Data Source=server_name;Initial Catalog=database_name;User Id=username;Password=password;";
9        using (SqlConnection connection = new SqlConnection(connectionString))
10        {
11            connection.Open();
12            Console.WriteLine("Connected to the database!");
13        }
14    }
15}

In this example, we create a connection string that specifies the server name, database name, username, and password. We then use the SqlConnection class to establish a connection to the database. The using statement ensures that the connection is properly closed after use.

Once connected, you can execute SQL queries and commands using the SqlCommand class. You can retrieve data using the ExecuteReader method, and perform insert, update, and delete operations using the ExecuteNonQuery method.

Database access is a critical skill for building data-driven applications. Whether you're working with a SQL database, NoSQL database, or an ORM framework, understanding database access concepts is essential for storing and retrieving data.

As you progress in your C# programming journey, you'll explore more advanced topics such as working with databases in multi-tier architectures, using ORMs, and implementing data caching strategies to optimize performance.

Next, let's dive into the exciting world of creating graphical user interfaces using Windows Forms!