Remover zeros à direita

Tenho alguns campos retornados por uma coleção como

2.4200
2.0044
2.0000

Eu quero resultados como

2.42
2.0044
2

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

Não é tão simples assim, se a entrada é 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 entradas.

Atualização Confira os formatos numéricos padrão que tive que definir explicitamente o especificador de precisão para 29, conforme os documentos afirmam 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

A atualização Konrad apontou nos comentários:

Cuidado com valores como 0,000001. O formato G29 os apresentará da maneira mais curta possível, para mudar para a notação exponencial. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))dará "1E-08" como resultado.

Corri para o mesmo problema, mas em um caso em que não tenho controle da saída para string, que foi resolvida por uma biblioteca. Depois de analisar os 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 apenas o necessário. Chamar ToString () no decimal de saída escreverá o número sem nenhum 0. à direita.

1.200m.Normalize().ToString();

Na minha opinião, é mais seguro usar seqüências de formato numérico personalizadas .

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

Eu uso esse código para evitar a notação científica "G29":

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

EDIT: usando o sistema CultureInfo.NumberFormat.NumberDecimalSeparator:

public static string DecimalToString(this decimal dec)
{
    string sep = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
    string strdec = dec.ToString(CultureInfo.CurrentCulture);
    return strdec.Contains(sep) ? strdec.TrimEnd('0').TrimEnd(sep.ToCharArray()) : strdec;
}

Use o #símbolo de hash ( ) para exibir apenas os zeros à 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%

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

Basicamente

decimal v=2.4200M;

v.ToString("#.######"); // Will return 2.42. The number of # is how many decimal digits you support.

Uma abordagem de nível muito baixo, mas acredito que essa seria a maneira mais eficiente de usar apenas cálculos inteiros rápidos (e nenhum método de análise de seqüência lenta e métodos sensíveis à 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);
}

Isso funcionará:

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

Ou se o seu valor inicial for string:

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

Preste atenção a este comentário .

Isto é simples.

decimal decNumber = Convert.ToDecimal(value);
        return decNumber.ToString("0.####");

Testado.

Felicidades :)

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

Se, para exibição, considere a formatação, os números são x.ToString ("")

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

http://msdn.microsoft.com/en-us/library/0c899ak8.aspx

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

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

Se você obtiver seu valor de um banco de dados, considere converter em vez de converter: double value = (decimal) myRecord ["columnName"];

Você pode apenas definir como:

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

Caso deseje manter o número decimal, tente o seguinte exemplo:

number = Math.Floor(number * 100000000) / 100000000;

Tentando fazer uma solução mais amigável do DecimalToString ( https://stackoverflow.com/a/34486763/3852139 ):

private static decimal Trim(this decimal value)
{
    var s = value.ToString(CultureInfo.InvariantCulture);
    return s.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)
        ? Decimal.Parse(s.TrimEnd('0'), CultureInfo.InvariantCulture)
        : value;
}

private static decimal? Trim(this decimal? value)
{
    return value.HasValue ? (decimal?) value.Value.Trim() : null;
}

private static void Main(string[] args)
{
    Console.WriteLine("=>{0}", 1.0000m.Trim());
    Console.WriteLine("=>{0}", 1.000000023000m.Trim());
    Console.WriteLine("=>{0}", ((decimal?) 1.000000023000m).Trim());
    Console.WriteLine("=>{0}", ((decimal?) null).Trim());
}

Resultado:

=>1
=>1.000000023
=>1.000000023
=>

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 sequência:

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

Retorna 789,5

Truncar Zeros à direita é muito fácil, resolva com uma conversão duplex:

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

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

(II) -> Primeiro: lance para dobrar e remova os zeros à direita. Segundo: Outra conversão para decimal porque não existe conversão implícita de decimal para dupla 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 converta isso para flutuar