Conversion de type en C#

Le type Casting en C# est défini comme si nous attribuions n'importe quel type de données à un autre type de données, puis l'appelions « Typecasting ». Tout langage de programmation avec des valeurs de type de données inférieures peut automatiquement être converti en valeurs de type de données supérieures. Dans cette situation, il n'y a pas de perte de données, alors que dans le cas d'une valeur de type de données supérieure vers une valeur de type de données inférieure, il peut y avoir un risque de perte de données. Le type de données inférieur au type de données supérieur peut être automatiquement effectué par le compilateur C#, mais le type de données supérieur vers le type de données inférieur, nous devons avoir besoin d'un transtypage explicite. Ce qui est connu sous le nom de « Casting explicite ».

Prenons un exemple de valeur longue en valeur int qui est un transtypage explicite.

Pourquoi le casting explicite nécessitait-il des types de données plus volumineux vers des types de données plus petits ?

Considérons une petite analogie et vous comprendrez très clairement qu'il y a 2 bouteilles d'eau, l'une fait 1 litre et l'autre fait 2 litres. On peut facilement verser 1 litre d'eau dans 2 litres de gourde sans déborder. De la même manière, si nous essayons de verser 2 litres d’eau d’une bouteille d’eau dans 1 litre, il peut y avoir un risque de débordement d’eau si une bouteille d’eau de 2 litres contient plus de 1 litre d’eau. Ainsi, dans ce cas, une bouteille d’eau de 1 litre est le type de données inférieur et les bouteilles d’eau de 2 litres sont un type de données supérieur. Même s'il y a un risque de débordement d'eau, nous voulons quand même verser 2 litres d'eau dans une bouteille d'eau de 1 litre que nous pouvons verser afin que les clients acceptent de le faire. De la même manière que les développeurs ont des idées claires, même si nous essayons de convertir le type de données supérieur en types de données inférieurs, il peut y avoir une perte de données, il doit donc l'accepter.

Types de casting en C#

Il existe 2 types de casting en C#.

• Casting de type explicite
• Casting de type implicite : la conversion d'un type de données plus petit en type de données plus grand est appelée « Casting de type implicite ». Ceci est effectué automatiquement par le compilateur C#. Il n'y a aucune perte de données.

1. Casting de type implicite

octet->short->int->long->float->double

Code :

Bigger_dataType  variableName=smaller_dataType_Value;

2. Casting de type explicite

La conversion d'un type de données plus gros en un type de données plus petit est appelée « transtypage explicite ». Cela n'est pas effectué automatiquement par le compilateur C#. Il peut y avoir une perte de données. Cela doit être fait explicitement par le développeur.

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

court->int, long, flottant, double

int->long, flottant, double

long->flotteur, double

flotteur->double

Code :

Smaller_dataType  variableName=(Smaller_dataType)Bigger_dataType_Value;

Remarque : La conversion s'applique uniquement aux types de données compatibles, cela signifie les nombres avec conversion de nombres uniquement, mais pas les chaînes avec les nombres vice versa, etc. Je le fais donc, des exceptions non prises en charge peuvent se produire.

Méthodes de conversion de type

• ToBoolean : il convertira un type en valeur booléenne.
• ToChar : il convertira un type en valeur de caractère.
• ToByte : il convertira une valeur en valeur d'octet.
• ToDecimal : il convertira une valeur en valeur décimale.
• ToDouble : il convertira un type en type de données double.
• ToInt16 : il convertira un type en un entier 16 bits
• ToInt32 : il convertira un type en un entier 32 bits
• ToInt64 : il convertira un type en un entier 64 bits
• ToString : il convertira un type donné en String
• ToUInt16 : il convertira un type en un entier 16 bits non signé
• ToUInt32 : il convertira un type en un entier 32 bits non signé
• ToUInt64 : il convertira un type en un entier 64 bits non signé

Exemples pour implémenter la conversion de type en C#

Voici quelques exemples mentionnés :

Exemple n°1

Casting de type implicite

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);
}
}

Sortie :

Exemple n°2

Essayer d'agrandir le type pour réduire le type Casting de type implicite

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);
}
}

Sortie :

Exemple #3

Casting de type explicite

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>

Sortie :

Exemple n°4

Casting de type explicite avec des méthodes prédéfinies

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));
}
}

Sortie :

Conclusion

C# il existe 2 types de transtypage de type, le 1^st l'un est un transtypage de type implicite et le second est un transtypage explicite. Le transtypage de type implicite est automatiquement effectué par le compilateur, mais le développeur de transtypage de type explicite doit l'effectuer car dans ce cas, il peut y avoir un risque de perte de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!