Tenho uma função que lança um valor doubleem string.

string variable = "5.00"; 

double varDouble = (double)variable;

Uma alteração de código foi verificada e o projeto é compilado com o erro: System.InvalidCastException: Specified cast is not valid.

No entanto, depois de fazer o seguinte ...

string variable = "5.00"; 

double varDouble = Convert.ToDouble(variable);

... o projeto é construído sem erros.

Qual é a diferença entre lançar e usar o Convert.To()método? Por que o casting lança um Exceptione o Convert.To()não?

Mesmo que você possa vê-los de alguma forma como equivalentes, eles têm propósitos completamente diferentes. Vamos primeiro tentar definir o que é um elenco:

Casting é a ação de transformar uma entidade de um tipo de dados em outro.

É um pouco genérico e de alguma forma equivalente a uma conversão porque um elenco geralmente tem a mesma sintaxe de uma conversão, então a questão deve ser quando um elenco (implícito ou explícito) é permitido pela linguagem e quando você deve usar um ( mais) conversão explícita?

Deixe-me primeiro traçar uma linha simples entre eles. Formalmente (mesmo se equivalente para a sintaxe da linguagem), um elenco irá alterar o tipo, enquanto uma conversão irá / pode alterar o valor (eventualmente junto com o tipo). Além disso, um elenco é reversível, enquanto uma conversão pode não ser.

Este tópico é muito vasto, então vamos tentar restringi-lo um pouco excluindo os operadores de elenco personalizados do jogo.

Casts implícitos

Em C #, uma conversão está implícita quando você não perderá nenhuma informação (observe que essa verificação é realizada com tipos e não com seus valores reais ).

Tipos primitivos

Por exemplo:

int tinyInteger = 10;
long bigInteger = tinyInteger;

float tinyReal = 10.0f;
double bigReal = tinyReal;

Esses casts são implícitos porque durante a conversão você não perderá nenhuma informação (você apenas torna o tipo mais amplo). O cast implícito vice-versa não é permitido porque, independentemente de seus valores reais (porque eles podem ser verificados apenas em tempo de execução), durante a conversão você pode perder algumas informações. Por exemplo, este código não compilará porque a doublepode conter (e realmente contém) um valor não representável com float:

// won't compile!
double bigReal = Double.MaxValue;
float tinyReal = bigReal;

Objetos

No caso de um objeto (um ponteiro para), o elenco está sempre implícito quando o compilador pode ter certeza de que o tipo de origem é uma classe derivada (ou implementa) o tipo da classe de destino, por exemplo:

string text = "123";
IFormattable formattable = text;

NotSupportedException derivedException = new NotSupportedException();
Exception baseException = derivedException;

Nesse caso, o compilador sabe que stringimplementa IFormattablee que NotSupportedExceptioné (deriva de), Exceptionportanto, o elenco está implícito. Nenhuma informação é perdida porque os objetos não mudam seus tipos (isso é diferente com se structtipos primitivos porque com um elenco você cria um novo objeto de outro tipo ), o que muda é a sua visão deles.

Casts explícitos

Uma conversão é explícita quando a conversão não é feita implicitamente pelo compilador e você deve usar o operador de conversão. Normalmente significa que:

• Você pode perder informações ou dados, portanto, deve estar ciente disso.
• A conversão pode falhar (porque você não pode converter um tipo em outro), então, novamente, você deve estar ciente do que está fazendo.

Tipos primitivos

Uma conversão explícita é necessária para tipos primitivos quando durante a conversão você pode perder alguns dados, por exemplo:

double precise = Math.Cos(Math.PI * 1.23456) / Math.Sin(1.23456);
float coarse = (float)precise;

float epsilon = (float)Double.Epsilon;

Em ambos os exemplos, mesmo se os valores estiverem dentro do floatintervalo, você perderá informações (neste caso, a precisão), portanto, a conversão deve ser explícita. Agora tente isto:

float max = (float)Double.MaxValue;

Esta conversão irá falhar, então, novamente, ela deve ser explícita para que você esteja ciente disso e possa fazer uma verificação (no exemplo, o valor é constante, mas pode vir de alguns cálculos de tempo de execução ou E / S). De volta ao seu exemplo:

