0Pricing
C# Academy · Lektion

Statisches versus Instanzdesign

Entscheiden Sie, wann ein statischer Zustand angemessen ist.

Statisches versus Instanzdesign ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Eine Designentscheidung

Die Wahl zwischen static und Instanz ist eine Designentscheidung. Die entscheidende Frage lautet: Hängt das Verhalten vom Zustand des jeweiligen Objekts ab oder nur von seinen Eingaben?

using System;

class Program
{
    // Depends only on inputs -> good static method
    static int Max(int a, int b) => a > b ? a : b;

    static void Main()
    {
        Console.WriteLine(Max(3, 8));
    }
}

Static für zustandslose Logik verwenden

Wenn eine Methode keine Instanzfelder benötigt und lediglich Eingaben transformiert, machen Sie sie zu static. Mathematische Hilfsmethoden und Formatierer sind typische Beispiele.

using System;

static class Convert2
{
    public static double MilesToKm(double miles) => miles * 1.60934;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Convert2.MilesToKm(10).ToString("0.0") + " km");
    }
}

Instanzen für Zustände verwenden

Wenn das Verhalten von Daten abhängt, die je nach Objekt variieren, verwenden Sie eine Instanz. Jedes Objekt trägt seinen eigenen Zustand.

using System;

class Counter
{
    private int _count;
    public void Increment() => _count++;
    public int Value => _count;
}

class Program
{
    static void Main()
    {
        var a = new Counter();
        var b = new Counter();
        a.Increment();
        a.Increment();
        b.Increment();
        Console.WriteLine("a=" + a.Value + ", b=" + b.Value);
    }
}

Gemeinsamer Zustand ist globaler Zustand

Ein statisches Feld ist im Grunde global. Es kann subtile Fehler verursachen, wenn viele Teile eines Programms es lesen und schreiben. Bevorzugen Sie Instanzzustand, wenn jeder Benutzer eine eigene Kopie benötigt.

using System;

class BadCart
{
    public static int Items;   // shared by EVERYONE -> usually wrong for a cart
}

class Program
{
    static void Main()
    {
        BadCart.Items++;
        BadCart.Items++;
        Console.WriteLine("All carts share: " + BadCart.Items);
    }
}

Testbarkeit

Reine statische Methoden lassen sich leicht testen: gleiche Eingabe, gleiche Ausgabe. Veränderlicher statischer Zustand wird dagegen zwischen Tests weitergegeben und macht sie anfällig.

using System;

static class Calc
{
    public static int Add(int a, int b) => a + b;   // trivially testable
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Calc.Add(2, 2) == 4 ? "pass" : "fail");
    }
}

Static für Factory-Hilfsmethoden

Statische Factory-Methoden bieten eine klare Möglichkeit, konfigurierte Instanzen mit einem aussagekräftigen Namen zu erstellen.

using System;

class Color
{
    public int R, G, B;
    private Color(int r, int g, int b) { R = r; G = g; B = b; }

    public static Color Red() => new Color(255, 0, 0);
    public static Color White() => new Color(255, 255, 255);
}

class Program
{
    static void Main()
    {
        var c = Color.Red();
        Console.WriteLine(c.R + "," + c.G + "," + c.B);
    }
}

Static nicht nur verwenden, um new zu vermeiden

Machen Sie nicht alles static, nur um das Erstellen von Objekten zu vermeiden. Wenn ein Typ ein Objekt mit Zustand modelliert, halten Instanzen diesen Zustand getrennt und sicher.

using System;

class Player
{
    public string Name;
    public int Health = 100;
    public void TakeDamage(int d) => Health -= d;
}

class Program
{
    static void Main()
    {
        var p1 = new Player { Name = "A" };
        var p2 = new Player { Name = "B" };
        p1.TakeDamage(30);
        Console.WriteLine(p1.Name + ": " + p1.Health + ", " + p2.Name + ": " + p2.Health);
    }
}

