C# Data Types — Silent Truncation Breaks Your Math

using System;

class VariableDeclarations
{
    static void Main()
    {
        // Explicit declaration: type is written out by hand
        // 'int' means whole numbers only — no decimals
        int playerScore = 0;

        // String holds text — always wrap text values in double quotes
        string playerName = "Alex";

        // bool holds only true or false — perfect for on/off flags
        bool isLoggedIn = true;

        // 'var' lets the compiler infer the type from the right-hand side
        // The compiler sees 3.14 and decides this is a 'double'
        var piApproximation = 3.14;

        // You can declare first and assign later
        // But you CANNOT read it before assigning — the compiler will refuse
        int livesRemaining;
        livesRemaining = 3; // assignment happens here, now it's safe to use

        // Printing the values to the console so we can see what's stored
        Console.WriteLine($"Player: {playerName}");
        Console.WriteLine($"Score: {playerScore}");
        Console.WriteLine($"Lives: {livesRemaining}");
        Console.WriteLine($"Logged in: {isLoggedIn}");
        Console.WriteLine($"Pi approx: {piApproximation}");
    }
}

using System;

class BuiltInDataTypes
{
    static void Main()
    {
        // INTEGER TYPES — whole numbers, no decimals
        byte playerLevel = 42;            // 0 to 255 — small non-negative numbers
        short temperatureCelsius = -18;   // -32,768 to 32,767
        int worldPopulationMillions = 8100; // most common integer type
        long distanceToStarInMeters = 9_460_730_472_580_800L; // 'L' suffix = long literal
        // Note: underscores in number literals are just for readability — C# ignores them

        // FLOATING POINT TYPES — numbers with a decimal point
        float bodyTemperatureF = 98.6f;   // 'f' suffix required for float literals
        double gravitationalConstant = 6.674e-11; // scientific notation works too
        decimal productPrice = 19.99m;    // 'm' suffix required — use for all money values

        // TEXT TYPES
        char bloodType = 'O';             // Single quotes for a single character
        string customerName = "Jordan";   // Double quotes for text sequences

        // BOOLEAN TYPE
        bool hasPremiumSubscription = false; // Only ever true or false

        // Showing the type AND value together using GetType()
        Console.WriteLine($"playerLevel is {playerLevel} (type: {playerLevel.GetType().Name})");
        Console.WriteLine($"productPrice is {productPrice:C} (type: {productPrice.GetType().Name})");
        Console.WriteLine($"customerName is '{customerName}' (type: {customerName.GetType().Name})");
        Console.WriteLine($"gravitationalConstant is {gravitationalConstant} (type: {gravitationalConstant.GetType().Name})");
        Console.WriteLine($"hasPremiumSubscription is {hasPremiumSubscription} (type: {hasPremiumSubscription.GetType().Name})");

        // Showing the minimum and maximum values built into each type
        Console.WriteLine($"\nMax int value: {int.MaxValue}");
        Console.WriteLine($"Max long value: {long.MaxValue}");
        Console.WriteLine($"Max decimal precision: {decimal.MaxValue}");
    }
}

using System;

// A simple class — classes are always reference types
class ShoppingCart
{
    public int ItemCount; // public field so we can access it directly in this example
}

class ValueVsReferenceTypes
{
    static void Main()
    {
        // ── VALUE TYPE DEMO ──────────────────────────────────────────
        int originalScore = 100;
        int backupScore = originalScore; // A completely independent COPY is made

        backupScore = 999; // We change only the copy

        // The original is untouched — each int lives in its own memory slot
        Console.WriteLine($"originalScore: {originalScore}"); // still 100
        Console.WriteLine($"backupScore:   {backupScore}");   // 999

        Console.WriteLine();

        // ── REFERENCE TYPE DEMO ──────────────────────────────────────
        ShoppingCart customerCart = new ShoppingCart();
        customerCart.ItemCount = 3;

        // This does NOT copy the cart — it copies the ADDRESS of the cart
        // Both variables now point at the SAME object in memory
        ShoppingCart checkoutCart = customerCart;

        checkoutCart.ItemCount = 7; // We change it through checkoutCart...

        // ...but customerCart reflects the change because they share one object
        Console.WriteLine($"customerCart.ItemCount: {customerCart.ItemCount}"); // 7 !
        Console.WriteLine($"checkoutCart.ItemCount: {checkoutCart.ItemCount}"); // 7

        Console.WriteLine();

        // ── STRING IMMUTABILITY DEMO ─────────────────────────────────
        string originalGreeting = "Hello";
        string modifiedGreeting = originalGreeting;

        // This looks like we're changing modifiedGreeting in place
        // but C# actually creates a BRAND NEW string and points modifiedGreeting at it
        modifiedGreeting = modifiedGreeting + ", World";

        Console.WriteLine($"originalGreeting: {originalGreeting}"); // still "Hello"
        Console.WriteLine($"modifiedGreeting: {modifiedGreeting}"); // "Hello, World"
    }
}

