Easy Learn C#

Example:

using System;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}
                            

// Single statements end with semicolons
int x = 10;
Console.WriteLine(x);

// Code blocks use curly braces
if (x > 5) 
{
    Console.WriteLine("x is greater than 5");
    x = 5;  // This is also within the block
}

// Single statement blocks can omit braces (not recommended)
if (x == 5)
    Console.WriteLine("x equals 5");  // Only this line is in the if block
                            

// These are three different variables
int value = 10;
int Value = 20;
int VALUE = 30;

// This works
Console.WriteLine(value);  // Outputs: 10
Console.WriteLine(Value);  // Outputs: 20
Console.WriteLine(VALUE);  // Outputs: 30

// This would cause an error
// Console.WriteLine(vAlUe);  // Variable 'vAlUe' doesn't exist
                            

// This is a single-line comment

/* This is a 
   multi-line comment */

/// <summary>
/// XML documentation comments are used to generate documentation
/// </summary>
public void DocumentedMethod()
{
    // Method implementation
}
                            

Example:

// WriteLine adds a new line after the output
Console.WriteLine("Hello World!");
Console.WriteLine("I am learning C#");

// Write doesn't add a new line
Console.Write("Hello ");
Console.Write("World");  // Output: Hello World (on the same line)
                            

String Concatenation:

string name = "John";
int age = 25;
Console.WriteLine("Name: " + name + ", Age: " + age);
                            

String Formatting (composite formatting):

string name = "John";
int age = 25;
Console.WriteLine("Name: {0}, Age: {1}", name, age);
                            

