🔑 Difference Between Classes, Structs, and Records

e.g., Class = DbContext, Struct = DateTime, Record = WeatherForecast in Web API

Code Examples

🔹 Class

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

• Reference type → Equality is by reference:

var p1 = new Person { Name = "Alice", Age = 30 };
var p2 = new Person { Name = "Alice", Age = 30 };

Console.WriteLine(p1 == p2); // False (different references)

🔹 Struct

struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

• Value type → Equality is by value:

var p1 = new Point { X = 5, Y = 10 };
var p2 = new Point { X = 5, Y = 10 };

Console.WriteLine(p1.Equals(p2)); // True

🔹 Record

public record PersonRecord(string Name, int Age);

• Reference type but compares by value:

var r1 = new PersonRecord("Alice", 30);
var r2 = new PersonRecord("Alice", 30);

Console.WriteLine(r1 == r2); // True (structural equality)

• With-expressions for immutability:

var r3 = r1 with { Age = 31 };  
Console.WriteLine(r3); // PersonRecord { Name = Alice, Age = 31 }

✅ Quick Rules of Thumb

• Use Class → For OOP, inheritance, polymorphism, and complex business logic.

• Use Struct → For small, lightweight objects that represent values (like Point, DateTime). Avoid large structs (>16 bytes) because copying becomes expensive.

• Use Record → For immutable, data-centric models (DTOs, events, state in DDD, serialization).

👉 In short:

• Class = Reference type, identity-based.

• Struct = Value type, efficient, no inheritance.

• Record = Reference type with value-based equality + immutability (best for data models).

Great one 👍 — this is a classic interview trap: ref vs out in C#.

Let’s carefully break it down:

🔑 Difference Between ref and out in C#

Code Example: ref

using System;

class Program
{
    static void DoubleValue(ref int number)
    {
        number = number * 2;   // modifies caller's value
    }

    static void Main()
    {
        int x = 5;  // must be initialized
        DoubleValue(ref x);
        Console.WriteLine(x); // Output: 10
    }
}

Code Example: out

using System;

class Program
{
    static void Divide(int dividend, int divisor, out int quotient, out int remainder)
    {
        quotient = dividend / divisor;   // must assign
        remainder = dividend % divisor;
    }

    static void Main()
    {
        int q, r;  // uninitialized is OK
        Divide(10, 3, out q, out r);
        Console.WriteLine($"Quotient = {q}, Remainder = {r}");  
        // Output: Quotient = 3, Remainder = 1
    }
}

✅ Summary

• ref → variable already has a value, method may read & modify it.

• out → variable has no value, method must initialize it before returning.
  👉 Think of it like this:

• ref = “I’m giving you my value, you can update it.”

• out = “I don’t have a value, please give me one.”

real .NET framework example (like Int32.TryParse(string, out int) which uses out)?

🔑 Enums

An Enum (short for enumeration) is a special value type in C# that lets you define a set of named constants for better readability and maintainability.

👉 Instead of using raw numbers (magic numbers), you use meaningful names.

Declaring an Enum

enum Weekday
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

By default:

• Underlying type = int

• Values start from 0 and increment by 1 (Monday = 0, Tuesday = 1, ...).

Custom Values

You can explicitly assign values:

enum ErrorCode
{
    None = 0,
    NotFound = 404,
    ServerError = 500,
    Unauthorized = 401
}

Usage Example

class Program
{
    static void Main()
    {
        Weekday today = Weekday.Monday;

        if (today == Weekday.Monday)
        {
            Console.WriteLine("Start of the week!");
        }

        // Casting to int
        int dayValue = (int)Weekday.Friday;
        Console.WriteLine(dayValue);  // Output: 4

        // Casting from int
        Weekday w = (Weekday)6;
        Console.WriteLine(w);  // Output: Sunday
    }
}

Enum Methods

C# provides built-in helpers:

foreach (var day in Enum.GetValues(typeof(Weekday)))
{
    Console.WriteLine(day);
}
// Output: Monday Tuesday ... Sunday

Flags Enum (Bitwise Enums)

• Use [Flags] attribute for combinations of values.

• Great for permissions, states, etc.

[Flags]
enum FileAccess
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4
}

class Program
{
    static void Main()
    {
        FileAccess access = FileAccess.Read | FileAccess.Write;
        Console.WriteLine(access); // Output: Read, Write

        bool canWrite = access.HasFlag(FileAccess.Write);
        Console.WriteLine(canWrite); // Output: True
    }
}

✅ Summary

• Enums = named constants (improves readability).
• Default underlying type = int (can be changed to byte, short, etc.).
• Useful for states, categories, error codes, permissions.
• With [Flags], enums can represent bitwise combinations.

👉 In short:

• Use Enums to replace magic numbers with meaningful names.
• Use Flags Enums for combinable options.

real .NET example where Enums are used (like System.DayOfWeek or ConsoleColor)?

👍 Converting a string to enum is very common in C#.

Here are the main ways:

🔑 1. Using Enum.Parse

enum Weekday
{
    Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
}

class Program
{
    static void Main()
    {
        string input = "Friday";

        Weekday day = (Weekday)Enum.Parse(typeof(Weekday), input);
        Console.WriteLine(day);  // Output: Friday
    }
}

