c# - recortar - string remove

Eliminar ceros finales

Question

Tengo algunos campos devueltos por una colección como

2.4200
2.0044
2.0000

Quiero resultados como

2.42
2.0044
2

Intenté con String.Format , pero devuelve 2.0000 y al establecerlo en N0 redondea también los otros valores.

Answer 1

¿No es tan simple como esto, si la entrada ES una cadena? Puedes usar uno de estos:

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

Esto debería funcionar para todas las entradas.

Actualización Revise los formatos numéricos estándar que he tenido que establecer explícitamente el especificador de precisión en 29 como los documentos indican claramente:

Sin embargo, si el número es un decimal y se omite el especificador de precisión, siempre se utiliza la notación de punto fijo y se conservan los ceros al final

Actualización Konrad señaló en los comentarios:

Tenga cuidado con valores como 0.000001. El formato G29 los presentará de la manera más breve posible, por lo que cambiará a la notación exponencial. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US"))) dará como resultado "1E-08".

Answer 2

Depende de lo que representa su número y cómo desea administrar los valores: ¿es una moneda, necesita redondeo o truncamiento, necesita este redondeo solo para mostrar?

Si para la visualización, considere formatear los números son x.ToString ("")

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

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

Si solo se está redondeando, use Math.Round overload que requiere una sobrecarga de MidPointRounding

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

Si obtiene su valor de una base de datos, considere la conversión en lugar de la conversión: double value = (decimal) myRecord ["columnName"];

Answer 3

El siguiente código podría usarse para no usar el tipo de cadena:

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

Devuelve 789.5

Answer 4

En mi opinión es más seguro usar cadenas 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

Answer 5

Encontré una solución elegante de http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Básicamente

decimal v = 2.4200M;

v.ToString ("#. ######"); // Regresará 2.42. El número de # es cuántos dígitos decimales admite.

Answer 6

Esto hace exactamente lo que quieres:

Si su valor inicial es decimal :

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

Si su valor inicial es string :

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

Y debería costar un rendimiento mínimo.

Answer 7

Me encontré con el mismo problema, pero en un caso en el que no tengo el control de la salida en la cadena, que fue atendida por una biblioteca. Después de buscar detalles en la implementación del tipo Decimal (ver http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), se me ocurrió un truco ingenioso (aquí como una extensión) método):

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

La parte exponente del decimal se reduce a lo que se necesita. Llamar a ToString () en el decimal de salida escribirá el número sin ningún seguimiento de 0. Por ejemplo

1.200m.Normalize().ToString();

Answer 8

Puedes simplemente establecer como:

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

Answer 9

Truncar los ceros finales es muy fácil, resolver con un molde dúplex:

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

(I) -> Parse el valor decimal de cualquier fuente de cadena.

(II) -> Primero: Convertir al doble para eliminar los ceros finales. Segundo: Otro elenco a decimal porque no existe conversión implícita de decimal a doble y viceversa

Answer 10

Un enfoque de muy bajo nivel, pero creo que esta sería la forma más eficaz al usar solo cálculos de enteros rápidos (y sin métodos lentos de análisis de cadenas y de cultivo):

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);
}

Answer 11

Una respuesta muy simple es usar TrimEnd (). Aquí está el resultado,

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

La salida es 1 Si mi valor es 1.01, entonces mi salida será 1.01

Answer 12

Use el símbolo hash ( # ) para mostrar solo los 0 finales cuando sea necesario. Vea las pruebas a continuación.

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%

Answer 13

Utilizo este código para evitar la notación científica "G29":

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

Answer 14

o puede convertir su doble valor en el doble como Convert.ToDouble([double vlaue]) . eliminará el cero final, si hay alguno.

Answer 15

prueba así

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

y luego convertir eso en flotar

Answer 16

prueba este código:

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