Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Math.Round-Methode

Rundet einen Wert auf die nächste Ganzzahl oder auf die angegebene Anzahl von Bruchstellen.

Dieser Member wird überladen. Klicken Sie auf einen Namen in der Überladungsliste, um vollständige Informationen zu diesem Member sowie zu Syntax, Nutzung und Beispielen zu erhalten.

  Name Beschreibung
Öffentliche Methode Statischer Member Round(Decimal) Rundet einen Dezimalwert auf den nächsten ganzzahligen Wert.
Öffentliche Methode Statischer Member Round(Double) Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächsten ganzzahligen Wert.
Öffentliche Methode Statischer Member Round(Decimal, Int32) Rundet einen Dezimalwert auf die angegebene Anzahl von Nachkommastellen.
Öffentliche Methode Statischer Member Round(Decimal, MidpointRounding) Rundet einen Decimal-Wert auf die nächste Ganzzahl. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.
Öffentliche Methode Statischer Member Round(Double, Int32) Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Nachkommastellen.
Öffentliche Methode Statischer Member Round(Double, MidpointRounding) Rundet einen Gleitkommawert mit doppelter Genauigkeit auf die nächste Ganzzahl. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.
Öffentliche Methode Statischer Member Round(Decimal, Int32, MidpointRounding) Rundet einen Dezimalwert auf die angegebene Anzahl von Nachkommastellen. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.
Öffentliche Methode Statischer Member Round(Double, Int32, MidpointRounding) Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Nachkommastellen. Ein Parameter gibt an, wie der Wert gerundet wird, wenn er genau zwischen zwei Zahlen liegt.
Zum Seitenanfang

In diesem Abschnitt

Syntax der überladenen Methode
Parameter
Rückgabewert
Ausnahmen
Welche Methode erhalte ich auf?
Mittelpunktwerte öffnende und Konventionen
Runden und Genauigkeit
Runden und Gleitkommawerte mit einfacher Genauigkeit
Beispiele:
       Math.Round (dezimal)
       Math.Round (Double)
       Math.Round (dezimal, Int32)
       Math.Round (dezimal, MidpointRounding)
       Math.Round (Double, Int32)
       Math.Round (Double, MidpointRounding)
       Math.Round (dezimal, Int32, MidpointRounding)
       Math.Round (Double, Int32, MidpointRounding)
Versionsinformationen

Syntax der überladenen Methode

Zusätzliche Hinweise zum Auswählen einer Überladung finden Sie unter Welche Methode erhalte ich auf?

Decimal Math.Round(Decimal d )

Rundet einen Dezimalwert auf die nächste ganze Zahl gerundet Mittelpunktwerte und zur nächsten gerade Anzahl (Beispiel).

Double Math.Round(Double a )

Rundet eine Gleitkommazahl mit doppelter Genauigkeit auf die nächste ganze Zahl gerundet Mittelpunktwerte und zur nächsten gerade Anzahl (Beispiel).

Decimal Math.Round(Decimal d , Int32 decimals )

Rundet einen Dezimalwert auf eine angegebene Anzahl und Mittelpunktwerte Dezimalstellen gerundet zur nächsten gerade Anzahl (Beispiel).

Double Math.Round(Double value , Int32 digits )

Rundet eine Gleitkommazahl mit doppelter Genauigkeit zu einer angegebenen Anzahl und Mittelpunktwerte Dezimalstellen gerundet zur nächsten gerade Anzahl (Beispiel).

Decimal Math.Round(Decimal d , MidpointRounding mode )

Rundet einen Dezimalwert auf die nächste ganze Zahl und verwendet die angegebene Rundungskonvention für Mittelpunktwerte (Beispiel).

Double Math.Round(Double value , MidpointRounding mode )

Rundet eine Gleitkommazahl mit doppelter Genauigkeit auf die nächste ganze Zahl und verwendet die angegebene Rundungskonvention für Mittelpunktwerte (Beispiel).

Decimal Math.Round(Decimal d , Int32 decimals , MidpointRounding mode )

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und verwendet die angegebene Rundungskonvention für Mittelpunktwerte (Beispiel).

