Kursinhalt

C# Über die Grundlagen Hinaus

1. Zusätzliche Strukturen & Dateiverarbeitung

Was Sind Listen?Übung zur Listendeklaration Listenmethoden Was Sind Wörterbücher?Üben von Wörterbüchern Dateien Mit StreamReader Lesen Dateien Lesen mit Dateimethoden Dateien Schreiben Fehlerbehandlung Fehlerbehandlung Üben

2. Strukturen & Enumeratoren

Was Sind Strukturen?Definieren und Verwenden Einer Structure Üben von Strukturen Strukturen mit Anderen Datenstrukturen Strukturmethoden Felder in Strukturmethoden Korrekt Zugreifen Methoden Üben Strukturkonstruktoren Konstruktoren Üben Enumeratoren Enumerator Üben

3. Einführung in die Objektorientierte Programmierung (OOP)

Was Ist Objektorientierte Programmierung?Klassen Definieren Praxis: Klassen Erstellen Klassenobjekte Klassenobjekte vs Struct-Objekte Praxis: Objects Klassenmethoden Praxis: Methoden Klassenkonstruktoren Praxis: Constructors

4. OOP Essentials

Abgeleitete Klassen Abgeleitete Klassen Üben Allgemeine Zugriffsmodifikatoren Zugriffsmodifikatoren Üben Das `static` Schlüsselwort Übung des `Static` Schlüsselworts Methodenüberladung Methodenüberladung Üben

5. OOP-Prinzipien

Was Sind die Prinzipien der OOP?Vererbung Vererbung Üben Polymorphismus Polymorphismus Üben Kapselung Kapselungsübung Abstraktion Abstraktionsübung Was Kommt als Nächstes?

Was Sind Listen?

Stellen Sie sich vor, wir haben eine Situation, in der wir die Namen aller Studenten speichern möchten, die einen bestimmten Kurs belegen. Die erste Lösung, die uns einfällt, ist die Erstellung eines Arrays:

index


              123456
            
using System;

class Program
{
    string[] studentNames = new string[50];
}

Wenn es jedoch irgendwann mehr als 50 Studenten gibt, können wir ihre Namen nicht speichern. In einer Situation, in der es weniger als 50 Studenten gibt, sind die ungenutzten Plätze im Array eine Verschwendung von Speicher - dies wird besonders bei großen Arrays zu einem Problem.

Hier benötigen wir eine neue Struktur, die eine variable Anzahl von Elementen speichern kann. Glücklicherweise existiert eine solche Struktur bereits, sie wird als Liste bezeichnet.

Listen sind Arrays sehr ähnlich, jedoch ist die Anzahl der Elemente, die in einer Liste gespeichert werden, veränderbar.

Folgendes ist die Syntax zur Deklaration einer leeren Liste:

Mit dieser Syntax können wir eine Liste erstellen, um die Namen der Studenten zu speichern:

index


              12345678910
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
    	List<string> students = new List<string>();
  	}
}

Es ist wichtig zu beachten, dass wir das Generic-Modul importieren müssen, um Listen verwenden zu können.

Sie müssen einfach diese Zeile unter using System; hinzufügen, um das erforderliche Modul zu importieren.

Add()-Methode

Wir können Elemente zu einer Liste hinzufügen, indem wir die Add-Methode verwenden:

index


              123456789101112131415
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string>();

        students.Add("Anna");
        students.Add("Laura");
        students.Add("Jacob");
        students.Add("Aron");
    }
}

Der obige Code wird vier Elemente zur students-Liste hinzufügen.

Genau wie ein Array vom Typ string nur string-Elemente enthalten kann, kann eine Liste vom Typ string nur string-Elemente akzeptieren.

Indexierung

Das erste Element ist Anna, daher hat es den Index 0, während Laura den Index 1 hat und so weiter. Elemente einer Liste können über Indexierung wie ein Array zugegriffen werden:

index


              1234567891011121314151617
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string>();

        students.Add("Anna");
        students.Add("Laura");
        students.Add("Jacob");
        students.Add("Aron");

        Console.WriteLine(students[2]);
    }
}

Count() Methode

Wir können die Länge einer Liste mit ihrem Count Attribut abrufen:

index


              123456789101112131415161718
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string>();

        students.Add("Anna");
        students.Add("Laura");
        students.Add("Jacob");
        students.Add("Aron");

        Console.WriteLine(students[2]);
        Console.WriteLine(students.Count);
    }
}

Dynamische Länge

Beachten Sie, dass die Länge einer Liste dynamisch (veränderbar) ist, sodass sie sich ändert, wenn wir Elemente hinzufügen:

index


              1234567891011121314151617181920
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string>();

        Console.WriteLine(students.Count);
        students.Add("Anna");
        Console.WriteLine(students.Count);
        students.Add("Laura");
        Console.WriteLine(students.Count);
        students.Add("Jacob");
        Console.WriteLine(students.Count);
        students.Add("Aron");
        Console.WriteLine(students.Count);
    }
}

Initialisierung

Wir können eine Liste auch mit einigen Elementen initialisieren, indem wir die folgende Syntax verwenden:

Zum Beispiel:

index


              12345678910111213141516
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string> { "Anna", "Laura", "Jacob", "Aron" };

        // It is still possible to add additional elements after initialization
        students.Add("Markus"); 

        Console.WriteLine(students.Count);
        Console.WriteLine(students[4]);
    }
}

Durch Listen Schleifen

Durch eine Liste zu schleifen ist ähnlich wie durch Arrays zu schleifen

- Verwenden einer for-Schleife:

index


              123456789101112131415
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string> { "Anna", "Laura", "Jacob", "Aron" };

        for (int i = 0; i < students.Count; i++)
        {
            Console.WriteLine(students[i]);
        }
    }
}

- Verwendung einer foreach-Schleife

index


              123456789101112131415
            
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> students = new List<string> { "Anna", "Laura", "Jacob", "Aron" };

        foreach (string studentName in students)
        {
            Console.WriteLine(studentName);
        }
    }
}

Tipp:

Um die Deklarationssyntax zu verkürzen, können wir auch die implizite Deklaration verwenden. Zur Erinnerung: Eine explizite Deklaration liegt vor, wenn wir den Datentyp bei der Variablendeklaration angeben, zum Beispiel:

index


              1
            
float number = 7.9f;

Andererseits können wir bei der impliziten Deklaration einfach das var Schlüsselwort verwenden und der Compiler leitet den Datentyp der Variablen automatisch anhand des zugewiesenen Wertes ab:

index


              1
            
var number = 7.9f;

Wir können auch eine implizite Deklaration verwenden, wenn wir Listen deklarieren:

Zum Beispiel:

index


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

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 1

C# Über die Grundlagen Hinaus

Was Sind Listen?

Add()-Methode

Indexierung

Count() Methode

Dynamische Länge

Initialisierung

Durch Listen Schleifen

- Verwenden einer for-Schleife:

- Verwendung einer foreach-Schleife

1. Was wird die Ausgabe des folgenden Codes sein:

2. Welches Modul muss importiert werden, um Listen zu verwenden?

3. Welche Methode wird verwendet, um die Größe (Länge) einer Liste abzurufen?