Wird geladen...

Leitfäden
C#
Ueber
Kontakt
Thema
Hell Dunkel
Rot Grün Blau Violett Orange
DE
EN ES FR TR

Klassen, Objekte, Eigenschaften und Methoden in C#

Erlernen Sie die Grundlagen von Klassen, Objekten, Eigenschaften und Methoden in C# für objektorientierte Programmierung.

Im objektorientierten Programmieren (OOP) ist eine Klasse eine Vorlage, die die Daten (Properties) und das Verhalten (Methoden) eines bestimmten Konzepts zusammenfasst. Aus dieser Vorlage erstellte Instanzen nennt man Objekte. Properties dienen dem Datenzugriff, Methoden definieren das Verhalten.

Was ist eine Klasse?

Eine Klasse ist eine Vorlage, die verwendet wird, um ein Konzept oder eine Entität in der Software zu modellieren. Sie definiert Eigenschaften (Properties), Felder (Fields) und Methoden. Zum Beispiel kann eine Product-Klasse Daten wie Name und Preis speichern und zusätzlich Funktionen wie „Information ausgeben“ bereitstellen. 


public class Product
{
    private decimal _price;

    public string Name { get; set; } = string.Empty;

    public decimal Price
    {
        get => _price;
        set => _price = value < 0 ? 0 : value; // negativer Preis verhindert
    }

    public void PrintInfo()
    {
        Console.WriteLine($"{Name} - {Price:0.00} EUR");
    }
}

Objekt erstellen

Um eine konkrete Instanz (Objekt) aus einer Klasse zu erstellen, wird das Schlüsselwort new verwendet. Dabei wird im Speicher ein Objekt entsprechend der Klassendefinition erzeugt. Properties können gesetzt und Methoden aufgerufen werden. 


var notebook = new Product();
notebook.Name = "Notebook";
notebook.Price = 45m;
notebook.PrintInfo();

// Ausgabe:
Notebook - 45.00 EUR

Objekte können auch mit einem Object Initializer kürzer erstellt werden: 


var pen = new Product { Name = "Pen", Price = 12.5m };
pen.PrintInfo();

Arten von Properties

Properties ermöglichen den kontrollierten Zugriff auf Daten innerhalb einer Klasse. Anstatt Felder direkt freizugeben, erlauben Properties das Hinzufügen von Validierungen und Geschäftslogik.

Auto-Properties: Die praktischste Wahl, wenn keine zusätzliche Logik erforderlich ist.


public class Customer
{
    public int Id { get; set; }
    public string FullName { get; set; } = string.Empty;
}

Property mit Backing Field: Zugriff über ein privates Feld gesteuert.


public class Temperature
{
    private double _celsius;

    public double Celsius
    {
        get => _celsius;
        set => _celsius = value;
    }

    public double Fahrenheit => (_celsius * 9 / 5) + 32; // nur lesbar
}

