Ändern und Umwandeln von Kollektionen

1. Einführung

Mit Kollektionen zu arbeiten bedeutet nicht nur, sie zu durchlaufen, zu filtern oder zu sortieren. Sehr oft musst du Kollektionen verändern oder umgestalten, damit sie zu deinen Anforderungen passen: Zum Beispiel eine Kollektion von Strings in eine Kollektion von Zahlen verwandeln, Duplikate aus einer Liste entfernen oder die Datenstruktur komplett ändern.

All das kannst du mit Standardmethoden der Kollektionen, einfachen Schleifen und Basis-Algorithmen lösen. Das ist zwar etwas länger als mit LINQ, aber dafür komplett durchschaubar und super, um die Prinzipien von Kollektionen zu verstehen.

Die wichtigsten Wege, Kollektionen zu ändern

Kollektionen kann man auf verschiedene Arten ändern, meistens brauchst du einen dieser Ansätze:

• Inhalt modifizieren: Elemente hinzufügen, löschen oder ersetzen.
• Elemente umwandeln: Die Ausgangskollektion nehmen und daraus eine neue machen – mit anderer Struktur, anderem Typ oder Format (zum Beispiel aus List<int> eine List<string> machen).
• Darstellung ändern: Die Kollektion umstrukturieren – zum Beispiel sortieren, umdrehen (reverse) oder gruppieren.

Wir konzentrieren uns auf die ersten beiden Gruppen, weil das Thema Sortieren schon in einer eigenen Vorlesung behandelt wurde.

Veränderbare und unveränderbare Kollektionen: ein wichtiger Punkt

Denk dran: Manche Kollektionen in .NET kannst du beliebig ändern (zum Beispiel List<T>), andere aber nicht (IReadOnlyList<T>, Arrays mit readonly-Modifikatoren usw.).

• Modifikation – du änderst die konkrete Kollektion (zum Beispiel mit Add, Remove, Clear usw.).
• Umwandlung – du lässt das Original in Ruhe und bekommst eine neue Kollektion, meistens indem du eine neue Liste anlegst und sie mit Elementen aus der Ausgangskollektion füllst.

2. Inhalt von Kollektionen modifizieren

Alle Kollektionen, die ICollection<T> implementieren, bieten dir grundlegende Methoden, um den Inhalt zu ändern. Schauen wir uns das am Beispiel eines Buchkatalogs an.

Elemente hinzufügen und löschen

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public int Year { get; set; }
}

List<Book> books = new List<Book>
{
    new Book { Title = "Sauberer Code", Author = "Robert Martin", Year = 2008 },
    new Book { Title = "CLR via C#", Author = "Jeffrey Richter", Year = 2012 }
};

// Neue Buch hinzufügen
books.Add(new Book { Title = "Head First C#", Author = "Andrew Stellman", Year = 2010 });

// Buch nach Bedingung löschen (zum Beispiel nach Autor)
for (int i = books.Count - 1; i >= 0; i--)
{
    if (books[i].Author == "Robert Martin")
        books.RemoveAt(i);
}

// Konkretes Objekt löschen (wenn es in der Liste ist)
Book someBook = books[0];
books.Remove(someBook);

// Ganze Kollektion leeren
books.Clear();

// Element an bestimmter Position einfügen
books.Insert(0, new Book { Title = "Pro C# 9", Author = "Andrew Troelsen", Year = 2021 });

Elemente ersetzen und aktualisieren

Angenommen, jemand hat sich beim Erscheinungsjahr vertan. Wie kann man das korrigieren?

// Das richtige Buch per Schleife finden und das Jahr korrigieren
for (int i = 0; i < books.Count; i++)
{
    if (books[i].Title == "Head First C#")
    {
        books[i].Year = 2018; // Jahr korrigiert
        break;
    }
}

3. Kollektionen umwandeln

Typ der Elemente umwandeln (zum Beispiel von Book zu String)

Alle Buchtitel als Kollektion holen:

List<string> bookTitles = new List<string>();
foreach (Book book in books)
{
    bookTitles.Add(book.Title);
}

foreach (var title in bookTitles)
{
    Console.WriteLine(title);
}

Alle Erscheinungsjahre holen:

List<int> bookYears = new List<int>();
foreach (Book book in books)
{
    bookYears.Add(book.Year);
}

Umwandlung in einen neuen Typ/Struktur:

public class BriefBookInfo
{
    public string Title;
    public int Year;
}