Double Math.Round(Double value , Int32 digits , MidpointRounding mode )

Rundet eine Gleitkommazahl mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und verwendet die angegebene Rundungskonvention für Mittelpunktwerte (Beispiel).

Parameter

Dies ist eine vollständige Liste von Parametern für die Round-Methode. Informationen zu den Parametern, die von jeder Überladung verwendet werden, finden Sie die Überladungssyntax oben.

Parameter

Type

Beschreibung

d

Decimal

Eine Zahl gerundet werden.

a

- oder -

value

Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

decimals

- oder -

digits

Int32

Die Anzahl der Bruchziffern im Rückgabewert. Für Decimal-Werte kann sie von 0 bis 28 reichen. Für Double-Werte kann sie von 0 bis 15 reichen. Beachten Sie, dass 15 die maximale Anzahl des Integrals ist und Bruchziffern, die vom Double-Typ unterstützt werden.

Standardwert: 0, das auf eine ganze Zahl gerundet wird

mode

MidpointRounding

Ein Flag, das angibt der Konvention, die zum Abrunden des Mittelpunkts verwenden, beschränkt. Siehe Mittelpunktwerte öffnende und Konventionen.

Standardwert: MidpointRounding.ToEven

Rückgabewert

Typ: Decimal oder Double, je nach Art des Werts gerundet werden.
Ein numerischer Wert mit demselben Typ wie d, a oder value, aber gerundet entweder in eine ganze Zahl oder der angegebenen Anzahl der Dezimalstellen. finden Sie unter Mittelpunktwerte öffnende und Konventionen Informationen zum das Runden von Zahlen mit Mittelpunktwerten.

Warnhinweis Vorsicht

Wenn er Mittelpunktwerte rundet, führt der rundende Algorithmus einen Übereinstimmungstest aus. Aufgrund der möglichen Probleme der binären Darstellung und die Genauigkeit im Gleitkommaformat, kann der Wert, der von der Methode zurückgegebene, unerwartet auftreten. Weitere Informationen finden Sie unter Runden und Genauigkeit.

Wenn eine Überladung mit einem Parameter Double mit Double.NaN, gibt die Methode Double.NaN zurück. Wenn sie mit Double.PositiveInfinity oder Double.NegativeInfinity aufgerufen wird, gibt die Methode Double.PositiveInfinity oder Double.NegativeInfinity bzw., zurück.

Ausnahmen

Welche Methode erhalte ich auf?

Nach

Call

Rundet eine Zahl auf eine ganze Zahl mit der Konvention "Rundung auf den nächsten Wert".

Round(Decimal)

- oder -

Round(Double)

Rundet eine Zahl auf eine ganze Zahl mit einer angegebenen rundenden Konvention.

Round(Decimal, MidpointRounding)

- oder -

Round(Double, MidpointRounding)

Rundet eine Zahl auf eine angegebene Anzahl von Dezimalstellen mithilfe der Konvention "Rundung auf den nächsten Wert".

Round(Decimal, Int32)

- oder -

Round(Double, Int32)

Rundet eine Zahl auf eine angegebene Anzahl von Dezimalstellen mit einer angegebenen rundenden Konvention.

Round(Decimal, Int32, MidpointRounding)

- oder -

Round(Double, Int32, MidpointRounding)

Rundet einen Single-Wert einer angegebenen Anzahl Dezimalstellen mit einer angegebenen rundenden Konvention und das Minimieren des Verbindungsverlusts besteht darin von Genauigkeit.

Konvertieren Sie Single in Decimal und rufen Round(Decimal, Int32, MidpointRounding) auf.

Rundet eine Zahl auf eine angegebene Anzahl von Dezimalstellen beim Minimieren von Problemen von Genauigkeit, wenn Mittelpunktwerte gerundet werden.

Rufen Sie eine rundende Methode auf, die ein "größer als oder annähernd gleich" Vergleich implementiert. Siehe Runden und Genauigkeit.

Rundet einen Bruchteil in eine ganze Zahl, die größer ist, als der Bruchwert. Beispielsweise ein 3,1 bis 4.

