C# Cheatsheet

Datentypen

int x = 42; 32-bit Integer

long x = 9_000_000_000L; 64-bit Integer

double x = 3.14; 64-bit Gleitkomma

decimal x = 19.99m; Präzise Dezimalzahl

bool b = true; Boolean

char c = 'A'; Einzelnes Zeichen

string s = "Hallo"; Zeichenkette

var x = 42; Typinferenz

int? n = null; Nullable Typ

n ?? 0 Null-Koaleszenz

OOP Klassen

class Foo : Bar { } Vererbung

interface IFoo { } Interface

abstract class A { } Abstrakte Klasse

sealed class S { } Nicht ableitbar

override void Foo() { } Methode überschreiben

public int Prop { get; set; } Auto-Property

record Point(int X, int Y); Record (immutable)

static void Foo() { } Statische Methode

Collections

int[] arr = { 1, 2, 3 }; Array

var list = new List<int>(); Liste

list.Add(42); Element hinzufügen

list.Remove(42); Element entfernen

var dict = new Dictionary<string, int>(); Dictionary

dict["key"] = 1; Wert setzen

dict.TryGetValue("key", out var v); Sicherer Zugriff

var set = new HashSet<int>(); HashSet (einzigartig)

LINQ

list.Where(x => x > 5) Filtern

list.Select(x => x * 2) Transformieren

list.FirstOrDefault(x => x > 5) Erstes Element

list.OrderBy(x => x) Sortieren aufsteigend

list.OrderByDescending(x => x) Sortieren absteigend

list.GroupBy(x => x.Category) Gruppieren

list.Any(x => x > 5) Mindestens eines

list.All(x => x > 0) Alle erfüllen

list.Count(x => x > 5) Anzahl zählen

list.Sum() / .Min() / .Max() Aggregation

list.ToList() / .ToArray() Materialisieren

Async / Await

async Task FooAsync() { } Async Methode

async Task<int> GetAsync() { } Async mit Rückgabe

await FooAsync(); Await Aufruf

await Task.Delay(1000); Warten (ms)

await Task.WhenAll(t1, t2); Parallele Tasks

await Task.WhenAny(t1, t2); Erster Task fertig

Task.Run(() => HeavyWork()); Thread Pool

CancellationToken ct Abbruch-Token

Exceptions

try { } catch (Exception e) { } Try-Catch

finally { } Immer ausführen

throw new ArgumentException("..."); Exception werfen

throw; Weiterwerfen

catch (InvalidOp e) when (e.Code == 5) Exception Filter

using var res = new Resource(); Auto-Dispose

Generics

class Box<T> { public T Value; } Generische Klasse

T Foo<T>(T val) => val; Generische Methode

where T : class Constraint: Referenztyp

where T : struct Constraint: Werttyp

where T : IComparable<T> Constraint: Interface

where T : new() Constraint: Konstruktor

Delegates & Events

Action<int> a = x => Console.WriteLine(x); Action (kein Rückgabewert)

Func<int, bool> f = x => x > 0; Func (mit Rückgabewert)

Predicate<int> p = x => x > 0; Predicate (bool)

event Action<int> OnChange; Event deklarieren

OnChange += Handler; Handler registrieren

OnChange?.Invoke(42); Event auslösen

(int x, int y) => x + y Lambda Ausdruck

Schleifen

for (int i = 0; i < 10; i++) { } For-Schleife

foreach (var item in list) { } Foreach-Schleife

while (x > 0) { x--; } While-Schleife

do { x--; } while (x > 0); Do-While (mind. 1x)

break; Schleife abbrechen

continue; Iteration überspringen

for (int i = 0; i < arr.Length; i++) Array durchlaufen

for (int i = arr.Length - 1; i >= 0; i--) Rückwärts iterieren

Enumerable.Range(0, 10).ToList() Range erzeugen

Entity Framework EF Core

class AppDbContext : DbContext { } DbContext erstellen

public DbSet<User> Users { get; set; } Tabelle als Property

services.AddDbContext<AppDbContext>(opt =>
  opt.UseSqlServer(connStr));

DI registrieren

dotnet ef migrations add InitialCreate Migration erstellen

dotnet ef database update Migration anwenden

dotnet ef migrations remove Letzte Migration löschen

await ctx.Users.ToListAsync(); Alle laden

await ctx.Users.FindAsync(id); Per Primary Key

ctx.Users.Where(u => u.Active) Filtern mit LINQ

ctx.Users.Include(u => u.Orders) Navigation laden (Eager)

ctx.Users.Add(user);
await ctx.SaveChangesAsync();

Einfügen

ctx.Users.Remove(user);
await ctx.SaveChangesAsync();

Löschen

ctx.Entry(user).State = EntityState.Modified; Update markieren

[Key] / [Required] / [MaxLength(100)] Data Annotations

modelBuilder.Entity<User>().HasKey(u => u.Id); Fluent API