What are Variables?

Introduction

A variable is a storage location used inside programming for storing data that can be changed and retrieved at any time during a program’s execution. In C# the variables are primary building blocks for holding values related to different data types including numbers, characters and boolean. This is owing developers flexible and dynamic code writing by referring to data through variable names instead of hardcoding values.

In C# variables are type strongly, so once you have declared the variable with a certain type the value of this variable is is only certain type of being, but not another type if you want so you just have to explicitly convert it to another type. Strong typing increases code reliability and decreases runtime errors by ensuring all variables get type appropriate operations performed on them.

Naming Your Variables

Giving meaningful and descriptive name to your variables is important for read to maintain the code. The variable name should tell you what the variable is about or what the data is. A C# variable name is a case sensitive series of letters or underscore characters that begins with a letter or underscore and may contain letters, numbers or underscores.

Camel case is a good C# practice for variable names: the first word starts with a lowercase letter and each following word with uppercase, such as totalScore or userName. Don’t use reserved keywords such as int, class, namespace as variable names, nor should you choose overly short or single character names unless they conform to common conventions like i in loops.

Where are Variables Stored?

To make a good programmer and an optimization you need to understand, where exactly your variables live in memory. The type of the variable being stored determines where the variable is stored in either the stack or heap; both are dependent on the scope. Stack: Value types, int, float, bool, etc; Reference types, objects, arrays, strings, etc. are usually stored on heap.

Value types and pointer to the reference types are stored in a region of memory called the stack. It has quick access and automatic memory management and works in last in, first out manner. However, the heap is larger pool of memory that is used to allocate dynamically. Objects on the heap since they have longer lifetime as well they are managed by the garbage collector that frees up memory when object is not in use anymore.

int age = 30;
string name = "Alice";
Person person = new Person();

In this code snippet, the integer variable age is stored on the stack because it’s a value type. The string name and the Person object person are reference types. The reference (or pointer) to these objects is stored on the stack, but the actual data is stored on the heap. This distinction is important because it affects how variables are accessed and how memory is managed during the program’s execution.

Variable Syntax

Declaration

Declaring a variable in C# involves specifying the data type followed by the variable name. This tells the compiler what kind of data the variable will hold and reserves the appropriate amount of memory. The basic syntax is:

dataType variableName;

int score;
double temperature;
char grade;

int, double, char are data types whereas score, temperature and grade are variable names in these declarations. The variable are now declared but not initialized with a value.

Initialization

Initialization is an action which is assigned with initial value at the time of declaration of the variable. Assignment operator = is used after the variable name. The syntax is:

dataType variableName = value;

int score = 100;
double temperature = 36.6;
char grade = 'A';

An important practice is to initialize variables so that you don’t get the error of uninitialized variables, which can produce unexpected behavior in your programs.

Example (How to Assign a Value to a Variable?)

You can define and set a value for a variable in declaration statement itself or later its code. Here’s how you can declare a variable and assign a value to it:

int total; // Declaration
total = 50; // Assignment

Alternatively, you can combine both steps:

int total = 50; // Declaration and initialization

You can also change the value of a variable after its initial assignment:

total = 75; // Reassignment

This flexibility lets variables have different values on different times, something that is necessary to make computations and do things with some data in programming.

Variable Types

Integer

Integer data type(int) is used to store whole numbers, with or without decimal points, C# will store both positive and negative values without decimal points. It is an integer, 32 bits long signed and contains a range from -2,147,483,648 to 2,147,483,647.

int population = 1000000;

We often use integers for counting, indexing and non fractional valued calculations.

Float

When we have to store the numbers with decimal points, float data type is used for storing single precision floating point number. It is a 32 bit IEEE 754 floating point, which is memory saving in large arrays of floating point numbers.

float price = 19.99f;

There is a suffix f after the number, meaning the literal is a float. When you don’t care for precision, you use floats in order to save on memory.

Char

The char data type is one Unicode character, and is enclosed in single quotes.

char letter = 'A';

To work on the level of the character we need to store individual characters and use chars for that.

Boolean

The boolean data type (bool) can hold only two possible values: true or false. If you want to do more than just the basics, it’s generally used in conditional statements and control flow.

bool isVerified = true;

Amongst your code’s decision making structures, booleans are fundamental, such as if statements and loops.

What is the var Data Type?

In C# the var keyword is used and that helps us with implicit typing. It has to be initialized at the point of declaration.

var count = 10; // Implicitly typed as int
var name = "John"; // Implicitly typed as string

var is an option that helps make the code more compact where using it sparsely keeps the code sensible to read and understand.

Variable Type Sizes as Table

Data Type	Size (bits)	Range
byte	8	0 to 255
sbyte	8	-128 to 127
short	16	-32,768 to 32,767
ushort	16	0 to 65,535
int	32	-2,147,483,648 to 2,147,483,647
uint	32	0 to 4,294,967,295
long	64	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
ulong	64	0 to 18,446,744,073,709,551,615
float	32	±1.5 x 10^−45 to ±3.4 x 10^38
double	64	±5.0 × 10^−324 to ±1.7 × 10^308
decimal	128	±1.0 x 10^-28 to ±7.9 x 10^28
char	16	Unicode characters
bool	8	true or false

The size and range of data types are important if you want to optimize the memory used, and stay within the parameters of what your variables can take in, without getting an overflow error.

Variable Casting

What is Casting?

Converting one variable to another is called casting. Casting can be implicit in C# or explicitly. Implicit casting takes place automatically, the way converting an int into a long doesn’t result in data loss. On some occasions, explicit casting may cause data loss, for example, converting a double to an int, so it uses a cast operator.

Casting is necessary when you always want to perform operations between two different data types or if you need to pass in a given type of parameter to a method. It’s flexible but must be used carefully, as you get runtime errors if you use it incorrectly.

Implicit Casting (Safe Conversion):

int num = 100;
long bigNum = num; // Implicitly casts int to long

In this case an int is implicitly cast to a long , as long has a larger range and can safely hold a value of an int.

Explicit Casting (Risky Conversion):

double decimalNum = 9.78;
int wholeNum = (int)decimalNum; // Explicitly casts double to int

In the following casting a double to an int truncates the decimal part, which could lose data. There for such, an explicit cast is needed.

Using Convert Class:

string strNumber = "123";
int intNumber = Convert.ToInt32(strNumber);

The Convert class has methods to convert from one type to another without crashing when the conversion fails, rather, they throw exceptions.

Casting is an important element by which you can manipulate the values of various type of variables to make your program work as desired.