Respostas:
decimalVar.ToString ("#.##"); // returns "" when decimalVar == 0
ou
decimalVar.ToString ("0.##"); // returns "0" when decimalVar == 0
Decimal
e Double
type ToString
aceita argumento para formatação. Tente converter seu valor para decimal / duplo primeiro.
Sei que essa é uma pergunta antiga, mas fiquei surpreso ao ver que ninguém parecia postar uma resposta;
Isto é o que eu usaria:
decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);
decimalVar.ToString("F");
Isso vai:
23.456
→23.46
23
→ 23.00
; 12.5
→12.50
Ideal para exibição de moeda.
Confira a documentação do ToString ("F") (graças a Jon Schneider).
.
pode ser substituído por com ,
base na cultura. Você deve passar adiante CultureInfo.InvariantCulture
como o segundo argumento para desativar isso.
Se você só precisa disso para exibição, use string.Format
String.Format("{0:0.00}", 123.4567m); // "123.46"
http://www.csharp-examples.net/string-format-double/
O "m" é um sufixo decimal. Sobre o sufixo decimal:
Dado decimal d = 12,345; as expressões d.ToString ("C") ou String.Format ("{0: C}", d) rendem US $ 12,35 - observe que são usadas as configurações de moeda da cultura atual, incluindo o símbolo.
Observe que "C" usa o número de dígitos da cultura atual. Você sempre pode substituir o padrão para forçar a precisão necessária com o C{Precision specifier}
gosto String.Format("{0:C2}", 5.123d)
.
Se você quiser que ele seja formatado com vírgulas e um ponto decimal (mas sem símbolo de moeda), como 3.456.789,12 ...
decimalVar.ToString("n2");
Já existem duas respostas de alta pontuação que se referem a Decimal.Round (...), mas acho que é necessária uma explicação um pouco mais - porque há uma propriedade importante inesperada de Decimal que não é óbvia.
Um decimal 'sabe' quantas casas decimais se baseou em sua origem.
Por exemplo, o seguinte pode ser inesperado:
Decimal.Parse("25").ToString() => "25"
Decimal.Parse("25.").ToString() => "25"
Decimal.Parse("25.0").ToString() => "25.0"
Decimal.Parse("25.0000").ToString() => "25.0000"
25m.ToString() => "25"
25.000m.ToString() => "25.000"
Fazer as mesmas operações com Double
não fornecerá casas decimais ( "25"
) para cada uma das opções acima.
Quando você deseja um decimal com duas casas decimais, há cerca de 95% de chance, é porque é a moeda; nesse caso, isso provavelmente é bom para 95% das vezes:
Decimal.Parse("25.0").ToString("c") => "$25.00"
Ou no XAML você apenas usa {Binding Price, StringFormat=c}
Um caso em que encontrei onde eu precisava de um decimal, era como um decimal ao enviar XML para o serviço web da Amazon. O serviço estava reclamando porque um valor decimal (originalmente do SQL Server) estava sendo enviado 25.1200
e rejeitado ( 25.12
era o formato esperado).
Tudo o que eu precisava fazer era Decimal.Round(...)
com duas casas decimais para corrigir o problema.
// This is an XML message - with generated code by XSD.exe
StandardPrice = new OverrideCurrencyAmount()
{
TypedValue = Decimal.Round(product.StandardPrice, 2),
currency = "USD"
}
TypedValue
é do tipo Decimal
que eu não podia fazer ToString("N2")
e precisava arredondá-lo e mantê-lo como a decimal
.
Aqui está um pequeno programa do Linqpad para mostrar diferentes formatos:
void Main()
{
FormatDecimal(2345.94742M);
FormatDecimal(43M);
FormatDecimal(0M);
FormatDecimal(0.007M);
}
public void FormatDecimal(decimal val)
{
Console.WriteLine("ToString: {0}", val);
Console.WriteLine("c: {0:c}", val);
Console.WriteLine("0.00: {0:0.00}", val);
Console.WriteLine("0.##: {0:0.##}", val);
Console.WriteLine("===================");
}
Aqui estão os resultados:
ToString: 2345.94742
c: $2,345.95
0.00: 2345.95
0.##: 2345.95
===================
ToString: 43
c: $43.00
0.00: 43.00
0.##: 43
===================
ToString: 0
c: $0.00
0.00: 0.00
0.##: 0
===================
ToString: 0.007
c: $0.01
0.00: 0.01
0.##: 0.01
===================
Muito raramente, você deseja uma sequência vazia se o valor for 0.
decimal test = 5.00;
test.ToString("0.00"); //"5.00"
decimal? test2 = 5.05;
test2.ToString("0.00"); //"5.05"
decimal? test3 = 0;
test3.ToString("0.00"); //"0.00"
A resposta mais votada está incorreta e perdeu 10 minutos do tempo (da maioria) das pessoas.
"#"
significa dígito do número (se necessário) (sem preenchimento se não for necessário) "0"
significa dígito do número (não importa o que) (preenchidos com zeros se não disponível)
A resposta de Mike M. foi perfeita para mim no .NET, mas o .NET Core ainda não possui um decimal.Round
método.
No .NET Core, eu tive que usar:
decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);
Um método hacky, incluindo a conversão em string, é:
public string FormatTo2Dp(decimal myNumber)
{
// Use schoolboy rounding, not bankers.
myNumber = Math.Round(myNumber, 2, MidpointRounding.AwayFromZero);
return string.Format("{0:0.00}", myNumber);
}
Nenhuma delas fez exatamente o que eu precisava, forçar 2 pontos de pontos e arredondar0.005 -> 0.01
Forçar 2 dp exige aumentar a precisão em 2 dp para garantir que tenhamos pelo menos 2 dp
arredondando para garantir que não temos mais de 2 pontos
Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero)
6.665m.ToString() -> "6.67"
6.6m.ToString() -> "6.60"
A resposta com melhor classificação descreve um método para formatar a representação em seqüência do valor decimal e funciona.
No entanto, se você realmente deseja alterar a precisão salva no valor real, precisa escrever algo como o seguinte:
public static class PrecisionHelper
{
public static decimal TwoDecimalPlaces(this decimal value)
{
// These first lines eliminate all digits past two places.
var timesHundred = (int) (value * 100);
var removeZeroes = timesHundred / 100m;
// In this implementation, I don't want to alter the underlying
// value. As such, if it needs greater precision to stay unaltered,
// I return it.
if (removeZeroes != value)
return value;
// Addition and subtraction can reliably change precision.
// For two decimal values A and B, (A + B) will have at least as
// many digits past the decimal point as A or B.
return removeZeroes + 0.01m - 0.01m;
}
}
Um exemplo de teste de unidade:
[Test]
public void PrecisionExampleUnitTest()
{
decimal a = 500m;
decimal b = 99.99m;
decimal c = 123.4m;
decimal d = 10101.1000000m;
decimal e = 908.7650m
Assert.That(a.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("500.00"));
Assert.That(b.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("99.99"));
Assert.That(c.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("123.40"));
Assert.That(d.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("10101.10"));
// In this particular implementation, values that can't be expressed in
// two decimal places are unaltered, so this remains as-is.
Assert.That(e.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("908.7650"));
}
Você pode usar system.globalization para formatar um número em qualquer formato necessário.
Por exemplo:
system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");
Se você tiver um decimal d = 1.2300000
e precisar recortá-lo com 2 casas decimais, ele poderá ser impresso assim em d.Tostring("F2",ci);
que F2 está formando uma string com 2 casas decimais e ci é a localidade ou a informação da cultura.
para obter mais informações, consulte este link
http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx
https://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx
Este link explica em detalhes como você pode lidar com seu problema e o que você pode fazer se quiser saber mais. Para fins de simplicidade, o que você quer fazer é
double whateverYouWantToChange = whateverYouWantToChange.ToString("F2");
se você quiser isso para uma moeda, facilite digitando "C2" em vez de "F2"
Double Amount = 0;
string amount;
amount=string.Format("{0:F2}", Decimal.Parse(Amount.ToString()));
Se você precisar manter apenas 2 casas decimais (ou seja, cortar todo o restante dos dígitos decimais):
decimal val = 3.14789m;
decimal result = Math.Floor(val * 100) / 100; // result = 3.14
Se você precisar manter apenas 3 casas decimais:
decimal val = 3.14789m;
decimal result = Math.Floor(val * 1000) / 1000; // result = 3.147