C# Nullable Arithmetic — Silent £0.00 from Null BasePrice

using System;

class NullableInternals
{
    static void Main()
    {
        // int? is just syntactic sugar for Nullable<int>
        // Both of these declarations are identical:
        int? playerScore = null;          // shorthand — what you'll write day-to-day
        Nullable<int> alsoPlayerScore = null; // longhand — what the compiler actually sees

        // HasValue tells you whether the nullable actually contains a number
        Console.WriteLine($"Has a score been set? {playerScore.HasValue}"); // False

        // Assign a real value
        playerScore = 4200;
        Console.WriteLine($"Has a score been set? {playerScore.HasValue}"); // True
        Console.WriteLine($"The score is: {playerScore.Value}");           // 4200

        // DANGER ZONE: Accessing .Value when HasValue is false
        // throws InvalidOperationException, NOT NullReferenceException
        int? unsetScore = null;
        try
        {
            int boom = unsetScore.Value; // this will throw
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"Caught: {ex.Message}");
            // Output: Nullable object must have a value.
        }

        // GetValueOrDefault() is the safe alternative — returns 0 if no value is set
        int safeScore = unsetScore.GetValueOrDefault(); // returns 0, no exception
        Console.WriteLine($"Safe fallback score: {safeScore}");            // 0

        // You can also provide a custom default
        int customDefault = unsetScore.GetValueOrDefault(defaultValue: -1);
        Console.WriteLine($"Custom fallback score: {customDefault}");      // -1
    }
}

using System;

// Simulates a database row for a customer account
class CustomerAccount
{
    public string Name { get; set; }
    public int? LoyaltyPoints { get; set; }      // null means: never made a purchase
    public DateTime? LastPurchaseDate { get; set; } // null means: no purchase history
    public decimal? CreditLimit { get; set; }    // null means: not yet assessed
}

class RealWorldNullablePatterns
{
    // Returns the display string for loyalty points
    // Without nullable types you'd use -1 or 0 as a sentinel — both are misleading
    static string GetPointsDisplay(CustomerAccount account)
    {
        // ?? operator: "use LoyaltyPoints if it has a value, otherwise use 0"
        int pointsToShow = account.LoyaltyPoints ?? 0;
        return $"{pointsToShow} pts";
    }

    // Calculates days since last purchase, or returns null if no purchase exists
    static int? DaysSinceLastPurchase(CustomerAccount account)
    {
        // If LastPurchaseDate is null, this whole expression returns null — no crash
        // The cast to int? means the result can also be null
        return (int?)(DateTime.Today - account.LastPurchaseDate)?.TotalDays;
    }

    // Applies a credit limit, but only if one hasn't been set yet
    static void EnsureCreditLimit(CustomerAccount account, decimal defaultLimit)
    {
        // ??= operator: only assigns if CreditLimit is currently null
        account.CreditLimit ??= defaultLimit;
    }

