Simple variabler

Alle moderne programmeringssprog giver mulighed for at opbevare midlertidige værdier i hukommelsen, mens en applikation afvikles, og typisk kan man få adgang til disse værdier gennem selvvalgte navne. Det kaldes variabler og dækker i virkeligheden over en ret kompleks funktionalitet – herunder hvor og hvordan værdier skal placeres i hukommelsen, sammenhæng mellem variabelnavne og adresser i hukommelsen, hvilken kode har adgang til hvilke variabler, hvordan og hvornår skal der ryddes op, optimering og meget andet.

Men heldigvis skal du i C# ikke bekymre dig om særlig meget i relation til variabler – i hvert fald ikke i den grundlæggende C#. Det klarer kompiler og runtime for dig.

Hukommelse

Når en C# applikation startes, vil den blive tildelt plads i hukommelsen af runtime og efterfølgende af operativsystemet:

Der vil både blive afsat (allokeret med et fint ord) plads til de binære instruktioner og de midlertidige data. I C# vil du primært befinde dig i data-delen, men som du skal se senere, kan du også skabe referencer til metoder (brug af Delegate-typen), som er placeret i program-delen.

I modsætning til nogle andre programmeringssprog vil du i C# typisk ikke have nogen adgang til hukommelsen, medmindre det sker gennem variabler. I andre sprog kan du tilgå hukommelsen gennem pointere (pegepinde), men det er i grundlæggende C# ikke en mulighed.

C# er jo som tidligere nævnt typestærk og det betyder, at alle variabler skal oprettes (erklæres) af en konkret type. Det sker blandt andet for at runtime ved, hvor meget plads, der skal allokeres, og for at det er nemmere at optimere.

Så når du skriver kode, der anmoder om en variabel, der kan opbevare et heltal, skal du tage stilling til, hvilken type du vil benytte. Den mest benyttede heltalstype i C# er en Int32 (int) og den fylder 32 bit.

Udover typen skal du også tage stilling til det navn, du gerne vil benytte som tilgang til værdien.

Så når du skriver kode som:

int a = 0;

Hvis du skriver kode som:

bool a = false;
double b = 200.23;
DateTime c = new DateTime(2019, 9, 21);

anmoder du runtime om at allokere 8 bit til a (sand/falsk) samt tildele værdien false, allokere 64 bit til b (kommatal) samt tildele værdien 200,23 og allokere 64 bit til c (dato og tid) samt tildele værdien 21/9-2019.

Variabelnavne

Du kan navngive dine variabler, som du har lyst – med nogle få undtagelser:

• Navnet skal begynde med et bogstav eller en underscore (_)
• Navnet må ikke kun bestå af underscores
• Navnet må kun bestå af bogstaver, tal eller underscores
• Man må gerne benytte Æ, Ø, Å og andre tegn.

De fleste udviklere benytter en navngivningsstandard, så der er en eller anden form for fælles standard, men det er helt op til dig. Jeg vil dog anbefale dig at bruge Microsofts navngivningsstandard , som kan forkortes ned til, at variabler i metoder starter med et lille bogstav, og benytter CamelCasing (hvert ord i en variabel skrives med stort bortset fra det første).

Her er et par eksempler:

a
antal
månederPrÅr
gennemsnitLøn
gadeOgBy

int 名 = 1;
Console.WriteLine(名);

Men kompileren er altså ligeglad.

Virkefelter

C# er et rigtigt semikolon- og tuborgklammesprog, og tuborgklammerne bruges til at definere en blok kode. Det kaldes også et virkefelt (på engelsk scope).

Når du erklærer variabler i en metode, kan du antage, at de lever og kan tilgås i denne metode – samt eventuelle indre virkefelter (andre tuborgklammer). Kompileren skal nok sørge for at blokere adgang andre steder fra.

Derfor er det vigtigt, at du har styr på tuborgklammerne. De definerer et område i koden, hvor variabler lever.

Se følgende kode:

bool a = true;
if (a == true)
{
    // Et virkefelt       
}

for (int i = 0; i < 10; i++)
{
    // Et virkefelt
}

{
    // Et virkefelt
}

void Test()
{
    // Et virkefelt
    { 
        // Et indre virkefelt
    }
}

int a = 1;
// her kan a tilgås
{
    int b = 2;
    // her kan a og b tilgås
    {
        int c = 3;
        // her kan a, b og c tilgås
    }
    // her kan a og b tilgås
}
// her kan a tilgås

Det står dig jo frit for at benytte tabuleringer, men som du kan se, giver det et godt overblik over kode og virkefelter. Du kan selv formatere koden, men du vil kunne spare tid ved at lade Visual Studio gøre det. Forudsat at der ikke er nogen fejl i koden, kan du bruge Format document fra Advanced-menuen under Edit-menuen. Genvejstasten er Ctrl+E+D eller Ctrl+K+D i Visual Studio. I Visual Studio Code kan du trykke F1 og skrive format.