// won't compile!
string text = "123";
double value = (double)text;

Isso não será compilado porque o compilador não pode converter texto em números. O texto pode conter qualquer caractere, não apenas números e isso é demais, em C #, mesmo para uma conversão explícita (mas pode ser permitido em outro idioma).

Objetos

As conversões de ponteiros (para objetos) podem falhar se os tipos não estiverem relacionados, por exemplo, este código não compilará (porque o compilador sabe que não há conversão possível):

// won't compile!    
string text = (string)AppDomain.Current;
Exception exception = (Exception)"abc";

Este código será compilado, mas pode falhar em tempo de execução (depende do tipo efetivo de objetos fundidos) com um InvalidCastException:

object obj = GetNextObjectFromInput();
string text = (string)obj;

obj = GetNextObjectFromInput();
Exception exception = (Exception)obj;

Conversões

Então, finalmente, se casts são conversões, por que precisamos de classes como Convert? Ignorando as diferenças sutis que vêm da Convertimplementação e IConvertibleimplementações, na verdade, porque em C # com um elenco você diz ao compilador:

confie em mim, esse tipo é aquele mesmo que você não possa saber agora, deixe-me fazer isso e você verá.

-ou-

não se preocupe, não me importo se algo se perderá nesta conversão.

Para qualquer outra coisa, uma operação mais explícita é necessária (pense nas implicações dos casts fáceis , é por isso que C ++ introduziu uma sintaxe longa, detalhada e explícita para eles). Isso pode envolver uma operação complexa (para string-> doubleconversão será necessária uma análise). Uma conversão para string, por exemplo, sempre é possível (via ToString()método), mas pode significar algo diferente do que você espera, então deve ser mais explícito do que um elenco ( mais você escreve, mais você pensa no que está fazendo ).

Essa conversão pode ser feita dentro do objeto (usando instruções IL conhecidas para isso), usando operadores de conversão personalizados (definidos na classe para lançar) ou mecanismos mais complexos ( TypeConverters ou métodos de classe, por exemplo). Você não está ciente do que vai acontecer para fazer isso, mas está ciente de que pode falhar (é por isso que IMO, quando uma conversão mais controlada é possível, você deve usá-lo). No seu caso, a conversão simplesmente analisará o stringpara produzir um double:

double value = Double.Parse(aStringVariable);

É claro que isso pode falhar, então se você fizer isso, você sempre deve capturar a exceção que pode lançar ( FormatException). Está fora do assunto aqui, mas quando um TryParseestiver disponível, você deve usá-lo (porque semanticamente você diz que pode não ser um número e é ainda mais rápido ... falhar).

As conversões no .NET podem vir de vários lugares, TypeConverterconversões implícitas / explícitas com operadores de conversão definidos pelo usuário, implementação IConvertiblee métodos de análise (esqueci de algo?). Dê uma olhada no MSDN para obter mais detalhes sobre eles.

Para terminar esta longa resposta, apenas algumas palavras sobre os operadores de conversão definidos pelo usuário. É apenas o açúcar para deixar o programador usar um elenco de converter um tipo para outro. É um método dentro de uma classe (aquela que será lançada) que diz "ei, se ele quiser converter este tipo para aquele tipo então eu posso fazer isso". Por exemplo:

float? maybe = 10; // Equals to Nullable<float> maybe = 10;
float sure1 = (float)maybe; // With cast
float sure2 = maybe.Value; // Without cast

Nesse caso, é explícito porque pode falhar, mas isso é deixado para a implementação (mesmo que haja diretrizes sobre isso). Imagine que você escreva uma classe de string personalizada como esta:

EasyString text = "123"; // Implicit from string
double value = (string)text; // Explicit to double

Em sua implementação, você pode decidir "tornar a vida do programador mais fácil" e expor essa conversão por meio de um elenco (lembre-se de que é apenas um atalho para escrever menos). Alguns idiomas podem até permitir isso:

double value = "123";

Permitindo a conversão implícita para qualquer tipo (a verificação será feita em tempo de execução). Com as opções adequadas, isso pode ser feito, por exemplo, em VB.NET. É apenas uma filosofia diferente.