using System;

class TypeConversion
{
    static void Main()
    {
        // ── IMPLICIT CONVERSION ──────────────────────────────────────
        // int fits perfectly inside a long — no data can be lost, so C# allows it silently
        int monthsInYear = 12;
        long secondsInYear = monthsInYear * 30L * 24L * 60L * 60L; // int auto-promotes to long
        Console.WriteLine($"Seconds in a year (approx): {secondsInYear}");

        // ── EXPLICIT CONVERSION (CASTING) ────────────────────────────
        double exactAverageScore = 87.9;
        // We MUST cast explicitly because going from double to int loses the decimal
        // The cast does NOT round — it truncates (chops off) the decimal part
        int roundedScore = (int)exactAverageScore;
        Console.WriteLine($"Exact score: {exactAverageScore}");
        Console.WriteLine($"After casting to int: {roundedScore}"); // 87, not 88!

        // If you want proper rounding, use Math.Round before casting
        int properlyRoundedScore = (int)Math.Round(exactAverageScore);
        Console.WriteLine($"Properly rounded: {properlyRoundedScore}"); // 88

        Console.WriteLine();

        // ── PARSING — converting strings to numbers ──────────────────
        string userInputAge = "29";     // Imagine this came from a text box
        int parsedAge = int.Parse(userInputAge); // Works, but throws if input is invalid
        Console.WriteLine($"Parsed age: {parsedAge} (type: {parsedAge.GetType().Name})");

        // ── TRYPARSE — the safe, production-ready approach ───────────
        string suspiciousInput = "twenty"; // User typed a word instead of a number

        // TryParse returns true/false and writes the result into 'parsedValue' via 'out'
        bool parseSucceeded = int.TryParse(suspiciousInput, out int parsedValue);

        if (parseSucceeded)
        {
            Console.WriteLine($"Parsed successfully: {parsedValue}");
        }
        else
        {
            // This branch runs — no exception thrown, we handle it gracefully
            Console.WriteLine($"Could not parse '{suspiciousInput}' as an integer. Please enter digits only.");
        }

        // ── Convert class — another option for common conversions ─────
        double pi = 3.14159;
        string piAsText = Convert.ToString(pi); // Converts double to string
        Console.WriteLine($"Pi as a string: '{piAsText}'");
    }
}

using System;

class NullableValueTypes
{
    static void Main()
    {
        // ── DECLARING A NULLABLE VALUE TYPE ──────────────────────────
        int? temperature = null; // 'int?' is equivalent to 'Nullable<int>'
        int? age = 25;           // Can hold a normal int value too

        // ── CHECKING FOR VALUE ───────────────────────────────────────
        if (temperature.HasValue)
        {
            Console.WriteLine($"Temperature: {temperature.Value}°C");
        }
        else
        {
            Console.WriteLine("Temperature not recorded.");
        }

        // ── NULL-COALESCING OPERATOR ────────────────────────────────
        int displayTemperature = temperature ?? 20; // default 20 if null
        Console.WriteLine($"Display: {displayTemperature}°C");

        // ── WORKING WITH GENERIC COLLECTIONS ─────────────────────────
        var readings = new int?[] { null, 36, 37, null, 39 };
        int sum = 0;
        int count = 0;
        foreach (var r in readings)
        {
            if (r.HasValue)
            {
                sum += r.Value;
                count++;
            }
        }
        double average = count > 0 ? (double)sum / count : 0;
        Console.WriteLine($"Average of recorded readings: {average:F1}°C");

        // ── COMPARISON WITH DEFAULT VALUE ───────────────────────────
        // default(int?) is null, not 0
        int? defaultNullable = default;
        int defaultInt = default;
        Console.WriteLine($"default(int?) is null: {defaultNullable == null}");
        Console.WriteLine($"default(int) is 0: {defaultInt == 0}");
    }
}