Heltal

Der findes især fire forskellige typer, du kan bruge til at skabe heltal i C#. De kan enten tilgås gennem et reelt typenavn eller et genvejsnavn, som de fleste benytter:

Når du skriver en heltalskonstant (altså blot et tal) i koden vil kompileren opfatte det som en int, og i virkeligheden vil du sjældent bruge de andre variabeltyper.

Du undrer dig måske over, at du ikke skal spare så meget plads som muligt og eksempelvis bruge en byte, hvis du blot skal tælle til 10. Men du skal mere kigge på den CPU, som applikationen afvikles på. Hvis der er tale om en 32 bit eller 64 bit arkitektur giver det ikke den store (om nogen) forskel at flytte 32 bit rundt i stedet for 8 bit. Med moderne maskiner kan man faktisk undre sig over, at det ikke er et 64 bit heltal (long) som er default i stedet for et 32 bit heltal (int). Men det skyldes historik og kompatibilitet.

Hvis du vil erklære en variabel af typen int, kan du gøre det på flere måder. Det nemmeste at forstå, og det mest pædagogiske, er således:

System.Int32 a = new System.Int32();

Samme kode kunne skrives ved brug af int, da int er genvejsnavnet til System.Int32:

int b = new int();

Det giver præcis samme resultat – skab variabel kaldet b af typen System.Int32, skab en ny instans og gem værdien. Variablen b vil også blive tildelt en defaultværdi på 0.

Du må gerne skrive kode således, men Microsoft har givet mulighed for, at man kan skabe variabler af de fleste strukturer på en nemmere måde – uden brug af new:

System.Int32 a;
int b;

Men prøv at læse koden:

int a;

som

System.Int32 a = new System.Int32();

og tænk: erklær en variabel af typen System.Int32 kaldet a, skab en ny (new) instans og bind variablen og instansen sammen.

Du kan dog vælge at initialisere variablen sammen med erklæringen:

System.Int32 a = 0;
int b = 0;

int a = 1;

Så længe du arbejder med samme type, må du gerne erklære flere variabler i samme instruktion:

int a = 0, b = 0, c = 0, d = 0;

Kommatal

Der findes grundlæggende tre forskellige typer til at håndtere kommatal:

Både float og double benytter den såkaldte floating-point standard, som i de fleste programmeringssprog benyttes til at repræsentere reelle tal. De betydende cifre (før eller efter komma) er afhængig af størrelsen, men generelt kan en double indeholde et meget stort (få decimaler) eller meget lille (mange decimaler) tal. Kommatal skrives med punktum, når du benytter konstanter i koden:

float a = 0;
double b = 0;
decimal c = 0;

b = 233.2341;

double a = .1 + .1 + .1 + .1 + .1 + .1 + .1 + .1 + .1 + .1;
// a = 0.99999999999999989

Foretager man samme beregning med en decimal, er resultatet 1.

Du behøver i langt de fleste tilfælde ikke være så bevidst om eventuelle afrundingsproblemer på 16. eller 17. decimal og blot benytte en double til de dine kommatal.

Operatorer relateret til tal

Når først du har fat i heltal eller reelle tal, kan du naturligvis foretage diverse beregninger ved hjælp af indbyggede operatorer:

Her er et par eksempler på brug af operatorerne:

int a = 10; // a = 10            
a = a + 10; // a = 20            
a += 10;    // a = 30

int b = 50; // b = 50
b = b - 10; // b = 40            
b -= 10;    // b = 30

int c = 10; // c = 10            
c = c * 2;  // c = 20            
c *= 2;     // c = 40
c /= 4;     // c = 10

int d = 10; // d = 10            
d++;        // d = 11
d--;        // d = 10

int a = 10;
int b = 3;
int c = a / b;  // c = 3

double d = 3.0;

// fejl - udtryk returnerer en double og passer ikke ind i en int
// int e = a / d;  

double e = a / d;   // e = 3.333333333

Hvis du gerne vil vide lidt mere om tal og operatorer i C#, kan du søge efter info om ”overflow/checked”, som dækker over hvad der sker, når en variabel eksempelvis rammer loftet af sin maksimale værdi. Der findes også mere avancerede datatyper som UInt16, UInt64, store heltal i BigInteger-typen samt avancerede komplekse tal i Complex-typen.

Formatering af tal

Du har tit behov for at gemme eller udskrive et tal i formateret form – med eller uden separator, i et givet antal decimaler og i en given kultur (dansk, tysk, amerikansk med videre).

