C# Variabelen & Primitive Datatypes onder de knie krijgen: Complete gids

C# Variabelen en (Primitieve) Datatypes

In deze tutorial leren we over variabelen, hoe u variabelen in C# aanmaakt en de verschillende datatypes die de C# programmeertaal ondersteunt.

Een variabele is een symbolische naam gegeven aan een geheugenlocatie. Variabelen worden gebruikt om data in een computerprogramma op te slaan.

Hoe variabelen te declareren in C#?

Hier is een voorbeeld om een variabele in C# te declareren.

int age;

In dit voorbeeld wordt een variabele age van type int (integer) gedeclareerd en kan het alleen gehele waarden opslaan.

We kunnen later in ons programma een waarde aan de variabele toekennen zoals:

int age;
...
...
...
age = 24;

De variabele kan echter ook geïnitialiseerd worden met een waarde tijdens declaratie. Bijvoorbeeld,

int age = 24;

Hier wordt een variabele age van type int gedeclareerd en geïnitialiseerd op 24 tegelijkertijd.

Aangezien het een variabele is, kunnen we de waarde van variabelen ook wijzigen. Bijvoorbeeld,

int age = 24;
age = 35;

Hier wordt de waarde van age gewijzigd naar 35 vanaf 24.

Variabelen in C# moeten gedeclareerd worden voordat ze gebruikt kunnen worden. Dit betekent dat de naam en het type van de variabele bekend moeten zijn voordat ze een waarde kunnen krijgen. Dit is waarom C# een statisch-getypte taal heet.

Eenmaal gedeclareerd, kan het datatype van een variabele niet gewijzigd worden binnen een scope. Een scope kan gedacht worden als een blok code waar de variabele zichtbaar of beschikbaar is voor gebruik. Als u de vorige statement niet begrijpt, geen zorgen – we leren over scopes in latere hoofdstukken.

Voor nu onthoud, we kunnen het volgende NIET doen in C#:

int age;
age = 24;
...
...
...
float age;

Impliciet getypte variabelen

Alternatief in C# kunnen we een variabele declareren zonder het type te weten met het var keyword. Zulke variabelen heten implicit getypte lokale variabelen.

Variabelen gedeclareerd met var keyword moeten geïnitialiseerd worden op het moment van declaratie.

var value = 5;

De compiler bepaalt het type van de variabele vanuit de waarde die aan de variabele toegewezen is. In het bovenstaande voorbeeld is value van type int. Dit is equivalent aan:

int value;
value = 5;

U kunt meer leren over implicit getypte lokale variabelen.

Regels voor het benoemen van variabelen in C#

Er zijn bepaalde regels die we moeten volgen bij het benoemen van een variabele. De regels voor het benoemen van een variabele in C# zijn:

De variabelenaam mag letters (hoofdletters en kleine letters), underscore (_) en cijfers bevatten.

De variabelenaam moet beginnen met een letter, underscore of @ symbool. Bijvoorbeeld,

Regels voor het benoemen van variabelen in C#
Variabelenamen	Opmerkingen
`name`	Geldig
`subject101`	Geldig
`_age`	Geldig (Best practice voor private member variabelen)
`@break`	Geldig (Gebruikt als naam gereserveerd keyword is)
`101subject`	Ongeldig (Begint met cijfer)
`your_name`	Geldig
`your name`	Ongeldig (Bevat witruimte)

C# is case sensitive. Dit betekent age en Age verwijzen naar 2 verschillende variabelen.
Een variabelenaam mag geen C# keyword zijn. Bijvoorbeeld, if, for, using kunnen geen variabelenaam zijn. We zullen meer over C# keywords bespreken in de volgende tutorial.

Best Practices voor het benoemen van een variabele

Kies een variabelenaam die zinvol is. Bijvoorbeeld, name, age, subject maken meer zin dan n, a en s.
Gebruik camelCase notatie (begint met kleine letter) voor lokale variabelen. Bijvoorbeeld, numberOfStudents, age, etc.
Gebruik PascalCase of CamelCase (begint met hoofdletter) voor publieke member variabelen. Bijvoorbeeld, FirstName, Price, etc.
Gebruik een leidende underscore (_) gevolgd door camelCase notatie voor private member variabelen. Bijvoorbeeld, _bankBalance, _emailAddress, etc.

