Directorio de artículos
conversión de tipo
Simplemente dividimos los tipos de valor en 5 tipos: entero, punto flotante, booleano, carácter y una cadena que es un tipo de referencia.
Debido a que C# tiene un tipo estático en el momento de la compilación, una variable no se puede volver a declarar después de declararla ni se le puede asignar un valor de otro tipo, a menos que ese tipo se pueda convertir implícitamente al tipo de la variable.
-
Conversión implícita : dado que esta conversión siempre se realiza correctamente y no provoca pérdida de datos, no es necesario utilizar ninguna sintaxis especial. Los ejemplos incluyen conversiones de tipos enteros más pequeños a tipos enteros más grandes y conversiones de clases derivadas a clases base.
-
Conversión explícita (transmisión) : se debe utilizar una expresión de conversión para realizar una conversión explícita. La conversión es necesaria cuando se puede perder información en la conversión o cuando la conversión puede no tener éxito por otros motivos. Los ejemplos típicos incluyen conversiones de valores numéricos a tipos de menor precisión o rango y conversiones de instancias de clase base a clases derivadas.
No entraré en detalles sobre las dos conversiones anteriores. Tanto la conversión implícita como la conversión explícita son muy básicas.
-
Conversiones definidas por el usuario : las conversiones definidas por el usuario se realizan utilizando métodos especiales que se pueden definir para permitir conversiones explícitas e implícitas entre tipos personalizados que no tienen relaciones de clases base y derivadas. Para obtener más información, consulte Operadores de conversión definidos por el usuario.
-
Conversión mediante clases auxiliares : para convertir entre tipos incompatibles (como enteros y objetos System.DateTime, o cadenas hexadecimales y matrices de bytes), utilice la clase System.BitConverter, la clase System.Convert y el método Parse de tipos numéricos integrados ( como Int32.Parse). Para obtener más información, consulte Cómo convertir una matriz de bytes a un int, Cómo convertir una cadena en un número y Cómo convertir entre una cadena hexadecimal y un tipo numérico.
Convertir caracteres a números
Obtener valor numérico
GetNumericValue es un método proporcionado por el tipo char. Se utiliza para convertir caracteres en números con valores dobles. Si falla, se devuelve -1.0.
Lo que me desconcierta es que el tipo de carácter solo puede almacenar números entre 0 y 9, y es imposible almacenar números de punto flotante. No sé por qué el valor de retorno es de tipo doble.
public int a = 123;
char tmp;
tmp = a.ToString()[0];
char.GetNumericValue(tmp);// 使用char提供的GetNumericValue方法可以将char转为double的1
Convertir.ToInt32
Existe una gran cantidad de sobrecargas para la conversión de tipo Convert, que básicamente puede manejar todas las situaciones de conversión.
public int a = 123;
char tmp;
tmp = a.ToString()[0];
int b =Convert.ToInt32(tmp); // 使用ToInt32会将字符1转为ASCII码49
Cálculo de conversión implícita
int a = 123;
char tmp;
tmp = a.ToString()[0];
int t = tmp - '0'; // 使用char类型进行计算，最后的结果类型是整数型，输出结果是ASCII码相减
// 49 - 48 = 1
Convertir cadena a número
Convertir cadenas en números es un método relativamente versátil, porque el objeto proporciona el método ToString, que puede convertir cualquier tipo de valor en una cadena.
Método Parse o TryParse
Los métodos Parse y TryParse ignoran los espacios al principio y al final de la cadena, pero todos los demás caracteres deben ser de un tipo numérico adecuado (int, long, ulong, float, decimal, etc.).
char tmp = '1';
int a = Int32.Parse(" -105 "); // a = -105,无视空格
a = Int32.Parse(tmp.ToString()); // a = 1
bool b = Int32.TryParse("200", out a); // a = 200,方法本身返回布尔值,b = true
Uso incorrecto:
Int32.Parse(" -1.05 "); //浮点型不能用整型的Parse方法，应该为float.Parse或其他浮点型的Parse方法
Int32.Parse(" 1 05 "); // 数字之间不能有空格
Int32.Parse(" 10e1 "); // 不接受科学计数法，
Convertir matriz de bytes a entero
Porque el tipo de entero general Int es System.Int32. Un byte representa 8 bits, por lo que un Int32 = 4 bytes. Por lo tanto, si desea convertir un byte en un número entero, generalmente deberá convertirlo de cuatro en cuatro.
Utilice la clase BitConverter para manipular matrices de bytes
byte[] bytes = {
0, 0, 0, 25 };
// 此处是根据操作系统来决定字符顺序的
// 不同计算机的字节体系不同，可能高八位，可能低八位
if (BitConverter.IsLittleEndian)
Array.Reverse(bytes);
int i = BitConverter.ToInt32(bytes, 0);
Console.WriteLine("int: {0}", i);
// Output: int: 25
como, está echado
es
El operador is comprueba si el tipo de tiempo de ejecución del resultado de la expresión es compatible con el tipo dado. El operador is también prueba el resultado de la expresión con un patrón.
Una expresión con un operador is probado tiene la forma
E is T
E is not T
donde Ees una expresión que devuelve un valor y Tes el tipo o nombre de un parámetro de tipo. ENo debe ser un método anónimo ni una expresión Lambda.
En pocas palabras, ¿el juicio es verdadero? Corresponde a cuatro juicios.
- cuando
EdeTtipo - Cuando se trata
Tde una clase derivada, subclase o clase heredada (incluidas clases e interfaces). - Cuando
EesTun tipo que acepta valores NULL y no esT?NULLE - Cuando la conversión implica boxear y
EunboxingT
Veamos estas cuatro sentencias correspondientes respectivamente:
Cuando Ede Ttipo:
int a = 0;
if (a is int) // true
{
Debug.Log(a);
}
if (a is long) // false
{
Debug.Log(a);
}
Cuando es Tuna clase derivada, subclase o clase heredada (incluidas clases e interfaces):
class Parent
{
}
interface IDonothing
{
}
class child : Parent, IDonothing
{
}
void Start()
{
child c = new child();
int a = 0;
if (c is Parent) // true
{
Debug.Log(0);
}
if (c is IDonothing) // true
{
Debug.Log(1);
}
}
Cuando Ees Tun tipo que acepta valores NULL y no esT? NULLE
int? a = null;
if (a is int) // a为int?但为空,false
{
Debug.Log(1);
}
if (a is int?) // a为int?但为空,false
{
Debug.Log(2);
}
int b = 1;
if (b is int) // b为int,true
{
Debug.Log(3);
}
if (b is int?) // b为int,true
{
Debug.Log(4);
}
a = 1;
if (a is int) // a为int?且不为空,true
{
Debug.Log(5);
}
if (a is int?) // a为int?且不为空,true
{
Debug.Log(6);
}
Cuando Ese trata Tde empacar y desempaquetar
object O;
int a = 1;
O = a;
if (O is int) // true
{
Debug.Log(1);
}
if (O is int?) // true
{
Debug.Log(2);
}
if (a is object) // true,毕竟object是所有类的父类，此时符合第二条E为T的派生类
{
Debug.Log(3);
}
Al detectar el tipo, el tipo is realizará la conversión de tipo T en el tipo E para determinar si es un tipo T, pero no afectará el tipo de E en sí. Pero el tipo is no considera la conversión de tipos definidos por el usuario.
como
asEl operador convierte explícitamente el resultado de una expresión a una referencia determinada o un tipo con capacidad de valor null. Si la conversión no es posible, asel operador devuelve null. A diferencia de las expresiones de conversión, aslos operadores nunca lanzan una excepción.
E as T
Utilice el operador as, que es igual que el siguiente operador ternario:
E is T ? (T)(E) : (T)null
Las conversiones se realizan utilizando asel operador Convertible, donde el tipo Tdebe ser un nulltipo con valor
as. Solo se consideran los tipos de referencia para las nullconversiones Convertible, Boxed y Unboxing. No puede utilizar asoperadores para realizar conversiones definidas por el usuario. Para hacer esto, use una expresión de conversión.
object o = new object() as string;
o = "1";
Debug.Log(o.GetType()); // string类型
transformación definida por el usuario
implicit operatoro explicit operatorla palabra clave se utiliza para definir la conversión implícita o la conversión explícita, respectivamente. El tipo que define una conversión debe ser el tipo de origen o de destino de la conversión. Las conversiones entre dos tipos definidos por el usuario se pueden definir utilizando cualquiera de los tipos.
using System;
public readonly struct Digit
{
private readonly byte digit;
public Digit(byte digit)
{
if (digit > 9)
{
throw new ArgumentOutOfRangeException(nameof(digit), "Digit cannot be greater than nine.");
}
this.digit = digit;
}
public static implicit operator byte(Digit d) => d.digit;
public static explicit operator Digit(byte b) => new Digit(b);
public override string ToString() => $"{
digit}";
}
public static class UserDefinedConversions
{
public static void Main()
{
var d = new Digit(7);
byte number = d;
Console.WriteLine(number); // output: 7
Digit digit = (Digit)number;
Console.WriteLine(digit); // output: 7
}
}
Puede definir conversiones implícitas y conversiones explícitas utilizando tipos personalizados, pero preste atención a la coincidencia de tipos.