Curriculum

Variables in C#

Variables are a fundamental concept in programming, and they allow you to store data in memory and refer to it by a name. In C#, variables are used to store values of different types, such as integers, floating-point numbers, and strings.

In this tutorial, we will explore the different types of variables in C# and how to use them.

Types of Variables

There are several types of variables in C#, including:

1. Integer Variables

Integer variables are used to store whole numbers. In C#, you can declare an integer variable using the int keyword. Here’s an example:

int myNumber = 42;

This declares an integer variable called myNumber and assigns the value 42 to it.

2. Floating-Point Variables

Floating-point variables are used to store decimal numbers. In C#, you can declare a floating-point variable using the float or double keyword. Here’s an example:

float myFloat = 3.14f;
double myDouble = 3.14159;

The float keyword is used to declare a single-precision floating-point variable, while the double keyword is used to declare a double-precision floating-point variable.

3. String Variables

String variables are used to store text. In C#, you can declare a string variable using the string keyword. Here’s an example:

string myString = "Hello, World!";

This declares a string variable called myString and assigns the value "Hello, World!" to it.

4. Boolean Variables

Boolean variables are used to store true/false values. In C#, you can declare a boolean variable using the bool keyword. Here’s an example:

bool myBool = true;

This declares a boolean variable called myBool and assigns the value true to it.

Variable Declaration and Assignment

In C#, you declare a variable by specifying its data type, followed by its name. Here’s an example:

int myNumber;

This declares an integer variable called myNumber. However, this variable does not have a value assigned to it yet. To assign a value to a variable, you use the assignment operator (=). Here’s an example:

myNumber = 42;

This assigns the value 42 to the myNumber variable. You can also declare and assign a variable in a single statement, like this:

int myNumber = 42;

This declares an integer variable called myNumber and assigns the value 42 to it in a single statement.

Variable Naming Rules

In C#, variable names must follow certain rules. Here are some guidelines to keep in mind when naming your variables:

Variable names must begin with a letter or an underscore.
Variable names can contain letters, numbers, and underscores.
Variable names cannot contain spaces.
Variable names are case-sensitive.
Variable names should be descriptive and meaningful.

Here are some examples of valid variable names:

int myNumber;
float myFloat;
string myString;
bool myBool;

Variable Scope

The scope of a variable determines where it can be accessed in your code. In C#, variables can have either local or global scope.

Local Variables

Local variables are declared inside a method or a block of code, and they are only accessible within that method or block. Here’s an example:

void MyMethod()
{
    int myNumber = 42;
    Console.WriteLine(myNumber);
}

In this example, the myNumber variable is declared inside the MyMethod method, which means it has local scope. It can only be accessed within the MyMethod method.

Global Variables

Global variables, also known as class-level variables, are declared outside of any method, and they can be accessed from anywhere within the class. Here’s an example:

class MyClass
{
    int myNumber = 42;
    
    void MyMethod()
    {
        Console.WriteLine(myNumber);
    }
}

In this example, the myNumber variable is declared outside of any method, which means it has global scope. It can be accessed from within the MyMethod method, as well as from any other method in the MyClass class.

In this tutorial, we explored the different types of variables in C# and how to declare and assign them. We also discussed the rules for naming variables and the scope of variables. By understanding these concepts, you can start writing more complex programs that involve storing and manipulating data using variables.

C#