Flere metoder i C# tager såkaldte formateringstegn som argument, og dem kan du bruge for at slippe for selv at formatere tal. Her er nogle af de vigtigste:

En af metoderne, der benyttes meget i forbindelse med formatering, er ToString-metoden, som findes på alle typer:

int a = 25123;
double b = 232345.3426;
double c = 0.25;

Console.WriteLine(a.ToString("N2"));    // Udskriver 25.125,00
Console.WriteLine(a.ToString("N3"));    // Udskriver 25.125,000
Console.WriteLine(a.ToString("F1"));    // Udskriver 25125,0
Console.WriteLine(a.ToString("C2"));    // Udskriver 25.125,00 kr.

Console.WriteLine(b.ToString("N2"));    // Udskriver 232.345,34
Console.WriteLine(b.ToString("N3"));    // Udskriver 232.345,343 
Console.WriteLine(b.ToString("F5"));    // Udskriver 232345,34260

Console.WriteLine(c.ToString("P0"));    // 25 %
Console.WriteLine(c.ToString("P2"));    // 25,00 %

Samme metode kan også benyttes til forskellige kulturer:

int a = 25123;
double b = 232345.3426;
double c = 0.25;
System.Globalization.CultureInfo culture = new 
        System.Globalization.CultureInfo("en-US");

Console.WriteLine(a.ToString("N2", culture));    // Udskriver 25,123.00
Console.WriteLine(a.ToString("N3", culture));    // Udskriver 25,123.000
Console.WriteLine(a.ToString("F1", culture));    // Udskriver 25123.0
Console.WriteLine(a.ToString("C2", culture));    // Udskriver $25,123.00 

Console.WriteLine(b.ToString("N2", culture));    // Udskriver 232,345.34
Console.WriteLine(b.ToString("N3", culture));    
// Udskriver 232,345.343 
Console.WriteLine(b.ToString("F5", culture));    
// Udskriver 232345.34260

Console.WriteLine(c.ToString("P0", culture));    // 25%
Console.WriteLine(c.ToString("P2", culture));    // 25,00%

Kultur

Du bør angive en kultur, når du formaterer, for du kan ikke styre, hvilken maskine din applikation afvikles på, og det kan give forskellige udfordringer. Sørg derfor altid for at have følgende kode i starten af en applikation:

System.Threading.Thread.CurrentThread.CurrentCulture 
    = new System.Globalization.CultureInfo("en-US");

Thread.CurrentThread.CurrentCulture 
    = new System.Globalization.CultureInfo("en-US");

Koden for den danske kultur er ”da-DK”, og du kan finde alle de andre hos Microsoft. Der findes også en del andre formateringstegn, som du ligeledes kan finde i dokumentationen.

Typekonvertering af tal

Du har tit brug for at konvertere én datatype til en anden, og det kan ske implicit eller eksplicit.

Implicit datakonvertering betyder konvertering af tal fra en lille datatype (eksempelvis en 8-bit byte) til en stor datatype (eksempelvis en 32-bit int):

Her behøver du ikke foretage dig andet end at tildele den store variabel værdien af den lille:

byte a = 10;
int b = a;

Her eksempelvis fra int til byte:

int a = 10;
// byte b = a; FEJL

Her er et par eksempler fra int til byte med brug af ToByte:

int a = 10;
byte b = System.Convert.ToByte(a); 
// det går fint - 10 er nu placeret i en byte
int c = 300;
byte d = System.Convert.ToByte(c); 
// vil fejle - 300 ikke kan være i en byte

byte a = 0;
short b = 0;
int c = 0;
long d = 0;
a = System.Convert.ToByte(b);
a = System.Convert.ToByte(c);
a = System.Convert.ToByte(d);

double e = 3434.45;
float f = System.Convert.ToSingle(e);

og hvis du forsøger at konvertere tal, der kræver afrunding, vil Convert-metoderne også klare det:

double a = 100.96;
int b = System.Convert.ToInt32(a);  // b = 101

Sluttelig vil du nogle gange skulle hjælpe kompileren med at konvertere konstanter. Her kan du benytte et bogstav i slutningen af konstanten for at fortælle kompileren, at den skal opfatte tallet som en konkret type:

Det kan eksempelvis bruges som følger:

long a = 1001L;     // L = long
float b = 1002.34F; // F = float

Brugen af disse konstantkoder er især brugbart ved metodekald, hvor du skal sende en konkret type med, samt ved erklæring af variabler med var-kodeordet, som vi kigger på senere:

float res = LægSammen(10.4F, 20.7F);

float LægSammen(float a, float b) {
    return a + b;
}

Der findes ligeledes konstantkoder til at konvertere binære (0b) og hexadecimale (0x) konstanter. Se mere i dokumentationen på MSDN

Opgaver