List<BriefBookInfo> briefInfos = new List<BriefBookInfo>();
foreach (Book book in books)
{
    briefInfos.Add(new BriefBookInfo { Title = book.Title, Year = book.Year });
}

foreach (var info in briefInfos)
{
    Console.WriteLine($"{info.Title} ({info.Year})");
}

Kollektion von Kollektionen in eine flache Kollektion umwandeln (flat map)

Wenn ein Buch eine Liste von Tags hat, alle Tags in eine einzige Liste holen:

public class Book
{
    public string Title { get; set; }
    public List<string> Tags { get; set; }
}

List<Book> booksWithTags = new List<Book>
{
    new Book { Title = "Sauberer Code", Tags = new List<string> { "Clean Code", "Refactoring" } },
    new Book { Title = "CLR via C#", Tags = new List<string> { "CLR", "Internals" } }
};

List<string> allTags = new List<string>();
foreach (var book in booksWithTags)
{
    foreach (var tag in book.Tags)
    {
        allTags.Add(tag);
    }
}

foreach (string tag in allTags)
{
    Console.WriteLine(tag);
}

4. Oft genutzte Methoden zum Umwandeln von Kollektionen

ToArray

Um ein Array aus einer Liste zu bekommen:

string[] bookTitlesArray = bookTitles.ToArray();

Distinct – Duplikate loswerden

Einzigartige Autoren (ohne LINQ):

List<string> authors = new List<string>();
foreach (Book book in books)
{
    if (!authors.Contains(book.Author))
        authors.Add(book.Author);
}

Reverse – Kollektion umdrehen

Um die Reihenfolge umzukehren:

books.Reverse(); // ändert die Liste direkt!

Wenn du das Original nicht ändern willst:

var reversed = new List<Book>(books);
reversed.Reverse();

Sortieren (siehe Vorlesung zum Sortieren)

books.Sort((a, b) => a.Year.CompareTo(b.Year)); // nach Jahr sortieren

Gruppieren nach Feld (GroupBy nachbauen)

Bücher nach Autor gruppieren (Dictionary "Autor – Liste von Büchern" bekommen):

Dictionary<string, List<Book>> booksByAuthor = new Dictionary<string, List<Book>>();
foreach (Book book in books)
{
    if (!booksByAuthor.ContainsKey(book.Author))
        booksByAuthor[book.Author] = new List<Book>();
    booksByAuthor[book.Author].Add(book);
}

foreach (var pair in booksByAuthor)
{
    Console.WriteLine($"Autor: {pair.Key}");
    foreach (var b in pair.Value)
        Console.WriteLine($"  {b.Title}");
}

5. Nützliche Tipps

• Umwandlungen mit Schleifen funktionieren immer und überall.
• Um Duplikate zu vermeiden, nutze temporäre Kollektionen und die Methoden Contains/Add.
• Verändere eine Kollektion nicht während du sie mit foreach durchläufst! Wenn du viele Elemente löschen willst, sammel sie erst in einer separaten Liste.

6. Typische Aufgaben

Liste der Bücher aus einem bestimmten Jahr holen

List<Book> recentBooks = new List<Book>();
foreach (Book book in books)
{
    if (book.Year > 2010)
        recentBooks.Add(book);
}
foreach (var book in recentBooks)
{
    Console.WriteLine($"{book.Title} ({book.Year})");
}

Alle einzigartigen Erscheinungsjahre aufsteigend ausgeben

List<int> years = new List<int>();
foreach (Book book in books)
{
    if (!years.Contains(book.Year))
        years.Add(book.Year);
}
years.Sort();

foreach (int year in years)
    Console.WriteLine(year);

Bücher für den Export vorbereiten (DTO-Liste erstellen)

public class BookExport
{
    public string Name;
    public string Writer;
    public int PublishedYear;
}

List<BookExport> booksForExport = new List<BookExport>();
foreach (Book book in books)
{
    booksForExport.Add(new BookExport
    {
        Name = book.Title,
        Writer = book.Author,
        PublishedYear = book.Year
    });
}

7. Typische Fehler und Stolperfallen

Methoden wie Add, Remove, Clear, Insert und Sort ändern die Kollektion direkt.

Wenn du eine neue Kollektion brauchst – leg eine neue Liste an und füge dort die gewünschten Elemente hinzu.

Beim Löschen von Elementen während des Durchlaufens der Kollektion nutze eine Schleife von hinten (for (int i = Count-1; i >= 0; i--)).

Wenn du eine Liste mit einzigartigen Elementen willst, achte auf Wiederholungen: Nutze Contains oder HashSet<T>.