Easy Learn C#

Value Type Behavior:

int a = 10;
int b = a;    // Value is copied, b now has its own copy of 10
a = 20;       // Changing a does not affect b
Console.WriteLine(b);  // Outputs: 10
                            

Custom Struct Example:

// Defining a struct
struct Point
{
    public int X;
    public int Y;
    
    // Constructor
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
    
    // Method
    public double DistanceFromOrigin()
    {
        return Math.Sqrt(X * X + Y * Y);
    }
}

// Using the struct
Point p1 = new Point(3, 4);
Console.WriteLine($"Distance from origin: {p1.DistanceFromOrigin()}");  // Outputs: 5
                            

Enum Example:

// Defining an enum
enum DaysOfWeek
{
    Monday,     // 0 by default
    Tuesday,    // 1
    Wednesday,  // 2
    Thursday,   // 3
    Friday,     // 4
    Saturday,   // 5
    Sunday      // 6
}

// Using an enum
DaysOfWeek today = DaysOfWeek.Wednesday;
Console.WriteLine(today);         // Outputs: Wednesday
Console.WriteLine((int)today);    // Outputs: 2

// Enum with explicit values
enum HttpStatusCode
{
    OK = 200,
    NotFound = 404,
    InternalServerError = 500
}

HttpStatusCode status = HttpStatusCode.NotFound;
Console.WriteLine($"Status: {status}, Code: {(int)status}");  // Outputs: Status: NotFound, Code: 404
                            

Reference Type Behavior:

string a = "Hello";
string b = a;       // Both a and b reference the same string
a = "World";        // a now references a new string
Console.WriteLine(b);  // Outputs: Hello (unchanged)

// For objects (classes), changing properties affects all references
Person person1 = new Person { Name = "Alice" };
Person person2 = person1;   // Both reference the same object
person1.Name = "Bob";       // Change affects both references
Console.WriteLine(person2.Name);  // Outputs: Bob
                            

String Examples:

// String declaration and initialization
string firstName = "John";
string lastName = "Smith";
string emptyString = string.Empty;  // Preferred way to create an empty string

// String concatenation
string fullName = firstName + " " + lastName;  // "John Smith"

// String interpolation (C# 6.0+)
string greeting = $"Hello, {firstName}!";  // "Hello, John!"

// String methods
string message = "   Learn C# Programming   ";
string trimmed = message.Trim();                  // "Learn C# Programming"
string uppercase = message.ToUpper();             // "   LEARN C# PROGRAMMING   "
string replaced = message.Replace("C#", "C++");   // "   Learn C++ Programming   "
bool contains = message.Contains("C#");           // true
int length = message.Length;                      // 27
int index = message.IndexOf("C#");                // 9

// String comparison
bool isEqual = firstName == "John";               // true
bool startsWithJ = firstName.StartsWith("J");     // true
bool ignoreCase = firstName.Equals("john", StringComparison.OrdinalIgnoreCase);  // true

// Verbatim string literal (preserves whitespace and newlines)
string path = @"C:\Program Files\Microsoft\Windows";  // No need to escape backslashes

// String with multiple lines
string multiline = @"This is a
multi-line
string";

// String interpolation with verbatim strings (C# 8.0+)
string combinedPath = $@"C:\Users\{userName}\Documents";
                            

Default Value Example:

// Explicit default values
int number = default;           // 0
bool flag = default;            // false
string text = default;          // null
double price = default;         // 0.0

// Using default expression (C# 7.1+)
DateTime date = default;        // 01/01/0001 00:00:00
int[] array = default;          // null

// Using default operator
var defaultInt = default(int);    // 0
var defaultBool = default(bool);  // false
var defaultString = default(string);  // null
                            

// Regular value type cannot be null
// int regularInt = null;  // Error!

// Nullable value type can be null
int? nullableInt = null;
double? nullableDouble = null;

// Checking for null before using
if (nullableInt.HasValue)
{
    Console.WriteLine(nullableInt.Value);  // Safe to access value
}

// Null coalescing operator to provide a default value
int result = nullableInt ?? 0;  // If nullableInt is null, use 0
                            

// Type inference with var
var count = 10;              // Inferred as int
var name = "Alice";          // Inferred as string
var items = new List(); // Inferred as List
var today = DateTime.Now;    // Inferred as DateTime

// Restrictions:
// var must be initialized
// var price;  // Error! Must be initialized

// Type is fixed at compile-time
var number = 5;  // Type is int
// number = "string";  // Error! Cannot assign string to int
                            

// Dynamic typing
dynamic value = 10;
Console.WriteLine(value);  // 10

value = "Hello";           // Can change type at runtime
Console.WriteLine(value);  // Hello

value = new List { 1, 2, 3 };
Console.WriteLine(value.Count);  // 3

// No compile-time checking
// Only runtime checking for methods/properties
dynamic obj = new { Name = "Test" };
Console.WriteLine(obj.Name);       // Works
// Console.WriteLine(obj.Missing);  // Runtime error!
                            

Type Checking Examples:

object obj = "This is a string";

// Using is operator
if (obj is string)
{
    Console.WriteLine("obj is a string");
}

// Using GetType() and typeof
if (obj.GetType() == typeof(string))
{
    Console.WriteLine("obj is of type string");
}

// Using is with pattern matching (C# 7.0+)
if (obj is string message)
{
    // message is now a string variable containing the value of obj
    Console.WriteLine($"Message: {message}");
}

// Using switch expression with pattern matching (C# 8.0+)
string result = obj switch
{
    string s => $"String of length {s.Length}",
    int i => $"Integer: {i}",
    _ => "Unknown type"
};