Ceiling

Rundet einen Bruchteil in eine ganze Zahl, die kleiner ist, als der Bruchwert. Beispielsweise ein 3,9 bis 3.

Floor

Mittelpunktwerte öffnende und Konventionen

Das Runden umfasst, einen numerischen Wert in eine angegebene Genauigkeit zum nächsten Wert mit weniger Genauigkeit zu konvertieren. Beispielsweise können Sie die Round(Double)-Methode, um einen Wert von 3,4 bis 3,0 abzurunden und die Methode Round(Double, Int32) verwenden, um einen Wert von 3,579 bis 3,58 abzurunden.

In einem Mittelpunktwert ist der Wert nach der wenigen signifikanten Ziffern im Ergebnis genau halbe Methode zwischen zwei Zahlen. Beispielsweise ist 3,47500 ein Mittelpunktwert, wenn zwei Dezimalstellen gerundet werden soll, und 7,500 ist ein Mittelpunktwert, wenn er auf eine ganze Zahl gerundet werden soll. In diesen Fällen kann der nächste Wert ohne eine Rundungskonvention leicht identifiziert werden.

Die Round-Methode unterstützt zwei Rundungskonvention zum Behandeln von Mittelpunktwerten:

Runden positiver

Mittelpunktwerte werden zur folgenden Zahl positiver Richtung gerundet. Beispielsweise wird 3,75 auf 3,8 gerundet, 3,85 auf 3,9, -3,75 auf -3,8 und -3,85 auf -3,9. Diese Form des Rundens wird vom MidpointRounding.AwayFromZero-Enumerationsmember dargestellt.

Das Runden positiver ist das weiter bekannte Formular des Rundens.

So neben runden oder unverzerrte Rundung (Banker's Rounding)

Mittelpunktwerte werden zur nächsten gerade Zahl gerundet. Beispielsweise 3,75 und 3,85 rund auf 3,8 und -3,75 und -3,85 rund bis -3,8. Diese Form des Rundens wird vom MidpointRounding.ToEven-Enumerationsmember dargestellt.

Das Runden ist neben das Standardformular des Rundens verwendet in Finanz- und statistischen Vorgängen. Es entspricht an IEEE-Standard Abschnitt 754, 4. an. Wenn es in mehrerer verwendet wird, die Operationen rundet, reduziert es den Rundungsfehler, die verursacht wird, indem Mittelpunktwerte konsistent in einer bestimmten Richtung gerundet. In einigen Fällen kann dieser Rundungsfehler erheblich sein.

Das folgende Beispiel veranschaulicht die Neigung, die von Mittelpunktwerte in einer Richtung einzelnen einheitlich runden entstehen kann. Im Beispiel wird den wahren Durchschnitt eines Arrays Decimal-Werte und daraufhin wird der Mittelwert, wenn die Werte im Array gerundet werden, indem die beiden Konventionen verwendet. In diesem Beispiel sind der echte Durchschnitt und Mittelwert, der entsteht, wenn es neben rundet, identisch. jedoch unterschiedlich Mittelwert, der beim Runden positiver entsteht, durch .05 (oder durch 3,6%) vom tatsächlichen Durchschnitt.


using System;

public class Example
{
   public static void Main()
   {
      decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
      decimal sum = 0;

      // Calculate true mean.
      foreach (var value in values)
         sum += value;

      Console.WriteLine("True mean:     {0:N2}", sum/values.Length);

      // Calculate mean with rounding away from zero.
      sum = 0;
      foreach (var value in values)
         sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);

      Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length);

      // Calculate mean with rounding to nearest.
      sum = 0;
      foreach (var value in values)
         sum += Math.Round(value, 1, MidpointRounding.ToEven);

      Console.WriteLine("ToEven:        {0:N2}", sum/values.Length);
   }
}
// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40


Standardmäßig verwendet die Round-Methode das Runden zur nächsten Konvention. Die folgende Tabelle zeigt die Überladungen der Round-Methode und der rundenden Konvention auf, die jede verwendet.

Überladung

