C#-variabelen en (primitieve) gegevenstypen

In deze zelfstudie leren we over variabelen, het maken van variabelen in C# en verschillende gegevenstypen die door de programmeertaal C# worden ondersteund.

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

Hoe variabelen declareren in C#?

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

int age;

In dit voorbeeld is een variabele leeftijd van het type int (geheel getal) is gedeclareerd en kan alleen gehele waarden opslaan.

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

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

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

int age = 24;

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

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

int age = 24;
age = 35;

Hier, de waarde van leeftijd is veranderd in 35 van 24.

Variabelen in C# moeten worden gedeclareerd voordat ze kunnen worden gebruikt. Dit betekent dat de naam en het type variabele bekend moeten zijn voordat ze een waarde kunnen krijgen. Dit is de reden waarom C# een statisch getypeerde taal wordt genoemd.

Eenmaal gedeclareerd, kan het datatype van een variabele niet worden gewijzigd binnen een bereik. Een scope kan worden gezien als een codeblok waarin de variabele zichtbaar of beschikbaar is voor gebruik. Als u de vorige verklaring niet begrijpt, hoeft u zich geen zorgen te maken, we zullen in de latere hoofdstukken meer leren over scopes.

Onthoud voor nu dat we het volgende niet kunnen doen in C#:

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

Impliciet getypte variabelen

Als alternatief kunnen we in C# een variabele declareren zonder het type te kennen met var trefwoord. Dergelijke variabelen worden impliciet getypte lokale variabelen . genoemd .

Variabelen gedeclareerd met var trefwoord moet worden geïnitialiseerd op het moment van aangifte.

var value = 5;

De compiler bepaalt het type variabele uit de waarde die aan de variabele is toegewezen. In het bovenstaande voorbeeld, waarde is van het type int . Dit komt overeen met:

int value;
value = 5;

U kunt meer leren over impliciet 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 naam van de variabele mag alleen letters (hoofdletters en kleine letters), underscore( _ ) en cijfers bevatten.

De naam van de variabele moet beginnen met een letter, een onderstrepingsteken of een @-teken. Bijvoorbeeld

Regels voor het benoemen van variabelen in C#
Variabelenamen	Opmerkingen
`naam`	Geldig
`onderwerp101`	Geldig
`_leeftijd`	Geldig (Best practice voor het benoemen van variabelen voor privéleden)
`@break`	Geldig (gebruikt als naam een gereserveerd trefwoord is)
`101onderwerp`	Ongeldig (begint met cijfer)
`uw_naam`	Geldig
`uw naam`	Ongeldig (bevat witruimte)

C# is hoofdlettergevoelig. Het betekent leeftijd en Leeftijd verwijst naar 2 verschillende variabelen.
Een variabelenaam mag geen C#-sleutelwoord zijn. Bijvoorbeeld if , for , using kan geen variabelenaam zijn. In de volgende zelfstudie bespreken we meer over C#-zoekwoorden.

Beste praktijken voor het benoemen van een variabele

Kies een variabelenaam die logisch is. Bijvoorbeeld naam , leeftijd , onderwerp is logischer dan n , een en s .
Gebruik camelCase notatie (begint met een kleine letter) voor het benoemen van lokale variabelen. Bijvoorbeeld numberOfStudents , leeftijd , enz.
Gebruik PascalCase of CamelCase (begint met een hoofdletter) voor het benoemen van openbare lidvariabelen. Bijvoorbeeld Voornaam , Prijs , enz.
Gebruik een leidend onderstrepingsteken (_) gevolgd door camelCase notatie voor het benoemen van privé-lidvariabelen. Bijvoorbeeld _bankBalance , _emailAddress , enz.

U kunt hier meer leren over naamgevingsconventies in C#.

Maak je geen zorgen over openbare en privé-lidvariabelen. We zullen er in latere hoofdstukken meer over leren.

C# primitieve gegevenstypen

Variabelen in C# worden grofweg ingedeeld in twee typen:Waardetypen en Referentietypen . In deze tutorial zullen we het hebben over primitieve (eenvoudige) datatypes, wat een subklasse is van Waardetypes.

Referentietypen worden in latere zelfstudies behandeld. Als u echter meer wilt weten over typen variabelen, gaat u naar C#-typen en variabelen (officiële C#-documenten).

Boolean (bool)

Booleaans gegevenstype heeft twee mogelijke waarden:true of false
Standaardwaarde :false
Booleaanse variabelen worden over het algemeen gebruikt om voorwaarden te controleren, zoals in if-statements , loops , enz.

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

True

Getekende integraal

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

1. sbyte

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

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

Probeer waarden buiten het bereik toe te wijzen, d.w.z. kleiner dan -128 of groter dan 127 en kijk wat er gebeurt.

2. kort

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

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

-1109

3. int

Maat :32 bits
Bereik :-231 tot 231-1
Standaardwaarde :0

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

4. lang

Maat :64 bits
Bereik :-263 tot 263-1
Standaardwaarde :0L [L aan het einde geeft aan dat de waarde van het lange type is]

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

-7091821871

Niet-ondertekende integraal

Deze gegevenstypen bevatten alleen waarden die gelijk zijn aan of groter zijn dan 0. We gebruiken deze gegevenstypen over het algemeen om waarden op te slaan als we zeker weten dat we geen negatieve waarden zullen hebben.