Init-only Property (C# 9+): Kann nur bei der Objekterstellung gesetzt werden, nicht danach.


public class User
{
    public string Username { get; init; } = string.Empty;
    public string Email { get; init; } = string.Empty;
}

var u = new User { Username = "john", Email = "j@example.com" };
// u.Username = "michael"; // Fehler: init-only Property

Methoden

Methoden definieren die Aktionen, die ein Objekt ausführen kann. Sie können Parameter entgegennehmen und Werte zurückgeben. Mehrere Methoden mit demselben Namen, aber unterschiedlichen Signaturen sind möglich (Überladung). 


public class MathUtil
{
    public static int Sum(int a, int b) => a + b;
    public static int Sum(int a, int b, int c) => a + b + c; // Überladung
}

int x = MathUtil.Sum(2, 3);     // 5
int y = MathUtil.Sum(1, 2, 3);  // 6

Instanzmethoden werden über ein Objekt aufgerufen, statische Methoden direkt über die Klasse.

Zugriffsmodifikatoren

In C# wird die Sichtbarkeit von Klassen und deren Mitgliedern mit Zugriffsmodifikatoren wie public, private, protected und internal gesteuert:

Zugriffsmodifikatoren bestimmen, von welchen Teilen des Programms eine Klasse oder deren Mitglieder (Properties, Methoden, Felder) erreichbar sind. private-Mitglieder sind nur innerhalb der Klasse sichtbar, wodurch externe Eingriffe verhindert und Datensicherheit gewährleistet wird. public-Mitglieder sind überall zugänglich und stellen die öffentliche Schnittstelle der Klasse dar. protected-Mitglieder sind in der Klasse selbst und in abgeleiteten Klassen verfügbar, was Flexibilität bei Vererbungsszenarien ermöglicht. internal-Mitglieder sind nur innerhalb derselben Assembly sichtbar, nicht aber in anderen Projekten. So wird festgelegt, „welche Informationen nach außen freigegeben werden und welche gekapselt bleiben sollen“, wodurch Abhängigkeiten reduziert, Kapselung (Encapsulation) umgesetzt und eine sichere, wartbare Architektur geschaffen wird. 


public class Account
{
    private decimal _balance; // nur innerhalb der Klasse sichtbar

    public decimal Balance { get; private set; } // von außen nur lesbar

    protected string Owner { get; set; } = string.Empty; // in abgeleiteten Klassen nutzbar

    internal string? Tag { get; set; } // innerhalb desselben Projekts nutzbar

    public void Deposit(decimal amount)
    {
        if (amount <= 0) return;
        Balance += amount;
    }
}

Beispiel: Einfaches Bibliothekssystem

Im folgenden Beispiel werden eine Book-Klasse und eine verwaltende LibraryService-Klasse definiert. Dies zeigt, wie Objekte erstellt, gespeichert und verarbeitet werden. 


public class Book
{
    public int Id { get; init; }
    public string Title { get; set; } = string.Empty;
    public string Author { get; set; } = string.Empty;

    public void Print() => Console.WriteLine($"{Id} - {Title} ({Author})");
}

public class LibraryService
{
    private readonly List<Book> _books = new();

    public void Add(Book b) => _books.Add(b);

    public Book? FindById(int id) => _books.FirstOrDefault(b => b.Id == id);

    public void PrintAll()
    {
        if (_books.Count == 0)
        {
            Console.WriteLine("Die Bibliothek ist leer.");
            return;
        }
        foreach (var b in _books) b.Print();
    }
}

// Verwendung
var lib = new LibraryService();
lib.Add(new Book { Id = 1, Title = "Clean Code", Author = "Robert C. Martin" });
lib.Add(new Book { Id = 2, Title = "CLR via C#", Author = "Jeffrey Richter" });
lib.PrintAll();

Kurz & Knapp

  • Klasse: Vorlage, die Daten + Verhalten definiert.
  • Objekt: Konkrete Instanz einer Klasse.
  • Property: Kontrollierter Zugriff auf Daten (Encapsulation).
  • Methode: Definiert, was ein Objekt tun kann (Instanz oder statisch).
  • Zugriffsmodifikatoren: Steuern Sichtbarkeit mit public, private, protected, internal.

Beispiel: Firmendaten und Validierung

In diesem Beispiel speichert die Company-Klasse nicht nur Benutzereingaben, sondern validiert sie auch mit einer Validate()-Methode. Das Ergebnis wird als ValidationResult-Enum zurückgegeben. So kann der Grund für einen Fehler klar identifiziert werden. 


public enum ValidationResult
{
    Success,
    NameMissing,
    PhoneMissing,
    PhoneInvalid,
    AddressMissing
}

public class Company
{
    public string Name { get; set; } = string.Empty;
    public string Phone { get; set; } = string.Empty;
    public string Address { get; set; } = string.Empty;
    public string Sector { get; set; } = string.Empty;

    public void PrintInfo()
    {
        Console.WriteLine("=== Firmendaten ===");
        Console.WriteLine($"Name    : {Name}");
        Console.WriteLine($"Telefon : {Phone}");
        Console.WriteLine($"Adresse : {Address}");
        Console.WriteLine($"Branche : {Sector}");
    }

    public ValidationResult Validate()
    {
        if (string.IsNullOrWhiteSpace(Name))
            return ValidationResult.NameMissing;

        if (string.IsNullOrWhiteSpace(Phone))
            return ValidationResult.PhoneMissing;

        if (!Phone.All(char.IsDigit))
            return ValidationResult.PhoneInvalid;

        if (string.IsNullOrWhiteSpace(Address))
            return ValidationResult.AddressMissing;

        return ValidationResult.Success;
    }
}

class Program
{
    static void Main()
    {
        var company = new Company();

        Console.Write("Firmennamen eingeben: ");
        company.Name = Console.ReadLine();

        Console.Write("Telefonnummer eingeben: ");
        company.Phone = Console.ReadLine();

        Console.Write("Adresse eingeben: ");
        company.Address = Console.ReadLine();

        Console.Write("Branche eingeben: ");
        company.Sector = Console.ReadLine();

        var result = company.Validate();

        if (result == ValidationResult.Success)
        {
            Console.WriteLine();
            company.PrintInfo();
        }
        else
        {
            Console.WriteLine($"Fehler: {result}");
        }
    }
}

Die Validate()-Methode prüft die Gültigkeit der Eingaben und gibt das Ergebnis als Enum zurück. Statt nur true/false zu liefern, wird der konkrete Fehler angegeben. Beispielsweise, wenn der Firmenname fehlt, die Telefonnummer nicht angegeben ist oder nicht nur aus Ziffern besteht. Dies macht die Fehlerbehandlung verständlicher und leichter wartbar.