O que posso fazer com eles?

Portanto, a questão final é quando você deve usar um ou outro. Vamos ver quando você pode usar um elenco explícito:

• Conversões entre tipos básicos.
• Conversões de objectpara qualquer outro tipo (isso também pode incluir unboxing).
• Conversões de uma classe derivada para uma classe base (ou para uma interface implementada).
• Conversões de um tipo para outro por meio de operadores de conversão personalizados.

Apenas a primeira conversão pode ser feita com Convertas outras que você não tem escolha e precisa usar um elenco explícito.

Vamos ver quando você pode usar Convert:

• Conversões de qualquer tipo base para outro tipo base (com algumas limitações, consulte MSDN ).
• Conversões de qualquer tipo que implemente IConvertibleem qualquer outro tipo (compatível).
• Conversões de / para uma bytematriz de / para uma string.

Conclusões

O IMO Convertdeve ser usado sempre que você souber que uma conversão pode falhar (por causa do formato, por causa do intervalo ou porque pode ser incompatível), mesmo se a mesma conversão puder ser feita com um elenco (a menos que algo mais esteja disponível). Deixa claro para quem vai ler seu código qual é sua intenção e que ele pode falhar (simplificando a depuração).

Para todo o resto você precisa usar um elenco, sem escolha, mas se outro método melhor estiver disponível, eu sugiro que você o use. Em seu exemplo, uma conversão de stringpara doubleé algo que (especialmente se o texto vem do usuário) muitas vezes falhará, então você deve torná-lo o mais explícito possível (além disso, você obtém mais controle sobre isso), por exemplo, usando um TryParsemétodo.

Edit: qual é a diferença entre eles?

De acordo com a pergunta atualizada e mantendo o que escrevi antes (sobre quando você pode usar um elenco em comparação com quando você pode / deve usar Convert), o último ponto a esclarecer é se há diferença entre eles (além disso, Convertusa IConvertiblee IFormattableinterfaces para que possa realizar operações não permitido com moldes).

A resposta curta é sim, eles se comportam de maneira diferente . Eu vejo a Convertclasse como uma classe de métodos auxiliares com tanta frequência que fornece algum benefício ou comportamentos ligeiramente diferentes. Por exemplo:

double real = 1.6;
int castedInteger = (int)real; // 1
int convertedInteger = Convert.ToInt32(real); // 2

Muito diferente, certo? O elenco trunca (é o que todos esperamos), mas Convertexecuta um arredondamento para o número inteiro mais próximo (e isso pode não ser esperado se você não estiver ciente disso). Cada método de conversão apresenta diferenças, portanto, uma regra geral não pode ser aplicada e devem ser vistos caso a caso ... 19 tipos de base para converter para qualquer outro tipo ... a lista pode ser bem longa, muito melhor consultar o MSDN caso por caso!

Casting é uma maneira de dizer ao compilador: "Eu sei que você acha que esta variável é um Bar, mas por acaso sei mais do que você; o objeto é na verdade um Foo, então deixe-me tratá-lo como se fosse um Foo de agora." Então, em tempo de execução, se o objeto real acabou por ser realmente um Foo, então seu código funciona; se descobrir que o objeto não era um Foo, você obterá uma exceção. (Especificamente um System.InvalidCastException.)

Converter, por outro lado, é uma maneira de dizer: "Se você me der um objeto do tipo Bar, posso criar um objeto Foo totalmente novo que represente o que está nesse objeto Bar. Não vou mudar o objeto original, ele vai" para tratar o objeto original de forma diferente, ele criará algo novo que se baseia apenas em algum outro valor . Quanto a como fará isso, pode ser qualquer coisa. No caso, Convert.ToDoubleele acabará chamandoDouble.Parseque tem todos os tipos de lógica complexa para determinar quais tipos de strings representam quais valores numéricos. Você poderia escrever seu próprio método de conversão que mapeou strings para duplicar de forma diferente (talvez para suportar alguma convenção totalmente diferente para exibir números, como numerais romanos ou qualquer outra coisa). Uma conversão pode fazer qualquer coisa, mas a ideia é que você não está realmente pedindo ao compilador para fazer nada por você; você é quem está escrevendo o código para determinar como criar o novo objeto porque o compilador, sem sua ajuda, não tem como saber como mapear (por exemplo) a stringpara a double.