• N105 Simple tal
• N115 Typekonvertering

Sand eller falsk

Hvis du skal bruge en variabel, der kan få værdien sand eller falsk, kan du benytte 8-bit typen System.Boolean. De fleste benytter dog genvejsnavnet bool, og en variabel af denne type kaldes typisk for en boolsk variabel:

Den er simpel i brug, fordi den kun kan tildeles værdien sand eller falsk og ikke som i nogen andre sprog andre værdier, som så typekonverteres automatisk.

Som i de fleste simple variabeltyper kan du vælge, om du vil benytte typenavnet (System.Boolean) eller genvejsnavnet (bool):

System.Boolean a;
a = true;

bool b;
b = false;

bool c = true;
bool d, e, f;

Husk, at når du ser koden

bool a = true;

System.Boolean a = new System.Boolean();
a = true;

Boolske operatorer

En boolsk variabel benyttes især ved styring og kontrol af programflow. Kode som hvis dette er sandt så gør dette ellers så gør dette, er grundlaget for al programmering. Der findes derfor et par logiske operatorer, som du skal kende til:

De benyttes typisk i if-instruktioner, som du skal se senere, men kan også benyttes til at tildele værdier til variabler:

bool a = true;      // a = true
bool b = false;     // b = false

bool c = a == b;    // c = false
bool d = a != b;    // d = true
bool e = a && b;    // e = false
bool f = a || b;    // f = true
bool g = !b;        // g = true

bool a = true;              // a = true
bool b = false;             // b = false
bool c = !(a == b) && true; // c = true

Den sidste linje ser teknisk ud, men skal læses som den modsatte værdi af true=false OG true kan forkortes til den modsatte værdi af false OG true, som kan forkortes til true OG true, som er true.

Dato

Opbevaring, og især beregning, af dato og tid kan være lidt af en udfordring, og derfor stiller .NET flere strukturer til rådighed, der kan hjælpe.

System.DateTime er en 64 bit struktur, som repræsenterer dato og tid fra 01-01-0001 til 31-12-9999, og består i virkeligheden af et meget stort tal, der dækker antallet af såkaldte ticks (100 nanosekunder). Du arbejder dog sjældent med ticks, men benytter instanser af strukturen som en repræsentation af dato og tid:

System.DateTime har mystisk nok ikke noget genvejsnavn (som int eller bool), og der er heller ikke nogen måde at skrive en dato og tid som en konstant. Du er for det meste tvunget til at initialisere værdien ved hjælp af strukturens konstruktør (den kode der afvikles, når der skabes en ny instans), og dem er der en del af. De meste brugte er som følger:

// Ikke initialiseret
System.DateTime a;

// Samme som ovenfor - men kræver "using System;"
DateTime b;

// Initialiseret til 1-1-1 0:0:0
DateTime c = new DateTime();

// d initialiseret til 15/10-2019
DateTime d = new DateTime(2019, 10, 15);

// e initialiseret til 15/10-2019 kl. 8:15
DateTime e = new DateTime(2019, 10, 15, 8, 15, 0);

DateTime-typen har ligeledes nogle statiske medlemmer, som kan benyttes ved initialisering:

// Lokal systemtid (dato og tid)
DateTime a = DateTime.Now;

// Lokal systemdato 
DateTime b = DateTime.Today;

// Lokal systemtid (dato og tid)
DateTime a = DateTime.Now;
int dagIMåned = a.Day;
DayOfWeek ugedag = a.DayOfWeek; 
int time = a.Hour;
int minut = a.Minute;
int month = a.Month;
int sekund = a.Second;
int år = a.Year;

Nogle metoder returnerer en ny DateTime-variabel:

DateTime a = new DateTime(2019, 10, 17);
Console.WriteLine(a.ToShortDateString());   // 17-10-2019
a.AddDays(1);
Console.WriteLine(a.ToShortDateString());   // 17-10-2019

a = a.AddDays(1);
Console.WriteLine(a.ToShortDateString());   // 18-10-2019

a.AddDays(1);

På linjen:

a = a.AddDays(1);

gemmes værdien i en variabel. Det kunne være en helt ny variabel, men hvis du ikke har noget at bruge den gamle værdi til, kan du lige så godt genbruge variablen.

Hvis du er i tvivl om, hvad en metode returnerer, bliver du nødt til at se i dokumentationen, eller være opmærksom på hvad Visual Studio fortæller dig:

Bemærk, at Visual Studio (Code) fortæller dig, at der på instanser af DateTime (1) findes metoden AddDays (2), der som argumenter tager en double (3), og at den returnerer en DateTime (4). Læs også beskrivelsen af metoden.

