Decimal.Round Decimal.Round Decimal.Round Decimal.Round Method

Definition

Rundet einen Wert auf die nächste Ganzzahl oder auf die angegebene Anzahl von Dezimalstellen.Rounds a value to the nearest integer or specified number of decimal places.

Überlädt

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Rundet einen Decimal-Wert auf die nächste Ganzzahl.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Rundet einen Decimal-Wert auf die angegebene Anzahl von Dezimalstellen.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Rundet einen Decimal-Wert auf die nächste Ganzzahl.Rounds a decimal value to the nearest integer. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Rundet einen Decimal-Wert auf eine angegebene Genauigkeit.Rounds a decimal value to a specified precision. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Rundet einen Decimal-Wert auf die nächste Ganzzahl.Rounds a decimal value to the nearest integer.

public:
 static System::Decimal Round(System::Decimal d);
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Decimal-Zahl.A decimal number to round.

Gibt zurück

Die Ganzzahl, die dem d-Parameter am nächsten ist.The integer that is nearest to the d parameter. Wenn d genau in der Mitte zwischen zwei Ganzzahlen liegt (von denen eine gerade und die andere ungerade ist), wird die gerade Zahl zurückgegeben.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Ausnahmen

Das Ergebnis liegt außerhalb des Bereichs eines Decimal-Werts.The result is outside the range of a Decimal value.

Beispiele

Im folgenden Beispiel wird einen Bereich von Decimal Werte zwischen 100 und 102 auf die nächste Ganzzahl.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Da die Methode unverzerrte Rundung verwendet, beachten Sie, dass es sich bei 100.5 100 und 101.5 Zehnerpotenzen 102 rundet.Because the method uses banker's rounding, note that 100.5 rounds to 100 and 101.5 rounds to 102.

using System;

public class Example
{
   public static void Main()
   {
      for (decimal value = 100m; value <= 102m; value += .1m)
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value));

   }
}
// The example displays the following output:
//     100 --> 100
//     100.1 --> 100
//     100.2 --> 100
//     100.3 --> 100
//     100.4 --> 100
//     100.5 --> 100
//     100.6 --> 101
//     100.7 --> 101
//     100.8 --> 101
//     100.9 --> 101
//     101.0 --> 101
//     101.1 --> 101
//     101.2 --> 101
//     101.3 --> 101
//     101.4 --> 101
//     101.5 --> 102
//     101.6 --> 102
//     101.7 --> 102
//     101.8 --> 102
//     101.9 --> 102
//     102.0 --> 102
Module Example
   Public Sub Main()
      For value As Decimal = 100d To 102d Step .1d
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value))
      Next
   End Sub
End Module
' The example displays the following output:
'     100 --> 100
'     100.1 --> 100
'     100.2 --> 100
'     100.3 --> 100
'     100.4 --> 100
'     100.5 --> 100
'     100.6 --> 101
'     100.7 --> 101
'     100.8 --> 101
'     100.9 --> 101
'     101.0 --> 101
'     101.1 --> 101
'     101.2 --> 101
'     101.3 --> 101
'     101.4 --> 101
'     101.5 --> 102
'     101.6 --> 102
'     101.7 --> 102
'     101.8 --> 102
'     101.9 --> 102
'     102.0 --> 102

Hinweise

Das Verhalten dieser Methode folgt Standard IEEE-754, Abschnitt 4.The behavior of this method follows IEEE Standard 754, section 4. Diese Art der Rundung bezeichnet runden Hälfte auch oder Banker rounding.This kind of rounding is sometimes called round half to even or banker's rounding. Es so werden Rundungsfehler reduziert, die aus der Mitte liegenden Werten in einer Richtung einheitlichen runden entstehen.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. Dies entspricht dem Aufrufen der Round(Decimal, MidpointRounding) -Methode mit einer mode Argument MidpointRounding.ToEven.It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Siehe auch

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Rundet einen Decimal-Wert auf die angegebene Anzahl von Dezimalstellen.Rounds a Decimal value to a specified number of decimal places.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public static decimal Round (decimal d, int decimals);
static member Round : decimal * int -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Decimal-Zahl.A decimal number to round.

decimals
Int32 Int32 Int32 Int32