Então, quando você se converte e quando lança o elenco? Em ambos os casos, temos alguma variável de um tipo, digamos A, e queremos uma variável do tipo B. Se nosso objeto A realmente, na verdade, por baixo do capô, for um B, então lançamos. Se não for realmente um B, então precisamos convertê-lo e definir como o programa deve obter um B de um A.

De MSDN:

Conversões explícitas (conversões): as conversões explícitas requerem um operador de conversão. A conversão é necessária quando as informações podem ser perdidas na conversão ou quando a conversão pode não ser bem-sucedida por outros motivos. Os exemplos típicos incluem a conversão numérica para um tipo que tem menos precisão ou um intervalo menor e a conversão de uma instância da classe base em uma classe derivada.

Considere o seguinte exemplo:

double a = 2548.3;
int b;
b = (int)a; //2548 --> information (.3) lost in the conversion

E também:

Um elenco é uma forma de informar explicitamente ao compilador que você pretende fazer a conversão e que está ciente de que pode ocorrer perda de dados.

Você pode usar a System.Convertclasse quando quiser converter entre tipos não compatíveis . A principal diferença entre lançar e converter é a compilação e o tempo de execução . As exceções de conversão de tipo aparecem em tempo de execução , ou seja, uma conversão de tipo que falha em tempo de execução fará com que um InvalidCastExceptionseja lançado.

double s = 2;
int a = (int) s;

Mas na conversão você está dizendo ao compilador há uma maneira de criar um novo objeto a partir ado tipo b, por favor, fazê-lo e projeto cria sem erros, mas como eu disse se o tipo de conversão falhar em tempo de execução, ele irá causar um InvalidCastExceptionpara ser jogado .

Por exemplo, o código a seguir nunca é compilado porque o compilador detecta que não pode converter uma expressão de tipo DateTimepara tipo int:

DateTime s = DateTime.Now;
int a = (int)(s);

Mas este foi compilado com sucesso:

DateTime s = DateTime.Now;
int a = Convert.ToInt32(s);

Mas em tempo de execução você obterá o InvalidCastExceptionque diz:

Conversão inválida de 'DateTime' para 'Int32'.

Em seu exemplo, você está tentando converter uma string para um double (tipo não integral).

Uma conversão explícita é necessária para que funcione.

E devo apontar que você poderia ter usado em Convert.ToDoublevez de, Convert.ToInt64pois você pode perder as partes fracionárias do valor duplo ao converter para um int.

se sua variável tiver o valor "5,25" varDouble teria sido 5,00 (perda de 0,25 por causa da conversão para Int64)

Para responder à sua pergunta sobre transmissão x conversão.

Seu elenco (um elenco explícito) não atende aos requisitos para um elenco explícito. o valor que você está tentando converter com o operador de conversão é inválido (ou seja, não integral).

Visite esta página do MSDN para as regras de casting / conversões

O Convert.Doublemétodo, na verdade, apenas chama internamente oDouble.Parse(string) método .

Nem o Stringtipo nem oDouble tipo definem uma conversão explícita / implícita entre os dois tipos, portanto, a conversão sempre falhará.

O Double.Parsemétodo examinará cada caractere no stringe construirá um valor numérico baseado nos valores dos caracteres no string. Se algum dos caracteres for inválido, o Parsemétodo falha (fazendo com que o Convert.Doublemétodo também falhe).

A fundição não envolve nenhuma conversão, ou seja, a representação interna de um valor não é alterada. Exemplo:

object o = "Hello"; // o is typed as object and contains a string.
string s = (string)o; // This works only if o really contains a string or null.

Você pode converter um doublepara stringassim

double d = 5;
string s = d.ToString(); // -> "5"

// Or by specifying a format
string formatted = d.ToString("N2"); // -> "5.00"

Você pode converter stringa doubleem de várias maneiras (aqui apenas duas):