I programmeringsteori kalder man dette for immutable data fordi den underliggende værdi ikke kan rettes, men skal tildeles en ny. DateTime-typen er, ligesom mange andre simple variabeltyper, en immutabel datatype, og årsagerne til, at nogle datatyper er immutable og andre er mutable, er relateret til sikkerhed, performance og optimering.

Tid

Hvis du vil repræsentere tid, kan du bruge System.TimeSpan-strukturen – enten for blot at repræsentere tid som en værdi eller som resultatet af en beregning:

// uinitialiseret
TimeSpan a;

// initialiseret til 0:00
TimeSpan b = new TimeSpan();

// initialiseret til 10 timer, 15 minutter og 25 sekunder
TimeSpan c = new TimeSpan(10, 15, 25);

// initialiseret til 1 dag, 10 timer, 15 minutter og 25 sekunder
TimeSpan d = new TimeSpan(1, 10, 15, 25);

DateTime a = new DateTime(2019, 1, 1);
DateTime b = new DateTime(2019, 8, 28);
TimeSpan c = b.Subtract(a);
TimeSpan d = b - a;  // samme som Subtract

DateTime a = new DateTime(2019, 1, 1, 15, 20, 0);
DateTime b = new DateTime(2019, 8, 28, 8, 0, 0);
TimeSpan c = b - a;

int antalMinutter = c.Minutes;                  
// 40 (antal minutter mellem 0 og 20 minutter)

double totalAntalMinutter = c.TotalMinutes;     
// 343.780 (total antal minutter mellem a og b)

int antalTimer = c.Hours;                       // 16
double totalAntalTimeDouble = c.TotalHours;     // 5.728,66

int antalDage = c.Days;                         // 238
double TotalAntalDage = c.TotalDays;            // 238,69

Og sluttelig en masse muligheder for at regne på tid.

TimeSpan a = new TimeSpan(8, 0, 0);

TimeSpan b = a * 5;                              
// 8 timer * 5

TimeSpan c = a / 2;                              
// 8 timer / 2

TimeSpan d = a.Add(new TimeSpan(0, 90, 0));      
// 8 timer + 90 minutter

TimeSpan e = a.Subtract(new TimeSpan(0, 90, 0)); 
// 8 timer - 90 minutter

Formatering af dato og tid

En instans af en DateTime indeholder metoderne ToShortDateString, ToLongDateString, ToShortTimeString og ToLongTimeString, som du kan bruge til en hurtig formatering, men ligesom tal kan dato og tid også udskrives eller gemmes i formateret form ved brug af formateringstegn.

Der er rigtig mange at vælge imellem, men her er de vigtigste:

Du kan eventuelt benytte ToString-metoden til formatering:

// Forudsætter afvikling på en dansk maskine med dansk (da-DK) kultur
DateTime a = new DateTime(2019, 10, 17, 13, 37, 25);

// brug af indbyggede metoder
Console.WriteLine(a.ToShortDateString());   // 17-10-2019
Console.WriteLine(a.ToLongDateString());    // 17. oktober 2019
Console.WriteLine(a.ToShortTimeString());   // 13:37
Console.WriteLine(a.ToLongTimeString());    // 13:37:25

// brug af ToString og formateringstegn
Console.WriteLine(a.ToString());            // 17-10-2019 13:37:25
Console.WriteLine(a.ToString("dd"));        // 17
Console.WriteLine(a.ToString("ddd"));       // to   
Console.WriteLine(a.ToString("dddd"));      // torsdag
Console.WriteLine(a.ToString("MM"));        // 10
Console.WriteLine(a.ToString("MMM"));       // okt
Console.WriteLine(a.ToString("yy"));        // 19
Console.WriteLine(a.ToString("yyyy"));      // 2019

Console.WriteLine(a.ToString("HH"));        // 13
Console.WriteLine(a.ToString("mm"));        // 37
Console.WriteLine(a.ToString("ss"));        // 25

Console.WriteLine(a.ToString("dd-MM-yyyy"));// 17-10-2019
Console.WriteLine(a.ToString("ddMMyyyy"));  // 17102019
Console.WriteLine(a.ToString("yyyyMMdd"));  // 20191017

Men ligesom ved formatering af tal bør du måske angive en kultur for at sikre, at formatering er ligegyldig, uanset hvilken maskine der afvikles på. Det kan gøres i de enkelte metoder eller ved at sætte kultur en gang for alle:

System.Globalization.CultureInfo c = new 
        System.Globalization.CultureInfo("en-US");
System.Threading.Thread.CurrentThread.CurrentCulture = c;

DateTime a = new DateTime(2019, 10, 17, 13, 37, 25);
Console.WriteLine(a.ToShortDateString());   // 10/17/2019
Console.WriteLine(a.ToLongDateString());    
// Thursday, October 17, 2019
Console.WriteLine(a.ToShortTimeString());   // 1:37 PM
Console.WriteLine(a.ToLongTimeString());    // 1:37:25 PM

