In this article, we explore variables.
What they are, how to create them, and how to use them.
Variables are one of the most important elements of a program, making it dynamic.
Of course, there is more to variables than what we can cover in a single article; this is only the beginning.
This article is the second of a learn programming series where you need no prior knowledge of programming.
If you want to learn how to program and want to learn it using .NET/C#, this is the right place.
I suggest reading the whole series in order, but that's not mandatory.
Before beginning, it is essential to know what we are aiming at.
A variable is an identifier that we can use programmatically to access a value stored in memory.
Let's break that down, an identifier is a name, a way to identify your variable.
We then can use that identifier to read or write data into memory.
That memory is the random-access memory (RAM) of the computer executing the code.
But you don't even have to worry about that because .NET manages most of it for you.
First, all you need to know is how to declare a variable and how to use it.
There are many different types of variables and ways to optimize memory usage. Still, the concept always remains similar to what we are covering now.
C# offers many ways of creating variables.
The most straightforward one is to use the
The syntax is as follow:
var identifier = initial_value;
Next, let's dissect this line of code.
var is a keyword to create a variable.
It implicitly represents the type of that variable.
That type is inferred from the value of
initial_value, the right-end part of the declaration statement.
C# is a strongly-typed language, so it requires each variable to be of a specific type.
The type of a variable cannot change after being declared, but its value can.
We will explore types more in-depth in future articles, but for now, think of the type as the type of data that we want to use, for example, a string (text) or a number.
An alternative way to declare a variable is to use C# 1.0 syntax and use the type of the variable directly instead of
Here are a few examples:
var identifier = "Hello C# Ninja!"; // This is the way we are exploring string identifier = "Hello C# Ninja!"; // This is the equivalent of the previous line string identifier; // We can do this because C# don't have to infer the type; it is specified explicitly. var identifier; // We cannot do this because C# don't know what type to use.
I prefer the
var keyword as I find it simplifies the declaration of variables.
It also makes all identifiers horizontally aligned on the screen.
// C# 1.0 string variable1 = ...; int variable2 = ...; List<MyCustomType> variable3 = ...; // Using the `var` keyword var variable1 = ...; var variable2 = ...; var variable3 = ...;
More info: some languages are weakly-typed.
That means you can change the type of data referenced by a variable implicitly, at any time.
These types of changes can lead to unintended or unforeseen consequences.
I recommend learning a strongly-typed language like C# to understand these concepts first.
Afterward, moving to a weakly-typed language is easier.
The learning curve of moving from weakly- to strongly-typed language is way more challenging.
Furthermore, typing errors are caught at compile-time when using a strongly-typed language instead of at runtime, which should lead to less-buggy products.
Next, let's explore the identifier part of our initial statement.
identifier represents the name of the variable and must be as specific as possible.
A variable's name must describe what that variable is holding, so anyone reading your code knows without the need to investigate.
An identifier must start with either a letter or an
It can then be composed of different Unicode characters.
The identifier is case sensitive, meaning that
thisidentifier is different from
I strongly suggest using only letters and numbers to keep names simple and universal.
Not everyone can easily make unusual characters like
ï using their keyboard's layout.
I will explain casing styles and code convention in one or more other articles.
For now, your goal is to write working code.
Not knowing every detail of every subject is ok. If you wait for that, you will never start.
Next, we explore another operator.
As a refresher, we learned about the member access operators in the first article of the series.
Now that we named our variable, it is time to assign it a value.
That value also defines the type of the variable when using the
= character is the assignment operator.
The assignment operator assigns the value of the right-hand operand to the left side.
For example, to assign the string value
"How are you?" to a variable named
howAreYou we could write the following code:
var howAreYou = "How are you?";
= takes the right-hand value (
"How are you?") and assigns it to the variable named
We can now use and work with that variable using its identifier (
We could, for example, write its value to the console.
Next, let's briefly recap on the
initial_value of the initial statement.
We already talked about this while explaining the other parts of the statement, but I'll make a quick recap.
The initial value could be pretty much anything: a string, an integer, or an instance of an object.
The initial value is what defines the type of a variable declared using the
Here are a few examples:
var greetings = "Hello, John Doe!"; // type: string var age = 25; // type: int var length = 12.87; // type: float var now = DateTime.Now; // type: DateTime
If you don't know what
DateTime means, it's ok.
They are types available in C# or .NET. As mentioned before, we are going to cover types in subsequent installments of this series.
For now, the important part is to understand the syntax.
By looking at the following image, we can see all the building blocks (below):
varkeyword inferring the variable type from its value (4).
identifierof the variable (its name).
- The assignment operator, assigning the value (4) to the variable (2).
- The variable's initial value, defining its type when
var(1) is used.
- The end of the statement.
Side note: Coding is very similar to playing LEGO®.
Like LEGO®, we assemble blocks—of text—together to build a computer program.
Enough syntax and theory, let's try this out next.
Let's reuse the program we built in the first article of the series, which looked like this:
using System; Console.WriteLine("Hello .NET Ninja!");
Practice: You can also create a new program, which will make you practice the use of the .NET CLI, introduced in the
Creating your first .NET/C# program article.
To prepare the program for more advanced use-cases, we want to extract the text
Hello .NET Ninja! in a variable.
To do so, based on what we just explored, we can write the following:
using System; var greetings = "Hello .NET Ninja!"; Console.WriteLine(greetings);
Hint: One crucial detail in the preceding code is that we don't wrap the
"when passing it as an argument of the
We write it directly, like this:
Console.WriteLine(greetings);, since we don't want to pass the string
"greetings"to the method, but the value referenced by the
"is the string delimiter character.
We will cover strings in more detail in a subsequent article.
After executing the code above, we can see that we get the same result as before but using a variable instead of inputting text directly into the
What happened is the following:
- We assigned the value
"Hello .NET Ninja!"to the
- The type of the
- The type of the
- We wrote the value of the
greetingsvariable to the console.
- If we change the value of the
greetingsvariable, the message written in the console would change.
- If we change the value of the
- This step represents the variable's identifier substituted by its value, which dynamically became
Console.WriteLine("Hello .NET Ninja!");. This is the equivalent (a representation) of what is happening in the background at runtime.
That may seem useless for now, but keep in mind that a variable's value can be modified, assigned from user inputs, computed, and more.
We are only beginning and will explore and use variables in future articles, most likely in every single one of them.
Variables are foundational to programming.
Next, we look at how to make that variable's value vary.
Now that we covered how to declare a variable and dissected the building blocks, let's look at how to change the variable's value.
We will reuse the assignment operator (
=) to assign a new value to the same variable.
In the following micro-program, we assign the value
17 to the variable
age, then we update its value to
var age = 17; Console.Write("Age: "); Console.WriteLine(age); age = 18; Console.Write("Congratz, you are now "); Console.Write(age); Console.WriteLine("!");
age = 18; statement of the preceding code, we only removed the
var keyword if we compare it with the initial one (
var age = 17;).
That's because the
var keyword's objective is only to declare a new variable.
To update the value of a variable, we must assemble the following building blocks (syntax):
identifier = new_value;.
Note: declaring a variable with the same identifier will cause an error. The name of a variable must be unique.
But don't worry, there are ways to organize our code to limit naming conflicts, but that's for another day.
Executing the program will write the following in the console:
Age: 17 Congratz, you are now 18!
More info: the
Console.Writemethod does the same thing as
Console.WriteLine, without the "enter" at the end.
That's it; to change the value of a variable, you only have to assign it a new value using the assignment operator (
However, the type of that new value must be the same.
Next, it is your turn to try it out.
Unfortunately, I was not able to recreate the exercise on this platform, so please look at the exercise on the original post on my blog. I'm sorry for the inconvenience.
In this article, we learned how to declare a variable and set its value.
We also dived into more syntax, explored the
var keyword and the assignment operator.
The variable concept is essential.
Most importantly, you learned that a variable stores reusable data, accessible through its identifier (name).
This is a lot of theory and small details to take in, but the more you advance and the more you practice, the easier it will become.
It is now time to move to the next article: Introduction to C# constants which is coming soon. Stay tuned by following me on dev.to, Twitter, or other places you can find me (look at my blog for more info on that).