U kunt meer leren over naming conventions in C# hier.

Maak u geen zorgen over public en private member variabelen. We leren daarover in latere hoofdstukken.

C# Primitieve Datatypes

Variabelen in C# zijn breder ingedeeld in twee typen: Value types en Reference types. In deze tutorial bespreken we primitieve (eenvoudige) datatypes wat een subklasse is van Value types.

Reference types zullen in latere tutorials behandeld worden. Als u meer wilt weten over variabelentypes, bezoek C# Types and variables (officiële C# docs).

Boolean (bool)

Boolean datatype heeft twee mogelijke waarden: true of false
Standaardwaarde: false
Boolean variabelen worden doorgaans gebruikt om condities te controleren zoals in if statements, loops, etc.

Voorbeeld:

using System;
namespace DataType {
    class BooleanExample {
        public static void Main(string[] args) {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}

Wanneer we het programma draaien, is de output:

True

Gesigneerde Integraal

Deze datatypes houden gehele waarden (zowel positief als negatief). Van de totale beschikbare bits, wordt één bit gebruikt voor teken.

1. sbyte

Grootte: 8 bits
Bereik: -128 tot 127.
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class SByteExample {
        public static void Main(string[] args) {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}

Output:

Probeer waarden buiten bereik toe te wijzen, dus kleiner dan -128 of groter dan 127 en zie wat er gebeurt.

2. short

Grootte: 16 bits
Bereik: -32.768 tot 32.767
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class ShortExample {
        public static void Main(string[] args) {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}

Output:

-1109

3. int

Grootte: 32 bits
Bereik: -2³¹ tot 2³¹-1
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class IntExample {
        public static void Main(string[] args) {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}

Output:

4. long

Grootte: 64 bits
Bereik: -2⁶³ tot 2⁶³-1
Standaardwaarde: 0L [L aan het einde duidt aan dat de waarde long type is]

Voorbeeld:

using System;
namespace DataType {
    class LongExample {
        public static void Main(string[] args) {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}

Output:

-7091821871

OnGesigneerde Integraal

Deze datatypes houden alleen waarden gelijk aan of groter dan 0. We gebruiken deze datatypes doorgaans om waarden op te slaan wanneer we zeker weten dat we geen negatieve waarden zullen hebben.

1. byte

Grootte: 8 bits
Bereik: 0 tot 255.
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class ByteExample {
        public static void Main(string[] args) {
            byte age = 62;
            Console.WriteLine(age);
        }
    }
}

Output:

2. ushort

Grootte: 16 bits
Bereik: 0 tot 65.535
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class UShortExample {
        public static void Main(string[] args) {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}

Output:

3. uint

Grootte: 32 bits
Bereik: 0 tot 2³²-1
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class UIntExample {
        public static void Main(string[] args) {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}

Output:

4. ulong

Grootte: 64 bits
Bereik: 0 tot 2⁶⁴-1
Standaardwaarde: 0

Voorbeeld:

using System;
namespace DataType {
    class ULongExample {
        public static void Main(string[] args) {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}

Output:

17091821871

Drijvende Komma (Floating Point)

Deze datatypes houden drijvende komma waarden, dus getallen met decimale waarden. Bijvoorbeeld, 12.36, -92.17, etc.

1. float

Single-precision drijvende komma type
Grootte: 32 bits
Bereik: 1.5 × 10⁻⁴⁵ tot 3.4 × 10³⁸
Standaardwaarde: 0.0F [F aan het einde duidt aan dat de waarde float type is]

Voorbeeld:

using System;
namespace DataType {
    class FloatExample {
        public static void Main(string[] args) {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}

Output:

43.27

2. double

Double-precision drijvende komma type. Wat is het verschil tussen single en double precision drijvende komma?
Grootte: 64 bits
Bereik: 5.0 × 10⁻³²⁴ tot 1.7 × 10³⁰⁸
Standaardwaarde: 0.0D [D aan het einde duidt aan dat de waarde double type is]

Voorbeeld:

using System;
namespace DataType {
    class DoubleExample {
        public static void Main(string[] args) {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}

Output:

-11092.53

Karakter (char)

Het vertegenwoordigt een 16-bit unicode karakter.
Grootte: 16 bits
Standaardwaarde: '\0'
Bereik: U+0000 ('\u0000') tot U+FFFF ('\uffff')

Voorbeeld:

using System;
namespace DataType {
    class CharExample {
        public static void Main(string[] args) {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}

Output:

B x

De unicode waarde van 'B' is '\u0042', dus printen van ch1 print 'B'.

Decimal

Decimal type heeft meer precisie en een kleiner bereik vergeleken met drijvende komma types (double en float). Dus het is geschikt voor monetaire berekeningen.
Grootte: 128 bits
Standaardwaarde: 0.0M [M aan het einde duidt aan dat de waarde decimal type is]
Bereik: (-7.9 x 10²⁸ tot 7.9 x 10²⁸) / (10⁰ tot 10²⁸)

Voorbeeld:

using System;
namespace DataType {
    class DecimalExample {
        public static void Main(string[] args) {
            decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}

Output:

53005.25

M of m moet aan het einde toegevoegd worden anders wordt de waarde behandeld als een double en een fout gegenereerd.

C# Literals

Laten we de volgende statement bekijken:

int number = 41;

Hier,

int is een datatype
number is een variabele en
41 is een literal

Literals zijn vaste waarden die in het programma voorkomen. Ze vereisen geen berekening. Bijvoorbeeld, 5, false, 'w' zijn literals die direct in een programma voorkomen zonder berekening.

Boolean Literals

true en false zijn de beschikbare boolean literals.
Ze worden gebruikt om boolean variabelen te initialiseren.

Voorbeeld:

bool isValid = true; bool isPresent = false;

Integer Literals

Integer literals worden gebruikt om variabelen van integer datatypes te initialiseren: sbyte, short, int, long, byte, ushort, uint en ulong.
Als een integer literal eindigt met L of l, is het van type long. Voor best practice gebruik L (niet l).
```
long value1 = 4200910L; long value2 = -10928190L;
```
Als een integer literal begint met 0x, vertegenwoordigt het een hexadecimale waarde. Getallen zonder prefixes worden als decimaal behandeld. Octale en binaire representatie zijn niet toegestaan in C#.
```
int decimalValue = 25; int hexValue = 0x11c; // decimale waarde 284
```

Drijvende Komma Literals

Drijvende komma literals worden gebruikt om variabelen van float en double datatypes te initialiseren.
Als een drijvende komma literal eindigt met suffix f of F, is het van type float. Als het eindigt met d of D, is het van type double. Als geen van de suffixen aanwezig is, is het standaard van type double.

Deze literals bevatten e of E wanneer in wetenschappelijke notatie uitgedrukt.

double number = 24.67; // double by default
float value = -12.29F;
double scientificNotation = 6.21e2; // equivalent aan 6.21 x 10² dus 621

Karakter en String Literals

Karakter literals worden gebruikt om variabelen van char datatypes te initialiseren.
Karakter literals zijn omringd door enkele quotes. Bijvoorbeeld, 'x', 'p', etc.

Ze kunnen vertegenwoordigd worden als karakter, hexadecimale escape sequence, unicode representatie of integraal waarden gecast naar char.

char ch1 = 'R'; // karakter
char ch2 = '\x0072'; // hexadecimaal
char ch3 = '\u0059'; // unicode
char ch4 = (char)107; // gecast van integer

String literals zijn de verzameling van karakter literals.
Ze zijn omringd door dubbele quotes. Bijvoorbeeld, "Hello", "Easy Programming", etc.
```
string firstName = "Richard";
string lastName = " Feynman";
```
C# ondersteunt ook escape sequence karakters zoals:

Karakter Betekenis

\' Enkele quote

\" Dubbele quote

\\ Backslash

\n Nieuwe regel

\r Carriage return

\t Horizontale Tab

\a Alert

\b Backspace

Karakter	Betekenis
`\'`	Enkele quote
`\"`	Dubbele quote
`\\`	Backslash
`\n`	Nieuwe regel
`\r`	Carriage return
`\t`	Horizontale Tab
`\a`	Alert
`\b`	Backspace

C# Keywords en Identifiers begrijpen: Regels, lijsten en best practices C# Operators – Uitgebreide gids voor operators in C#

C Taal