Skip to main content

1 - Introduction

1.1 - What is C#?​

C# (pronounced "C-sharp") is a versatile, high-level programming language that supports multiple programming paradigms, including static and strong typing, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming. It was designed by Anders Hejlsberg at Microsoft in 2000 and has since been adopted as an international standard by Ecma (ECMA-334) and ISO/IEC (ISO/IEC 23270).

Initially introduced alongside the .NET Framework and Visual Studio, C# was part of Microsoft's move towards a comprehensive and robust development environment. Despite its origins in a proprietary setting, significant components of the C# development ecosystem have transitioned to open source, including the Roslyn compiler platform and the .NET runtime, ensuring its widespread use across different operating systems and platforms.

C# continues to evolve with regular updates, with the latest versions introducing features that make the language more expressive, concise, and powerful while maintaining its core principles of type safety and performance.

🔰 Beginner's Corner: What is a Programming Language?​

If you're new to programming, think of a programming language as a way for humans to communicate with computers. Just as we use English, Spanish, or Mandarin to communicate with other people, we use programming languages like C# to give instructions to computers.

Key points to understand:

  1. Programming languages are precise - Unlike human languages where there can be ambiguity, programming languages require exact syntax (grammar rules).

  2. C# is like giving a recipe to a computer - When you write C# code, you're essentially creating a detailed recipe that tells the computer exactly what to do, step by step.

  3. High-level language - C# is considered "high-level" because it's designed to be readable by humans. The computer translates it into machine code (binary instructions) that it can understand.

  4. Versatile - C# can be used to create many different types of applications: desktop programs, web applications, games, mobile apps, and more.

Why C# is great for beginners:

  • It has clear syntax rules that help you avoid mistakes
  • It provides immediate feedback when you make errors
  • It has excellent tools and documentation
  • It's widely used in the industry, so skills you learn are valuable

As you progress through this guide, don't worry if you don't understand all the terminology at first. Programming concepts build upon each other, and with practice, the pieces will start to fit together!

Learn more at:

1.2 - Installing C# and .NET​

To start developing with C#, you'll need to install the .NET SDK, which includes the runtime and compiler tools needed to begin writing, building, and running C# applications.

Steps to Install .NET SDK​

  1. Download the SDK: Visit the .NET download page and select the SDK version appropriate for your system.
  2. Install the SDK: Execute the installer and follow the on-screen instructions to complete the installation.

Verify your installation by running the following command in your terminal or command prompt:

dotnet --version

This command should return the version number of the .NET SDK that you have installed.

1.3 - Setting up Your Development Environment​

1.3.1 - For Desktop & Enterprise Application Applications​

For desktop development, Visual Studio provides a comprehensive environment with tools for designing, testing, and deploying applications.

1.3.2 - For Web Development​

For developing web applications, consider using Visual Studio Code with the C# Dev Kit. This extension enhances your C# development environment by integrating powerful tools and utilities that aid in writing, debugging, and maintaining code efficiently.

1.3.3 - For Mobile Development​

For mobile app development using C#, Xamarin, a part of the Microsoft .NET platform, provides tools to build cross-platform mobile apps for Android, iOS, and Windows devices. Xamarin uses C# for code sharing across platforms, significantly reducing development time and helping maintain consistency.

1.3.4 - For Cloud Development​

Developing cloud applications with C# can be optimally managed through Azure Development Tools. These tools provide integrated features such as Azure SDKs, client libraries, PowerShell scripts, and support for deploying applications using containers or as app services.

1.3.5 - For Game Development​

For game development with C#, Unity is the recommended environment. It integrates seamlessly with C# for scripting game behavior and logic.

1.3.6 - Additional Tools​

1.4 - Creating Your First C# Program​

Creating a basic C# program involves a few simple steps. Let's walk through the process of creating, understanding, and running a "Hello, World!" application.

🧩 Visual Learning: The Programming Process​

Before we dive in, let's understand the basic process of creating and running a C# program:

