Decimal.Increment Operator

Parameters

• d
  Type: System.Decimal
  The Decimal operand.

Return Value

Type: System.Decimal
The value of d incremented by 1.

' Example of the Decimal increment, decrement, unary negation, and 
' unary plus operators.

Module Example

   ' Get the exception type name; remove the namespace prefix.
   Function GetExceptionType(ByVal ex As Exception) As String

      Dim exceptionType As String = ex.GetType().ToString()
      Return exceptionType.Substring( _
          exceptionType.LastIndexOf("."c) + 1)
   End Function

   ' Display the argument and the incremented and decremented values.
   Sub DecIncrDecrUnary(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal argument As Decimal)

      Dim toBeIncr As Decimal = argument
      Dim toBeDecr As Decimal = argument

      outputBlock.Text &= String.Format("{0,-36}{1}", "Decimal argument: ", _
          argument) & vbCrLf

      ' The op_Increment and op_Decrement operators must be 
      ' explicitly coded in Visual Basic.

      ' Catch the exception if the increment operator throws one.
      outputBlock.Text &= String.Format("{0,-36}", "Decimal.op_Increment( argument )")
      Try
         toBeIncr = Decimal.op_Increment(toBeIncr)
         outputBlock.Text &= String.Format("{0}", toBeIncr) & vbCrLf
      Catch ex As Exception
         outputBlock.Text &= String.Format("{0}", GetExceptionType(ex)) & vbCrLf
      End Try

      ' Catch the exception if the decrement operator throws one.
      outputBlock.Text &= String.Format("{0,-36}", "Decimal.op_Decrement( argument )")
      Try
         toBeDecr = Decimal.op_Decrement(toBeDecr)
         outputBlock.Text &= String.Format("{0}", toBeDecr) & vbCrLf
      Catch ex As Exception
         outputBlock.Text &= String.Format("{0}", GetExceptionType(ex)) & vbCrLf
      End Try

      outputBlock.Text &= vbCrLf
   End Sub

   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      outputBlock.Text &= String.Format( _
          "This example of the Decimal increment, decrement, " & _
          "unary negation, " & vbCrLf & "and unary plus " & _
          "operators generates the following output. It " & vbCrLf & _
          "displays the results of the operators on several " & _
          "Decimal values." & vbCrLf) & vbCrLf

      ' Create objects to compare with the reference.
      DecIncrDecrUnary(outputBlock, 0.000000123D)
      DecIncrDecrUnary(outputBlock, New Decimal(123000000, 0, 0, False, 9))

      ' The op_UnaryNegation and op_UnaryPlus operators must be
      ' explicitly coded in Visual Basic. If unary + or - is used,
      ' other methods are called.
      DecIncrDecrUnary(outputBlock, Decimal.op_UnaryNegation( _
          New Decimal(123000000, 0, 0, False, 9)))
      DecIncrDecrUnary(outputBlock, Decimal.op_UnaryPlus(Decimal.MaxValue))
      DecIncrDecrUnary(outputBlock, Decimal.op_UnaryNegation(Decimal.MaxValue))
      DecIncrDecrUnary(outputBlock, Decimal.op_UnaryPlus( _
          7.5000000000000000000000000001D))
   End Sub
End Module

' This example of the Decimal increment, decrement, unary negation,
' and unary plus operators generates the following output. It
' displays the results of the operators on several Decimal values.
' 
' Decimal argument:                   0.000000123
' Decimal.op_Increment( argument )    1.000000123
' Decimal.op_Decrement( argument )    -0.999999877
' 
' Decimal argument:                   0.123000000
' Decimal.op_Increment( argument )    1.123000000
' Decimal.op_Decrement( argument )    -0.877000000
' 
' Decimal argument:                   -0.123000000
' Decimal.op_Increment( argument )    0.877000000
' Decimal.op_Decrement( argument )    -1.123000000
' 
' Decimal argument:                   79228162514264337593543950335
' Decimal.op_Increment( argument )    OverflowException
' Decimal.op_Decrement( argument )    79228162514264337593543950334
' 
' Decimal argument:                   -79228162514264337593543950335
' Decimal.op_Increment( argument )    -79228162514264337593543950334
' Decimal.op_Decrement( argument )    OverflowException
' 
' Decimal argument:                   7.5000000000000000000000000001
' Decimal.op_Increment( argument )    8.500000000000000000000000000
' Decimal.op_Decrement( argument )    6.5000000000000000000000000001

// Example of the decimal increment, decrement, unary negation, and 
// unary plus operators.
using System;

class Example
{
   // Get the exception type name; remove the namespace prefix.
   public static string GetExceptionType(Exception ex)
   {
      string exceptionType = ex.GetType().ToString();
      return exceptionType.Substring(
          exceptionType.LastIndexOf('.') + 1);
   }

   // Display the argument and the incremented and decremented values.
   public static void DecIncrDecrUnary(System.Windows.Controls.TextBlock outputBlock, decimal argument)
   {
      decimal toBeIncr = argument;
      decimal toBeDecr = argument;

      outputBlock.Text += String.Format("{0,-26}{1}", "decimal argument: ",
          argument) + "\n";

      // Catch the exception if the increment operator throws one.
      outputBlock.Text += String.Format("{0,-26}", "argument ++");
      try
      {
         toBeIncr++;
         outputBlock.Text += String.Format("{0}", toBeIncr) + "\n";
      }
      catch (Exception ex)
      {
         outputBlock.Text += String.Format("{0}", GetExceptionType(ex)) + "\n";
      }

      // Catch the exception if the decrement operator throws one.
      outputBlock.Text += String.Format("{0,-26}", "argument --");
      try
      {
         toBeDecr--;
         outputBlock.Text += String.Format("{0}", toBeDecr) + "\n";
      }
      catch (Exception ex)
      {
         outputBlock.Text += String.Format("{0}", GetExceptionType(ex)) + "\n";
      }

      outputBlock.Text += "\n";
   }

   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      outputBlock.Text += String.Format("This example of the decimal increment, " +
          "decrement, unary negation, \nand unary plus operators " +
          "generates the following output. It \ndisplays the " +
          "results of the operators on several decimal values.\n") + "\n";

      // Create objects to compare with the reference.
      DecIncrDecrUnary(outputBlock, 0.000000123M);
      DecIncrDecrUnary(outputBlock, new decimal(123000000, 0, 0, false, 9));
      DecIncrDecrUnary(outputBlock, -new decimal(123000000, 0, 0, false, 9));
      DecIncrDecrUnary(outputBlock, +decimal.MaxValue);
      DecIncrDecrUnary(outputBlock, -decimal.MaxValue);
      DecIncrDecrUnary(outputBlock, +7.5000000000000000000000000001M);
   }
}

/*
This example of the decimal increment, decrement, unary negation,
and unary plus operators generates the following output. It
displays the results of the operators on several decimal values.

decimal argument:         0.000000123
argument ++               1.000000123
argument --               -0.999999877

decimal argument:         0.123000000
argument ++               1.123000000
argument --               -0.877000000

decimal argument:         -0.123000000
argument ++               0.877000000
argument --               -1.123000000

decimal argument:         79228162514264337593543950335
argument ++               OverflowException
argument --               79228162514264337593543950334

decimal argument:         -79228162514264337593543950335
argument ++               -79228162514264337593543950334
argument --               OverflowException

decimal argument:         7.5000000000000000000000000001
argument ++               8.500000000000000000000000000
argument --               6.5000000000000000000000000001
*/