⚠️ If the string doesn’t match, it throws an exception.

🔑 2. Using Enum.TryParse (Safe way)

string input = "Friday";

if (Enum.TryParse<Weekday>(input, out var day))
{
    Console.WriteLine(day);  // Output: Friday
}
else
{
    Console.WriteLine("Invalid enum value!");
}

✅ No exception → returns false if the string is invalid.

🔑 3. Case-insensitive Parsing

string input = "friday";

Weekday day = (Weekday)Enum.Parse(typeof(Weekday), input, ignoreCase: true);
Console.WriteLine(day);  // Output: Friday

With TryParse:

Enum.TryParse("friday", true, out Weekday day);
Console.WriteLine(day); // Output: Friday

✅ Summary

• Enum.Parse → quick but throws exception if invalid.

• Enum.TryParse → safer, preferred in production.

• Both support ignoreCase for case-insensitive parsing.

👉 Example:

• "Friday" → Weekday.Friday

• "friday" (with ignoreCase) → Weekday.Friday

• "Funday" → fails gracefully with TryParse.

🔑 ** Equals(object obj)**

• Used to check equality of two objects.

• Default implementation (in object) does reference equality → two objects are equal only if they refer to the same memory location.

• You can override it in your class/struct to define value-based equality.

Example:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is Person other)
        {
            return this.Name == other.Name && this.Age == other.Age;
        }
        return false;
    }
}

Usage:

var p1 = new Person { Name = "Alice", Age = 30 };
var p2 = new Person { Name = "Alice", Age = 30 };

Console.WriteLine(p1.Equals(p2)); // True (because we overrode Equals)

🔑 ** GetHashCode()**

• Returns an integer hash code for the object.

• Used in hash-based collections like Dictionary<TKey,TValue>, HashSet<T>.

• If two objects are equal according to Equals(), they must return the same GetHashCode().

• But the reverse is not true → two different objects can have the same hash code (collision).

Example:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is Person other)
        {
            return this.Name == other.Name && this.Age == other.Age;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age); // .NET built-in helper
    }
}

Usage:

var set = new HashSet<Person>();
set.Add(new Person { Name = "Alice", Age = 30 });
set.Add(new Person { Name = "Alice", Age = 30 });

Console.WriteLine(set.Count); // 1 (because Equals + GetHashCode match)

✅ Rules to Remember

1. If you override Equals(), you must also override GetHashCode().

   • Otherwise, two objects considered equal may produce different hash codes, breaking collections like Dictionary.

2. Consistency:

   • Equal objects → same hash code.

   • Unequal objects → can have same or different hash codes.

3. Use HashCode.Combine(...) (C# 8+) or a good hash algorithm for combining multiple fields.

Real-life Analogy

• Equals() → Do these two books have the same content?

• GetHashCode() → A numeric label on the book for quick lookup in a library.

  • Different books can (rarely) share a label (collision).

  • But if two books are the same, they must share the same label.

👉 In short:

• Equals() → Defines equality logic.

• GetHashCode() → Provides a numeric shortcut for fast lookups in hash-based collections.

🔑 Difference Between ==, Equals(), and ReferenceEquals()

1. Using ==

string s1 = "hello";
string s2 = "hello";

Console.WriteLine(s1 == s2); // True (string overrides == to compare values)

• For strings: == is overridden → compares contents.

• For classes (if not overloaded): compares references.

2. Using Equals()

object o1 = "hello";
object o2 = "hello";

Console.WriteLine(o1.Equals(o2)); // True (string overrides Equals to compare content)

• By default (in object): compares reference.

• But many .NET types override it for value equality (like string, DateTime, Guid).

3. Using ReferenceEquals()

string a = "hello";
string b = string.Copy(a);

Console.WriteLine(Object.ReferenceEquals(a, b)); // False (different objects in memory)
Console.WriteLine(a == b);                       // True  (content is same)
Console.WriteLine(a.Equals(b));                  // True  (content is same)

• Always true only if both references point to same memory object.

• Ignores operator overloading and Equals() overrides.

✅ Quick Rules

• == → behaves differently for reference types vs value types (can be overloaded).

• Equals() → use for semantic equality (do these objects represent the same thing?).

• ReferenceEquals() → use for identity check (is it the exact same object?).

Real-life Analogy

• == → “These two cars look the same (depends on how we define equality).”

• Equals() → “Do these cars have the same VIN number (logical equality)?”

• ReferenceEquals() → “Is this literally the same physical car in front of me?”

👉 In short:

• Use == for quick comparison (can be overloaded).

• Use Equals() when defining logical equality (override in your class).

• Use ReferenceEquals() when you want to check if two variables point to the same memory object.

TimeSpan Struct -

• https://learn.microsoft.com/en-us/dotnet/api/system.timespan?view=net-9.0
• Object -> ValueType -> TimeSpan
• TimeSpan represents a duration, not an absolute time.
• Can be positive or negative
• Can be created using constructors or TimeSpan.FromX() methods.
• Supports addition, subtraction, and comparison.
• Used in DateTime operations for time calculations.