Typumwandlung in C#

Type Casting in C# ist so definiert, dass wir einen beliebigen Datentyp einem anderen Datentyp zuweisen und es dann als „Typecasting“ bezeichnen. Untere Datentypwerte jeder Programmiersprache können automatisch in obere Datentypwerte umgewandelt werden. In dieser Situation kommt es zu keinem Datenverlust, wohingegen im Fall eines oberen Datentypwerts in einen unteren Datentypwert die Gefahr eines Datenverlusts besteht. Der C#-Compiler kann die Umstellung vom unteren Datentyp auf den oberen Datentyp automatisch durchführen, für die Typumwandlung vom oberen Datentyp zum unteren Datentyp ist jedoch eine explizite Typumwandlung erforderlich. Dies wird als „explizites Casting“ bezeichnet.

Nehmen wir ein Beispiel für einen Long-Wert in einen Int-Wert, bei dem es sich um eine explizite Typumwandlung handelt.

Warum erforderte die explizite Umwandlung größere Datentypen in kleinere Datentypen?

Betrachten wir eine kleine Analogie, dann werden Sie ganz klar verstehen, dass es zwei Wasserflaschen gibt, eine mit 1 Liter und die andere mit 2 Litern. Wir können problemlos 1 Liter Wasser in 2 Liter Wasserflasche füllen, ohne dass es überläuft. Wenn wir versuchen, 2 Liter Wasser aus einer Wasserflasche in eine 1-Liter-Flasche zu gießen, besteht die Möglichkeit, dass Wasser überläuft, wenn eine 2-Liter-Wasserflasche mehr als 1 Liter Wasser enthält. In diesem Fall ist eine 1-Liter-Wasserflasche der untere Datentyp und 2-Liter-Wasserflaschen der obere Datentyp. Selbst wenn das Wasser überläuft, möchten wir dennoch 2 Liter Wasser in eine 1-Liter-Wasserflasche gießen, die wir einschenken können, sodass die Kunden dies akzeptieren müssen. Ebenso wie Entwickler klare Vorstellungen haben, selbst wenn wir versuchen, obere Datentypen in niedrigere Datentypen umzuwandeln, kann es zu einem Datenverlust kommen, den er akzeptieren muss.

Arten des Castings in C#

Es gibt zwei Arten des Castings in C#.

• Explizite Typumwandlung
• Implizite Typumwandlung: Die Konvertierung von kleineren Datentypen in größere Datentypen wird als „implizite Typumwandlung“ bezeichnet. Dies erfolgt automatisch durch den C#-Compiler. Es gibt keinen Datenverlust.

1. Implizite Typumwandlung

byte->short->int->long->float->double

Code:

Bigger_dataType  variableName=smaller_dataType_Value;

2. Explizite Typumwandlung

Die Konvertierung eines größeren Datentyps in einen kleineren Datentyp wird als „explizite Typumwandlung“ bezeichnet. Dies wird vom C#-Compiler nicht automatisch durchgeführt. Es kann zu Datenverlust kommen. Dies muss vom Entwickler explizit erfolgen.

byte->short, int, long, float, double

short->int, long, float, double

int->long, float, double

long->float, double

float->double

Code:

Smaller_dataType  variableName=(Smaller_dataType)Bigger_dataType_Value;

Hinweis: Die Umwandlung ist nur bei kompatiblen Datentypen anwendbar, d. h. nur bei Zahlen mit Zahlenkonvertierung, nicht aber bei Zeichenfolgen mit Zahlen umgekehrt usw. Ich tue dies, damit möglicherweise eine nicht unterstützte Ausnahme auftritt.

Methoden zur Typkonvertierung

