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

byte b = 10;
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

int intValue = 42;
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

int i = 10;
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

double doubleValue = 3.14;
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

int intValue = 42;
float floatValue = (float)intValue; // Forzar de int a float, los datos pueden perder precisión

Conversión forzada a tipo cadena:

Ejemplo

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

El siguiente ejemplo muestra una conversión de tipos explícita:

Ejemplo

using System;

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
1ToBoolean
Convierte el tipo a booleano, si es posible.
2ToByte
Convierte el tipo a byte.
3ToChar
Convierte el tipo a un solo carácter Unicode, si es posible.
4ToDateTime
Convierte el tipo (entero o cadena) a una estructura de fecha y hora.
5ToDecimal
Convierte el tipo de punto flotante o entero a tipo decimal.
6ToDouble
Convierte el tipo a double (doble precisión).
7ToInt16
Convierte el tipo a entero de 16 bits.
8ToInt32
Convierte el tipo a entero de 32 bits.
9ToInt64
Convierte el tipo a entero de 64 bits.
10ToSbyte
Convierte el tipo a byte con signo.
11ToSingle
Convierte el tipo a tipo float (punto flotante pequeño).
12ToString
Convierte el tipo a tipo cadena.
13ToType
Convierte el tipo al tipo especificado.
14ToUInt16
Convierte el tipo a entero sin signo de 16 bits.
15ToUInt32
Convierte el tipo a entero sin signo de 32 bits.
16ToUInt64
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

using System;

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

string str = "123";
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

string str = "123.45";
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

string str = "123.45";
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

using System;

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étodoMétodoDescripción
Conversión implícitaConversión realizada automáticamenteNo 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)valueRequiere especificación explícita, generalmente se usa en casos que pueden causar pérdida de datos o fallo de conversión.
ConvertMétodos de claseConvert.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étodoBoolean.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étodoBoolean.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
Otras extensiones