C# Language
Statische Klassen

Statisches Schlüsselwort

Das statische Schlüsselwort bedeutet zwei Dinge:

1. Dieser Wert ändert sich nicht von Objekt zu Objekt, sondern ändert sich für eine Klasse als Ganzes
2. Statische Eigenschaften und Methoden erfordern keine Instanz.

public class Foo
{
    public Foo{
        Counter++;
        NonStaticCounter++;
    }

    public static int Counter { get; set; }
    public int NonStaticCounter { get; set; }
}

public class Program 
{
    static void Main(string[] args)
    {
        //Create an instance
        var foo1 = new Foo();
        Console.WriteLine(foo1.NonStaticCounter); //this will print "1"

        //Notice this next call doesn't access the instance but calls by the class name.
        Console.WriteLine(Foo.Counter); //this will also print "1"

        //Create a second instance
        var foo2 = new Foo();

        Console.WriteLine(foo2.NonStaticCounter); //this will print "1"

        Console.WriteLine(Foo.Counter); //this will now print "2"
        //The static property incremented on both instances and can persist for the whole class

    }
}

Statische Klassen

Das Schlüsselwort "statisch" hat beim Verweisen auf eine Klasse drei Auswirkungen:

1. Sie können keine Instanz einer statischen Klasse erstellen (dadurch wird sogar der Standardkonstruktor entfernt).
2. Alle Eigenschaften und Methoden in der Klasse müssen ebenfalls statisch sein.
3. Eine static Klasse ist eine sealed Klasse, dh sie kann nicht vererbt werden.

public static class Foo
{
    //Notice there is no constructor as this cannot be an instance
    public static int Counter { get; set; }
    public static int GetCount()
    {
        return Counter;
    }
}

public class Program 
{
    static void Main(string[] args)
    {
        Foo.Counter++;
        Console.WriteLine(Foo.GetCount()); //this will print 1
        
        //var foo1 = new Foo(); 
        //this line would break the code as the Foo class does not have a constructor
    }
}

Statische Klassenlebensdauer

Eine static Klasse wird beim Member-Zugriff träge initialisiert und ist für die Dauer der Anwendungsdomäne gültig.

void Main()
{
    Console.WriteLine("Static classes are lazily initialized");
    Console.WriteLine("The static constructor is only invoked when the class is first accessed");
    Foo.SayHi();

    Console.WriteLine("Reflecting on a type won't trigger its static .ctor");
    var barType = typeof(Bar);

    Console.WriteLine("However, you can manually trigger it with System.Runtime.CompilerServices.RuntimeHelpers");
    RuntimeHelpers.RunClassConstructor(barType.TypeHandle);
}

// Define other methods and classes here
public static class Foo
{
    static Foo()
    {
        Console.WriteLine("static Foo.ctor");
    }
    public static void SayHi()
    {
        Console.WriteLine("Foo: Hi");
    }
}
public static class Bar
{
    static Bar()
    {
        Console.WriteLine("static Bar.ctor");
    }
}