C# Cheat Sheet

using System; // 'using' allows for easier access to types in a namespace.

namespace YourNamespace // Namespaces organize code and prevent naming collisions.
{
    class YourClass // A 'class' defines the blueprint of objects.
    {
        static void Main(string[] args) // 'Main' is where the program starts execution.
        {
            Console.WriteLine("Hello, World!"); // Displays text in the console.
        }
    }
}

Console.WriteLine("Hello, World");

int num = 5; // Declares an integer variable and assigns it the value 5.
string word = "Hello"; // Declares a string variable and assigns it the value "Hello".

// We can use var because the compiler knows that "..." is a string
var name = "Peter";

// We can use var because we state that we create a new object of type Person.
var person = new Person();

const int ConstNum = 5; // The value of 'ConstNum' will always be 5.

if (condition) { /*...*/ } // Executes if 'condition' is true.
else if (condition) { /*...*/ } // Additional conditions if the above ones fail.
else { /*...*/ } // Executes if no conditions are met.

switch (variable) // Useful when comparing a single variable to many values.
{
    case value1:
        // Code for value1
        break; // Exits the switch statement.
    // ... other cases ...
    default:
        // Executes if no other case matches.
        break;
}

for (int i = 0; i < 10; i++) { /*...*/ } // Loops 10 times, incrementing 'i' each time.
foreach (var item in collection) { /*...*/ } // Loops over each item in 'collection'.
while (condition) { /*...*/ } // Continues looping as long as 'condition' remains true.
do { /*...*/ } while (condition); // Executes once before checking 'condition'.

int[] numbers = new int[5] {1, 2, 3, 4, 5}; // Declares an array of integers.

using System.Collections.Generic; // Required namespace for Lists.
List<int> list = new List<int>() {1, 2, 3, 4, 5}; // Initializes a List with 5 integers.

list.Add(6); // Add the number 6 to the list
list.Remove(2) // Remove the element at index 2 (0-based) from the list.

using System.Collections.Generic;
Dictionary<string, int> dict = new Dictionary<string, int>()
{
    {"one", 1}, // "one" is the key, 1 is its associated value.
    {"two", 2}
};

dict.Add("key", "value"); // Add a new item to the dictionary.
dict["key"] // Access the value of the dictionary at the key 'key'.

public returnType MethodName(parameters) { /*...*/ } // A method's signature.

// A Sum method returning int with two int parameters.
public int Sum(int a, int b)
{
		return a + b;
}

public class MyClass
{
    public string PropertyName { get; set; } // Properties store data for an object.
    public void MethodName() { /*...*/ } // Methods define actions an object can take.
}

MyClass obj = new MyClass(); // Creates a new object of type 'MyClass'.

try
{
    // Code that might throw an exception.
}
catch (SpecificException ex) // Catches specific exceptions, allowing tailored responses.
{
    // Handle this specific error.
}
finally
{
    // Cleanup code. Executes regardless of whether an exception was thrown.
}

// A type that represents methods with a specific signature.
public delegate void MyDelegate(); 

// An event that can be triggered when certain actions occur.
event MyDelegate MyEvent;

Func<int, int, int> add = (a, b) => a + b; // Lambda expression. A concise way to define methods.

using System.Linq; // Required for LINQ queries.
var result = from s in list where s.Contains("test") select s; // Sample query to filter data.

[Obsolete("This method is deprecated.")] // An attribute warning developers about deprecated methods.
public void OldMethod() { /*...*/ }

public async Task<returnType> MethodName()
{
    return await OtherAsyncMethod(); // 'await' pauses method execution until the awaited task completes.
}

string.Concat(); // Combines multiple strings.
string.Join(); // Joins elements with a separator.
str.Split(); // Splits a string based on delimiters.
str.ToUpper(); // Converts to uppercase.
str.ToLower(); // Converts to lowercase.
str.Trim(); // Removes leading and trailing whitespace.
str.Substring(); // Extracts a portion of the string.

using System.IO; // Necessary for most File I/O operations.

File.ReadAllText(path); // Reads the entire content of a file into a string.
File.WriteAllText(path, content); // Writes a string to a file, creating or overwriting it.
File.Exists(path); // Checks if a file exists at the specified path.

DateTime current = DateTime.Now; // Gets the current date and time.
current.AddDays(1); // Adds a day to the current date.
current.ToShortDateString(); // Converts the date to a short date string format.

public class MyGenericClass<T> // 'T' is a placeholder for any type.
{
    private T item;
    public void UpdateItem(T newItem)
    {
        item = newItem;
    }
}

int? nullableInt = null; // '?' makes the int nullable.
bool hasValue = nullableInt.HasValue; // Checks if nullable type has a value.

[MyCustomAttribute] // Custom attribute applied to a class.
public class MyClass
{
    //...
}

// Using reflection to get the attribute:
Attribute[] attrs = Attribute.GetCustomAttributes(typeof(MyClass));

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
}

public interface IService
{
    void DoSomething();
}

public class MyService : IService
{
    public void DoSomething()
    {
        // Implementation here
    }
}

public class Consumer
{
    private readonly IService _service;

    public Consumer(IService service)
    {
        _service = service; // Dependency injection through constructor
    }
}

//Register services to the internal dependency injection container in the Program.cs file.
builder.Services.AddScoped<IService, MyService>();

public partial class MyClass
{
    public void MethodOne() { /*...*/ }
}

public partial class MyClass
{
    public void MethodTwo() { /*...*/ }
}

using System.Runtime.InteropServices; // Required for DllImport.

[DllImport("user32.dll")]
public static extern int MessageBox(IntPtr h, string m, string c, int type);

var anon = new { Name = "John", Age = 25 }; // The type of 'anon' is inferred at compile time.

var person = Tuple.Create("John", 25); // Creates a tuple with two items.

object obj = "hello";
if (obj is string str)
{
    Console.WriteLine(str); // str is "hello"
}

public void MyMethod()
{
    void LocalFunction()
    {
        // Implementation
    }

    LocalFunction(); // Calling the local function
}

public record Person(string Name, int Age);

var john = new Person("John", 30);
var jane = john with { Name = "Jane" }; // jane is now ("Jane", 30)

int[] arr = {0, 1, 2, 3, 4, 5};
var subset = arr[1..^1]; // Grabs elements from index 1 to the second to last.

using var reader = new StreamReader("file.txt"); // reader is disposed of at the end of the enclosing scope.

#nullable enable
string? mightBeNull; // Reference type that might be null.

public ref struct ResourceWrapper
{
    public void Dispose()
    {
        // Cleanup
    }
}

using var resource = new ResourceWrapper();

if (obj is Person { Name: "John", Age: var age })
{
    Console.WriteLine($"John's age is {age}");
}

public interface IPerson
{
    void Display();
    void Greet() => Console.WriteLine("Hello!"); // Default implementation.
}

dynamic d = 5;
d = "Hello"; // No compile-time type checking.