C# Academy · Lektion

Statisk kontra instansbaseret design

Vurdér, hvornår statisk tilstand er passende.

Lektion 4 af 413 trin

Statisk kontra instansbaseret design er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 4 lektioner i alt.

Et designvalg

At vælge mellem static og instans er et designvalg. Det afgørende spørgsmål er: Afhænger adfærden af tilstand pr. objekt eller kun af dens inddata?

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));
    }
}

Brug static til tilstandsløs logik

Hvis en metode ikke har brug for instansfelter og blot omdanner inddata, skal du gøre den static. Matematiske hjælpemetoder og formattere er gode eksempler.

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");
    }
}

Brug instanser til tilstand

Hvis adfærden afhænger af data, der varierer fra objekt til objekt, skal du bruge en instans. Hvert objekt har sin egen tilstand.

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);
    }
}

Delt tilstand er global tilstand

Et statisk felt er reelt globalt. Det kan forårsage vanskelige fejl, når mange dele af et program læser og skriver i det. Foretræk instanstilstand, når hver bruger har brug for sin egen kopi.

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);
    }
}

Testbarhed

Rene statiske metoder er nemme at teste: samme inddata, samme uddata. Foranderlig statisk tilstand siver derimod mellem testene og gør dem skrøbelige.

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");
    }
}

Statisk til fabrikhjælpemetoder

Statiske fabrikmetoder er en ren måde at oprette konfigurerede instanser med et beskrivende navn på.

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);
    }
}

Undgå static bare for at slippe for new

Gør ikke alting statisk bare for at undgå at oprette objekter. Hvis en type modellerer en ting med tilstand, holder instanser denne tilstand isoleret og sikker.

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);
    }
}

Bland dem på passende vis

Mange klasser bruger statiske medlemmer til delte konstanter eller tællere og instansmedlemmer til data pr. objekt. Den blanding er helt idiomatisk.

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);
    }
}

Samtidighedsproblem

Delt statisk tilstand kan tilgås af flere tråde på samme tid, hvilket medfører risiko for kapløbsbetingelser. Instanstilstand, der er begrænset til én tråd, er som standard sikrere.

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));
    }
}

En enkel tommelfingerregel

Statisk = adfærd, der hører til typen og ikke bruger tilstand pr. objekt. Instans = adfærd, der læser eller ændrer et bestemt objekt. Foretræk en instans til alt, der har tilstand, når du er i tvivl.

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));
    }
}

Sæt det hele sammen

Godt design adskiller tilstandsløse hjælpemetoder (statiske) fra tilstandsfulde modeller (instanser) og holder delt, foranderlig tilstand på et bevidst 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));
    }
}

Hurtigt tjek

Test din forståelse af statisk kontra instansbaseret design.

Besvar den i den interaktive lektion

Opsamling

Vælg statisk til tilstandsløs logik, der kun afhænger af inddata (hjælpemetoder, fabrikker, konstanter), og instans til adfærd, der er knyttet til tilstand pr. objekt. Foranderlig statisk tilstand er reelt global, sværere at teste og medfører risiko for samtidighedsfejl, så hold den på et bevidst minimum.

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());
    }
}

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Statisk kontra instansbaseret design” gratis?

Ja — hele teksten til “Statisk kontra instansbaseret design” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Statisk kontra instansbaseret design”?

Vurdér, hvornår statisk tilstand er passende. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Statisk kontra instansbaseret design”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til C# Academy