Remover zeros à direita

Eu tenho alguns campos retornados por uma coleção como

2.4200 2.0044 2.0000 

Quero resultados como

 2.42 2.0044 2 

Eu tentei com String.Format , mas retorna 2.0000 e defini-lo para N0 arredonda os outros valores também.

Não é tão simples assim, se a input é uma string? Você pode usar um destes:

 string.Format("{0:G29}", decimal.Parse("2.0044")) decimal.Parse("2.0044").ToString("G29") 2.0m.ToString("G29") 

Isso deve funcionar para todas as inputs.

Atualização Confira os Formatos numéricos padrão que tive para definir explicitamente o especificador de precisão como 29, conforme os documentos indicam claramente:

No entanto, se o número for um Decimal e o especificador de precisão for omitido, a notação de ponto fixo será sempre usada e os zeros à direita serão preservados.

Atualização Konrad apontou nos comentários:

Fique atento a valores como 0,000001. O formato G29 irá apresentá-los da maneira mais curta possível, de modo que passará para a notação exponencial. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US"))) fornecerá “1E-08” como resultado.

Eu corri para o mesmo problema, mas em um caso onde eu não tenho controle da saída para string, que foi atendido por uma biblioteca. Depois de examinar detalhes na implementação do tipo Decimal (consulte http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), criei um truque interessante (aqui como uma extensão método):

 public static decimal Normalize(this decimal value) { return value/1.000000000000000000000000000000000m; } 

A parte do expoente do decimal é reduzida para o que é necessário. Chamar ToString () no decimal de saída irá escrever o número sem nenhum 0. 0. Exemplo:

 1.200m.Normalize().ToString(); 

Na minha opinião, é mais seguro usar Strings de Formato Numérico Personalizado .

 decimal d = 0.00000000000010000000000m; string custom = d.ToString("0.#########################"); // gives: 0,0000000000001 string general = d.ToString("G29"); // gives: 1E-13 

Eu uso este código para evitar a notação científica “G29”:

 public static string DecimalToString(decimal dec) { string strdec = dec.ToString(CultureInfo.InvariantCulture); return strdec.Contains(".") ? strdec.TrimEnd('0').TrimEnd('.') : strdec; } 

Eu encontrei uma solução elegante de http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Basicamente

v = decimal de 2.4200M;

v.ToString (“#. ######”); // retornará 2.42. O número de # é quantos dígitos decimais você suporta.

Use o símbolo de hash ( # ) para exibir somente 0 à direita quando necessário. Veja os testes abaixo.

 decimal num1 = 13.1534545765; decimal num2 = 49.100145; decimal num3 = 30.000235; num1.ToString("0.##"); //13.15% num2.ToString("0.##"); //49.1% num3.ToString("0.##"); //30% 

Isso faz exatamente o que você quer:

Se o seu valor inicial é decimal :

 decimal source = 2.4200m; string output = ((double)source).ToString(); 

Se o seu valor inicial é string :

 string source = "2.4200"; string output = double.Parse(source).ToString(); 

E deve custar desempenho mínimo.

Depende do que o seu número representa e de como você deseja gerenciar os valores: é uma moeda, precisa de arredondamento ou truncamento, você precisa desse arredondamento apenas para exibição?

Se para exibição considere formatar os números são x.ToString (“”)

http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx e

http://msdn.microsoft.com/pt-br/library/0c899ak8.aspx

Se for apenas arredondamento, use a sobrecarga Math.Round que requer uma sobrecarga do MidPointRounding

http://msdn.microsoft.com/en-us/library/ms131274.aspx )

Se você obter seu valor de um database, considere converter em vez de conversão: double value = (decimal) myRecord [“columnName”];

Uma abordagem de nível muito baixo, mas acredito que essa seria a maneira mais eficaz de usar somente cálculos de números inteiros rápidos (e nenhum método de análise de cadeia lenta e sensível a cultura):

 public static decimal Normalize(this decimal d) { int[] bits = decimal.GetBits(d); int sign = bits[3] & (1 < < 31); int exp = (bits[3] >> 16) & 0x1f; uint a = (uint)bits[2]; // Top bits uint b = (uint)bits[1]; // Middle bits uint c = (uint)bits[0]; // Bottom bits while (exp > 0 && ((a % 5) * 6 + (b % 5) * 6 + c) % 10 == 0) { uint r; a = DivideBy10((uint)0, a, out r); b = DivideBy10(r, b, out r); c = DivideBy10(r, c, out r); exp--; } bits[0] = (int)c; bits[1] = (int)b; bits[2] = (int)a; bits[3] = (exp < < 16) | sign; return new decimal(bits); } private static uint DivideBy10(uint highBits, uint lowBits, out uint remainder) { ulong total = highBits; total <<= 32; total = total | (ulong)lowBits; remainder = (uint)(total % 10L); return (uint)(total / 10L); } 

Resposta muito simples é usar TrimEnd (). Aqui está o resultado

 double value = 1.00; string output = value.ToString().TrimEnd('0'); 

A saída é 1 Se meu valor for 1.01, minha saída será 1.01

O código a seguir pode ser usado para não usar o tipo de string:

 int decimalResult = 789.500 while (decimalResult>0 && decimalResult % 10 == 0) { decimalResult = decimalResult / 10; } return decimalResult; 

Retorna 789,5

Você pode apenas definir como:

 decimal decNumber = 23.45600000m; Console.WriteLine(decNumber.ToString("0.##")); 

Truncate Zeros final é muito fácil, resolva com um duplex:

  decimal mydecimal = decimal.Parse("1,45000000"); //(I) decimal truncate = (decimal)(double)mydecimal; //(II) 

(I) -> Analisa o valor decimal de qualquer fonte de string.

(II) -> Primeiro: Elenco para dobrar isto remove os zeros à direita. Segundo: Outro convertido para decimal porque não existe conversão implícita de decimal para double e vice versa

tente este código:

 string value = "100"; value = value.Contains(".") ? value.TrimStart('0').TrimEnd('0').TrimEnd('.') : value.TrimStart('0'); 

tente assim

 string s = "2.4200"; s = s.TrimStart('0').TrimEnd('0', '.'); 

e depois converter isso para flutuar