Console.WriteLine(a.ToString());            // 10/17/2019 1:37:25 PM
Console.WriteLine(a.ToString("dd"));        // 17
Console.WriteLine(a.ToString("ddd"));       // Thu   
Console.WriteLine(a.ToString("dddd"));      // Thursday
Console.WriteLine(a.ToString("MM"));        // 10
Console.WriteLine(a.ToString("MMM"));       // okt
Console.WriteLine(a.ToString("yy"));        // 19
Console.WriteLine(a.ToString("yyyy"));      // 2019

Console.WriteLine(a.ToString("HH"));        // 13
Console.WriteLine(a.ToString("mm"));        // 37
Console.WriteLine(a.ToString("ss"));        // 25

Console.WriteLine(a.ToString("dd-MM-yyyy"));// 17-10-2019
Console.WriteLine(a.ToString("ddMMyyyy"));  // 17102019
Console.WriteLine(a.ToString("yyyyMMdd"));  // 20191017

Typekonvertering af dato og tid

Såvel DateTime som TimeSpan kan typekonverteres fra strenge af mange forskellige formater, og der er mange måder at gøre det på. Du kan vælge at benytte metoder fra Convert-klassen

DateTime a = Convert.ToDateTime("2019-10-15");
DateTime b = Convert.ToDateTime("2019-10-15T20:15:30");
DateTime c = Convert.ToDateTime("15. Oktober 2019");

eller eksempelvis den statiske Parse-metode fra DateTime/TimeSpan-strukturen selv:

DateTime a = DateTime.Parse("2019-10-15");
DateTime b = DateTime.Parse("2019-10-15T20:15:30");
DateTime c = DateTime.Parse("15. Oktober 2019");
TimeSpan d = TimeSpan.Parse("15:25");

Du skal dog være opmærksom på, hvilket format der konverteres fra. Førnævnte kode forventer en dansk kultur, men det anbefales enten at angive kulturen:

DateTime a = DateTime.Parse("15. Oktober 2019 20:15", new 
     System.Globalization.CultureInfo("da-DK"));

DateTime a = DateTime.ParseExact("15102019", "ddMMyyyy", new 
     System.Globalization.CultureInfo("da-DK"));

Formatet på strengen (ddMMyyyy) angives med specielle tegn, som er generelle for både konvertering og formatering.

Opgaver

• N110 Dato og tid

DateTimeOffset

Der findes ligeledes en DateTimeOffset-struktur, som minder meget om DateTime-strukturen. Den kan benyttes hvis man ønsker større kontrol over tidzoner. Se mere på https://docs.microsoft.com/en-us/dotnet/standard/datetime/choosing-between-datetime.

DateOnly og TimeOnly

I C# 10 blev to nye typer tilføjet System.DateOnly og System.TimeOnly. De har som navnet antyder til formål at repræsentere en dato og et tidspunkt (og ikke begge dele som System.DateTime). Det kan gøre det lidt nemmere at arbejde med enten datoer eller tidspunkter.

Her er et par eksempler på brugen af DateOnly:

DateOnly d1 = new DateOnly(2021, 5, 31);
Console.WriteLine(d1.Year);      // 2021
Console.WriteLine(d1.Month);     // 5
Console.WriteLine(d1.Day);       // 31
Console.WriteLine(d1.DayOfWeek); // Mandag

// Manipulation
DateOnly d2 = d1.AddMonths(1);
Console.WriteLine(d2);

int days = d2.DayNumber - d1.DayNumber;
Console.WriteLine($"{days} dage mellem {d1} og {d2}");