string s = "5";
double d = Double.Parse(s); // Throws an exception if s does not contain a valid number

Ou o caminho seguro

string s = "5";
double d;
if (Double.TryParse(s, out d)) {
    Console.WriteLine("OK. Result = {0}", d);
} else {
    Console.WriteLine("oops!");
}

string variable = "5.00";     
double varDouble = (double)variable;

A conversão acima simplesmente não é permitida pelo idioma. Aqui está uma lista de conversões explícitas para tipos numéricos: http://msdn.microsoft.com/en-us/library/yht2cx7b.aspx Como você pode ver, nem mesmo todos os tipos numéricos podem ser convertidos para outro tipo numérico

Mais algumas informações sobre o elenco aqui

E como isso difere de Convert.ToDouble ()?

Quando você lança um tipo, a estrutura de dados não é alterada. Bem, no caso de conversão de valores numéricos, você pode perder alguns bits ou obter alguns 0 bits adicionais. Mas você ainda está trabalhando com um número.Você está apenas alterando a quantidade de memória ocupada por esse número. Isso é seguro o suficiente para o compilador fazer tudo o que for necessário.

Mas quando você está tentando converter string para um número, você não pode fazer isso porque não é suficiente alterar a quantidade de memória usada pela variável. Por exemplo, 5,00como string é uma sequência de "números": 53 (5) 46 (.) 48 (0) 48 (0) - isto é para ASCII, mas string conterá algo semelhante. Se o compilador apenas pegar os primeiros N (4 para o dobro? Não tenho certeza) bytes de uma string - esse pedaço conterá um número duplo completamente diferente. Ao mesmo tempo, Convert.ToDouble () executa um algoritmo especial que pegará cada símbolo de uma string, descobrirá o dígito que ele representa e fará um número duplo para você, se a string representar um número. Linguagens como PHP irão, grosso modo, chamar Convert.ToDouble para você em segundo plano. Mas o C #, como uma linguagem digitada estaticamente, não fará isso por você. Isso permite que você tenha certeza de que qualquer operação é de tipo seguro e você não obterá algo inesperado fazendo algo como:

double d = (double)"zzzz"

Converter uma string para um double como esse não é permitido em C # e é por isso que você obtém uma exceção, você precisa ter a string convertida ( documento do MSDN que mostra caminhos de conversão aceitáveis). Isso ocorre simplesmente porque uma string não irá necessariamente conter dados numéricos, mas os vários tipos numéricos irão (exceto valores nulos). UMAConvert executará um método que verificará a string para ver se ela pode ser transformada em um valor numérico. Se puder, ele retornará esse valor. Se não puder, ele lançará uma exceção.

Para convertê-lo, você tem várias opções. Você usou o Convertmétodo em sua pergunta, Parseque é bastante semelhante ao Convert, mas você também deve olhar o TryParse, que permite que você faça:

string variable = "5.00"; 

double varDouble;

if (Double.TryParse(variable, out varDouble)) {
    //Code that runs if the conversion succeeded.
} else {
    //Code that runs if the conversion failed.
}

Isso evita a possível exceção caso você tente Convertou Parseuma string não numérica.

double varDouble = (double)variableassume que variablejá é um duplo. Se variablenão for um duplo (é uma string), isso irá falhar. double varDouble = Convert.ToDouble(variable)faz como diz - converte. Se ele puder analisar ou extrair um duplo variable, ele o fará.

Eu segundo usando Double.Parseou Double.TryParseporque indica mais claramente o que deveria estar acontecendo. Você está começando com uma string e espera que ela seja conversível em uma double. Se tiver alguma dúvida, use TryParse.

Se variablefor um argumento de método, altere o tipo para double. Torne o chamador responsável por fornecer o tipo correto. Dessa forma, o compilador faz o trabalho para você.

A diferença mais importante é que se a conversão de tipo for usada e a conversão falhar (digamos que estamos convertendo um valor flutuante muito grande em int), nenhuma exceção será lançada e o valor mínimo que um int pode conter será mostrado. Mas no caso de usar o Convert , uma exceção será lançada para tais cenários.