Abrunden der Konvention

Round(Decimal)

ToEven

Round(Double)

ToEven

Round(Decimal, Int32)

ToEven

Round(Double, Int32)

ToEven

Round(Decimal, MidpointRounding)

Bestimmt Parameter von mode.

Round(Double, MidpointRounding)

Bestimmt Parameter von mode

Round(Decimal, Int32, MidpointRounding)

Bestimmt Parameter von mode

Round(Double, Int32, MidpointRounding)

Bestimmt Parameter von mode

Runden und Genauigkeit

Um festzustellen ob ein rundender Operation ein Mittelpunktwert umfasst, multipliziert die Round-Methode den durch 10n abgerundet werden ursprünglichen Wert, wobei n die gewünschte Anzahl von Dezimalstellen im Rückgabewert ist, und bestimmt dann ob der verbleibende Bruchteil der Wert größer oder gleich .5 ist. Dies ist eine geringfügige Variation einen Übereinstimmungstest und wie im "Tests für Gleichheit" Abschnitt des Double Referenzthemas, Tests auf Gleichheit mit Gleitkommawerten erläutert auf Probleme des Gleitkommaformats mit binären und Genauigkeit problematisch sind. Dies bedeutet, dass jeder Bruchteil einer Zahl, die etwas niedriger ist, als .5 (aufgrund eines Verlust von Genauigkeit) nicht nach oben gerundet.

Das Problem wird anhand des folgenden Beispiels veranschaulicht. Es fügt wiederholt .1 auf 11,0 gerundet hinzu und das Ergebnis auf die nächste ganze Zahl. Unabhängig von der Rundungskonvention 11,5, rund bis 12 bei. Während die Ausgabe im Beispiel zeigt, wird es nicht. Im Beispiel wird "R" numerische Standardformatzeichenfolge, um die vollständige Genauigkeit des Gleitkommawerts anzuzeigen und stellt dar, dass der gerundet werden Wert Genauigkeit während sich wiederholender Hinzufügungen verloren hat, und sein Wert ist tatsächlich 11,499999999999998. Da .499999999999998 kleiner als .5 ist, wird der Wert nicht zur nächsten höchsten ganze Zahl gerundet. Wie das Beispiel auch darstellt, tritt dieses Problem nicht auf, wenn Sie einfach den konstanten Wert 11,5 zu einer Double-Variablen zuweisen.


using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero");
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)    
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//       
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//       
//        11.5                 11.5            12              12


Probleme von Genauigkeit, wenn Sie Mittelpunktwerte rundet, wahrscheinlich, in den folgenden Bedingungen auftreten: zu

  • Wenn ein nicht Bruchwert im Binärformat des Gleitkommatyps genau ausgedrückt werden kann.

  • Wenn der gerundet werden Wert eines oder mehrerer Gleitkommavorgängen abgeleitet wird.

  • Wenn der gerundet werden Wert Single statt Double oder Decimal ist. Weitere Informationen finden Sie im nächsten Abschnitt, Runden und Gleitkommawerte mit einfacher Genauigkeit.

In Fällen wo der Mangel an, Genauigkeit, wenn die Vorgänge rundet, problematisch ist, können Sie folgendermaßen vorgehen:

  • Wenn der rundende Vorgang eine Überladung aufrufen, die einen Double-Wert gerundet, können Sie Double in einen Decimal-Wert ändern und eine Überladung aufrufen, die einen Decimal-Wert stattdessen rundet. Obwohl der Decimal Datentyp auch Probleme der Darstellung und Genauigkeitsverlust hat, wurden diese Probleme weit weniger gebräuchlich.

  • Definieren Sie einen benutzerdefinierten rundenden Algorithmus, der einen "fast gleichen" Test ausgeführt wird, ermitteln, ob der Wert ist akzeptabel eng an einem Mittelpunktwert gerundet. Im folgenden Beispiel wird eine RoundApproximate-Methode, die überprüft, ob ein Bruchwert genug neben einem Mittelpunktwert, ist, um das Mittelpunktrunden ausgesetzt sein. Die Ausgabe im Beispiel zeigt, korrigierte sie das rundende Problem, das im vorherigen Beispiel gezeigt.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero");
          double value = 11.1;
          for (int ctr = 0; ctr <= 5; ctr++)    
             value = RoundValueAndAdd(value);
    
          Console.WriteLine();
    
          value = 11.5;
          RoundValueAndAdd(value);
       }
    
       private static double RoundValueAndAdd(double value)
       {
          const double tolerance = 8e-14;
    
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
          return value + .1;
       }
    
       private static double RoundApproximate(double dbl, int digits, double margin, 
                                         MidpointRounding mode)
       {                                      
          double fraction = dbl * Math.Pow(10, digits);
          double value = Math.Truncate(fraction); 
          fraction = fraction - value;   
          if (fraction == 0)
             return dbl;
    
          double tolerance = margin * dbl;
          // Determine whether this is a midpoint value.
          if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance)) {
             if (mode == MidpointRounding.AwayFromZero)
                return (value + 1)/Math.Pow(10, digits);
             else
                if (value % 2 != 0)
                   return (value + 1)/Math.Pow(10, digits);
                else
                   return value/Math.Pow(10, digits);
          }
          // Any remaining fractional value greater than .5 is not a midpoint value.
          if (fraction > .5)
             return (value + 1)/Math.Pow(10, digits);
          else
             return value/Math.Pow(10, digits);
       }
    }
    // The example displays the following output:
    //       Value       Full Precision        ToEven    AwayFromZero
    //       
    //        11.1                 11.1            11              11
    //        11.2                 11.2            11              11
    //        11.3   11.299999999999999            11              11
    //        11.4   11.399999999999999            11              11
    //        11.5   11.499999999999998            12              12
    //        11.6   11.599999999999998            12              12
    //       
    //        11.5                 11.5            12              12
    
    
    

Runden und Gleitkommawerte mit einfacher Genauigkeit

