cast “inteligente” da dupla de duas cordas de forma diferente formatados?

Question

Eu estou trabalhando com um banco de dados que tem o limite que o somente (numérico) tipo de dados pode armazenar é um duplo . O que eu quero fazer é escolher o número para uma determinada linha e colocá-lo em uma solicitação HTTP. As gira em torno de problema que eu não posso saber se este número deve ou não deve ter casas decimais.

Por exemplo, se a dupla é um ID, eu não posso ter qualquer tipo de formatação que seja, desde que o site que recebe o HTTP pedido será confundido. Observe os seguintes exemplos:

site.com/showid.php?id=12300000 // OK
site.com/showid.php?id=1.23E7 // Bad; scientific notation
site.com/showid.php?id=12300000.0 // Bad; trailing decimal

A solução para isso seria a lançá-lo para um longo . Ignorar o problema de transbordamento do tempo, ele resolve a notação científica e (obviamente) à direita decimal. Esta poderia ser uma solução aceitável, mas seria bom se o código não assumir que eram IDs estávamos lidando. E se, por exemplo, eu fosse para consultar um site que mostra um mapa eo número são coordenadas, onde as casas decimais são muito importantes? Em seguida, um elenco e longo não é mais aceitável.

Em suma;

• Se o casal não tem decimais, não adicione um decimal à direita.
• Se tiver decimais, mantê-los todos.
• Nenhum dos casos deve ter notação científica ou separadores de milhar.

Esta solução vai ser portado para C # e Java para que eu aceitar respostas em ambas as línguas. (Oh, e eu não tinha ideia do que para chamar a esta pergunta, sinta-se livre para mudar o nome, se você tem algo melhor.)

Answer 1

Heres minha própria conclusão:

• Verifique se o casal tem casas decimais.
• Dependendo que, formatar a string em conformidade.

• E então algo importante; sem especificar uma cultura invariável, a vírgula no caso tem-decimais pode ser um "" em vez de um "" que is not apreciado por solicitações HTTP. Naturalmente, este problema só surge se o seu sistema operacional está definido para uma localidade que prefere a vírgula.

  public static string DoubleToStringFormat(double dval)
  {
      long lval = (long)dval;
      if ((double)lval == dval)
      {
          // has no decimals: format as integer
          return dval.ToString("#.", CultureInfo.InvariantCulture);
      }
      else
      {
          // has decimals: keep them all
          return dval.ToString("0.##################", CultureInfo.InvariantCulture);
      }
  }
  

Answer 2

Para complementar a resposta da gustafc (que me bater por 1 minuto), aqui está a linha de código relevante para C #:

MyDouble.ToString("0.################")

ou

string.Format("{0:0.################}", MyDouble);

Answer 3

Uma vez que é seguro para formatar o valor sem zeros à direita se é integral (se ele representa um ID ou uma coordenada), porque não basta codificar a lógica que você descrever em seus pontos de bala? Por exemplo (C #, mas deve traduzir facilmente para Java):

// Could also use Math.Floor, etc., to determine if it is integral
long integralPart = (long)doubleValue;
if ((double)integralPart == doubleValue)
{
  // has no decimals: format it as an integer e.g. integralPart.ToString("D") in C#
}
else
{
  // has decimals: keep them all e.g. doubleValue.ToString("F17")
}

Answer 4

Como cerca de encapsular o número em um tipo personalizado?

public class IntelligentNumber
{
    private readonly double number;

    public IntelligentNumber(double number)
    {
        this.number = number;
    }

    public override string ToString()
    {
        long integralPart = (long)this.number;
        if((double)integralPart == this.number)
        {
            return integralPart.ToString();
        }
        else
        {
            return this.number.ToString();
        }
    }
}

---

Veja também a resposta de Vilx-for um algoritmo melhor do que o descrito acima.

Answer 5

Verifique se num == round (num)

Answer 6

Em Java, você pode fazer isso com DecimalFormat .

static String format(double n) { 
    return new DecimalFormat("0.###########################").format(n); 
}

Os espaços reservados # não vai aparecer a menos que o número de algo diferente de zeros para colocar lá, e o ponto decimal não aparece a menos que haja algo que se lhe segue.