1. byte

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

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

2. kort

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

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

3. uint

Maat :32 bits
Bereik :0 tot 232-1
Standaardwaarde :0

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

4. ulong

Maat :64 bits
Bereik :0 tot 264-1
Standaardwaarde :0

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

17091821871

Drijvend punt

Deze gegevenstypen bevatten waarden met drijvende komma, d.w.z. getallen met decimale waarden. Bijvoorbeeld 12.36, -92.17, enz.

1. zweven

Single-precision floating point type
Maat :32 bits
Bereik :1,5 × 10−45 tot 3,4 × 1038
Standaardwaarde :0.0F [F aan het einde staat voor de waarde van het type float]

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

43.27

2. dubbel

Dubbele precisie drijvende-kommatype. Wat is het verschil tussen zwevende komma met enkele en dubbele precisie?
Maat :64 bits
Bereik :5,0 × 10−324 tot 1,7 × 10308
Standaardwaarde :0.0D [D aan het einde geeft aan dat de waarde van het dubbele type is]

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

-11092.53

Teken (char)

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

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

B
x

De unicode-waarde van 'B' is '\u0042' , vandaar het afdrukken van ch1 zal 'B' . afdrukken .

Decimaal

Decimaaltype heeft meer precisie en een kleiner bereik in vergelijking met typen met drijvende komma (dubbel en zwevend). Het is dus geschikt voor monetaire berekeningen.
Maat :128 bits
Standaardwaarde :0.0M [M aan het einde staat voor de waarde van het decimale type]
Bereik :(-7,9 x 1028 tot 7,9 x 1028) / (100 tot 28)

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

53005.25

Het achtervoegsel M of m moet aan het einde worden toegevoegd, anders wordt de waarde als een dubbele behandeld en wordt er een fout gegenereerd.

C#-letters

Laten we eens kijken naar de volgende verklaring:

int number = 41;

Hier,

int is een gegevenstype
nummer is een variabele en
41 is een letterlijke

Letters zijn vaste waarden die in het programma verschijnen. Ze vereisen geen berekening. Bijvoorbeeld 5 , false , 'w' zijn letterlijke waarden die direct in een programma verschijnen zonder enige berekening.

Booleaanse Literatuur

waar en onwaar zijn de beschikbare booleaanse letterlijke waarden.
Ze worden gebruikt om booleaanse variabelen te initialiseren.

Bijvoorbeeld:

bool isValid = true;
bool isPresent = false;

Integer Letters

Gehele letterlijke waarden worden gebruikt om variabelen van gegevenstypen met gehele getallen te initialiseren, bijv. sbyte , short , int , long , byte , ushort , uint en ulong .
Als een letterlijke integer eindigt op L of l , het is van het type lang. Gebruik voor de beste werkwijze L (niet l ).
```
long value1 = 4200910L;
long value2 = -10928190L;
```
Als een letterlijke integer begint met een 0x , het vertegenwoordigt een hexadecimale waarde. Getal zonder voorvoegsels wordt behandeld als decimale waarde. Octale en binaire weergave zijn niet toegestaan in C#.
```
int decimalValue = 25;
int hexValue = 0x11c;// decimal value 284
```

Drijvende puntletters

Floating point literals worden gebruikt om variabelen van float en dubbele datatypes te initialiseren.
Als een letterlijke drijvende komma eindigt met een achtervoegsel f of F , het is van het type float. Evenzo, als het eindigt met d of D , het is van het type dubbel. Als geen van beide achtervoegsels aanwezig is, is deze van het type double by standaard .

Deze letterlijke termen bevatten e of E wanneer ze worden uitgedrukt in wetenschappelijke notatie.

double number = 24.67;// double by default
float value = -12.29F;
double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Letterlijke tekens en tekenreeksen

Letterlijke tekens worden gebruikt om variabelen van char-gegevenstypen te initialiseren.
Letterlijke tekens staan tussen enkele aanhalingstekens. Bijvoorbeeld 'x' , 'p' , enz.
Ze kunnen worden weergegeven als teken, hexadecimale ontsnappingsreeks, unicode-weergave of integrale waarden die naar char worden gegoten.
```
char ch1 = 'R';// character
char ch2 = '\x0072';// hexadecimal
char ch3 = '\u0059';// unicode
char ch4 = (char)107;// casted from integer
```
Letterlijke tekenreeksen zijn de verzameling letterlijke tekens.
Ze staan tussen dubbele aanhalingstekens. Bijvoorbeeld "Hallo" , "Eenvoudig programmeren" , enz.
```
string firstName = "Richard";
string lastName = " Feynman";
```
C# ondersteunt ook tekens voor escape-reeksen, zoals:

Karakter Betekenis

\' Enkel aanhalingsteken

\" Dubbele aanhalingstekens

\\ Backslash

\n Nieuwe regel

\r Koetsretour

\t Horizontaal tabblad

\a Waarschuwing

\b Backspace

Karakter	Betekenis
`\'`	Enkel aanhalingsteken
`\"`	Dubbele aanhalingstekens
`\\`	Backslash
`\n`	Nieuwe regel
`\r`	Koetsretour
`\t`	Horizontaal tabblad
`\a`	Waarschuwing
`\b`	Backspace

C#-zoekwoorden en -ID's C#-operators

C Taal