DateOnly d3 = DateOnly.ParseExact("24 Dec 2021", "dd MMM yyyy", System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine(d3);

DateOnly nu = DateOnly.FromDateTime(DateTime.Today);
Console.WriteLine(nu);

DateTime dt = d3.ToDateTime(new TimeOnly(0, 0));
Console.WriteLine(dt);

TimeOnly t1 = new TimeOnly(16, 30);
Console.WriteLine(t1.Hour);      // 16
Console.WriteLine(t1.Minute);    // 30
Console.WriteLine(t1.Second);    // 0

TimeOnly t2 = t1.AddHours(10);  // 02:30

// Hvor mange dage er der i 'overskud'
TimeOnly t3 = t2.AddMinutes(5000, out int wrappedDays); // 13:50, 3 (3 dage efter)


// Pas på rækkefølge når der trækkes fra
TimeOnly t4 = new TimeOnly(2, 0);
TimeOnly t5 = new TimeOnly(21, 0);
TimeSpan x = t5 - t4;   // 19
TimeSpan y = t4 - t5;   // 5

TimeOnly t6 = TimeOnly.ParseExact("5:00 pm", "h:mm tt", System.Globalization.CultureInfo.InvariantCulture);  // 17:00

// Til TimeSpan
TimeSpan ts = t6.ToTimeSpan();      // "17:00:00"

// Til DateTime
DateTime dt = new DateOnly(1970, 1, 1).ToDateTime(t6);

TimeOnly nu = TimeOnly.FromDateTime(DateTime.Now);

// I mellem ...
if (nu.IsBetween(t1, t2))
{}
else
{}

Du kan vælge at holde fast i brugen af System.DateTime. Den har levet siden den allerførste version af C#, og der findes derfor en masse eksempler og dokumentation. Men de to nye typer kan gøre koden mere simpel.

Guid

I C# er en Guid (Globally Unique Identifier) en struktureret datatype, der anvendes til at skabe unikke værdier. Disse værdier bruges ofte som entydige nøgler i databaser, som identifikatorer i distribuerede systemer eller som unikke referencer for objekter. En Guid er en 128-bit værdi, hvilket gør den stor nok til at sikre unikke værdier, selv når de genereres i store mængder og på tværs af forskellige systemer.

Her er et par eksempler på Guids:

d8dc8f6f-0706-4164-8443-61af48a5d496
5d19a739-d9ab-41ab-b830-37124f7f57ca
6889e1d1-2f86-4bc7-9a91-ef1f39a9bd1d
ee5f3a39-304f-4433-aa72-13863800e1a6

Du kan oprette en Guid på flere måder i C#. En almindelig metode er at bruge Guid.NewGuid()-metoden, som automatisk genererer en ny, unik Guid:

Guid newGuid = Guid.NewGuid();
Console.WriteLine(newGuid.ToString());

Dette vil udskrive en ny Guid som en streng, for eksempel: d9b1d7db-5b19-4ca3-8e4a-ef95a8e71834.

Du kan også oprette en Guid ud fra en streng ved at bruge Guid.Parse() eller Guid.TryParse():

string guidString = "d9b1d7db-5b19-4ca3-8e4a-ef95a8e71834";
Guid parsedGuid = Guid.Parse(guidString);
Console.WriteLine(parsedGuid);

Hvis strengen ikke er i et korrekt format, vil Guid.Parse() kaste en undtagelse, mens Guid.TryParse() vil returnere false.

Guid-værdier bruges bredt i softwareudvikling til formål, hvor unikke identifikatorer er nødvendige. Dette inkluderer:

• Databaser: Som primærnøgler i tabeller, hvilket sikrer, at hver række kan entydigt identificeres.
• Distribuerede systemer: Til at spore og identificere ressourcer på tværs af flere systemer og tjenester.
• Objektreferencer: I applikationer, hvor objekter skal kunne identificeres entydigt, f.eks. i cache-systemer.

Brugen af Guid i C# gør det nemt at arbejde med unikke identifikatorer uden at bekymre sig om kollisioner, selv i store og komplekse systemer.

Brug af var i C#

Du kan bruge nøgleordet var til at lade kompilatoren automatisk bestemme typen af en variabel baseret på den værdi, du tildeler den. Det kan gøre din kode lidt mere kompakt og lettere at læse, især når typen er tydelig fra tildelingen:

var number = 5;   // Kompilatoren ved, at number er af typen int
var text = "Hej"; // Kompilatoren ved, at text er af typen string

I dette eksempel: - number bliver automatisk til en int (heltal), fordi den er tildelt værdien 5. - text bliver en string (tekst), fordi den er tildelt en tekststreng.

var er praktisk, når typen er indlysende fra konteksten, eller når du arbejder med lange eller komplekse typer, såsom resultater fra metoder, der returnerer samlinger.

var customers = new List<string>(); // List<string> er en "lang" type

Der er dog nogle begrænsninger:

• var kan ikke bruges uden en tildeling, da kompilatoren ikke vil kunne bestemme typen:

var x; // Dette giver en fejl, fordi der ikke er nogen værdi at udlede typen fra

• var gør koden mindre eksplicit, så hvis typen ikke er åbenlys, bør du overveje at skrive typen direkte.
• Det kan være mindre tydeligt, hvilken type en variabel har, hvis det ikke er klart ud fra tildelingen.

men også fordele:

• Kortere kode.
• Mere læsbar kode, når typen er indlysende.

Generelt er det en god idé at bruge var, når det gør koden nemmere at læse, men undgå at bruge det, hvis det gør koden sværere at forstå.

Hvad er en datatype egentlig

Helt grundlæggende er en datatype som int, bool, DateTime mv. blot en type Microsoft har skabt for at repræsentere en speciel værdi, og du kan se en type som en skabelon for hvordan værdien skal gemmes i hukommelsen og hvordan de ønsker man skal kunne arbejde med den. Man kan ikke helt selv skabe datatyper på samme måde fordi Microsofts typer er bagt ind i frameworket på et niveau under hvad vi selv kan - men vi kan komme tæt på.

Her er eksempelvis brug af en datatype som repræsenterer det romerske talsystem (dog kun et tegn som I, V, X, L, C, D, og M), og som kan bruges som:

RomerskVærdi a = 'X'; 
Console.WriteLine(a);               // X
Console.WriteLine(a.TilTal());      // 10

RomerskVærdi b = new RomerskVærdi();
b = 'V';
Console.WriteLine(b);               // V
Console.WriteLine(b.TilTal());      // 5

Console.WriteLine(a > b);           // true
Console.WriteLine(a < b);           // false
Console.WriteLine(a == b);          // false
Console.WriteLine(a != b);          // true

Læg mærke til hvor meget det minder om en int eller bool eller andre typer. Du behøver ikke forstå koden bag RomerskVærdi men det er vigtigt at forstå, at en datatype ‘blot’ er en skabelon skabt af MS for hvordan man repræsenterer forskellige værdier.

public struct RomerskVærdi
{
    private char numeral;

    public RomerskVærdi()
    {
        numeral = 'I';
    }

    public RomerskVærdi(char numeral)
    {
        if ("IVXLCDM".IndexOf(numeral) == -1)
            throw new ArgumentException("Forkert tegn");

        this.numeral = numeral;
    }

    public static implicit operator RomerskVærdi(char numeral)
    {
        return new RomerskVærdi(numeral);
    }

    public int TilTal()
    {
        switch (numeral)
        {
            case 'I': return 1;
            case 'V': return 5;
            case 'X': return 10;
            case 'L': return 50;
            case 'C': return 100;
            case 'D': return 500;
            case 'M': return 1000;
            default: throw new InvalidOperationException("Forkert tegn");
        }
    }

    public static bool operator ==(RomerskVærdi a, RomerskVærdi b)
    {
        return a.numeral == b.numeral;
    }

    public static bool operator !=(RomerskVærdi a, RomerskVærdi b)
    {
        return !(a == b);
    }

    public static bool operator >(RomerskVærdi a, RomerskVærdi b)
    {
        return a.TilTal() > b.TilTal();
    }

    public static bool operator <(RomerskVærdi a, RomerskVærdi b)
    {
        return a.TilTal() < b.TilTal();
    }


    public override bool Equals(object? obj)
    {
        if (obj is RomerskVærdi other)
        {
            return numeral == other.numeral;
        }

        return false;
    }

    public override int GetHashCode()
    {
        return numeral.GetHashCode();
    }

    public override string ToString()
    {
        return numeral.ToString();
    }
}

Introduktion til stack og heap

Når man starter med at programmere i C#, er det vigtigt at forstå forskellen mellem stack og heap. Det er de to områder i hukommelsen, hvor C# gemmer data, men de håndteres forskelligt.

Stack’en er et område i hukommelsen, hvor data opbevares i en meget struktureret rækkefølge. Når en metode kaldes, reserveres et nyt område på stakken til denne funktion. Dette område kaldes en stackframe og indeholder metodens lokale variabler. Når metoden er færdig, fjernes stackframe’n, og hukommelsen bliver frigjort.

Heap’en er et mere fleksibelt område i hukommelsen. Når du opretter objekter (med nøgleordet new i C#), bliver de placeret på heap’en. Hukommelsen i heap’en forvaltes ikke automatisk på samme måde som stakken. I C# tager garbage collector’en sig af at rydde op og frigøre hukommelse, som ikke længere er i brug. Objekter på heap’en kan nås fra forskellige dele af programmet og har ikke samme livscyklus som variabler på stakken.

Det er vigtigt at huske, at i C# er værdityper (som int, double, bool, osv.) typisk opbevaret på stakken, mens reference-typer (som objekter af klasser skabt med new) opbevares på heap’en. Dette har betydning for, hvordan data overføres i programmet og hvordan hukommelse håndteres.

De variabeltyper vi har set på indtil nu, er alle værdityper (alle er baseret på structs).

Det er super vigtigt at kunne “tegne” et stack og heap diagram i hovedet - det gør alle professionelle udvikler helt automatisk. Indtil du lige har fået det på rygraden, kan du bruge et værktøj som SharpLap til at lave diagrammerne. Prøv at skrive følgende kode ind i SharpLab, vælge Run i højre vindue, og se hvad der sker:

using System;

int a = 10;
double b = 20.5;
bool c = true;
Datetime d = new DateTime(2021, 1, 1);
string e = "Hello";
Inspect.MemoryGraph(a, b, c, d, e);