📖 Variablers benämningar i C#

När vi pratar om variabler i C-Sharp menar vi egentligen flera olika saker. En variabel kan leva i olika delar av koden och bete sig på olika sätt beroende på om den är lokal, ett fält i en klass, en konstant eller en property.

Och som om det inte vore nog: Microsoft vill att du namnger dem olika beroende på var de finns.

📋 Översiktstabell

🔍 Några viktiga skillnader

• const → måste tilldelas direkt, värdet bränns in vid kompilering.
• readonly → kan sättas i konstruktorn men aldrig ändras efter objektets skapelse.
• static → delas av alla objekt i klassen, oavsett instanser.
• property → ser ut som en variabel men är egentligen en metod (getter/setter) med PascalCase.
• fält → “rå” variabel i en klass. Privata fält ska inte visas utåt, de göms ofta bakom en property.

🧩 Exempel i kod

public class Customer
{
    // Konstant (oföränderlig, PascalCase enligt MS)
    public const int MaxOrders = 100;

    // KONSTANT (historiskt, UPPER_CASE)
    public const int MAX_ORDERS = 100;

    // Readonly (kan sättas i konstruktor)
    public readonly DateTime CreatedAt;

    // Privat fält (camelCase eller _camelCase)
    private string _name;

    // Publik property (PascalCase), lagrar värdet i ett privat fält
    public string Name { get {return _name;} set {_name = value}; }

    // Klassvariabel (static property, PascalCase), lagrar värdet i sig själv (typ)
    public static int ActiveCustomers { get; set; } // Delas av alla instanser

    // Konstruktor
    public Customer(string name)
    {
        _name = name;
        CreatedAt = DateTime.Now;
    }
}

Exakt 👌 – det är där många studerande tappar tråden: de lär sig const, readonly och static men missar varför vi använder dem. Skillnaden mellan mutable/immutable och scope är egentligen grunden till att man ens behöver alla dessa nyckelord.

🧠 Viktiga begrepp: Mutable, Immutable och Scope

🔄 Mutable vs Immutable

• Mutable (föränderlig) → variabeln kan ändras under programmets gång. Exempel:

  int counter = 0;
  counter = counter + 1; // ändras, alltså mutable
  

• Immutable (oföränderlig) → när värdet väl är satt går det inte att ändra. Exempel:

  const int MaxUsers = 100; // konstant → kan aldrig ändras
  string text = "Hej";
  text.ToUpper(); // skapar en NY sträng, den gamla ändras inte
  

💡 Minnesregel: Mutable = “levande lera”, Immutable = “stenstaty”.

📦 Scope (var variabeln lever och syns)

Scope handlar om livslängd och synlighet för en variabel. Det är lite som “vem har nyckeln till rummet där variabeln bor”.

• Lokalt scope → bara tillgänglig i en metod eller ett block.

  void PrintName()
  {
      string name = "Anna"; // finns bara här
      Console.WriteLine(name);
  }
  

• Klass-scope (fält) → tillhör objektet (instansen).

  class Customer
  {
      private string name; // fält = lever så länge objektet lever
  }
  

• Static scope (klassvariabel) → delas av alla objekt.

  class Customer
  {
      public static int ActiveUsers; // samma för alla kunder
  }
  

• Global scope → i C-Sharp finns det inte riktigt (till skillnad från JavaScript), men Program.cs kan ha variabler på toppnivå i moderna versioner.

💡 Minnesregel: Scope = “hur långt variabeln orkar springa innan den dör”.

🚦 Hur hänger detta ihop med const, readonly, static?

• const → Immutable + klass-scope (delas av alla).
• readonly → Immutable efter initiering + instans-scope (eller klass-scope om static).
• static → Scope på klassnivå, men kan vara både mutable eller immutable beroende på nyckelord.

📝 Fusklapp: const vs readonly vs static

🎯 Sammanfattning

• camelCase → lokala variabler, parametrar, privata fält.
• PascalCase → publika properties, metoder, klasser, konstanter, statics.
• UPPER_CASE → historiskt för konstanter, inte rekommenderat i modern C-Sharp.
• readonly vs const → readonly är lite flexiblare (kan initieras i konstruktorn).
• property → ska alltid användas istället för publika fält.

🎯 Kom-ihåg-regler

• const → stenhugget i koden (kompilatorn ersätter värdet).
• readonly → fryst efter konstruktion (bra för tidsstämplar, IDs).
• static → alla delar samma variabel (klassnivå istället för objekt).
• static readonly → ofta bäst för konstanter som inte är primitiva tal, t.ex. DateTime, Guid.