Diretório de artigos
conversão de tipo
Simplesmente dividimos os tipos de valor em 5 tipos: inteiro, ponto flutuante, booleano, caractere, mais uma string que é um tipo de referência.
Como o C# é digitado estaticamente em tempo de compilação, uma variável não pode ser declarada novamente depois de ser declarada ou receber um valor de outro tipo, a menos que esse tipo possa ser convertido implicitamente no tipo da variável.
-
Conversão implícita : como essa conversão sempre é bem-sucedida e não causa perda de dados, não há necessidade de usar nenhuma sintaxe especial. Os exemplos incluem conversões de tipos inteiros menores para tipos inteiros maiores e conversões de classes derivadas para classes base.
-
Conversão explícita (cast) : uma expressão cast deve ser usada para realizar uma conversão explícita. A conversão é necessária quando informações podem ser perdidas na conversão ou quando a conversão pode não ser bem-sucedida por outros motivos. Exemplos típicos incluem conversões de valores numéricos para tipos de menor precisão ou intervalo e conversões de instâncias de classe base para classes derivadas.
Não entrarei em detalhes sobre as duas conversões acima. Tanto a conversão implícita quanto a conversão explícita são muito básicas.
-
Conversões definidas pelo usuário : as conversões definidas pelo usuário são executadas usando métodos especiais que podem ser definidos para permitir conversões explícitas e implícitas entre tipos personalizados que não possuem relacionamentos de classe base e derivada. Para obter mais informações, consulte Operadores de conversão definidos pelo usuário.
-
Convertendo usando classes auxiliares : para converter entre tipos incompatíveis (como inteiros e objetos System.DateTime ou strings hexadecimais e matrizes de bytes), use a classe System.BitConverter, a classe System.Convert e o método Parse de tipos numéricos integrados ( como Int32.Parse). Para obter mais informações, consulte Como converter uma matriz de bytes em um int, Como converter uma string em um número e Como converter entre uma string hexadecimal e um tipo numérico.
Converter caracteres em números
ObterNumericValue
GetNumericValue é um método fornecido pelo tipo char. Ele é usado para converter caracteres em números com valores duplos. Se falhar, -1.0 será retornado.
O que me intriga é que o tipo de caractere só pode armazenar números entre 0 e 9, e é impossível armazenar números de ponto flutuante. Não sei por que o valor de retorno é do tipo duplo.
public int a = 123;
char tmp;
tmp = a.ToString()[0];
char.GetNumericValue(tmp);// 使用char提供的GetNumericValue方法可以将char转为double的1
Converter.ToInt32
Há um grande número de sobrecargas para conversão do tipo Convert, que basicamente pode lidar com todas as situações de conversão.
public int a = 123;
char tmp;
tmp = a.ToString()[0];
int b =Convert.ToInt32(tmp); // 使用ToInt32会将字符1转为ASCII码49
Cálculo de conversão implícita
int a = 123;
char tmp;
tmp = a.ToString()[0];
int t = tmp - '0'; // 使用char类型进行计算，最后的结果类型是整数型，输出结果是ASCII码相减
// 49 - 48 = 1
Converter string em número
Converter strings em números é um método relativamente versátil, porque object fornece o método ToString, que pode converter qualquer tipo de valor em uma string.
Método Parse ou TryParse
Os métodos Parse e TryParse ignoram espaços no início e no final da string, mas todos os outros caracteres devem ser de um tipo numérico adequado (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 incorreto:
Int32.Parse(" -1.05 "); //浮点型不能用整型的Parse方法，应该为float.Parse或其他浮点型的Parse方法
Int32.Parse(" 1 05 "); // 数字之间不能有空格
Int32.Parse(" 10e1 "); // 不接受科学计数法，
Converter matriz de bytes em inteiro
Porque o tipo inteiro geral Int é System.Int32. Um byte representa 8 bits, portanto um Int32 = 4 bytes. Portanto, se você deseja converter um byte em um número inteiro, geralmente precisa convertê-lo de quatro por quatro.
Use a classe BitConverter para manipular matrizes 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, é lançado
é
O operador is verifica se o tipo de tempo de execução do resultado da expressão é compatível com o tipo fornecido. O operador is também testa o resultado da expressão em relação a um padrão.
Uma expressão com um operador is testado por tipo tem a forma
E is T
E is not T
onde Eé uma expressão que retorna um valor e Té o tipo ou nome de um parâmetro de tipo. ENão deve ser um método anônimo ou uma expressão Lambda.
Simplificando, o julgamento é verdadeiro corresponde a quatro julgamentos
- Quando
EdoTtipo - Quando é
Tuma classe derivada, subclasse ou classe herdada (incluindo classes e interfaces). - Quando
EéTum tipo anulável e não éT?nuloE - Quando a conversão para envolve boxe e
EunboxingT
Vejamos estes quatro julgamentos correspondentes, respectivamente:
Quando Edo Ttipo:
int a = 0;
if (a is int) // true
{
Debug.Log(a);
}
if (a is long) // false
{
Debug.Log(a);
}
Quando for Tuma classe derivada, subclasse ou classe herdada (incluindo classes 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);
}
}
Quando Eé Tum tipo anulável e não éT? nuloE
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);
}
Quando Ese trata Tde embalar e desembalar
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);
}
Ao detectar o tipo, o tipo is realizará a conversão do tipo T no tipo E para determinar se é um tipo T, mas não afetará o tipo de E em si. Mas o tipo is não considera a conversão de tipo definida pelo usuário.
como
asO operador converte explicitamente o resultado de uma expressão em uma determinada referência ou tipo com valor null. Se a conversão não for possível, aso operador retornará null. Ao contrário das expressões convertidas, asos operadores nunca lançam uma exceção.
E as T
Use o operador as, que é igual ao seguinte operador ternário:
E is T ? (T)(E) : (T)null
As conversões são realizadas usando aso operador Convertible, onde o tipo Tdeve ser um nulltipo com valor . Somente tipos de referência são considerados para as conversões
asConvertible, Boxed e Unboxing. nullVocê não pode usar asoperadores para realizar conversões definidas pelo usuário. Para fazer isso, use uma expressão de conversão.
object o = new object() as string;
o = "1";
Debug.Log(o.GetType()); // string类型
transformação definida pelo usuário
implicit operatorou explicit operatorpalavra-chave é usada para definir conversão implícita ou conversão explícita, respectivamente. O tipo que define uma conversão deve ser o tipo de origem ou destino da conversão. As conversões entre dois tipos definidos pelo usuário podem ser definidas usando qualquer tipo.
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
}
}
Você pode definir conversões implícitas e explícitas usando tipos personalizados, mas preste atenção à correspondência de tipos.