Introduction to C# Programming

The Blueprint of C#

Think of a C# program as a set of instructions organized in a very specific way. At the top level, you have a namespace, which is like a folder for your code. Inside that, you have a class, which acts as a blueprint for creating objects. Finally, inside the class, you have methods, which are blocks of code that perform specific tasks. Every C# application has a starting point called the Main method. It's the first thing that runs when you launch the program.

using System;

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

Let's break that down. using System; tells the program we want to use features from the System namespace, a collection of pre-written code. Console.WriteLine() is one of those features; it simply prints a line of text to the console. The rest of the code defines the namespace, the class, and the Main method that holds our instruction.

Storing Information

To do anything useful, a program needs to remember information. We store this information in variables. A variable is just a named spot in memory where you can keep a value. In C#, every variable must have a specific data type, which tells the computer what kind of data it will hold.

Think of data types like different kinds of containers. A box for shoes isn't the right shape for storing soup. Similarly, a variable for whole numbers (int) can't store text (string).

Here are some of the most common data types you'll encounter.

Data Type	Description	Example
`int`	Whole numbers	`10`, `-5`, `0`
`float`	Numbers with decimals	`3.14f`, `-0.5f`
`double`	More precise decimal numbers	`123.456`
`string`	A sequence of text	`"Hello there"`
`bool`	A true or false value	`true`, `false`
`char`	A single character	`'A'`, `'!'`

Declaring a variable involves giving it a type and a name. You can also assign it a value at the same time.

// Declaring and initializing variables
int playerScore = 100;
float speed = 5.5f; // Note the 'f' for floats
string playerName = "Alex";
bool isGameOver = false;

Making Decisions and Repeating Actions

Programs often need to make decisions or perform actions repeatedly. This is handled by control structures. The if statement allows your code to run only if a certain condition is true.

int health = 75;

if (health > 50)
{
    Console.WriteLine("Health is looking good!");
}
else if (health > 20)
{
    Console.WriteLine("Health is low. Be careful!");
}
else
{
    Console.WriteLine("Danger! Health is critical.");
}

Loops are for repeating a block of code. A for loop is perfect when you know exactly how many times you want to repeat the action.

// This loop will run 5 times, printing numbers 0 through 4.
for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Current number: " + i);
}

A while loop is better when you want to repeat an action as long as a condition remains true, but you don't know how many times that will be.

int enemyCount = 3;

while (enemyCount > 0)
{
    Console.WriteLine("Defeating an enemy!");
    enemyCount = enemyCount - 1; // Decrease the count
}

Console.WriteLine("All enemies defeated!");

Building Blocks of Code

As programs grow, you'll want to organize your code into reusable pieces. That's where methods come in. A method (sometimes called a function) is a named block of code that performs a specific task. You can give a method some data (called parameters) to work with, and it can return a result.

// This method takes two integers and returns their sum.
static int AddNumbers(int num1, int num2)
{
    int result = num1 + num2;
    return result;
}

// You can call it from your Main method like this:
static void Main(string[] args)
{
    int sum = AddNumbers(5, 7);
    Console.WriteLine("The sum is: " + sum); // Prints "The sum is: 12"
}

Methods make your code cleaner, easier to read, and less repetitive. If you need to add numbers in ten different places, you can just call your AddNumbers method ten times instead of writing the addition logic over and over.

An Object-Oriented World

C# is an object-oriented programming (OOP) language. This is a way of thinking about code that models real-world things as objects. An object bundles together related data (properties) and behaviors (methods).

The blueprint for creating an object is called a class. For example, you could create a Player class to represent a player in a game.

class Player
{
    // Properties (data)
    public string name;
    public int health = 100;

    // Method (behavior)
    public void TakeDamage(int amount)
    {
        health -= amount;
        Console.WriteLine(name + " took " + amount + " damage!");
    }
}

With this blueprint, you can create individual Player objects, each with its own name and health.

One key idea in OOP is inheritance. You can create a new class that inherits properties and methods from an existing one. For example, a Warrior class could inherit from Player but have a special Rage property, saving you from rewriting all the common player code.

Another powerful concept is polymorphism, which lets you treat different objects in the same way. If both a Warrior and a Mage class inherit from Player, they can both have a UseAbility method. The Warrior's method might perform a sword slash, while the Mage's might cast a fireball. Polymorphism lets you call UseAbility without needing to know the exact type of player, making your code more flexible.

Now, let's test your understanding of these core concepts.

Quiz Questions 1/6

What is the main entry point for every C# application?

Quiz Questions 2/6

In C#, a class is best described as a...

These are the fundamental pillars of C#. With variables, control structures, methods, and a basic understanding of classes, you have the tools to start building structured, powerful programs.

C# Game Development Fundamentals