Die Round-Methode schließt Überladungen, die Argumente des Typs Decimal und Double akzeptieren. Es gibt keine dieser Methoden schließenden Werte vom Typ Single. Wenn Sie einen Single-Wert bis eine der Überladungen der Round-Methode übergeben, wird sie umgewandelt (in C#) oder konvertiert (in Visual Basic) zu Double, und die entsprechende Round Überladung mit einem Parameter Double wird aufgerufen. Obwohl dieses eine Erweiterungskonvertierung ist, wird es häufig einen Genauigkeitsverlust mit ein, wie im folgenden Beispiel veranschaulicht. Wenn ein Single-Wert von 16,325 der Round-Methode übergeben wird und auf zwei Dezimalstellen mithilfe des Rundens zur nächsten Konvention gerundet, ist das Ergebnis 16,33 und nicht das erwartete Ergebnis 16,32.


using System;

public class Example
{
   public static void Main()
   {
      Single value = 16.325f;
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, (double) value, 
                        ((double) (value)).GetType().Name);
      Console.WriteLine(Math.Round(value, 2));
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
      Console.WriteLine();

      Decimal decValue = (decimal) value;
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name);
      Console.WriteLine(Math.Round(decValue, 2));
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//    
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33


Dies unerwartete Ergebnis ist aufgrund eines Verlust einer Präzision in der Konvertierung des Werts Single zu Double. Da der resultierende Double-Wert 16,325000762939453 ist kein Mittelpunktwert und größer als 16,325 ist, wird er immer nach oben gerundet.

In vielen Fällen während das Beispiel veranschaulicht, kann der Genauigkeitsverlust durch das Umwandeln oder Konvertieren des Single-Werts zu Decimal minimiert werden oder entfernt werden. Beachten Sie, dass, da dies eine Eingrenzungskonvertierung ist, sie mit einem Umwandlungsoperators oder den Aufruf einer Konvertierungsmethode erfordert.

Beispiel Math.Round (dezimal)

Im folgenden Beispiel wird die Round(Decimal)-Methode veranschaulicht. Beachten Sie, dass Decimal der Wert von 4.5 bis 4 statt 5 gerundet, da die Überladung die standardmäßige ToEven Konvention verwendet.


using System;

class Example
{
   static void Main()
   {
      for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
         Console.WriteLine("{0} --> {1}", value, Math.Round(value));
   }
}
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5


(Beispiel Math.Round Doppeltes)

Im folgenden Beispiel wird das Runden auf den nächsten Ganzzahlwert veranschaulicht.


using System;

class Program
{
    static void Main()
    {
    Console.WriteLine("Classic Math.Round in CSharp");
    Console.WriteLine(Math.Round(4.4)); // 4
    Console.WriteLine(Math.Round(4.5)); // 4
    Console.WriteLine(Math.Round(4.6)); // 5
    Console.WriteLine(Math.Round(5.5)); // 6
    }
}


Beispiel Math.Round (dezimal, Int32)

Das folgende Beispiel rundet Dezimalwerte mit zwei Dezimalstellen zu den Werten, die eine einzelne Dezimalstelle haben.


using System;

public class Sample {
   static void Main() {
      Console.WriteLine(Math.Round(3.44m, 1)); 
      Console.WriteLine(Math.Round(3.45m, 1)); 
      Console.WriteLine(Math.Round(3.46m, 1)); 
      Console.WriteLine();

      Console.WriteLine(Math.Round(4.34m, 1)); 
      Console.WriteLine(Math.Round(4.35m, 1)); 
      Console.WriteLine(Math.Round(4.36m, 1)); 
   }
}
// The example displays the following output:
//       3.4
//       3.4
//       3.5
//       
//       4.3
//       4.4
//       4.4


Beispiel Math.Round (Double, Int32)

Das folgende Beispiel rundet Double-Werte mit zwei Dezimalstellen an double-Werte, die eine einzelne Dezimalstelle haben.


Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4


Beispiel Math.Round (dezimal, MidpointRounding)

Im folgenden Beispiel werden die Werte angezeigt, die durch die Round(Decimal)-Methode, die Round(Decimal, MidpointRounding)-Methode mode mit einem Argument von ToEven und die Round(Decimal, MidpointRounding)-Methode mode mit einem Argument von AwayFromZero zurückgegeben werden.


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


Beispiel Math.Round (Double, MidpointRounding)

Im folgenden Beispiel werden die Werte angezeigt, die durch die Round(Double)-Methode, die Round(Double, MidpointRounding)-Methode mode mit einem Argument von ToEven und die Round(Double, MidpointRounding)-Methode mode mit einem Argument von AwayFromZero zurückgegeben werden.


using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                          12.7, 12.8, 12.9, 13.0 };
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {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


Beispiel Math.Round (dezimal, Int32, MidpointRounding)

Das folgende Beispiel zeigt, wie die Round-Methode mit der MidpointRounding-Enumeration verwendet.


// 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)

*/


Beispiel Math.Round (Double, Int32, MidpointRounding)

Das folgende Beispiel zeigt, wie die Round(Double, Int32, MidpointRounding)-Methode mit der MidpointRounding-Enumeration verwendet.


using System;

class Sample 
{
    public static void Main() 
    {
       double posValue =  3.45;
       double negValue = -3.45;

       // Round a positive and a negative value using the default. 
       double 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)\n", result, negValue);

       // Round a positive value using a MidpointRounding value. 
       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)\n", 
                         result, posValue);

       // Round a negative value using a MidpointRounding value. 
       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)\n", 
                         result, negValue);
   }
}
// The example displays the following output:
//        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)


Versionsinformationen

.NET Framework

Überladungen ohne einen MidpointRounding-Parameter werden in unterstützt: 4.5, 4, 3,5, 3,0, 2,0, 1,1, 1,0
Überladungen mit einem Parameter in MidpointRounding werden unterstützt: 4.5, 4, 3,5, 3,0, 2,0

.NET Framework Client Profile

Alle Überladungen werden in unterstützt: 4, 3,5 SP1

Portable Klassenbibliotheken

Alle Überladungen werden unterstützt

.NET für Windows Store-Apps

Alle Überladungen werden in unterstützt: Windows 8

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft