C#-Variablen und (primitive) Datentypen

C#-Variablen und (primitive) Datentypen

In diesem Tutorial lernen wir etwas über Variablen, wie man Variablen in C# erstellt und verschiedene Datentypen, die die Programmiersprache C# unterstützt.

Eine Variable ist ein symbolischer Name für einen Speicherplatz. Variablen werden verwendet, um Daten in einem Computerprogramm zu speichern.

---

Wie werden Variablen in C# deklariert?

Hier ist ein Beispiel, um eine Variable in C# zu deklarieren.

int age;

In diesem Beispiel eine Variable age vom Typ int (Integer) deklariert und kann nur Integer-Werte speichern.

Wir können der Variablen später in unserem Programm einen Wert wie folgt zuweisen:

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

Die Variable kann jedoch auch während der Deklaration auf einen bestimmten Wert initialisiert werden. Zum Beispiel

int age = 24;

Hier ein variables Alter vom Typ int wird deklariert und mit 24 initialisiert gleichzeitig.

Da es sich um eine Variable handelt, können wir auch den Wert von Variablen ändern. Zum Beispiel

int age = 24;
age = 35;

Hier der Wert von age wird von 24 auf 35 geändert.

---

Variablen in C# müssen deklariert werden, bevor sie verwendet werden können. Das heißt, Name und Typ der Variablen müssen bekannt sein, bevor ihnen ein Wert zugewiesen werden kann. Aus diesem Grund wird C# als statisch typisierte Sprache bezeichnet.

Einmal deklariert, kann der Datentyp einer Variablen innerhalb eines Gültigkeitsbereichs nicht mehr geändert werden. Ein Gültigkeitsbereich kann als Codeblock betrachtet werden, in dem die Variable sichtbar oder verfügbar ist. Wenn Sie die vorherige Aussage nicht verstehen, machen Sie sich keine Sorgen, wir werden in den späteren Kapiteln mehr über Bereiche erfahren.

Denken Sie vorerst daran, dass wir Folgendes in C# nicht tun können:

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

---

Implizit typisierte Variablen

Alternativ können wir in C# eine Variable mit var deklarieren, ohne ihren Typ zu kennen Stichwort. Solche Variablen werden implizit typisierte lokale Variablen genannt .

Mit var deklarierte Variablen Schlüsselwort muss zum Zeitpunkt der Deklaration initialisiert werden.

var value = 5;

Der Compiler bestimmt den Variablentyp aus dem Wert, der der Variablen zugewiesen wird. Im obigen Beispiel value ist vom Typ int . Dies entspricht:

int value;
value = 5;

Sie können mehr über implizit typisierte lokale Variablen erfahren.

---

Regeln für die Benennung von Variablen in C#

Es gibt bestimmte Regeln, die wir beim Benennen einer Variablen befolgen müssen. Die Regeln für die Benennung einer Variablen in C# lauten:

1. Der Variablenname darf nur Buchstaben (Groß- und Kleinbuchstaben), Unterstriche ( _ ) und Ziffern enthalten.
2. Der Variablenname muss entweder mit einem Buchstaben, einem Unterstrich oder einem @-Symbol beginnen. Beispiel:

   Regeln für die Benennung von Variablen in C#

   Variablennamen	Bemerkungen
   Name	Gültig
   subject101	Gültig
   _age	Gültig (Best Practice für die Benennung privater Mitgliedsvariablen)
   @break	Gültig (wird verwendet, wenn name ein reserviertes Schlüsselwort ist)
   101Betreff	Ungültig (Beginnt mit Ziffer)
   Ihr_Name	Gültig
   Ihr Name	Ungültig (enthält Leerzeichen)

3. C# unterscheidet zwischen Groß- und Kleinschreibung. Es bedeutet Alter und Alter bezieht sich auf 2 verschiedene Variablen.
4. Ein Variablenname darf kein C#-Schlüsselwort sein. Beispiel:if , for , using darf kein Variablenname sein. Wir werden im nächsten Tutorial mehr über C#-Schlüsselwörter diskutieren.

---

Best Practices für die Benennung einer Variablen

1. Wählen Sie einen sinnvollen Variablennamen. Beispiel:name , Alter , Betreff sinnvoller als n , ein und s .
2. Verwenden Sie camelCase Notation (beginnt mit Kleinbuchstaben) zur Benennung lokaler Variablen. Beispiel:numberOfStudents , Alter usw.
3. Verwenden Sie PascalCase oder CamelCase (beginnt mit einem Großbuchstaben) zur Benennung öffentlicher Member-Variablen. Beispiel:Vorname , Preis usw.
4. Verwenden Sie einen vorangestellten Unterstrich (_), gefolgt von camelCase Notation für die Benennung privater Member-Variablen. Beispiel:_bankBalance , _emailAddress usw.

Hier erfahren Sie mehr über Namenskonventionen in C#.

Machen Sie sich keine Gedanken über öffentliche und private Member-Variablen. Wir werden sie in späteren Kapiteln kennenlernen.

---

Primitive C#-Datentypen

Variablen in C# werden grob in zwei Typen eingeteilt:Werttypen und Referenztypen . In diesem Tutorial werden wir über primitive (einfache) Datentypen diskutieren, die eine Unterklasse von Werttypen sind.

Referenztypen werden in späteren Tutorials behandelt. Wenn Sie jedoch mehr über Variablentypen erfahren möchten, besuchen Sie C#-Typen und -Variablen (offizielle C#-Dokumentation).

Boolesch (bool)

• Der boolesche Datentyp hat zwei mögliche Werte:true oder false
• Standardwert :false
• Boolesche Variablen werden im Allgemeinen verwendet, um Bedingungen wie in if-Anweisungen zu prüfen , Schleifen usw.

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

True

---

Signiertes Integral

Diese Datentypen enthalten ganzzahlige Werte (sowohl positiv als auch negativ). Von den insgesamt verfügbaren Bits wird ein Bit für das Vorzeichen verwendet.

1. sbyte

• Größe :8 Bit
• Reichweite :-128 bis 127.
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

23

Versuchen Sie, Werte außerhalb des zulässigen Bereichs zuzuweisen, d. h. kleiner als -128 oder größer als 127, und sehen Sie, was passiert.

---

2. kurz

• Größe :16 Bit
• Reichweite :-32.768 bis 32.767
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

-1109

---

3. int

• Größe :32 Bit
• Reichweite :-231 bis 231-1
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

51092

---

4. lang

• Größe :64 Bit
• Reichweite :-263 bis 263-1
• Standardwert :0L [L am Ende stellt dar, dass der Wert vom Typ long ist]

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

-7091821871

---

Vorzeichenloses Integral

Diese Datentypen enthalten nur Werte gleich oder größer als 0. Wir verwenden diese Datentypen im Allgemeinen zum Speichern von Werten, wenn wir sicher sind, dass wir keine negativen Werte haben werden.

1. byte

• Größe :8 Bit
• Reichweite :0 bis 255.
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

62

---

2. ukurz

• Größe :16 Bit
• Reichweite :0 bis 65.535
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

42019

---

3. uint

• Größe :32 Bit
• Reichweite :0 bis 232-1
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

1151092

---

4. lang

• Größe :64 Bit
• Reichweite :0 bis 264-1
• Standardwert :0

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

17091821871

---

Fließkomma

Diese Datentypen enthalten Gleitkommawerte, d. h. Zahlen mit Dezimalwerten. Zum Beispiel 12.36, -92.17 usw.

1. schweben

• Gleitkommatyp mit einfacher Genauigkeit
• Größe :32 Bit
• Reichweite :1,5 × 10−45 bis 3,4 × 1038
• Standardwert :0.0F [F am Ende stellt dar, dass der Wert vom Float-Typ ist]

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

43.27

---

2. doppelt

• Gleitkommatyp mit doppelter Genauigkeit. Was ist der Unterschied zwischen Gleitkommazahlen mit einfacher und doppelter Genauigkeit?
• Größe :64 Bit
• Reichweite :5,0 × 10−324 bis 1,7 × 10308
• Standardwert :0.0D [D am Ende stellt dar, dass der Wert vom Typ Double ist]

Zum Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

-11092.53

---

Zeichen (char)