Ein Wert zwischen 0 (null) und 28, der die Anzahl der Dezimalstellen angibt, auf die gerundet werden soll.A value from 0 to 28 that specifies the number of decimal places to round to.

Gibt zurück

Die Dezimalzahl, die dem auf d Dezimalstellen gerundeten Wert von decimals entspricht.The decimal number equivalent to d rounded to decimals number of decimal places.

Ausnahmen

decimals ist kein Wert zwischen 0 (null) und 28.decimals is not a value from 0 to 28.

Beispiele

Im folgenden Beispiel wird mehrere Decimal Werte für eine angegebene Anzahl von Dezimalstellen, die mit der Round Methode.The following example rounds several Decimal values to a specified number of decimal places using the Round method.

using System;

class Example
{
   public static void Main()
   {
      // Define a set of Decimal values.
      decimal[] values = { 1.45m, 1.55m, 123.456789m, 123.456789m, 
                           123.456789m, -123.456m, 
                           new Decimal(1230000000, 0, 0, true, 7 ),
                           new Decimal(1230000000, 0, 0, true, 7 ), 
                           -9999999999.9999999999m, 
                           -9999999999.9999999999m };
      // Define a set of integers to for decimals argument.
      int[] decimals = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10};
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" );
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" );
      for (int ctr = 0; ctr < values.Length; ctr++)
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values[ctr], decimals[ctr], 
                          Decimal.Round(values[ctr], decimals[ctr]));
    }
}
// The example displays the following output:
//                   Argument  Digits                    Result
//                   --------  ------                    ------
//                       1.45       1                       1.4
//                       1.55       1                       1.6
//                 123.456789       4                  123.4568
//                 123.456789       6                123.456789
//                 123.456789       8                123.456789
//                   -123.456       0                      -123
//               -123.0000000       3                  -123.000
//               -123.0000000      11              -123.0000000
//     -9999999999.9999999999       9    -10000000000.000000000
//     -9999999999.9999999999      10    -9999999999.9999999999
Public Module Example
   Public Sub Main()
      ' Define a set of Decimal values.
      Dim values() As Decimal = { 1.45d, 1.55d, 123.456789d, 123.456789d, 
                                  123.456789d, -123.456d, 
                                  New Decimal(1230000000, 0, 0, true, 7 ),
                                  New Decimal(1230000000, 0, 0, true, 7 ), 
                                  -9999999999.9999999999d, 
                                  -9999999999.9999999999d }
      ' Define a set of integers to for decimals argument.
      Dim decimals() As Integer = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10}
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" )
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" )
      For ctr As Integer = 0 To values.Length - 1
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values(ctr), decimals(ctr), 
                          Decimal.Round(values(ctr), decimals(ctr)))
      Next
   End Sub
End Module
' The example displays the following output:
'                   Argument  Digits                    Result
'                   --------  ------                    ------
'                       1.45       1                       1.4
'                       1.55       1                       1.6
'                 123.456789       4                  123.4568
'                 123.456789       6                123.456789
'                 123.456789       8                123.456789
'                   -123.456       0                      -123
'               -123.0000000       3                  -123.000
'               -123.0000000      11              -123.0000000
'     -9999999999.9999999999       9    -10000000000.000000000
'     -9999999999.9999999999      10    -9999999999.9999999999

Hinweise

Diese Methode entspricht dem Aufrufen der Round(Decimal, Int32, MidpointRounding) -Methode mit einem mode Argument der MidpointRounding.ToEven. Wenn d wird genau in der Mitte zwischen zwei Werten gerundet, ist das Ergebnis der gerundete Wert, der eine gerade Zahl in die am weitesten rechts Dezimalstelle aufweist.This method is equivalent to calling the Round(Decimal, Int32, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.When d is exactly halfway between two rounded values, the result is the rounded value that has an even digit in the far right decimal position. Der Wert 2,345 wird z. B. bei einer Rundung auf zwei Dezimalziffern zu 2,34, und der Wert 2,355 wird zu 2,36.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Dieser Prozess wird als bezeichnet runden in Richtung sogar, oder Banker rounding.This process is known as rounding toward even, or banker's rounding. Es so werden Rundungsfehler reduziert, die aus der Mitte liegenden Werten in einer Richtung einheitlichen runden entstehen.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Siehe auch

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Rundet einen Decimal-Wert auf die nächste Ganzzahl.Rounds a decimal value to the nearest integer. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.A parameter specifies how to round the value if it is midway between two other numbers.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public static decimal Round (decimal d, MidpointRounding mode);
static member Round : decimal * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Decimal-Zahl.A decimal number to round.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Ein Wert, der angibt, wie d gerundet wird, wenn es genau zwischen zwei Zahlen liegt.A value that specifies how to round d if it is midway between two other numbers.

Gibt zurück

Die Ganzzahl, die dem d-Parameter am nächsten ist.The integer that is nearest to the d parameter. Wenn d genau in der Mitte zwischen zwei Zahlen liegt (von denen eine gerade und die andere ungerade ist), bestimmt der mode-Parameter, welche der beiden Zahlen zurückgegeben wird.If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned.

Ausnahmen

Das Ergebnis liegt außerhalb des Bereichs eines Decimal-Objekts.The result is outside the range of a Decimal object.

Beispiele

Das folgende Beispiel zeigt die Rückgabewerte der Round(Decimal) -Methode, der Round(Decimal, MidpointRounding) -Methode mit einer mode Argument der ToEven, und die Round(Decimal, MidpointRounding) -Methode mit eine mode Argument der AwayFromZero.The following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero");
      for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

Hinweise

In der Mitte liegenden Werten ist der Wert nach der am wenigsten signifikante Ziffer in das Ergebnis genau halbem Weg zwischen zwei Zahlen.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. 7.5 ist z. B. einen Wert für den Mittelpunkt aus, wenn es in eine ganze Zahl gerundet werden soll.For example, 7.5 is a midpoint value if it is to be rounded to an integer. Für die Werte für Mittelpunkt, der nächste Wert kann nicht einfach identifiziert werden ohne eine Rundung gilt, die von angegeben wird die mode Argument.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Die Round -Methode unterstützt zwei Rundung Konventionen für die Behandlung Mittelpunkt-Werte.The Round method supports two rounding conventions for handling midpoint values.

Von NULL Weg gerundet.Rounding away from zero.
Mittelpunkt Werte werden auf der nächsten Anzahl von NULL Weg gerundet.Midpoint values are rounded to the next number away from zero. 3.5 abgerundet, 4, 4.5 runden beträgt 5-3.5 wird aufgerundet, um-4, und-4.5-5 rundet.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Diese Form der Rundung wird dargestellt, durch die MidpointRounding.AwayFromZero -Enumerationsmember.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Von NULL Weg gerundet ist die am häufigsten bekannten Form der Rundung.Rounding away from zero is the most widely known form of rounding.

Runden sogar oder unverzerrte RundungRounding to even, or banker's rounding
Mittelpunkt Werte werden auf die nächste gerade Zahl gerundet.Midpoint values are rounded to the nearest even number. Z. B. sowohl 3.5 und 4.5 runden, 4 und sowohl für-3.5-4.5 runden, -4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Diese Form der Rundung wird dargestellt, durch die MidpointRounding.ToEven -Enumerationsmember.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

Nächsten Wert gerundet wird der Standardform der Rundung der finanzielle und statistische Vorgänge verwendet.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Es entspricht dem Standard IEEE 754, Abschnitt 4.It conforms to IEEE Standard 754, section 4. Bei Verwendung in mehreren Rundungsoperationen wird verringert, die Rundungsfehler, die vom einheitlichen runden Mittelwert der Werte in einer Richtung verursacht wird.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In einigen Fällen kann diese Rundungsfehler erheblich sein.In some cases, this rounding error can be significant.

Siehe auch

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Rundet einen Decimal-Wert auf eine angegebene Genauigkeit.Rounds a decimal value to a specified precision. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.A parameter specifies how to round the value if it is midway between two other numbers.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);
static member Round : decimal * int * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Decimal-Zahl.A decimal number to round.

decimals
Int32 Int32 Int32 Int32

Die Anzahl der signifikanten Dezimalstellen (Genauigkeit) im Rückgabewert.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Ein Wert, der angibt, wie d gerundet wird, wenn es genau zwischen zwei Zahlen liegt.A value that specifies how to round d if it is midway between two other numbers.

Gibt zurück