    static void Main()
    {
        var newCustomer = new CustomerAccount
        {
            Name = "Priya Sharma",
            LoyaltyPoints = null,       // never purchased
            LastPurchaseDate = null,    // no purchase history
            CreditLimit = null          // not yet assessed
        };

        var regularCustomer = new CustomerAccount
        {
            Name = "James Okafor",
            LoyaltyPoints = 1850,
            LastPurchaseDate = DateTime.Today.AddDays(-12),
            CreditLimit = 500.00m
        };

        // ?? operator in action
        Console.WriteLine($"{newCustomer.Name}: {GetPointsDisplay(newCustomer)}");
        Console.WriteLine($"{regularCustomer.Name}: {GetPointsDisplay(regularCustomer)}");

        // null-conditional + ?? combo for safe navigation
        int? daysSinceNew = DaysSinceLastPurchase(newCustomer);
        int? daysSinceRegular = DaysSinceLastPurchase(regularCustomer);

        // ?? gives us a human-readable fallback when the value is null
        Console.WriteLine($"{newCustomer.Name} last purchased: {daysSinceNew?.ToString() ?? "Never"}");
        Console.WriteLine($"{regularCustomer.Name} last purchased: {daysSinceRegular} days ago");

        // ??= operator — only sets CreditLimit if it's currently null
        EnsureCreditLimit(newCustomer, defaultLimit: 250.00m);
        EnsureCreditLimit(regularCustomer, defaultLimit: 250.00m); // won't overwrite 500.00

        Console.WriteLine($"{newCustomer.Name} credit limit: {newCustomer.CreditLimit:C}");
        Console.WriteLine($"{regularCustomer.Name} credit limit: {regularCustomer.CreditLimit:C}");
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
// Simulated EF Core-style model — in a real project you'd reference
// Microsoft.EntityFrameworkCore and inherit from DbContext

// This model accurately reflects a real "orders" table
class Order
{
    public int OrderId { get; set; }             // NOT NULL in DB — always present
    public string CustomerEmail { get; set; }    // NOT NULL — required to place an order
    public DateTime OrderPlacedAt { get; set; }  // NOT NULL — timestamp is set on insert

    // These ARE nullable — they represent states that may not exist yet
    public DateTime? ShippedAt { get; set; }     // NULL until the item ships
    public DateTime? DeliveredAt { get; set; }   // NULL until delivery is confirmed
    public decimal? DiscountApplied { get; set; }// NULL if no discount was used
}

class EntityFrameworkNullableMapping
{
    // Simulates what EF Core would return from a database query
    static List<Order> GetSimulatedOrders()
    {
        return new List<Order>
        {
            new Order
            {
                OrderId = 101,
                CustomerEmail = "alice@example.com",
                OrderPlacedAt = DateTime.Today.AddDays(-5),
                ShippedAt = DateTime.Today.AddDays(-3),
                DeliveredAt = DateTime.Today.AddDays(-1),
                DiscountApplied = 15.00m
            },
            new Order
            {
                OrderId = 102,
                CustomerEmail = "bob@example.com",
                OrderPlacedAt = DateTime.Today.AddDays(-2),
                ShippedAt = DateTime.Today.AddDays(-1),
                DeliveredAt = null,          // not delivered yet
                DiscountApplied = null       // no discount used
            },
            new Order
            {
                OrderId = 103,
                CustomerEmail = "carol@example.com",
                OrderPlacedAt = DateTime.Today,
                ShippedAt = null,            // hasn't shipped yet
                DeliveredAt = null,
                DiscountApplied = 5.00m
            }
        };
    }

    static string GetOrderStatus(Order order)
    {
        // Pattern matching on nullable types — clean and expressive
        return order switch
        {
            // 'is not null' works naturally with nullable value types
            { DeliveredAt: not null } => $"Delivered on {order.DeliveredAt:dd MMM}",
            { ShippedAt: not null }   => "Shipped — awaiting delivery",
            _                         => "Processing"
        };
    }

    static void Main()
    {
        var orders = GetSimulatedOrders();

        foreach (var order in orders)
        {
            string status = GetOrderStatus(order);

            // ?? makes the discount display clean without if/else
            string discountInfo = order.DiscountApplied.HasValue
                ? $"Discount: {order.DiscountApplied:C}"
                : "No discount";

            Console.WriteLine($"Order #{order.OrderId} | {status} | {discountInfo}");
        }

        // LINQ works naturally with nullable types
        // Sum() on a nullable column requires the cast — this is a common real-world need
        decimal totalDiscounts = orders.Sum(o => o.DiscountApplied ?? 0m);
        Console.WriteLine($"\nTotal discounts given: {totalDiscounts:C}");

        // Find orders that are still pending (ShippedAt is null)
        int pendingCount = orders.Count(o => o.ShippedAt == null);
        Console.WriteLine($"Orders not yet shipped: {pendingCount}");
    }
}

using System;

class PatternMatchingWithNullables
{
    enum OrderStatus { Pending, Shipped, Delivered, Unknown }

    // Returns order status using switch expression with property patterns
    static OrderStatus GetOrderStatus(Order order) => order switch
    {
        { DeliveredAt: not null } => OrderStatus.Delivered,
        { ShippedAt: not null }   => OrderStatus.Shipped,
        _                         => OrderStatus.Pending
    };

    static string DescribeDiscount(decimal? discount) => discount switch
    {
        null => "No discount applied",
        > 100 => "Generous discount!",
        > 0  => $"Discount of {discount:C}",
        0    => "Coupon used but $0 discount",
        _    => $"Unexpected discount value: {discount}"
    };

    static void Main()
    {
        var order1 = new Order { ShippedAt = null, DeliveredAt = null };
        var order2 = new Order { ShippedAt = DateTime.Now, DeliveredAt = null };
        var order3 = new Order { ShippedAt = DateTime.Now, DeliveredAt = DateTime.Now };

        Console.WriteLine($"Order status: {GetOrderStatus(order1)} (expected: Pending)");
        Console.WriteLine($"Order status: {GetOrderStatus(order2)} (expected: Shipped)");
        Console.WriteLine($"Order status: {GetOrderStatus(order3)} (expected: Delivered)");

        Console.WriteLine(DescribeDiscount(null));        // No discount applied
        Console.WriteLine(DescribeDiscount(50m));         // Discount of £50.00
        Console.WriteLine(DescribeDiscount(150m));        // Generous discount!
    }
}

// Simple Order class for demonstration
class Order
{
    public DateTime? ShippedAt { get; set; }
    public DateTime? DeliveredAt { get; set; }
}

using System;

class NullableMistakesAndFixes
{
    static void Main()
    {
        // ─────────────────────────────────────────────────────────
        // MISTAKE 1: Casting a nullable to its base type without checking
        // ─────────────────────────────────────────────────────────

        int? temperatureReading = null; // sensor hasn't reported yet

        // BAD: This compiles fine but throws InvalidOperationException at runtime
        // int currentTemp = (int)temperatureReading;  // ← DON'T do this

        // FIX A: Use ?? to supply a safe fallback
        int currentTempFix1 = temperatureReading ?? -999; // -999 signals "no data"
        Console.WriteLine($"[Fix A] Temperature: {currentTempFix1}");

        // FIX B: Check HasValue before accessing Value
        if (temperatureReading.HasValue)
        {
            Console.WriteLine($"[Fix B] Temperature: {temperatureReading.Value}°C");
        }
        else
        {
            Console.WriteLine("[Fix B] Sensor has not reported yet.");
        }

        // ─────────────────────────────────────────────────────────
        // MISTAKE 2: Arithmetic with nullables produces null silently
        // Many developers expect this to throw — it doesn't
        // ─────────────────────────────────────────────────────────

        int? itemsInStock = null;    // stock count not yet loaded from database
        int reorderThreshold = 10;

        // BAD: This compiles and runs — but result is null, not an error!
        // If you then compare this to reorderThreshold, you'll get a wrong answer
        int? stockCheckResult = itemsInStock - reorderThreshold; // evaluates to null!
        Console.WriteLine($"\n[Mistake 2] Nullable arithmetic result: {stockCheckResult}");
        // Prints: [Mistake 2] Nullable arithmetic result:
        // (the null is just formatted as empty — silent and dangerous)

        // The comparison ALSO produces null (bool? not bool) — easy to misread
        bool? isBelowThreshold = itemsInStock < reorderThreshold;
        Console.WriteLine($"Is below threshold? {isBelowThreshold}"); // empty/null!

        // FIX: Decide what to do when the value isn't loaded yet, BEFORE the maths
        bool needsReorder;
        if (itemsInStock.HasValue)
        {
            needsReorder = itemsInStock.Value < reorderThreshold;
        }
        else
        {
            // Explicit business decision: treat unknown stock as needing a reorder
            needsReorder = true;
            Console.WriteLine("[Fix] Stock data unavailable — flagging for reorder review.");
        }
        Console.WriteLine($"[Fix] Needs reorder: {needsReorder}");

        // ─────────────────────────────────────────────────────────
        // MISTAKE 3: Using nullable when a default value is the right answer
        // ─────────────────────────────────────────────────────────

        // If 'no score' and '0 score' mean the SAME thing in your domain,
        // use int (defaulting to 0), not int?.
        // Only use int? when null carries a DIFFERENT meaning than any int value.

        // Example of CORRECTLY chosen nullable — null means "not yet graded"
        int? examScore = null;
        string gradeDisplay = examScore.HasValue
            ? $"Score: {examScore.Value}/100"
            : "Not yet graded";
        Console.WriteLine($"\n[Mistake 3 Fix] {gradeDisplay}");
    }
}

// io.thecodeforge — csharp tutorial

// What you should write in production
int? orderCount = null;
double? discountRate = 0.15;
bool? isVerified = true;

// What compiles to the same thing but makes you look like an intern
Nullable<int> legacyOrderCount = null;

// This compiles but is redundant noise
int? explicitNull = null;

// Reference type nullable — C# 8+ null-state analysis
string? customerName = null;

Console.WriteLine($"Orders: {orderCount?.ToString() ?? "none"}");
Console.WriteLine($"Rate: {discountRate}");
Console.WriteLine($"Verified: {isVerified}");

// io.thecodeforge — csharp tutorial

int? itemsShipped = null;

// Dangerous — silently returns 0
int shippedCount = itemsShipped.GetValueOrDefault();
Console.WriteLine($"Shipped (default): {shippedCount}");

// Better — explicit fallback
int safeCount = itemsShipped.GetValueOrDefault(-1);
Console.WriteLine($"Shipped (safe): {safeCount}");

// Clean pattern matching (C# 7+)
string status = itemsShipped switch
{
    null => "Pending",
    > 0 => $"{itemsShipped} shipped",
    _ => "Zero shipped"
};
Console.WriteLine($"Status: {status}");

// Throws InvalidOperationException if null — use only after HasValue check
// int crash = itemsShipped.Value; // DON'T

// io.thecodeforge — csharp tutorial

int? cachedTotal = null;

// ?? — provide fallback
int displayTotal = cachedTotal ?? 0;
Console.WriteLine($"Display: {displayTotal}");

// ??= — lazy init (C# 8+)
cachedTotal ??= ComputeExpensiveTotal();
Console.WriteLine($"Cached: {cachedTotal}");

// Chaining with null-conditional
var customer = new { Name = "Alice", Address = (string?)null };
string city = customer.Address?.Split(',')[1]?.Trim() ?? "Unknown";
Console.WriteLine($"City: {city}");

int ComputeExpensiveTotal()
{
    Console.WriteLine("Computing...");
    return 42;
}

// io.thecodeforge — csharp tutorial

int? maybe = 42;
object boxed = maybe;    // boxes to int, not Nullable<int>
int unboxed = (int)boxed; // OK

int? nullMaybe = null;
object boxedNull = nullMaybe; // null reference

// Wrong: (int?)boxed throws InvalidCastException
// Right: cast to int, then assign to int?
int? correct = (int)boxed;

int? another = 100;
object boxed2 = another;
bool isBoxedInt = boxed2 is int; // true

// io.thecodeforge — csharp tutorial

// Beginner
string? middleName = null;
if (middleName is not null)
    Console.WriteLine(middleName);

// Intermediate
int? score = GetScore();
string grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    null  => "Incomplete",
    _     => "Fail"
};

// Advanced
async Task<T?> FetchAsync<T>(int id) where T : struct
{
    return id == 0 ? null : (T)(object)id;
}