Introduction

Welcome to C# Basics for Beginners, your step-by-step guide to mastering the fundamentals of C# programming. This course is designed for students, self-taught programmers, and developers transitioning from other languages who want a solid foundation in C#.

By the end of this course, you will be able to:

• Understand the syntax and structure of C# programs
• Work confidently with variables, data types, and operators
• Implement control flow using decision and loop statements
• Create and use methods, classes, and objects
• Handle exceptions and perform debugging
• Explore advanced concepts including delegates, LINQ, and asynchronous programming
• Build practical applications like a simple calculator and contact manager

Prerequisites: Basic computer skills; no prior programming required but helpful; access to an IDE like Visual Studio or Visual Studio Code recommended.

Course Structure

This course is organized into topics, lessons, quizzes, and assignments, guiding you progressively from basics to advanced C# programming techniques.

1. Introduction to C# and Development Setup
   • Lesson: Overview of C# and .NET Framework
   • Lesson: Installing and configuring Visual Studio
   • Assignment: Set up your development environment
2. Basic Syntax and Programming Constructs
   • Lesson: Hello World and program structure
   • Lesson: Variables, data types, and constants
   • Lesson: Operators and expressions
   • Lesson: Control flow – if, switch, loops
   • Quiz: Basic syntax and control flow
   • Assignment: Build a simple calculator
3. Object-Oriented Programming Fundamentals
   • Lesson: Classes, objects, fields, and properties
   • Lesson: Methods and function parameters
   • Lesson: Inheritance and polymorphism
   • Quiz: OOP concepts
   • Assignment: Create a contact management system
4. Error Handling and Debugging
   • Lesson: Exception handling with try-catch-finally
   • Lesson: Debugging basics and tools
   • Assignment: Implement error handling in your applications
5. Advanced Concepts and Practical Applications
   • Lesson: Delegates, events, and lambda expressions
   • Lesson: Introduction to LINQ
   • Lesson: Async and await for asynchronous programming
   • Lesson: Generics and basic design patterns
   • Assignment: Develop a file processing utility

1. Understanding C# Syntax and Structure

1.1 The Anatomy of a C# Program

C# programs are built on the .NET framework and follow a structured syntax. A typical program contains namespaces, classes, methods, and statements.

using System;

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

Here’s what each part means:

• using System; – Imports the System namespace for built-in classes.
• namespace HelloWorldApp – Wraps your code in a named container to avoid conflicts.
• class Program – Defines a class named Program, the blueprint for objects.
• static void Main(string[] args) – The entry point method where execution starts.

1.2 Understanding Variables, Data Types, and Constants

Variables store data during program execution. You must declare a variable’s data type before use:

int age = 25;
double price = 19.99;
const double Pi = 3.14159;

C# offers a variety of built-in data types like int, double, char, bool, and string. Constants are immutable values defined with the const keyword.

1.3 Operators and Expressions

Operators perform operations on variables and values. Common operators include:

• Arithmetic: +, -, *, /, %
• Comparison: ==, !=, <, >, <=, >=
• Logical: && (AND), || (OR), ! (NOT)

Expressions combine variables and operators to produce values.

1.4 Control Flow Statements

C# uses statements like if, switch, and loops (for, while, do-while) to control the program’s execution flow.

if (age >= 18) {
    Console.WriteLine("Adult");
} else {
    Console.WriteLine("Minor");
}

Loops allow repeated execution:

for (int i = 0; i < 5; i++) {
    Console.WriteLine(i);
}

Real-World Example 1: Simple Calculator

A console app that takes two numbers and an operator, then outputs the result:

using System;

class Calculator
{
    static void Main()
    {
        Console.Write("Enter first number: ");
        double num1 = Convert.ToDouble(Console.ReadLine());

        Console.Write("Enter operator (+, -, *, /): ");
        string op = Console.ReadLine();

        Console.Write("Enter second number: ");
        double num2 = Convert.ToDouble(Console.ReadLine());

        double result = 0;

        switch (op)
        {
            case "+": result = num1 + num2; break;
            case "-": result = num1 - num2; break;
            case "*": result = num1 * num2; break;
            case "/":
                if (num2 != 0) result = num1 / num2;
                else Console.WriteLine("Error: Divide by zero");
                break;
            default: Console.WriteLine("Invalid operator"); break;
        }

        Console.WriteLine($"Result: {result}");
    }
}

This example illustrates data input/output, operators, and control flow working together.

2. Object-Oriented Programming Basics in C#

2.1 Classes and Objects

C# is an object-oriented language centered around classes, which define blueprints for objects. Objects are instances of classes.

class Person
{
    // Fields
    public string Name;
    public int Age;