Die Zahl, die dem d-Parameter am nächsten ist, der die gleiche Genauigkeit wie der decimals-Parameter aufweist.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Wenn d genau in der Mitte zwischen zwei Zahlen liegt (von denen eine gerade und die andere ungerade ist), bestimmt der mode-Parameter, welche der beiden Zahlen zurückgegeben wird.If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned. Wenn die Genauigkeit von d kleiner als decimals ist, wird d unverändert zurückgegeben.If the precision of d is less than decimals, d is returned unchanged.

Ausnahmen

decimals ist kleiner als 0 (null) oder größer als 28.decimals is less than 0 or greater than 28.

Das Ergebnis liegt außerhalb des Bereichs eines Decimal-Objekts.The result is outside the range of a Decimal object.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die Round(Decimal, Int32, MidpointRounding) -Methode mit dem MidpointRounding Enumeration.The following example demonstrates how to use the Round(Decimal, Int32, MidpointRounding) method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using System;

class Sample 
{
    public static void Main() 
    {
    decimal result = 0.0m;
    decimal posValue =  3.45m;
    decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

    result = Math.Round(posValue, 1);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math.Round(negValue, 1);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console.WriteLine();

// Round a positive value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

    result = Math.Round(posValue, 1, MidpointRounding.ToEven);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, posValue);
    result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, posValue);
    Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

    result = Math.Round(negValue, 1, MidpointRounding.ToEven);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, negValue);
    result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, negValue);
    Console.WriteLine();
    }
}
/*
This code example produces the following results:

 3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Imports System

Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub 'Main
End Class 'Sample
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'

Hinweise

Die decimals Parameter gibt die Anzahl der signifikanten Dezimalstellen im Rückgabewert und reicht von 0 bis 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Wenn decimals NULL ist, wird eine ganze Zahl zurückgegeben.If decimals is zero, an integer is returned.

In der Mitte liegenden Werten ist der Wert nach der am wenigsten signifikante Ziffer in das Ergebnis genau halbem Weg zwischen zwei Zahlen.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Beispielsweise ist 3.47500 Mitte liegenden Werten ist dies werden auf zwei Dezimalstellen gerundet und 7.500 ist ein Wert für den Mittelpunkt auf, wenn es in eine ganze Zahl gerundet werden soll.For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. In diesen Fällen der nächste Wert kann nicht einfach identifiziert werden ohne eine Rundung gilt, die von angegeben wird die mode Argument.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Die Round(Decimal, Int32, MidpointRounding) -Methode unterstützt zwei Rundung Konventionen für die Behandlung Mittelpunkt-Werte.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Von NULL Weg gerundet.Rounding away from zero.
Mittelpunkt Werte werden auf der nächsten Anzahl von NULL Weg gerundet.Midpoint values are rounded to the next number away from zero. Z. B. 3,75 Rundet auf 3.8, 3,85 Rundet auf 3.9,-3.75 wird aufgerundet, um-3.8, und-3.85 wird aufgerundet, um-3.9.For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. Diese Form der Rundung wird dargestellt, durch die MidpointRounding.AwayFromZero -Enumerationsmember.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Von NULL Weg gerundet ist die am häufigsten bekannten Form der Rundung.Rounding away from zero is the most widely known form of rounding.

Runden sogar oder unverzerrte RundungRounding to even, or banker's rounding
Mittelpunkt Werte werden auf die nächste gerade Zahl gerundet.Midpoint values are rounded to the nearest even number. Z. B. sowohl "3,75" und "3.85 werden zu 3.8 und sowohl für-3.75-3.85 runden, um-3.8.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Diese Form der Rundung wird dargestellt, durch die MidpointRounding.ToEven -Enumerationsmember.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

Nächsten Wert gerundet wird der Standardform der Rundung der finanzielle und statistische Vorgänge verwendet.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Es entspricht dem Standard IEEE 754, Abschnitt 4.It conforms to IEEE Standard 754, section 4. Bei Verwendung in mehreren Rundungsoperationen wird verringert, die Rundungsfehler, die vom einheitlichen runden Mittelwert der Werte in einer Richtung verursacht wird.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In einigen Fällen kann diese Rundungsfehler erheblich sein.In some cases, this rounding error can be significant.

Siehe auch

Gilt für: