Numeric

These include integers (whole numbers) and floating-point numbers (numbers with decimal points). Integers might be used for counting items or representing IDs, while floating-point numbers are used for more precise calculations involving fractions or decimals.

// Positive and Negative integer
int num1 = 10;
int num2 = -5;

// Single-precision floating point number
float floatNum = 3.14f;

// Double-precision floating point number
double doubleNum = 123.456;

// Decimal number with higher precision for financial calculations
decimal decimalNum = 99.99m;

String

This is for text data. It can hold letters, numbers, symbols, and even spaces. Strings are enclosed in quotation marks to differentiate them from variable names or commands.

string message = "Hello, World!";

Boolean

This is a binary data type that can hold only two values: true or false. It’s used for logical operations and comparisons.

bool isTrue = true; // Represents true
bool isFalse = false; // Represents false

Array and List

This type allows you to store multiple values of the same data type under one variable name. It’s like having a list or a collection where you can access individual elements by their position.

// Array
string[] colorsArray = { "Red", "Green", "Blue" };

// List
List<string> colorsList = new List<string> { "Red", "Green", "Blue" };

Object

Objects are more complex data types that can hold both data and methods (functions) to operate on that data. They are like containers that can store various types of data and actions related to that data.

// Dictionary with different data types
Dictionary<string, object> data = new Dictionary<string, object>
{
    { "Name", "John Doe" },
    { "Age", 30 },
    { "IsStudent", false },
    { "Height", 175.5 },
    { "DateOfBirth", new DateTime(1990, 5, 15) }
};

Other Data Types

Depending on the programming language, there may be additional data types like characters, dates, or custom-defined types.

// Custom data type
class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public int Pages { get; set; }
    public DateTime PublicationDate { get; set; }

    public Book(string title, string author, int pages, DateTime publicationDate)
    {
        Title = title;
        Author = author;
        Pages = pages;
        PublicationDate = publicationDate;
    }
}

// Usage
Book myBook = new Book("The Great Gatsby", "F. Scott Fitzgerald", 180, new DateTime(1925, 4, 10));

Dynamic vs. Static

Dynamic typing determines variable types at runtime, allowing flexibility but risking runtime errors. Static typing determines types at compile time, ensuring type safety and performance. Examples of dynamic typing languages include Python, while static typing languages include C#.

x = 10  # x is an integer
print(type(x))  # Output: <class 'int'>

x = "Hello"  # x is now a string
print(type(x))  # Output: <class 'str'>

int x = 10; // x is explicitly declared as an integer
Console.WriteLine(x.GetType()); // Output: System.Int32

// x = "Hello"; // Error: Cannot implicitly convert type 'string' to 'int'

Type Inference

Type inference is a feature in programming languages where the compiler or interpreter deduces the data types of variables based on their initialisation or usage, without explicit type declarations. It reduces verbosity, enhances readability, and combines benefits of static and dynamic typing.

// Compiler infers message as string
var message = "Hello, World!";

// Output: Hello, World!
Console.WriteLine(message);

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

// Compiler infers evenNumbers as IEnumerable<int>
var evenNumbers = numbers.Where(n => n % 2 == 0);
foreach (var num in evenNumbers)
{
    // Output: 2, 4
    Console.WriteLine(num);
}