C#-Datentypen

Wie der Name schon sagt, ist der Datentyp der Datentyp, den Sie in Ihrer Variablen speichern möchten. Der Datentyp wird verwendet, um dem Compiler oder Interpreter vorzuschlagen, welche Art von Daten er verarbeiten wird und wie viel Speicher für diese Daten benötigt wird.

Beispiel: int ist ein Datentyp, der numerische Werte speichert und vier Bytes benötigt.

Da C# eine stark typisierte Sprache ist, muss vor der Verwendung der Typ der Variablen oder Konstante deklariert werden. Die richtige Verwendung von Datentypen spart Speicherplatz und verbessert die Leistung der Anwendung.

Syntax:

datatype <variable_name> = value;

Beispiele für C#-Datentypen:

1. int intVal = 55; In diesem Beispiel: int ist ein Datentyp, intVal ist ein Variablenname, 55 ist ein Wert.

2. char charVal = ‘A’;

3. string strVal = „Hallo Welt!“;

4. float floatVal = 15.5f;

5. bool boolVal = true;

Top 3 C#-Datentypen

C#-Datentypen sind in drei Kategorien unterteilt:

1. Werttypen

• Speichert den Wert einer Variablen direkt im Speicher.
• Akzeptiert sowohl signierte als auch nicht signierte Literale.

In C# gibt es zwei Arten von Wertdatentypen:

1. Vordefinierte Datentypen wie int, char, bool usw.
2. Benutzerdefinierte Datentypen wie enum, struct usw.

2. Referenztypen

• Sie speichern die Adresse der Variablen, d. h. sie enthalten den Verweis auf eine Variable.
• Wenn die Daten durch eine Variable geändert werden, erhält die andere Variable automatisch den aktualisierten Wert.

In C# gibt es zwei Arten von Referenzdatentypen:

1. Vordefinierte Typen wie Object, String
2. Benutzerdefinierte Typen wie Klasse, Schnittstelle

3. Zeigertypen

• Sie enthalten die Speicheradresse der Variablen.

Im Zeiger verwendete Symbole:

1. &(kaufmännisches Und): Adressoperator, bestimmt die Adresse einer Variablen
2. *(Sternchen): Indirektionsoperator, greifen Sie auf den Wert einer Adresse zu

Beispiele für verschiedene Datentypen

Im Folgenden finden Sie einige Beispiele für verschiedene Datentypen in C#,

Beispiel #1: Einige Werttypen

using System;
public class ValueDataTypes
{
public static void Main()
{
//int - 32-bit signed integer type
int i = 55;
//char - 16-bit Unicode character
char ch = 'A';
//short - 16-bit signed integer type
short s = 56;
//long - 64-bit signed integer type
long l = 5564;
//uint - 32-bit unsigned integer type
uint ui = 100;
//ushort - 16-bit unsigned integer type
ushort us = 80;
//ulong - 64-bit unsigned integer type
ulong ul = 3625573;
//double - 64-bit double precision floating point type
double d = 6.358674532;
//float - 32-bit single-precision floating point type
//float needs 'f' or 'F' as suffix
float f = 2.7330645f;
//decimal - 128-bit precise decimal values with 28-29 significant digits
//decimal needs 'm' or 'M' as suffix
decimal dec = 339.5m;
Console.WriteLine("Integer: " + i);
Console.WriteLine("Char: " + ch);
Console.WriteLine("Short: " + s);
Console.WriteLine("Long: " + l);
Console.WriteLine("Unsinged integer: " + ui);
Console.WriteLine("Unsinged short: " + us);
Console.WriteLine("Unsinged long: " + ul);
Console.WriteLine("Double: " + d);
Console.WriteLine("Float: " + f);
Console.WriteLine("Decimal: " + dec);
}
}

Ausgabe:

Beispiel #2: Bool-, Enum- und Struct-Datentyp

Die Struktur ist ein zusammengesetzter Typ, der zum Speichern verwandter Daten mit unterschiedlichen Datentypen verwendet wird. Enum wird verwendet, um Integralkonstanten Namen zuzuweisen.

using System;
public class BoolEnumStruct
{
//declaring enum
enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
//declaring structure
struct Student
{
public int Id;
public string FirstName;
public string LastName;
public Student(int id, string fname, string lname)
{
Id = id;
FirstName = fname;
LastName = lname;
}
}
public static void Main()
{
//boolean data type
bool flag = true;
if(flag)
{
Console.WriteLine("Bool value: "+flag);
Console.WriteLine();
}
//Accessing enum value for Friday
Console.WriteLine("Enumeration:");
Console.WriteLine(Days.Friday);
Console.WriteLine((int)Days.Friday);
Console.WriteLine();
//passing values to structure members using constructor
Student student = new Student(1, "Riya", "Sen");
Console.WriteLine("Structure Members:");
Console.WriteLine(student.Id);
Console.WriteLine(student.FirstName);
Console.WriteLine(student.LastName);
}
}

Ausgabe:

Beispiel #3: Referenzdatentypen

using System;
public class StrObjDynamic
{
public static void Main()
{
string str = "C# ";
str += "Data Types";
Console.WriteLine("String: "+str);
Console.WriteLine();
//declaring object
object obj;
obj = 100;
Console.WriteLine("Object: "+obj);
//displaying type of object using GetType()
Console.WriteLine(obj.GetType());
Console.WriteLine();
//declaring dynamic variables
dynamic value1 = "Hello World!";
dynamic value2 = 5296;
dynamic value3 = 6.5;
//displaying actual type of dynamic variables using GetType()
Console.WriteLine("Dynamic:");
Console.WriteLine("Type of value1: {0}", value1.GetType().ToString());
Console.WriteLine("Type of value2: {0}", value2.GetType().ToString());
Console.WriteLine("Type of value3: {0}", value3.GetType().ToString());
}
}

Ausgabe:

Beispiel #4: Schnittstelle

Eine Schnittstelle kann Eigenschaften, Methoden, Ereignisse und Indexer als Mitglieder haben. Es enthält lediglich die Erklärung seiner Mitglieder. Die Implementierung seiner Mitglieder wird von der Klasse bereitgestellt, die sie implizit oder explizit implementiert.

using System;
interface Shape
{
void rectangle();
}
public class Area : Shape
{
//implementing interface method
public void rectangle()
{
Console.WriteLine("Area of rectangle is Length * Breadth");
}
public static void Main(String[] args)
{
Area area = new Area();
area.rectangle();
}
}

Ausgabe:

Beispiel #5: Delegieren

Ein Delegat ist ein Objekt, das den Verweis auf die Methode enthält.

using System;
public class DelegateDemo
{
// Declaring delegate
public delegate void Sum(int a, int b);
public void SumVal(int a, int b)
{
Console.WriteLine(a +"+"+ b+ " = {0}", a + b);
}
public static void Main(String[] args)
{
DelegateDemo delegateDemo = new DelegateDemo();
// Creating object of delegate
Sum sum = new Sum(delegateDemo.SumVal);
//Passing values to the method using delegate object
sum(100, 100);
}
}

Ausgabe:

Fazit

• Der Werttyp wird im Stapel gespeichert.
• Ein Referenztyp wird im Heap gespeichert.
• Wenn ein Werttyp in einen Referenztyp konvertiert wird, spricht man von Boxing (implizites Konvertierungsverfahren).
• Wenn ein Referenztyp in einen Werttyp konvertiert wird, spricht man von Unboxing (expliziter Konvertierungsprozess).

Das obige ist der detaillierte Inhalt vonC#-Datentypen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!