Cómo redondear al número entero más cercano en C #

¿Cómo puedo redondear valores como este?

1.1 => 1 1.5 => 2 1.9 => 2 

Math.Ceiling() no me está ayudando. ¿Algunas ideas?

Vea la documentación oficial para más. Por ejemplo:

Básicamente le das al método Math.Round tres parámetros.

  1. El valor que quieres redondear.
  2. La cantidad de decimales que desea conservar después del valor.
  3. Un parámetro opcional que puede invocar para usar el redondeo AwayFromZero. (se ignora a menos que el redondeo sea ambiguo, por ejemplo, 1.5 )

Código de muestra:

 var roundedA = Math.Round(1.1, 0); // Output: 1 var roundedB = Math.Round(1.5, 0, MidpointRounding.AwayFromZero); // Output: 2 var roundedC = Math.Round(1.9, 0); // Output: 2 var roundedD = Math.Round(2.5, 0); // Output: 2 var roundedE = Math.Round(2.5, 0, MidpointRounding.AwayFromZero); // Output: 3 var roundedF = Math.Round(3.49, 0, MidpointRounding.AwayFromZero); // Output: 3 

Demo en vivo

Necesita MidpointRounding.AwayFromZero si desea que se redondee un valor de .5. Lamentablemente, este no es el comportamiento predeterminado para Math.Round() . Si usa MidpointRounding.ToEven (el valor predeterminado), el valor se redondea al número par más cercano ( 1.5 se redondea a 2 , pero 2.5 también se redondea a 2 ).

 Math.Ceiling 

siempre redondea hacia arriba (hacia el techo)

 Math.Floor 

siempre redondea hacia abajo (hacia el piso)

lo que buscas es simplemente

 Math.Round 

que redondea según esta publicación

hay este manual, y un poco lindo también:

 double d1 = 1.1; double d2 = 1.5; double d3 = 1.9; int i1 = (int)(d1 + 0.5); int i2 = (int)(d2 + 0.5); int i3 = (int)(d3 + 0.5); 

simplemente agregue 0.5 a cualquier número, y empújelo a int (o piénselo) y será matemáticamente redondeado correctamente: D

Necesita Math.Round , no Math.Ceiling . Ceiling siempre se “redondea” hacia arriba, mientras que Round redondea hacia arriba o hacia abajo dependiendo del valor después del punto decimal.

Simplemente un recordatorio. Cuidado con el doble

 Math.Round(0.3 / 0.2 ) result in 1, because in double 0.3 / 0.2 = 1.49999999 Math.Round( 1.5 ) = 2 

Puede usar Math.Round como otros han sugerido (recomendado), o puede agregar 0.5 y lanzar a un int (que soltará la parte decimal).

 double value = 1.1; int roundedValue = (int)(value + 0.5); // equals 1 double value2 = 1.5; int roundedValue2 = (int)(value2 + 0.5); // equals 2 

Tiene la función Math.Round que hace exactamente lo que quiere.

 Math.Round(1.1) results with 1 Math.Round(1.8) will result with 2.... and so one. 

Use Math.Round :

 double roundedValue = Math.Round(value, 0) 

esto redondeará al 5 más cercano o no cambiará si ya es divisible por 5

 public static double R(double x) { // markup to nearest 5 return (((int)(x / 5)) * 5) + ((x % 5) > 0 ? 5 : 0); } 

Estaba buscando esto, pero mi ejemplo fue tomar un número, como 4.2769 y soltarlo en un lapso de solo 4.3. No es exactamente lo mismo, pero si esto ayuda:

 Model.Statistics.AverageReview < = it's just a double from the model 

Entonces:

 @Model.Statistics.AverageReview.ToString("n1") < =gives me 4.3 @Model.Statistics.AverageReview.ToString("n2") <=gives me 4.28 

etc ...

 var roundedVal = Math.Round(2.5, 0); 

Dará resultado:

 var roundedVal = 3 

Si trabajas con enteros en lugar de números de coma flotante, aquí está el camino.

 #define ROUNDED_FRACTION(numr,denr) ((numr/denr)+(((numr%denr)< (denr/2))?0:1)) 

Aquí tanto "numr" como "denr" son enteros sin signo.

Usando Math.Round(number) al número entero más cercano.

Escribe tu propio método de ronda. Algo como,

function round(x) rx = Math.ceil(x) if (rx - x < = .000001) return int(rx) else return int(x) end

 decimal RoundTotal = Total - (int)Total; if ((double)RoundTotal < = .50) Total = (int)Total; else Total = (int)Total + 1; lblTotal.Text = Total.ToString();