Skip to main content

0 - Introduction

0.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.

Learn more at:

0.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.

0.3 - Setting up VS Code For Unity Game Development​

Unity is the industry-leading game engine that uses C# as its primary scripting language. To create an optimal development environment for Unity game programming, we recommend setting up Visual Studio Code (VS Code) with specific extensions.

0.3.1 - Installing VS Code​

  1. Download and Install: Visit Visual Studio Code's official website and download the appropriate version for your operating system.
  2. Launch VS Code: After installation, open VS Code to begin customizing it for Unity development.

0.3.2 - Essential Extensions for Unity Development​

Install these extensions to enhance your Unity C# development experience:

  1. C# Dev Kit: Provides comprehensive C# language support, including IntelliSense, debugging, and refactoring tools.

  2. Unity Tools for VS Code: Offers Unity-specific features like Unity debugging, project synchronization, and Unity console integration.

0.3.3 - Configuring Unity to Use VS Code​

  1. Open Unity and navigate to Edit > Preferences > External Tools
  2. Set External Script Editor to Visual Studio Code
  3. Ensure Generate .csproj files for: options are checked for proper project integration

This configuration ensures that double-clicking scripts in Unity will open them in VS Code with full IntelliSense and Unity context awareness.

0.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.

0.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 two 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

0.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!");

0.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!

0.4.4 - Key Concepts Introduced​

This simple example introduces several fundamental C# concepts:

  • Namespaces: Organize code and prevent naming conflicts
  • Classes: Define the structure and behavior of objects
  • Methods: Contain executable code that performs specific tasks
  • The Main Method: Serves as the entry point for program execution
  • Top-level Statements: A C# 9.0+ feature that simplifies program structure
  • Console I/O: Basic input/output operations through the console

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

0.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.

0.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.

0.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.

0.6 - What's Ahead: Guide Roadmap​

This guide is structured to take you from C# fundamentals to advanced Unity-specific programming concepts. Here's what you can expect in the upcoming modules:

Module 2: C# Fundamentals​

Learn about variables, data types, operators, type conversion, and basic input/output operations that form the building blocks of any C# program.

Module 3: Control Flow​

Master conditional statements, loops, and control flow mechanisms that determine how your game logic executes under different conditions.

Module 4: Methods​

Explore how to create reusable code blocks, pass parameters, return values, and leverage method overloading to create flexible and maintainable game systems.

Module 5: Object-Oriented Programming​

Dive deep into classes, objects, inheritance, polymorphism, and other OOP concepts that are essential for structured game development.

Module 6: Arrays and Collections​

Learn to work with arrays and various collection types to efficiently manage groups of data, essential for inventory systems, enemy management, and more.

Module 7: Error Handling and Exceptions​

Master techniques for gracefully handling errors and exceptions to create robust, crash-resistant game code.

Module 8: Advanced C# Concepts​

Explore powerful C# features like delegates, events, lambda expressions, LINQ, and extension methods that enable sophisticated programming patterns.

Module 9: Basic File I/O & Data Serialization​

Learn to read and write files and serialize game data, essential for saving game progress, high scores, and configuration settings.

Module 10: Algorithms and Problem Solving​

Understand fundamental algorithms and problem-solving approaches that will help you implement efficient game mechanics and systems.

Module 11: Best Practices & Unity Bridge​

Master C# coding conventions, debugging techniques, and learn how your C# knowledge directly applies to Unity game development.

Module 12: Beyond Unity - Modern C#​

Explore cutting-edge C# features (versions 11-14) that expand your programming horizons beyond Unity's current implementation.

Appendices​

Reference additional resources, best practices for both C# coding and game design, and find answers to frequently asked questions.

By the end of this guide, you'll have a comprehensive foundation in C# programming specifically tailored for Unity game development, enabling you to create your own games with confidence while also possessing transferable skills for broader software development.