C# Conversión de tipos
En C#, la conversión de tipos es el proceso de convertir el valor de un tipo de datos a otro tipo de datos.
La conversión de tipos en C# se puede dividir en dos tipos:Conversión implícita de tiposyConversión explícita de tipos(también llamada conversión forzada).
Conversión implícita de tipos
La conversión implícita es una conversión que no requiere escribir código para especificarla; el compilador la realiza automáticamente.
La conversión implícita se refiere a que cuando se convierte un tipo de datos de rango menor a un tipo de datos de rango mayor, el compilador completa automáticamente la conversión de tipos. Estas conversiones son las que C# realiza de forma segura por defecto y no causan pérdida de datos.
Por ejemplo, de int a long, de float a double, etc.
De un tipo entero pequeño a un tipo entero grande, de una clase derivada a una clase base. Si se asigna una variable de tipo byte a una variable de tipo int, el compilador convertirá automáticamente el tipo byte a tipo int, sin necesidad de conversión explícita.
Ejemplo
int i = b; // Conversión implícita, no necesita conversión explícita
Asignar un entero a un entero largo, o asignar un número de punto flotante a un número de punto flotante de doble precisión; esta conversión no causa pérdida de datos:
Ejemplo
long longValue = intValue; // Conversión implícita, de int a long
Conversión explícita
La conversión explícita de tipos, es decir, la conversión forzada de tipos, requiere que el programador la especifique claramente en el código.
La conversión explícita se refiere a que cuando se convierte un tipo de datos de rango mayor a un tipo de datos de rango menor, o cuando se convierte un tipo de objeto a otro tipo de objeto, es necesario utilizar el símbolo de conversión forzada para realizar la conversión explícita. La conversión forzada puede causar pérdida de datos.
Por ejemplo, asignar una variable de tipo int a una variable de tipo byte requiere conversión explícita.
Ejemplo
byte b = (byte)i; // Conversión explícita, se necesita usar el símbolo de conversión forzada
Conversión forzada a tipo entero:
Ejemplo
int intValue = (int)doubleValue; // Forzar de double a int, los datos pueden perder la parte decimal
Conversión forzada a tipo de punto flotante:
Ejemplo
float floatValue = (float)intValue; // Forzar de int a float, los datos pueden perder precisión
Conversión forzada a tipo cadena:
Ejemplo
string stringValue = intValue.ToString(); // Convertir int a cadena
El siguiente ejemplo muestra una conversión de tipos explícita:
Ejemplo
namespace TypeConversionApplication
{
class ExplicitConversion
{
static void Main(string[] args)
{
double d = 5673.74;
int i;
// Convertir forzosamente double a int
i = (int)d;
Console.WriteLine(i);
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce los siguientes resultados:
5673
Métodos de conversión de tipos en C#
C# proporciona los siguientes métodos integrados de conversión de tipos:
| N.º | Método y descripción |
|---|---|
| 1 | ToBoolean Convierte el tipo a booleano, si es posible. |
| 2 | ToByte Convierte el tipo a byte. |
| 3 | ToChar Convierte el tipo a un solo carácter Unicode, si es posible. |
| 4 | ToDateTime Convierte el tipo (entero o cadena) a una estructura de fecha y hora. |
| 5 | ToDecimal Convierte el tipo de punto flotante o entero a tipo decimal. |
| 6 | ToDouble Convierte el tipo a double (doble precisión). |
| 7 | ToInt16 Convierte el tipo a entero de 16 bits. |
| 8 | ToInt32 Convierte el tipo a entero de 32 bits. |
| 9 | ToInt64 Convierte el tipo a entero de 64 bits. |
| 10 | ToSbyte Convierte el tipo a byte con signo. |
| 11 | ToSingle Convierte el tipo a tipo float (punto flotante pequeño). |
| 12 | ToString Convierte el tipo a tipo cadena. |
| 13 | ToType Convierte el tipo al tipo especificado. |
| 14 | ToUInt16 Convierte el tipo a entero sin signo de 16 bits. |
| 15 | ToUInt32 Convierte el tipo a entero sin signo de 32 bits. |
| 16 | ToUInt64 Convierte el tipo a entero sin signo de 64 bits. |
Estos métodos están definidos en la clase System.Convert, y al usarlos se debe incluir el espacio de nombres System. Proporcionan una forma segura de realizar conversiones de tipos, ya que pueden manejar valores null y lanzan excepciones si la conversión no es posible.
Por ejemplo, usando el método Convert.ToInt32 para convertir una cadena a entero:
string str = "123"; int number = Convert.ToInt32(str); // 转换成功,number为123
Si la cadena no es una representación válida de un entero, Convert.ToInt32 lanzará una FormatException.
El siguiente ejemplo convierte tipos de diferentes valores a tipo cadena:
Ejemplo
namespace TypeConversionApplication
{
class StringConversion
{
static void Main(string[] args)
{
// Definir una variable entera
int i = 75;
// Definir una variable de punto flotante
float f = 53.005f;
// Definir una variable de punto flotante de doble precisión
double d = 2345.7652;
// Definir una variable booleana
bool b = true;
// Convertir la variable entera a cadena y generar la salida
Console.WriteLine(i.ToString());
// Convertir la variable de punto flotante a cadena y generar la salida
Console.WriteLine(f.ToString());
// Convertir la variable de doble precisión a cadena y generar la salida
Console.WriteLine(d.ToString());
// Convertir la variable booleana a cadena y generar la salida
Console.WriteLine(b.ToString());
// Esperar a que el usuario presione una tecla para cerrar la ventana de consola
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce los siguientes resultados:
75 53.005 2345.7652 True
Al realizar conversiones de tipos, se deben tener en cuenta los siguientes puntos:
- La conversión implícita solo puede convertir tipos de datos de rango menor a tipos de datos de rango mayor; no puede convertir tipos de datos de rango mayor a tipos de datos de rango menor.
- La conversión explícita puede causar pérdida de datos o reducción de precisión, por lo que es necesario verificar la compatibilidad de los tipos de datos.
- Para la conversión de tipos de objeto, es necesario realizar la verificación de compatibilidad de la conversión de tipos y la verificación de seguridad de la conversión de tipos.
Métodos de conversión de tipos
C# proporciona varios métodos de conversión de tipos, como la clase Convert, el método Parse y el método TryParse. Estos métodos ayudan a manejar la conversión entre diferentes tipos de datos.
Usando la clase Convert
La clase Convert proporciona un conjunto de métodos estáticos que pueden realizar conversiones entre varios tipos de datos básicos.
Ejemplo
int num = Convert.ToInt32(str);
Usando el método Parse
El método Parse se utiliza para convertir una cadena al tipo numérico correspondiente; si la conversión falla, se lanza una excepción.
Ejemplo
double d = double.Parse(str);
Usando el método TryParse
El método TryParse es similar a Parse, pero no lanza excepciones; en su lugar, devuelve un valor booleano que indica si la conversión fue exitosa.
Ejemplo
double d;
bool success = double.TryParse(str, out d);
if (success) {
Console.WriteLine("Conversión exitosa: " + d);
} else {
Console.WriteLine("Conversión fallida");
}
Conversión de tipos personalizada
C# también le permite definir operaciones de conversión de tipos personalizadas, definiendo las palabras clave implicit o explicit en el tipo.
Ejemplo
public class Fahrenheit
{
public double Degrees { get; set; }
public Fahrenheit(double degrees)
{
Degrees = degrees;
}
// Conversión implícita de Fahrenheit a double
public static implicit operator double(Fahrenheit f)
{
return f.Degrees;
}
// Conversión explícita de double a 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("Fahrenheit object: " + f.Degrees + " degrees");
double temp = f; // Conversión implícita
Console.WriteLine("After implicit conversion to double: " + temp + " degrees");
Fahrenheit newF = (Fahrenheit)temp; // Conversión explícita
Console.WriteLine("After explicit conversion back to Fahrenheit: " + newF.Degrees + " degrees");
}
}
En el ejemplo anterior, definimos una clase Fahrenheit e implementamos la conversión implícita de Fahrenheit a double y la conversión explícita de double a Fahrenheit.
El resultado de salida se mostrará de la siguiente manera:
Fahrenheit object: 98.6 degrees After implicit conversion to double: 98.6 degrees After explicit conversion back to Fahrenheit: 98.6 degrees
Resumen
En C#, los métodos integrados de conversión de tipos se implementan principalmente de las siguientes maneras: conversión implícita, conversión explícita (conversión forzada), métodos de la clase Convert, método Parse y método TryParse. Estos métodos se aplican ampliamente en la conversión entre diferentes tipos de datos.
La siguiente es una tabla de los métodos integrados de conversión de tipos en C#:
| Categoría de método | Método | Descripción |
|---|---|---|
| Conversión implícita | Conversión realizada automáticamente | No requiere especificación explícita, generalmente se usa para conversiones de tipos seguras, como de un tipo menor a un tipo mayor. |
| Conversión explícita (conversión forzada) | (type)value | Requiere especificación explícita, generalmente se usa en casos que pueden causar pérdida de datos o fallo de conversión. |
ConvertMétodos de clase | Convert.ToBoolean(value) | Convierte el tipo especificado aBoolean |
Convert.ToByte(value) | Convierte el tipo especificado aByte | |
Convert.ToChar(value) | Convierte el tipo especificado aChar | |
Convert.ToDateTime(value) | Convertir el tipo especificado aDateTime | |
Convert.ToDecimal(value) | Convertir el tipo especificado aDecimal | |
Convert.ToDouble(value) | Convertir el tipo especificado aDouble | |
Convert.ToInt16(value) | Convertir el tipo especificado aInt16(entero corto) | |
Convert.ToInt32(value) | Convertir el tipo especificado aInt32(entero) | |
Convert.ToInt64(value) | Convertir el tipo especificado aInt64(entero largo) | |
Convert.ToSByte(value) | Convertir el tipo especificado aSByte | |
Convert.ToSingle(value) | Convertir el tipo especificado aSingle(flotante de precisión simple) | |
Convert.ToString(value) | Convertir el tipo especificado aString | |
Convert.ToUInt16(value) | Convertir el tipo especificado aUInt16(entero corto sin signo) | |
Convert.ToUInt32(value) | Convertir el tipo especificado aUInt32(entero sin signo) | |
Convert.ToUInt64(value) | Convertir el tipo especificado aUInt64(entero largo sin signo) | |
ParseMétodo | Boolean.Parse(string) | Analizar la cadena comoBoolean |
Byte.Parse(string) | Analizar la cadena comoByte | |
Char.Parse(string) | Analizar la cadena comoChar | |
DateTime.Parse(string) | Analizar la cadena comoDateTime | |
Decimal.Parse(string) | Analizar la cadena comoDecimal | |
Double.Parse(string) | Analizar la cadena comoDouble | |
Int16.Parse(string) | Analizar la cadena comoInt16 | |
Int32.Parse(string) | Analizar la cadena comoInt32 | |
Int64.Parse(string) | Analizar la cadena comoInt64 | |
SByte.Parse(string) | Analizar la cadena comoSByte | |
Single.Parse(string) | Analizar la cadena comoSingle | |
UInt16.Parse(string) | Analizar la cadena comoUInt16 | |
UInt32.Parse(string) | Analizar la cadena comoUInt32 | |
UInt64.Parse(string) | Analizar la cadena comoUInt64 | |
TryParseMétodo | Boolean.TryParse(string, out bool) | Intentar analizar la cadena comoBoolean, que devuelve un valor booleano que indica si se tuvo éxito |
Byte.TryParse(string, out byte) | Intentar analizar la cadena comoByte, que devuelve un valor booleano que indica si se tuvo éxito | |
Char.TryParse(string, out char) | Intentar analizar la cadena comoChar, que devuelve un valor booleano que indica si se tuvo éxito | |
DateTime.TryParse(string, out DateTime) | Intentar analizar la cadena comoDateTime, que devuelve un valor booleano que indica si se tuvo éxito | |
Decimal.TryParse(string, out decimal) | Intentar analizar la cadena comoDecimal, que devuelve un valor booleano que indica si se tuvo éxito | |
Double.TryParse(string, out double) | Intentar analizar la cadena comoDouble, que devuelve un valor booleano que indica si se tuvo éxito | |
Int16.TryParse(string, out short) | Intentar analizar la cadena comoInt16, que devuelve un valor booleano que indica si se tuvo éxito | |
Int32.TryParse(string, out int) | Intentar analizar la cadena comoInt32, que devuelve un valor booleano que indica si se tuvo éxito | |
Int64.TryParse(string, out long) | Intentar analizar la cadena comoInt64, que devuelve un valor booleano que indica si se tuvo éxito | |
SByte.TryParse(string, out sbyte) | Intentar analizar la cadena comoSByte, que devuelve un valor booleano que indica si se tuvo éxito | |
Single.TryParse(string, out float) | Intentar analizar la cadena comoSingle, que devuelve un valor booleano que indica si se tuvo éxito | |
UInt16.TryParse(string, out ushort) | Intentar analizar la cadena comoUInt16, que devuelve un valor booleano que indica si se tuvo éxito | |
UInt32.TryParse(string, out uint) | Intentar analizar la cadena comoUInt32, que devuelve un valor booleano que indica si se tuvo éxito | |
UInt64.TryParse(string, out ulong) | Intentar analizar la cadena comoUInt64, que devuelve un valor booleano que indica si se tuvo éxito |