C# .NET Framework

6 Kernbereiche

Die wichtigsten Bereiche des .NET Frameworks für C#: BCL · Collections · IO / FileSystem · Reflection · Garbage Collection · LINQ Das .NET Framework bietet eine riesige Klassenbibliothek für nahezu alle Programmieraufgaben. Diese Bereiche sind essenziell für die professionelle C#-Entwicklung.

BCL – Base Class Library

System · Console · String · DateTime

// Häufig verwendete Namespaces using System; using System.Collections.Generic; using System.Text; using System.Linq;

Base Class Library (BCL) ist die grundlegende Klassenbibliothek von .NET. Sie enthält die wichtigsten Typen für die tägliche Programmierung: primitive Typen, Strings, Collections, IO, Threading und mehr.

Die wichtigsten BCL-Typen

Namespace	Wichtige Typen	Beschreibung
System	String, DateTime, Console	Basistypen und Ein-/Ausgabe
System.Text	StringBuilder, Encoding	Textverarbeitung, Codierung
System.Collections	ArrayList, Hashtable (veraltet)	Legacy Collections
System.Collections.Generic	List<T>, Dictionary<TKey,TValue>	Generische Collections
System.Linq	Enumerable, Queryable	LINQ-Erweiterungen
System.Threading	Task, Thread, CancellationToken	Multithreading

Beispiele

// String-Manipulation

string text = "Hallo Welt";

text = text.Replace("Welt", "C#");

Console.WriteLine(text); // "Hallo C#"

// DateTime

var now = DateTime.Now;

var formatted = now.ToString("yyyy-MM-dd HH:mm:ss");

// StringBuilder (effizient für viele Konkatenationen)

var sb = new StringBuilder();

sb.AppendLine("Zeile 1");

sb.AppendLine("Zeile 2");

string result = sb.ToString();

Tipp: Verwenden Sie StringBuilder für viele Zeichenketten-Operationen in Schleifen – das ist deutlich effizienter als string += ....

Collections – Listen, Dictionaries, Sets

List<T> · Dictionary<K,V> · HashSet<T>

// Generische Collections List<string> names = new List<string> { "Anna", "Ben" }; Dictionary<int, string> users = new Dictionary<int, string>(); HashSet<int> unique = new HashSet<int>();

Collections sind Datenstrukturen zum Speichern und Verwalten von Objekten. Die generischen Collections im System.Collections.Generic-Namespace sind typsicher und performant.

Die wichtigsten Collections

Collection	Beschreibung	Wichtige Methoden
List<T>	Dynamisch wachsende Liste	Add, Remove, Insert, Sort, Find
Dictionary<K,V>	Schlüssel-Wert-Sammlung	Add, TryGetValue, ContainsKey, Remove
HashSet<T>	Menge eindeutiger Elemente	Add, Contains, UnionWith, IntersectWith
Queue<T>	FIFO-Warteschlange	Enqueue, Dequeue, Peek
Stack<T>	LIFO-Stapel	Push, Pop, Peek
LinkedList<T>	Doppelt verkettete Liste	AddFirst, AddLast, Find, Remove

Beispiele

// List

var zahlen = new List<int> { 1, 2, 3, 4, 5 };

zahlen.Add(6);

zahlen.RemoveAt(0);

zahlen.Sort();

// Dictionary

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

personen[1] = "Anna";

personen.Add(2, "Ben");

if (personen.TryGetValue(1, out string name)) {

Console.WriteLine(name);

}

// HashSet (eindeutige Elemente)

var set = new HashSet<string> { "A", "B", "C" };

set.Add("A"); // false (bereits vorhanden)

Tipp: Verwenden Sie Dictionary.TryGetValue() statt Dictionary[key], um KeyNotFoundException zu vermeiden.

IO / Dateisystem – Dateien und Verzeichnisse

File · Directory · FileStream · StreamReader

// Datei lesen string content = File.ReadAllText(@"C:\data.txt"); // Datei schreiben File.WriteAllText(@"C:\output.txt", content); // Verzeichnis erstellen Directory.CreateDirectory(@"C:\temp\sub");

IO ermöglicht den Zugriff auf das Dateisystem. Die Klassen File, Directory, FileStream und StreamReader bieten umfangreiche Funktionen für Dateioperationen.

Die wichtigsten IO-Klassen

Klasse	Beschreibung	Wichtige Methoden
File	Statische Methoden für Dateien	ReadAllText, WriteAllText, Copy, Delete, Exists
Directory	Statische Methoden für Verzeichnisse	CreateDirectory, GetFiles, GetDirectories, Exists
FileStream	Stream für Datei-I/O	Read, Write, Seek, Flush
StreamReader / StreamWriter	Textbasierte Streams	ReadLine, WriteLine, ReadToEnd
Path	Pfad-Operationen	Combine, GetFileName, GetExtension, GetDirectoryName

Beispiele

// Datei lesen mit StreamReader (zeilenweise)

using (var reader = new StreamReader(@"C:\log.txt")) {

string line;

while ((line = reader.ReadLine()) != null) {

Console.WriteLine(line);

}

// Datei schreiben mit StreamWriter

using (var writer = new StreamWriter(@"C:\output.txt", true)) {

writer.WriteLine($"Log: {DateTime.Now}");

}

// Verzeichnis-Operationen

string path = Path.Combine(@"C:\data", "backup", "file.txt");

string ext = Path.GetExtension(path); // ".txt"

string name = Path.GetFileNameWithoutExtension(path); // "file"

Tipp: Verwenden Sie using-Blöcke für StreamReader und StreamWriter, um Ressourcen automatisch freizugeben.

Reflection – Typen zur Laufzeit untersuchen

Type · Assembly · GetType · GetMethods

// Typinformationen abrufen Type type = typeof(string); Type type2 = obj.GetType(); // Methoden abfragen MethodInfo[] methods = type.GetMethods(); // Methode dynamisch aufrufen method.Invoke(obj, args);

Reflection ermöglicht die Untersuchung und Manipulation von Typen zur Laufzeit. Sie wird für Dependency Injection, Serialisierung, Testing und dynamische Codegenerierung verwendet.

Beispiele

// Typ-Informationen abrufen

Type type = typeof(List<int>);

Console.WriteLine(type.Name); // "List`1"

// Alle Methoden einer Klasse auflisten

foreach (var method in typeof(string).GetMethods()) {

Console.WriteLine(method.Name);

}

// Dynamischen Typ erstellen

Type dynamicType = Type.GetType("System.String");

object instance = Activator.CreateInstance(dynamicType, "Hallo");

// Methode dynamisch aufrufen

MethodInfo method = type.GetMethod("Add");

var list = new List<int>();

method.Invoke(list, new object[] { 42 });

Tipp: Reflection ist leistungsfähig, aber langsam. Verwenden Sie sie sparsam – für Dependency Injection oder Serialisierung gibt es oft schnellere Alternativen (z.B. Code-Generierung).

Garbage Collection – Speicherverwaltung

GC · IDisposable · using · Finalize

// Manuelle GC-Auslösung (nur in Ausnahmefällen) GC.Collect(); // IDisposable mit using using (var resource = new SomeResource()) { // Resource verwenden } // Dispose() wird automatisch aufgerufen

Garbage Collection verwaltet automatisch den Speicher für verwaltete Objekte. IDisposable wird für Ressourcen verwendet, die explizit freigegeben werden müssen (z.B. Dateien, Datenbankverbindungen).

GC-Generationen

Generation	Beschreibung
Gen 0	Kurzlebige Objekte (wird oft gesammelt)
Gen 1	Übergangsphase zwischen kurz- und langlebig
Gen 2	Langlebige Objekte (wird selten gesammelt)
Large Object Heap	Objekte > 85 KB (separat verwaltet)

Beispiele

// IDisposable implementieren

public class DatabaseConnection : IDisposable {

private bool _disposed = false;

public void Dispose() {

Dispose(true);

GC.SuppressFinalize(this);

}

protected virtual void Dispose(bool disposing) {

if (!_disposed) {

if (disposing) {

// Verwaltete Ressourcen freigeben

}

// Unverwaltete Ressourcen freigeben

}

_disposed = true;

}

// using für automatische Freigabe

using (var conn = new DatabaseConnection()) {

// Verbindung verwenden

} // Dispose() wird aufgerufen

// GC-Status abfragen

int gen = GC.GetGeneration(obj);

long memory = GC.GetTotalMemory(false);

Tipp: Rufen Sie GC.Collect() nur in Ausnahmefällen auf – der GC optimiert sich selbst. Implementieren Sie IDisposable für alle Ressourcen, die nicht verwaltet werden (Dateien, Sockets, etc.).

LINQ – Language Integrated Query

Where · Select · OrderBy · GroupBy

// Query-Syntax var result = from x in numbers where x > 5 select x; // Method-Syntax var result = numbers.Where(x => x > 5);

LINQ (Language Integrated Query) ermöglicht deklarative Datenabfragen auf Collections, Datenbanken, XML und mehr. Es gibt zwei Syntaxvarianten: Query-Syntax und Method-Syntax.

Die wichtigsten LINQ-Operatoren

Operator	Beschreibung	Beispiel
Where	Filtert Elemente	.Where(x => x > 10)
Select	Projiziert Elemente	.Select(x => x * 2)
OrderBy / OrderByDescending	Sortiert Elemente	.OrderBy(x => x.Name)
GroupBy	Gruppiert Elemente	.GroupBy(x => x.Category)
First / FirstOrDefault	Erstes Element	.First(x => x > 5)
Any / All	Prüft Bedingungen	.Any(x => x > 0)
Count / Sum / Average	Aggregationen	.Sum(x => x.Price)
Join	Verknüpft zwei Collections	.Join(orders, ...)

Beispiele

// Query-Syntax

var personen = new List<Person> { /* ... */ };

var result = from p in personen

where p.Age > 18

orderby p.Name

select p.Name;

// Method-Syntax

var result = personen

.Where(p => p.Age > 18)

.OrderBy(p => p.Name)

.Select(p => p.Name);

// GroupBy

var groups = personen.GroupBy(p => p.City);

foreach (var group in groups) {

Console.WriteLine($"Stadt: {group.Key}");

}

// Aggregationen

int sum = zahlen.Sum();

double avg = zahlen.Average();

bool has = zahlen.Any(x => x > 100);

Tipp: LINQ verwendet deferred execution – die Abfrage wird erst bei der Iteration ausgeführt. Verwenden Sie .ToList() oder .ToArray(), um die Abfrage sofort auszuführen.

.NET Framework im Überblick

BCL Basistypen
String, DateTime, Console

Collections Datenstrukturen
List, Dictionary, HashSet

IO Dateisystem
File, Directory, Streams

Reflection Typen zur Laufzeit
Type, Assembly, Activator

GC Speicherverwaltung
IDisposable, using

LINQ Datenabfragen
Where, Select, GroupBy

Quick Summary

System

BCL

List

Collections

File

IO / Dateisystem

Type

Reflection

IDisposable

Garbage Collection

LINQ

LINQ

using System.IO; · var list = new List<int>(); · var result = data.Where(x => x > 0).Select(x => x * 2);