┌───────────────────────────────────────────────────────────────────────┐
│                                                                       │
│  THE C# PROGRAMMING PROCESS                                           │
│                                                                       │
│  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  │  You write  │     │  Compiler   │     │  Computer   │     │    You see  │
│  │    code     │ ──► │  translates │ ──► │  executes   │ ──► │    results  │
│  │             │     │    code     │     │    program  │     │             │
│  └─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
│                                                                       │
│  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  │ Console.    │     │  IL Code    │     │ Program     │     │ Hello,      │
│  │ WriteLine(  │     │ (Intermediate│     │ runs in     │     │ World!      │
│  │ "Hello,     │     │  Language)  │     │ .NET Runtime│     │             │
│  │  World!");  │     │             │     │             │     │             │
│  └─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
│                                                                       │
└───────────────────────────────────────────────────────────────────────┘

Think of it like:

  1. Writing a recipe (your code)
  2. Translating the recipe into chef's instructions (compilation)
  3. Chef follows the instructions to cook the dish (execution)
  4. You taste the food and see how it turned out (output)

💡 Concept Breakdown: Key Terms for Beginners​

Before we start coding, let's understand some basic terms:

  1. Source Code - The human-readable instructions you write (like Console.WriteLine("Hello, World!");)
  2. Compiler - The tool that translates your C# code into a language the computer can understand
  3. Runtime - The environment where your program executes (.NET Runtime)
  4. Console - The text-based interface where your program will display output
  5. Solution/Project - A container for organizing your code files

1.4.1 - Setting Up the Project​

  1. Create a new project: Open your command line interface and run:
dotnet new console -n HelloWorld
cd HelloWorld

This command does three things:

  • dotnet new console creates a new console application project
  • -n HelloWorld names the project "HelloWorld"
  • cd HelloWorld navigates into the newly created project directory

💡 Concept Breakdown: What is a Console Application? A console application is a program that runs in a text-based window (the console or terminal). It doesn't have fancy graphics or buttons - just text input and output. It's the simplest type of application to create, making it perfect for beginners.

1.4.2 - Understanding the Code​

When you create a new console project, the .NET SDK generates a Program.cs file. Let's examine two approaches to writing the same program:

Traditional Approach (C# 1.0 - C# 8.0)​

// This line imports the System namespace, which contains fundamental classes
using System;

// A namespace organizes your code and prevents name conflicts
namespace HelloWorld
{
    // A class is a blueprint for creating objects
    class Program
    {
        // The Main method is the entry point of a C# application
        // static means it belongs to the class itself, not to instances of the class
        // void indicates this method doesn't return a value
        static void Main()
        {
            // Console.WriteLine outputs text to the console window
            // followed by a line terminator
            Console.WriteLine("Hello, World!");
        }
    }
}

Modern Approach (C# 9.0 and later)​

// Import the System namespace for Console class
using System;

// Top-level statements don't require a Program class or Main method
// The compiler automatically generates these elements behind the scenes
// This makes the code more concise and readable for simple programs
Console.WriteLine("Hello, World!");

🔰 Beginner's Corner: Breaking Down the Code

Let's understand the simplest version of our program:

  1. using System; - This tells C# that we want to use features from the "System" package of code. It's like telling your computer "I need to use the basic tools that come with C#."

  2. Console.WriteLine("Hello, World!"); - This is the actual instruction:

    • Console is the screen/terminal where text appears
    • WriteLine is a command that displays text and then moves to a new line
    • "Hello, World!" is the text we want to display (the quotes indicate it's text)
    • ; marks the end of the instruction (like a period at the end of a sentence)

⚠️ Common Pitfalls for Beginners:

  • Forgetting the semicolon (;) at the end of statements
  • Mistyping Console as console (C# is case-sensitive)
  • Forgetting the quotes around text
  • Missing parentheses or using the wrong type of brackets

1.4.3 - Running Your Program​

After writing your code, you can compile and run it with a single command:

dotnet run

This command:

  1. Compiles your C# code into Intermediate Language (IL)
  2. Executes the compiled program using the .NET runtime
  3. Displays the output: Hello, World!

💡 Concept Breakdown: What Happens When You Run Your Code?

When you type dotnet run:

  1. The C# compiler checks your code for errors (like a spell-checker)
  2. If there are no errors, it translates your code into a language the computer can understand
  3. The computer follows your instructions step by step
  4. The results are displayed on your screen

1.4.4 - Key Concepts Introduced​

This simple example introduces several fundamental C# concepts:

  • Namespaces: Organize code and prevent naming conflicts (like folders for your code)
  • Classes: Define the structure and behavior of objects (like blueprints)
  • Methods: Contain executable code that performs specific tasks (like actions or functions)
  • The Main Method: Serves as the entry point for program execution (where the program starts)
  • Top-level Statements: A C# 9.0+ feature that simplifies program structure
  • Console I/O: Basic input/output operations through the console (displaying and receiving text)

1.4.5 - Try It Yourself: Your First Code Modification​

Now that you've created your first program, try modifying it to make it your own:

  1. Change the message from "Hello, World!" to a personalized greeting
  2. Add a second Console.WriteLine() statement to display another line of text
  3. Run the program again to see your changes

Example:

using System;

Console.WriteLine("Hello, I'm learning C#!");
Console.WriteLine("This is my first program.");

As you progress through this guide, you'll build on these concepts to create more complex and powerful applications.

1.5 - C# Terminologies​

As you embark on your journey through C#, you'll come across various terminologies that are fundamental to understanding and effectively using the language. While these terms will be explored in depth in later chapters, this section aims to provide a concise introduction to key C# concepts. This early familiarization will help make source code samples more accessible and enhance your overall learning experience.

1.5.1 - Key Terms and Definitions​

  1. Class: In C#, a class is a blueprint from which objects are created. It defines a set of properties (attributes) and methods (functions) that the instantiated objects will have. For example, a Car class may include properties such as Color and Make, and methods such as Drive() and Brake().

  2. Object: An object is a specific instance of a class. No memory is allocated when a class is defined; memory is only allocated when an object is instantiated from a class. For instance, myCar could be an object of the Car class with its own unique properties.

  3. Method: A method in C# is a block of code designed to perform a particular function. It is associated with an object or class and can take parameters, execute code, and return a result. For example, the Drive() method in the Car class might implement actions that affect the car's speed.

  4. Property: Properties in C# are special methods called accessors used to read, write, or compute the values of private fields. They are an implementation of the encapsulation principle, helping to protect the fields of a class.

  5. Interface: An interface in C# declares a contract any class or struct can implement. Interfaces specify a group of related functionalities that a class or struct implements, but they do not specify how these functionalities should be implemented.

  6. Namespace: Namespaces help organize code elements in C#. They provide a way to group related classes, interfaces, structs, and other namespaces, facilitating the management of large code projects and minimizing naming conflicts.

  7. Object-Oriented Programming (OOP): OOP is a programming paradigm that uses "objects" to design applications. Objects are instances of classes and can contain data (fields or properties) and functions (methods). OOP focuses on enhancing software modularity, reusability, and maintainability through principles such as encapsulation, inheritance, and polymorphism.

  8. Abstraction: Abstraction is a principle of hiding the complex reality while exposing only the necessary parts. It helps in reducing programming complexity and increasing efficiency. In C#, abstraction can be implemented using abstract classes and interfaces.

  9. Inheritance: Inheritance allows a class to inherit properties and methods from another class. In C#, a class can inherit from another class, termed as the base class, which allows the derived class to inherit features of the base class, promoting code reuse and polymorphism.

  10. Polymorphism: Polymorphism allows methods to perform different tasks based on the object that invokes them. In C#, polymorphism is achieved by method overriding or method overloading, enabling objects to interact in more flexible and intuitive ways.

  11. Encapsulation: Encapsulation is the technique of bundling the data (variables) and methods that operate on the data into a single unit or class. It also restricts direct access to some of an object’s components, which can prevent data from being modified unintentionally.

  12. Assembly: An assembly in C# is a compiled code library used for application deployment, versioning, and security. Assemblies can be executable (.exe) or dynamic link libraries (.dll), and they contain MSIL (Microsoft Intermediate Language) code that can be executed by the .NET runtime.

  13. Framework Class Library (FCL): The FCL is a comprehensive library of classes, interfaces, and value types that constitute the .NET Framework. It provides a vast array of functionalities, including graphical user interface components, data access, and network communications, facilitating the development of robust and high-performing applications.

  14. Base Class Library (BCL): A subset of the FCL, the BCL provides classes that form the fundamental building blocks of applications in .NET. This library includes basic data types, collections, and utilities for handling exceptions, managing memory, and processing data.

  15. Data Structures: Data structures are specialized formats for organizing and storing data. In C#, common data structures include arrays, lists, dictionaries, stacks, and queues, each designed to optimize data access and manipulation based on specific requirements.

  16. Algorithms: Algorithms in C# refer to a set of rules or steps used to perform a task or solve a problem. Typical uses include searching for data within data structures, sorting data into a specific order, and other manipulations of data necessary to achieve application functionality.

  17. Compiler: In C#, the compiler is a key component that translates C# code into Microsoft Intermediate Language (MSIL), also known as Common Intermediate Language (CIL). This process involves parsing the source code, optimizing it, and then compiling it into an assembly that contains the IL code and metadata. The .NET runtime uses this assembly to execute the application. The C# compiler ensures that all code complies with the C# language specifications and catches syntax and some semantic errors before execution.

  18. Integrated Development Environment (IDE): An IDE is a software application that provides comprehensive facilities to computer programmers for software development. For C#, the most commonly used IDE is Microsoft Visual Studio, which offers powerful tools for developing, debugging, and testing code. It provides features such as code completion, intelligent code navigation, and integrated version control. Visual Studio, along with other IDEs like Visual Studio Code and JetBrains Rider, enhances the development experience by streamlining application development workflows and simplifying complex projects.

1.5.2 - Conclusion​

Understanding these terminologies will provide you with a useful framework as you delve deeper into C#. Each concept plays a crucial role in the structure and operation of C# applications, and a foundational understanding of these terms will enhance your ability to write and interpret C# code effectively. This early exposure will set the stage for more detailed studies in subsequent chapters.