String Interpolation (recommended, C# 6.0 and later):

string name = "John";
int age = 25;
Console.WriteLine($"Name: {name}, Age: {age}");
                            

Currency Formatting:

double price = 123.45;
Console.WriteLine($"Price: {price:C}");  // Outputs: Price: $123.45 (in US culture)
                            

Number Formatting:

double number = 12345.6789;
Console.WriteLine($"Number: {number:N2}");  // Outputs: Number: 12,345.68 (formatted with commas and 2 decimal places)
Console.WriteLine($"Percentage: {0.75:P0}");  // Outputs: Percentage: 75%
                            

Date Formatting:

DateTime now = DateTime.Now;
Console.WriteLine($"Date: {now:d}");  // Outputs: Date: 5/10/2023 (short date format)
Console.WriteLine($"Time: {now:t}");  // Outputs: Time: 10:30 AM (short time format)
Console.WriteLine($"Full: {now:F}");  // Outputs: Full: Friday, May 10, 2023 10:30:45 AM
                            

// Using escape sequences
Console.WriteLine("Hello\nWorld");  // Outputs Hello and World on separate lines
Console.WriteLine("I am learning \"C#\"");  // Outputs: I am learning "C#"
Console.WriteLine("Path: C:\\Program Files\\App");  // Outputs: Path: C:\Program Files\App

// Using verbatim strings (preceded by @)
Console.WriteLine(@"Path: C:\Program Files\App");  // No need to escape backslashes
Console.WriteLine(@"This is a
multi-line
string");  // Preserves line breaks
                            

Basic Variable Declaration:

// Type variableName = value;
int myNum = 5;               // Integer (whole number)
double myDoubleNum = 5.99D;  // Floating point number
char myLetter = 'D';         // Character
bool myBool = true;          // Boolean
string myText = "Hello";     // String
                            

Valid and Invalid Variable Names:

// Valid variable names
int age;
string userName;
double _temperature;
bool isActive;
int totalItems123;

// Invalid variable names
// int 1stNumber;      // Cannot start with a number
// string user-name;   // Cannot contain hyphen
// double class;       // Cannot use C# keywords
// bool my variable;   // Cannot contain spaces
                            

// Declaration without initialization (default values are assigned)
int count;          // Default value: 0
bool flag;          // Default value: false
string name;        // Default value: null

// Declaration with initialization
int age = 25;
string firstName = "John";

// Multiple declarations of the same type
int x = 10, y = 20, z = 30;

// Using var (type inference) - compiler determines the type based on the value
var total = 100;        // Inferred as int
var message = "Hello";  // Inferred as string
var price = 29.99;      // Inferred as double
var today = DateTime.Now;  // Inferred as DateTime
                            

Block Scope:

void ExampleMethod()
{
    // Method-level scope
    int outerVariable = 10;
    
    if (outerVariable > 5)
    {
        // Block-level scope
        int innerVariable = 20;
        Console.WriteLine(outerVariable);    // Can access outerVariable
        Console.WriteLine(innerVariable);    // Can access innerVariable
    }
    
    Console.WriteLine(outerVariable);    // Can access outerVariable
    // Console.WriteLine(innerVariable); // ERROR: Cannot access innerVariable here
}
                            

Class Scope:

class Person
{
    // Class-level fields (accessible throughout the class)
    private string _name;
    private int _age;
    
    // Constructor
    public Person(string name, int age)
    {
        // Constructor parameters (method scope)
        _name = name;  // Assign parameter to field
        _age = age;    // Assign parameter to field
    }
    
    public void DisplayInfo()
    {
        // Local variable (method scope)
        string message = $"Name: {_name}, Age: {_age}";
        Console.WriteLine(message);
    }
}
                            

// Constants must be assigned a value when declared
const double PI = 3.14159;
const int MAX_USERS = 100;
const string CONNECTION_STRING = "Server=myServerAddress;Database=myDataBase;";

// This will cause a compilation error:
// PI = 3.14; // Constants cannot be changed
                            

public class Configuration
{
    // Read-only fields - can only be assigned in declaration or constructor
    private readonly string _serverName;
    private readonly int _timeoutSeconds;
    public readonly DateTime CreationTime = DateTime.Now;
    
    public Configuration(string serverName)
    {
        _serverName = serverName;
        _timeoutSeconds = 30; // Can set in constructor
    }
    
    public void ChangeSettings()
    {
        // This would cause a compilation error:
        // _serverName = "newServer"; // Cannot modify readonly fields
    }
}
                            

Variable Operations:

// Arithmetic operations
int a = 10;
int b = 3;
int sum = a + b;        // Addition: 13
int difference = a - b; // Subtraction: 7
int product = a * b;    // Multiplication: 30
int quotient = a / b;   // Division: 3 (integer division)
int remainder = a % b;  // Modulus (remainder): 1

// Compound assignment operators
int count = 5;
count += 2;  // Equivalent to: count = count + 2; (count becomes 7)
count -= 1;  // Equivalent to: count = count - 1; (count becomes 6)
count *= 3;  // Equivalent to: count = count * 3; (count becomes 18)
count /= 2;  // Equivalent to: count = count / 2; (count becomes 9)

// Increment and decrement
int x = 10;
x++;  // Increment by 1 (x becomes 11)
x--;  // Decrement by 1 (x becomes 10)

// Pre-increment and post-increment
int y = 5;
int z1 = ++y;  // Pre-increment: y becomes 6, then z1 is assigned 6
int z2 = y++;  // Post-increment: z2 is assigned 6, then y becomes 7
                            

Output Methods:

// String concatenation (using + operator)
string name = "Alice";
int age = 28;
Console.WriteLine("Name: " + name + ", Age: " + age);

// String interpolation (recommended, C# 6.0+)
Console.WriteLine($"Name: {name}, Age: {age}");

// String.Format method
Console.WriteLine(String.Format("Name: {0}, Age: {1}", name, age));

// Composite formatting
Console.WriteLine("Name: {0}, Age: {1}", name, age);

// With formatting options
double price = 123.45;
Console.WriteLine($"Price: {price:C}");  // Currency format: $123.45 (locale-dependent)
Console.WriteLine($"Price: {price:F1}"); // Fixed-point: 123.5 (1 decimal place)
Console.WriteLine($"Tax rate: {0.0825:P}"); // Percentage: 8.25%
                            

Variable Shadowing Example:

int x = 10;  // Outer variable

if (true)
{
    int x = 20;  // Inner variable (shadows the outer one)
    Console.WriteLine(x);  // Outputs: 20 (refers to the inner variable)
}

Console.WriteLine(x);  // Outputs: 10 (refers to the outer variable)
                            

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"
};
                            

Basic LINQ Query:

// Data source
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Query syntax
var evenNumbers = from num in numbers
                 where num % 2 == 0
                 select num;

// Method syntax (alternative)
var evenNumbersMethod = numbers.Where(n => n % 2 == 0);

// Display results
foreach (var num in evenNumbers)
{
    Console.WriteLine(num);  // Outputs: 2, 4, 6, 8, 10
}
                            

Common LINQ Operations:

List<string> names = new List<string> { "Alice", "Bob", "Charlie", "David", "Emma" };

// Filtering - Get names with length > 4
var longNames = names.Where(name => name.Length > 4);

// Ordering - Sort names alphabetically
var orderedNames = names.OrderBy(name => name);

// Projection - Get lengths of all names
var nameLengths = names.Select(name => name.Length);

// Aggregation - Count, Sum, Average, etc.
int totalChars = names.Sum(name => name.Length);
double averageLength = names.Average(name => name.Length);
int maxLength = names.Max(name => name.Length);

// Grouping - Group by first letter
var nameGroups = names.GroupBy(name => name[0]);
                            

LINQ with Complex Objects:

// Define a class
class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }
}

// Create a list of products
List<Product> products = new List<Product>
{
    new Product { Id = 1, Name = "Laptop", Price = 1200, Category = "Electronics" },
    new Product { Id = 2, Name = "Desk Chair", Price = 250, Category = "Furniture" },
    new Product { Id = 3, Name = "Smartphone", Price = 800, Category = "Electronics" },
    new Product { Id = 4, Name = "Bookshelf", Price = 150, Category = "Furniture" },
    new Product { Id = 5, Name = "Headphones", Price = 100, Category = "Electronics" }
};

// Query for electronics under $1000
var affordableElectronics = products
    .Where(p => p.Category == "Electronics" && p.Price < 1000)
    .OrderBy(p => p.Price);

// Group products by category with average price
var productsByCategory = products
    .GroupBy(p => p.Category)
    .Select(g => new {
        Category = g.Key,
        Count = g.Count(),
        AveragePrice = g.Average(p => p.Price)
    });