C# Conversion de type

En C#, la conversion de type est le processus consistant à convertir une valeur d'un type de données vers un autre type de données.

La conversion de type en C# peut être divisée en deux types :conversion de type impliciteetconversion de type explicite(également appelée conversion de type forcée).

Conversion de type implicite

La conversion implicite est une conversion qui ne nécessite pas d'écrire du code pour la spécifier ; le compilateur l'effectue automatiquement.

La conversion implicite désigne le fait que lors de la conversion d'un type de données de plus petite plage vers un type de données de plus grande plage, le compilateur effectue automatiquement la conversion de type. Ces conversions sont des conversions par défaut de C# effectuées de manière sûre et n'entraînent pas de perte de données.

Par exemple, de int à long, de float à double, etc.

Conversion d'un petit type entier vers un grand type entier, ou d'une classe dérivée vers une classe de base. Lorsqu'on affecte une variable de type byte à une variable de type int, le compilateur convertit automatiquement le type byte en type int sans nécessiter de conversion explicite.

Exemple

octet b = 10;
int i = b; // Conversion implicite, aucune conversion explicite nécessaire

Affecter un entier à un entier long, ou affecter un nombre à virgule flottante à un nombre à virgule flottante à double précision, ce type de conversion n'entraîne pas de perte de données :

Exemple

int intValue = 42;
long longValue = intValue; // Conversion implicite de int à long

Conversion explicite

La conversion de type explicite, également appelée conversion de type forcée, nécessite que le programmeur la spécifie explicitement dans le code.

La conversion explicite désigne le fait que lors de la conversion d'un type de données de plus grande plage vers un type de données de plus petite plage, ou de la conversion d'un type d'objet vers un autre type d'objet, un opérateur de transtypage est requis pour une conversion explicite. La conversion forcée peut entraîner une perte de données.

Par exemple, affecter une variable de type int à une variable de type byte nécessite une conversion explicite.

Exemple

int i = 10;
byte b = (byte)i; // Conversion explicite, nécessite un opérateur de transtypage

Conversion vers un type entier :

Exemple

double doubleValue = 3.14;
int intValue = (int)doubleValue; // Conversion forcée de double en int ; les données peuvent perdre la partie fractionnaire

Conversion vers un type à virgule flottante :

Exemple

int intValue = 42;
float floatValue = (float)intValue; // Conversion forcée d'int en float, les données peuvent perdre de la précision

Conversion vers un type chaîne :

Exemple

int intValue = 123;
string stringValue = intValue.ToString(); // Convertir int en string

L'exemple suivant illustre une conversion de type explicite :

Exemple

using System;

namespace TypeConversionApplication
{
class ExplicitConversion
{
static void Main(string[] args)
{
double d = 5673.74;
int i;

// Convertir double en int
i = (int)d;
Console.WriteLine(i);
Console.ReadKey();

}
}
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Méthodes de conversion de type C#

C# fournit les méthodes de conversion de type intégrées suivantes :

Numéro de série	Metode & Deskripsi
1	ToBoolean Convertir un type en une valeur booléenne si possible.
2	To Convertit un type en un type byte.
3	ToChar Convertir un type en un type caractère Unicode unique si possible.
4	ToDateTime Convertit un type (type entier ou chaîne) en une structure date-heure.
5	ToDecimal Convertir un type à virgule flottante ou entier en un type décimal.
6	ToDouble Convertit un type en un type à virgule flottante à double précision.
7	ToInt16 Convertit un type en type entier 16 bits.
8	ToInt32 Convertit un type en type entier 32 bits.
9	ToInt64 Convertit un type en type entier 64 bits.
10	ToSbyte Convertit un type en type octet signé.
11	ToSingle Convertit un type en type à virgule flottante simple précision.
12	ToString Convertit un type en type chaîne.
13	ToType Convertit un type en un type spécifié.
14	ToUInt16 Convertit un type en un type entier non signé de 16 bits.
15	ToUInt32 Convertit un type en un type entier non signé de 32 bits.
16	ToUInt64 Convertit un type en un type entier non signé de 64 bits.

Ces méthodes sont toutes définies dans la classe System.Convert, et vous devez inclure l'espace de noms System lorsque vous les utilisez. Elles offrent un moyen sûr d'effectuer une conversion de type, car elles peuvent gérer les valeurs null et lèvent une exception si la conversion n'est pas possible.

Par exemple, en utilisant la méthode Convert.ToInt32 pour convertir une chaîne en entier :

string str = "123";
int number = Convert.ToInt32(str); // 转换成功，number为123

Si la chaîne n'est pas une représentation valide d'un entier, Convert.ToInt32 lèvera une FormatException.

L'exemple suivant convertit des types de valeurs différentes en types string :

Exemple

using System;

namespace TypeConversionApplication
{
class StringConversion
{
static void Main(string[] args)
{
// Définir une variable entière
int i = 75;

// Définir une variable à virgule flottante
float f = 53.005f;

// Définir une variable à virgule flottante en double précision
double d = 2345.7652;

// Définir une variable booléenne
bool b = true;

// Convertir une variable entière en chaîne de caractères et l'afficher
Console.WriteLine(i.ToString());

// Convertir une variable à virgule flottante en chaîne de caractères et l'afficher
Console.WriteLine(f.ToString());

// Convertir la variable à virgule flottante en double précision en chaîne de caractères et l'afficher
Console.WriteLine(d.ToString());

// Convertir une variable booléenne en chaîne de caractères et l'afficher
Console.WriteLine(b.ToString());

// Attendre que l'utilisateur appuie sur une touche avant de fermer la fenêtre de console
Console.ReadKey();
}
}
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

75
53.005
2345.7652
True

Lors d'une conversion de type, les points suivants doivent être pris en compte :

La conversion implicite ne peut convertir qu'un type de données ayant une plage plus petite vers un type de données ayant une plage plus grande, et ne peut pas convertir un type de données ayant une plage plus grande vers un type de données ayant une plage plus petite;
La conversion explicite peut entraîner une perte de données ou une précision réduite, donc des contrôles de compatibilité des types de données sont nécessaires ;
Pour la conversion de type d'objet, des contrôles de compatibilité pour la conversion de type et des contrôles de sécurité pour la conversion de type sont nécessaires.

Méthodes de conversion de type

C# fournit diverses méthodes de conversion de type, telles que la classe Convert, la méthode Parse et la méthode TryParse, qui peuvent aider à gérer les conversions entre différents types de données.

Utilisation de la classe Convert

La classe Convert fournit un ensemble de méthodes statiques qui peuvent convertir entre divers types de données de base.

Exemple

string str = "123";
int num = Convert.ToInt32(str);

Utilisation de la méthode Parse

La méthode Parse est utilisée pour convertir une chaîne au type numérique correspondant, et elle lève une exception si la conversion échoue.

Exemple

string str = "123.45";
double d = double.Parse(str);

Utilisation de la méthode TryParse

La méthode TryParse est similaire à Parse, mais elle ne lève pas d'exception ; à la place, elle retourne une valeur booléenne indiquant si la conversion a réussi.

Exemple

string str = "123.45";
double d;
bool success = double.TryParse(str, out d);

if (success) {
Console.WriteLine("Conversion réussie : " + d);
} else {
Console.WriteLine("Échec de la conversion");
}

Conversion de type personnalisée

C# vous permet également de définir des opérations de conversion de type personnalisées en définissant le mot-clé implicit ou explicit dans un type.

Exemple

using System;

public class Fahrenheit
{
public double Degrees { get; set; }

public Fahrenheit(double degrees)
{
Degrees = degrees;
}

// Conversion implicite de Fahrenheit en double
public static implicit operator double(Fahrenheit f)
{
return f.Degrees;
}

// Conversion explicite de double en Fahrenheit
public static explicit operator Fahrenheit(double d)
{
return new Fahrenheit(d);
}
}

public class Program
{
public static void Main()
{
Fahrenheit f = new Fahrenheit(98.6);
Console.WriteLine("Objet Fahrenheit : " + f.Degrees + " degrés");

double temp = f; // Conversion implicite
Console.WriteLine("Après conversion implicite en double : " + temp + " degrés");

Fahrenheit newF = (Fahrenheit)temp; // Conversion explicite
Console.WriteLine("Après conversion explicite vers Fahrenheit : " + newF.Degrés + " degrés");
}
}

Dans l'exemple ci-dessus, nous avons défini une classe Fahrenheit et implémenté une conversion implicite de Fahrenheit vers double et une conversion explicite de double vers Fahrenheit.

Le résultat de sortie s'affichera comme suit :

Fahrenheit object: 98.6 degrees
After implicit conversion to double: 98.6 degrees
After explicit conversion back to Fahrenheit: 98.6 degrees

Résumé

En C#, les méthodes de conversion de type intégrées sont principalement mises en œuvre des manières suivantes : conversion implicite, conversion explicite (conversion forcée), méthodes utilisant la classe Convert, la méthode Parse et la méthode TryParse. Ces méthodes sont largement utilisées pour la conversion entre différents types de données.

Le tableau suivant présente les méthodes de conversion de type intégrées de C# :

Catégorie de méthode	Méthodes	Description
Conversion implicite	Conversion automatique	Aucune spécification explicite n'est requise ; elle est généralement utilisée pour des conversions de type sûres, comme d'un type plus petit vers un type plus grand.
Conversion explicite (cast)	`(type)value`	Une spécification explicite est requise ; elle est généralement utilisée dans les cas pouvant entraîner une perte de données ou un échec de conversion.
`Convert`Méthodes de classe	`Convert.ToBoolean(value)`	Convertit le type spécifié en`Boolean`
	`Convert.ToByte(value)`	Convertit le type spécifié en`Byte`
	`Convert.ToChar(value)`	Convertit le type spécifié en`Char`
	`Convert.ToDateTime(value)`	Convertit le type spécifié en`DateTime`
	`Convert.ToDecimal(value)`	Convertit le type spécifié en`Decimal`
	`Convert.ToDouble(value)`	Convertit le type spécifié en`Double`
	`Convert.ToInt16(value)`	Convertit le type spécifié en`Int16`(entier court)
	`Convert.ToInt32(value)`	Convertit le type spécifié en`Int32`(entier)
	`Convert.ToInt64(value)`	Convertit le type spécifié en`Int64`(entier long)
	`Convert.ToSByte(value)`	Convertit le type spécifié en`SByte`
	`Convert.ToSingle(value)`	Convertit le type spécifié en`Single`(type à virgule flottante simple précision)
	`Convert.ToString(value)`	Convertit le type spécifié en`String`
	`Convert.ToUInt16(value)`	Convertit le type spécifié en`UInt16`(type entier court non signé)
	`Convert.ToUInt32(value)`	Convertit le type spécifié en`UInt32`(entier non signé)
	`Convert.ToUInt64(value)`	Convertit le type spécifié en`UInt64`(type entier long non signé)
`Parse`Méthodes	`Boolean.Parse(string)`	Analyser la chaîne comme`Boolean`
	`Byte.Parse(string)`	Analyser la chaîne comme`Byte`
	`Char.Parse(string)`	Analyser la chaîne comme`Char`
	`DateTime.Parse(string)`	Analyser la chaîne comme`DateTime`
	`Decimal.Parse(string)`	Analyser la chaîne comme`Decimal`
	`Double.Parse(string)`	Analyser la chaîne comme`Double`
	`Int16.Parse(string)`	Analyser la chaîne comme`Int16`
	`Int32.Parse(string)`	Analyser la chaîne comme`Int32`
	`Int64.Parse(string)`	Analyser la chaîne comme`Int64`
	`SByte.Parse(string)`	Analyser la chaîne comme`SByte`
	`Single.Parse(string)`	Analyser la chaîne comme`Single`
	`UInt16.Parse(string)`	Analyser la chaîne comme`UInt16`
	`UInt32.Parse(string)`	Analyser la chaîne comme`UInt32`
	`UInt64.Parse(string)`	Analyser la chaîne comme`UInt64`
`TryParse`Méthodes	`Boolean.TryParse(string, out bool)`	Essayer d'analyser la chaîne comme`Boolean`, renvoie une valeur booléenne indiquant si elle a réussi
	`Byte.TryParse(string, out byte)`	Essayer d'analyser la chaîne comme`Byte`, renvoie une valeur booléenne indiquant si elle a réussi
	`Char.TryParse(string, out char)`	Essayer d'analyser la chaîne comme`Char`, renvoie une valeur booléenne indiquant si elle a réussi
	`DateTime.TryParse(string, out DateTime)`	Essayer d'analyser la chaîne comme`DateTime`, renvoie une valeur booléenne indiquant si elle a réussi
	`Decimal.TryParse(string, out decimal)`	Essayer d'analyser la chaîne comme`Decimal`, renvoie une valeur booléenne indiquant si elle a réussi
	`Double.TryParse(string, out double)`	Essayer d'analyser la chaîne comme`Double`, renvoie une valeur booléenne indiquant si elle a réussi
	`Int16.TryParse(string, out short)`	Essayer d'analyser la chaîne comme`Int16`, renvoie une valeur booléenne indiquant si elle a réussi
	`Int32.TryParse(string, out int)`	Essayer d'analyser la chaîne comme`Int32`, renvoie une valeur booléenne indiquant si elle a réussi
	`Int64.TryParse(string, out long)`	Essayer d'analyser la chaîne comme`Int64`, renvoie une valeur booléenne indiquant si elle a réussi
	`SByte.TryParse(string, out sbyte)`	Essayer d'analyser la chaîne comme`SByte`, renvoie une valeur booléenne indiquant si elle a réussi
	`Single.TryParse(string, out float)`	Essayer d'analyser la chaîne comme`Single`, renvoie une valeur booléenne indiquant si elle a réussi
	`UInt16.TryParse(string, out ushort)`	Essayer d'analyser la chaîne comme`UInt16`, renvoie une valeur booléenne indiquant si elle a réussi
	`UInt32.TryParse(string, out uint)`	Essayer d'analyser la chaîne comme`UInt32`, renvoie une valeur booléenne indiquant si elle a réussi
	`UInt64.TryParse(string, out ulong)`	Essayer d'analyser la chaîne comme`UInt64`, renvoie une valeur booléenne indiquant si elle a réussi

autres extensions

C# Tutoriels avancés

C# Conversion de type

Conversion de type implicite

Exemple

Exemple

Conversion explicite

Exemple

Exemple

Exemple

Exemple

Exemple

Méthodes de conversion de type C#

Exemple

Méthodes de conversion de type

Utilisation de la classe Convert

Exemple

Utilisation de la méthode Parse

Exemple

Utilisation de la méthode TryParse

Exemple

Conversion de type personnalisée

Exemple

Résumé