    // Method
    public void Introduce()
    {
        Console.WriteLine($"Hi, my name is {Name} and I am {Age} years old.");
    }
}

Creating an object:

Person p = new Person();
p.Name = "Alice";
p.Age = 30;
p.Introduce();

2.2 Properties, Fields, and Methods

Fields store data directly. Properties provide controlled access with getters/setters:

public string Name { get; set; }

Methods encapsulate behavior, like the Introduce() method above.

2.3 Inheritance and Polymorphism

Inheritance enables classes to derive from other classes:

class Employee : Person
{
    public string Position { get; set; }

    public void Work()
    {
        Console.WriteLine($"{Name} is working as a {Position}.");
    }
}

Polymorphism allows methods to behave differently based on the derived type, often by overriding base class methods.

Real-World Example 2: Contact Management System

This system models contacts with inheritance:

class Contact
{
    public string Name { get; set; }
    public string Email { get; set; }
    public virtual void Display()
    {
        Console.WriteLine($"Name: {Name}, Email: {Email}");
    }
}

class BusinessContact : Contact
{
    public string Company { get; set; }
    public override void Display()
    {
        Console.WriteLine($"Name: {Name}, Email: {Email}, Company: {Company}");
    }
}

class Program
{
    static void Main()
    {
        Contact c = new Contact { Name = "John Doe", Email = "[email protected]" };
        BusinessContact bc = new BusinessContact { Name = "Jane Smith", Email = "[email protected]", Company = "Tech Corp" };

        c.Display();
        bc.Display();
    }
}

This example demonstrates inheritance, method overriding, and polymorphism.

3. Exception Handling and Debugging

3.1 Handling Exceptions

Runtime errors are inevitable. C# provides try-catch-finally blocks to safely handle exceptions without crashing programs.

try
{
    int[] numbers = {1, 2, 3};
    Console.WriteLine(numbers[5]); // IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("Oops! Index out of range: " + ex.Message);
}
finally
{
    Console.WriteLine("Execution completed.");
}

3.2 Debugging Techniques

Debugging is essential in software development. Use these tools and tips:

• Breakpoints: Pause execution to inspect variables.
• Watch windows: Monitor variable values live.
• Step over/into: Control execution flow line by line.
• Exception settings: Catch unhandled or specific exceptions.

3.3 Practical Debugging Example

Suppose your program crashes unexpectedly. Set breakpoints before suspected lines and step through your code, checking inputs and outputs, to pinpoint the error.

Real-World Example 3: File Processing with Error Handling

using System;
using System.IO;

class FileProcessor
{
    public static void ReadFile(string path)
    {
        try
        {
            string content = File.ReadAllText(path);
            Console.WriteLine(content);
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Error: File not found.");
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("Error: Access denied.");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Unexpected error: " + ex.Message);
        }
        finally
        {
            Console.WriteLine("File processing completed.");
        }
    }
}

This approach ensures your application handles common file-related issues gracefully.

4. Advanced C# Concepts

4.1 Delegates and Events

Delegates are type-safe pointers to methods, enabling callback mechanisms. Events use delegates to signal state changes or actions.

delegate void Notify(string message);

class Process
{
    public event Notify OnCompleted;

    public void Start()
    {
        Console.WriteLine("Process started.");
        // Some processing logic here
        OnCompleted?.Invoke("Process finished successfully!");
    }
}

class Program
{
    static void Main()
    {
        Process p = new Process();
        p.OnCompleted += MessageHandler;
        p.Start();
    }

    static void MessageHandler(string msg)
    {
        Console.WriteLine(msg);
    }
}

4.2 Lambda Expressions and LINQ Basics

Lambdas simplify inline function definitions. LINQ enables querying collections with SQL-like syntax.

int[] numbers = {1, 2, 3, 4, 5, 6};
var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach(var num in evenNumbers)
{
    Console.WriteLine(num);
}

4.3 Asynchronous Programming (async/await)

Async programming improves app responsiveness by allowing operations to run without blocking the main thread.

using System.Threading.Tasks;

async Task FetchDataAsync()
{
    await Task.Delay(2000); // Simulate delay
    return "Data retrieved";
}

async Task Main()
{
    Console.WriteLine("Fetching data...");
    string result = await FetchDataAsync();
    Console.WriteLine(result);
}

4.4 Generics and Type Safety

Generics allow you to create classes and methods with placeholders for data types, increasing code reusability and safety.

class Box<T>
{
    public T Value { get; set; }
}

var intBox = new Box<int> { Value = 123 };
var strBox = new Box<string> { Value = "Hello" };

Advanced Learning Tip

To master advanced topics, build small projects integrating these features. For example, extend the contact manager with events to notify when contacts are added.

5. Practical Exercises and Assignments