• ToBoolean: Es wird ein Typ in einen booleschen Wert konvertiert.
• ToChar: Konvertiert einen Typ in einen Zeichenwert.
• ToByte: Es wird ein Wert in einen Byte-Wert umgewandelt.
• ToDecimal: Es wird ein Wert in einen Dezimalpunktwert umgewandelt.
• ToDouble: Es wird ein Typ in einen Double-Datentyp konvertiert.
• ToInt16: Konvertiert einen Typ in eine 16-Bit-Ganzzahl
• ToInt32: Konvertiert einen Typ in eine 32-Bit-Ganzzahl
• ToInt64: Konvertiert einen Typ in eine 64-Bit-Ganzzahl
• ToString: Konvertiert einen bestimmten Typ in String
• ToUInt16: Konvertiert einen Typ in eine vorzeichenlose 16-Bit-Ganzzahl
• ToUInt32: Konvertiert einen Typ in eine vorzeichenlose 32-Bit-Ganzzahl
• ToUInt64: Konvertiert einen Typ in eine vorzeichenlose 64-Bit-Ganzzahl

Beispiele zur Implementierung der Typumwandlung in C#

Im Folgenden sind einige Beispiele aufgeführt:

Beispiel #1

Implizite Typumwandlung

Code:

//including System package in C#
using System;
//Creating class
public class ImplicitTypeCasting {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 200;
// Implicit int to long casting
long longType = intType;
// Implicit long to float casting
float floatType = longType;
// Printing output of implicit conversion variables
Console.WriteLine("INT value after Implicit conversion: " +intType);
Console.WriteLine("LONG value after Implicit conversion:" +longType);
Console.WriteLine("FLOAT value after Implicit conversion: " +floatType);
}
}

Ausgabe:

Beispiel #2

Versuch von größerer Schrift zu kleinerer Schrift. Implizite Typumwandlung

Code:

//including System package in C#
using System;
//Creating class
public class ImplicitCastingBiggerToSmaller {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 200;
// Trying to convert int to byte Implicitly but there is compile time error
byte byteType = intType;
// Trying to convert int to short Implicitly but there is compile time error
short shortType = intType;
// Printing output of implicit conversion variables
Console.WriteLine("INT value after Implicit conversion: " +intType);
Console.WriteLine("BYTE value after Implicit conversion:" +byteType);
Console.WriteLine("SHORT value after Implicit conversion: " +shortType);
}
}

Ausgabe:

Beispiel #3

Explizite Typumwandlung

Code:

//including System package in C#
using System;
//Creating class
public class ExplicitCastingBiggerToSmaller {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 9999999;
int intType1=120;
// Trying to convert int to byte explicitly
byte byteType = (byte)intType;
byte byteType1 = (byte)intType1;
// Trying to convert int to short explicitly
short shortType = (short)intType;
short shortType1 = (short)intType1;
// Printing output of explicit conversion variables
//Given int range is not in byte and short range so there must be loss of data result into incorrect output
Console.WriteLine("BYTE value after Explicit conversion: " +byteType);
Console.WriteLine("SHORT value after Explicit conversion: " +shortType);
Console.WriteLine("\n");
// Printing output of explicit conversion variables
//Given int range is in byte and short range so there no data loss
Console.WriteLine("BYTE value after Explicit conversion: " +byteType1);
Console.WriteLine("SHORT value after Explicit conversion: " +shortType1);
}
}<strong> </strong>

Ausgabe:

Beispiel #4

Explizite Typumwandlung mit vordefinierten Methoden

Code:

//including System package in C#
using System;
//Creating class
public class ExplicitCastingBiggerToSmaller {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 9999999;
double doubleType=122.23;
float floatType=222.222f;
// Printing output of explicit convertion variables
//By using C# predefined method for type casting
Console.WriteLine("INT to STRING type value with predefined method convertion: "+Convert.ToString(intType));
Console.WriteLine("DOUBLE to INT type value with predefined method convertion: "+Convert.ToInt32(doubleType));
Console.WriteLine("FLOAT to INT type value with predefined method convertion: "+Convert.ToUInt32(floatType));
}
}

Ausgabe:

Fazit

C# gibt es zwei Arten von Typumwandlungen, 1^st eine ist implizite Typumwandlung und die zweite ist explizite Typumwandlung. Die implizite Typumwandlung wird automatisch vom Compiler durchgeführt, die explizite Typumwandlung muss jedoch vom Entwickler durchgeführt werden, da in diesem Fall die Gefahr eines Datenverlusts besteht.

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