• Es stellt ein 16-Bit-Unicode-Zeichen dar.
• Größe :16 Bit
• Standardwert :'\0'
• Reichweite :U+0000 ('\u0000') bis U+FFFF ('\uffff')

Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

B
x

Der Unicode-Wert von 'B' ist '\u0042' , daher wird ch1 ausgegeben wird 'B' ausgeben .

---

Dezimal

• Der Dezimaltyp hat im Vergleich zu Gleitkommatypen (Double und Float) eine höhere Genauigkeit und einen kleineren Bereich. Es ist also für monetäre Berechnungen geeignet.
• Größe :128 Bit
• Standardwert :0.0M [M am Ende stellt dar, dass der Wert vom Dezimaltyp ist]
• Reichweite :(-7,9 x 1028 bis 7,9 x 1028) / (100 bis 28)

Beispiel:

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

53005.25

Das Suffix M oder m muss am Ende hinzugefügt werden, sonst wird der Wert als Double behandelt und ein Fehler generiert.

---

C#-Literale

Schauen wir uns die folgende Anweisung an:

int number = 41;

Hier,

• int ist ein Datentyp
• Nummer ist eine Variable und
• 41 ist ein Literal

Literale sind feste Werte, die im Programm erscheinen. Sie erfordern keine Berechnung. Beispiel:5 , false , 'w' sind Literale, die direkt ohne Berechnung in einem Programm erscheinen.

---

Boolesche Literale

• true und false sind die verfügbaren booleschen Literale.
• Sie werden verwendet, um boolesche Variablen zu initialisieren.

Zum Beispiel:

bool isValid = true;
bool isPresent = false;

---

Integer-Literale

• Integer-Literale werden verwendet, um Variablen von Integer-Datentypen zu initialisieren, z. B. sbyte , short , int , long , byte , ushort , uint und ulong .
• Wenn ein Integer-Literal mit L endet oder l , es ist vom Typ lang. Verwenden Sie für bewährte Verfahren L (nicht l ).

  long value1 = 4200910L;
  long value2 = -10928190L;

• Wenn ein Integer-Literal mit 0x beginnt , stellt es einen Hexadezimalwert dar. Zahlen ohne Präfixe werden als Dezimalwert behandelt. Oktal- und Binärdarstellung sind in C# nicht zulässig.

  int decimalValue = 25;
  int hexValue = 0x11c;// decimal value 284

---

Gleitkommaliterale

• Gleitkommaliterale werden verwendet, um Variablen vom Datentyp Float und Double zu initialisieren.
• Wenn ein Fließkommaliteral mit einem Suffix f endet oder F , es ist vom Typ Float. Ebenso, wenn es mit d endet oder D , es ist vom Typ Double. Wenn keines der Suffixe vorhanden ist, ist es standardmäßig vom Typ double .
• Diese Literale enthalten e oder E, wenn sie in wissenschaftlicher Notation ausgedrückt werden.

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

---

Zeichen- und Zeichenfolgenliterale

• Zeichenliterale werden verwendet, um Variablen vom Datentyp char zu initialisieren.
• Zeichenliterale werden in einfache Anführungszeichen gesetzt. Beispiel:'x' , 'p' usw.
• Sie können als Zeichen, hexadezimale Escape-Sequenz, Unicode-Darstellung oder ganzzahlige Werte, die in Zeichen umgewandelt werden, dargestellt werden.

  char ch1 = 'R';// character
  char ch2 = '\x0072';// hexadecimal
  char ch3 = '\u0059';// unicode
  char ch4 = (char)107;// casted from integer

• String-Literale sind die Sammlung von Zeichenliteralen.
• Sie werden in doppelte Anführungszeichen eingeschlossen. Beispiel: "Hallo" , "Einfache Programmierung" usw.

  string firstName = "Richard";
  string lastName = " Feynman";

• C# unterstützt auch Escape-Sequenzzeichen wie:
  

  Zeichen	Bedeutung
  \'	Einfaches Anführungszeichen
  \"	Doppeltes Anführungszeichen
  \\	Backslash
  \n	Neue Zeile
  \r	Wagenrücklauf
  \t	Horizontaler Tab
  \a	Warnung
  \b	Rücktaste