Beides sinnvoll kombinieren

Viele Klassen verwenden statische Member für gemeinsame Konstanten oder Zähler und Instanzmember für objektspezifische Daten. Diese Kombination ist völlig idiomatisch.

using System;

class Invoice
{
    private static int _seq = 1000;
    public readonly int Number;
    public decimal Amount;

    public Invoice(decimal amount)
    {
        Number = _seq++;
        Amount = amount;
    }
}

class Program
{
    static void Main()
    {
        var i1 = new Invoice(50m);
        var i2 = new Invoice(75m);
        Console.WriteLine(i1.Number + " / " + i2.Number);
    }
}

Problem bei Nebenläufigkeit

Auf gemeinsamen statischen Zustand können mehrere Threads gleichzeitig zugreifen, wodurch Race-Conditions drohen. Auf einen Thread beschränkter Instanzzustand ist standardmäßig sicherer.

using System;

class SafeCalc
{
    // No shared mutable state -> naturally thread-safe
    public static long Factorial(int n)
    {
        long result = 1;
        for (int i = 2; i <= n; i++) result *= i;
        return result;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(SafeCalc.Factorial(5));
    }
}

Eine einfache Faustregel

Static = Verhalten, das zum Typ gehört und keinen objektspezifischen Zustand verwendet. Instanz = Verhalten, das ein bestimmtes Objekt liest oder verändert. Im Zweifel sollten Sie für alles Zustandsbehaftete eine Instanz bevorzugen.

using System;

class Temperature
{
    public double Celsius;                                  // instance state
    public static double ToF(double c) => c * 9 / 5 + 32;   // stateless helper
}

class Program
{
    static void Main()
    {
        var t = new Temperature { Celsius = 30 };
        Console.WriteLine(Temperature.ToF(t.Celsius));
    }
}

Alles zusammenführen

Gutes Design trennt zustandslose Hilfsmethoden (static) von zustandsbehafteten Modellen (Instanz) und beschränkt gemeinsamen veränderlichen Zustand bewusst auf ein Minimum.

using System;

static class TaxRules
{
    public static decimal Apply(decimal amount, decimal rate) => amount + amount * rate;
}

class Sale
{
    public decimal Subtotal;
    public decimal Total(decimal rate) => TaxRules.Apply(Subtotal, rate);
}

class Program
{
    static void Main()
    {
        var s = new Sale { Subtotal = 100m };
        Console.WriteLine(s.Total(0.2m));
    }
}

Kurze Überprüfung

Testen Sie Ihr Verständnis des Designs mit static und Instanzen.

Zusammenfassung

Verwenden Sie static für zustandslose Logik, die nur von Eingaben abhängt (Hilfsmethoden, Factory-Methoden, Konstanten), und Instanzen für Verhalten, das an den Zustand einzelner Objekte gebunden ist. Veränderlicher statischer Zustand ist im Grunde global, schwerer zu testen und birgt das Risiko von Nebenläufigkeitsfehlern. Halten Sie ihn daher minimal und setzen Sie ihn bewusst ein.

using System;

static class Util { public static int Sq(int n) => n * n; }

class Box { public int Size; public int Area() => Util.Sq(Size); }

class Program
{
    static void Main()
    {
        var box = new Box { Size = 4 };
        Console.WriteLine(box.Area());
    }
}

Häufig gestellte Fragen

Ist die Lektion „Statisches versus Instanzdesign“ kostenlos?

Ja — der vollständige Text von „Statisches versus Instanzdesign“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Statisches versus Instanzdesign“?

Entscheiden Sie, wann ein statischer Zustand angemessen ist. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Statisches versus Instanzdesign“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Statische Methoden und Felder
  2. Statische Klassen für Hilfsfunktionen
  3. Konstanten und readonly-Felder
  4. Statisches versus Instanzdesign
← Zurück zu C# Academy