Data Types and Arrays in C#

Introduction to Data Types in C#

In C#, **data types** define the type of data that a variable can hold. Each variable must have a defined type, such as an integer, float, or string, which determines what kind of operations can be performed on it.

Data types in C# are broadly categorized into:

Value Types: Store actual data directly in memory (e.g., int, char, float).
Reference Types: Store a reference (address) to the actual data (e.g., string, arrays, classes).

Data Type Ranges

The following table shows the **minimum and maximum values** for some common **value types** in C#:

Data Type	Size (in bytes)	Minimum Value	Maximum Value
`byte`	1	0	255
`int`	4	-2,147,483,648	2,147,483,647
`float`	4	~1.5 × 10^-45	~3.4 × 10^38
`double`	8	~5.0 × 10^-324	~1.7 × 10^308
`char`	2	U+0000	U+FFFF

Different Types of Data Types in C#

Below is a **detailed classification** of C# **data types**:

Category	Data Type	Description
Integral Types	`int`	32-bit signed integer.
	`long`	64-bit signed integer.
	`short`	16-bit signed integer.
	`byte`	8-bit unsigned integer.
Floating Point Types	`float`	32-bit single-precision floating point.
Floating Point Types	`double`	64-bit double-precision floating point.
Character Type	`char`	Single Unicode character.
Boolean Type	`bool`	Represents `true` or `false`.
String Type	`string`	Sequence of characters.

Arrays in C#

An **array** is a **collection of elements** that are of the **same type**. Arrays in C# are **zero-indexed**, meaning the **first element is at index 0**.

Example: Single-Dimensional Array

int[] numbers = { 1, 2, 3, 4, 5 };

foreach (int num in numbers)
{
    Console.WriteLine(num);
}

Multi-Dimensional Arrays

A **multi-dimensional array** stores **data in rows and columns**. The most common type is the **two-dimensional array**, used for matrix representations.

Example: Two-Dimensional Array

int[,] matrix = new int[2, 2] { {1, 2}, {3, 4} };

for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        Console.Write(matrix[i, j] + " ");
    }
    Console.WriteLine();
}

Best Practices for Using Data Types and Arrays

Use the smallest data type: For example, use **byte instead of int** if the value is always between 0 and 255.
Prefer string over char[]: Strings are easier to manage and more memory-efficient.
Use foreach for array traversal: It is more readable and prevents index errors.
Avoid large multi-dimensional arrays: Consider using **collections like List** if the size is dynamic.