Export (0) Print
Expand All

Decimal.ToOACurrency Method

Converts the specified Decimal value to the equivalent OLE Automation Currency value, which is contained in a 64-bit signed integer.

[Visual Basic]
Public Shared Function ToOACurrency( _
   ByVal value As Decimal _
) As Long
[C#]
public static long ToOACurrency(
 decimal value
);
[C++]
public: static __int64 ToOACurrency(
 Decimal value
);
[JScript]
public static function ToOACurrency(
   value : Decimal
) : long;

Parameters

value
A Decimal value.

Return Value

A 64-bit signed integer that contains the OLE Automation equivalent of value.

Example

[Visual Basic, C#, C++] The following code example uses the ToOACurrency method to convert Decimal numbers to the equivalent OLE Automation Currency values that are contained in Int64 fields.

[Visual Basic] 
' Example of the Decimal.ToOACurrency method. 
Imports System
Imports Microsoft.VisualBasic

Module DecimalToOACurrencyDemo
    
    Const dataFmt As String = "{0,31}{1,27}"

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

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

    ' Display the Decimal.ToOACurrency parameter and the result 
    ' or exception.
    Sub ShowDecimalToOACurrency( Argument As Decimal )

        ' Catch the exception if ToOACurrency( ) throws one.
        Try
            Dim oaCurrency As Long = Decimal.ToOACurrency( Argument )
            Console.WriteLine( dataFmt, Argument, _
                oaCurrency )

        Catch ex As Exception
            Console.WriteLine( dataFmt, Argument, _
                GetExceptionType( ex ) )
        End Try
    End Sub

    Sub Main( )
        Console.WriteLine( "This example of the " & _
            "Decimal.ToOACurrency( ) method generates " & vbCrLf & _
            "the following output. It displays the argument as " & _
            "a Decimal " & vbCrLf & "and the OLE Automation " & _
            "Currency value as a Long." & vbCrLf )
        Console.WriteLine( dataFmt, "Argument", _
            "OA Currency or Exception" )
        Console.WriteLine( dataFmt, "--------", _
            "------------------------" )

        ' Convert Decimal values to OLE Automation Currency values.
        ShowDecimalToOACurrency( 0D )
        ShowDecimalToOACurrency( 1D )
        ShowDecimalToOACurrency( _
            Decimal.Parse( "1.0000000000000000000000000000" ) )
        ShowDecimalToOACurrency( 100000000000000D )
        ShowDecimalToOACurrency( _
            Decimal.Parse( "100000000000000.00000000000000" ) )
        ShowDecimalToOACurrency( 10000000000000000000000000000D )
        ShowDecimalToOACurrency( 0.000000000123456789D ) 
        ShowDecimalToOACurrency( 0.123456789D ) 
        ShowDecimalToOACurrency( 123456789D ) 
        ShowDecimalToOACurrency( 123456789000000000D ) 
        ShowDecimalToOACurrency( 4294967295D ) 
        ShowDecimalToOACurrency( 18446744073709551615D ) 
        ShowDecimalToOACurrency( -79.228162514264337593543950335D ) 
        ShowDecimalToOACurrency( -79228162514264.337593543950335D ) 
    End Sub
End Module 

' This example of the Decimal.ToOACurrency( ) method generates
' the following output. It displays the argument as a Decimal
' and the OLE Automation Currency value as a Long.
' 
'                        Argument   OA Currency or Exception
'                        --------   ------------------------
'                               0                          0
'                               1                      10000
'  1.0000000000000000000000000000                      10000
'                 100000000000000        1000000000000000000
'  100000000000000.00000000000000        1000000000000000000
'   10000000000000000000000000000          OverflowException
'            0.000000000123456789                          0
'                     0.123456789                       1235
'                       123456789              1234567890000
'              123456789000000000          OverflowException
'                      4294967295             42949672950000
'            18446744073709551615          OverflowException
' -79.228162514264337593543950335                    -792282
' -79228162514264.337593543950335        -792281625142643376

[C#] 
// Example of the decimal.ToOACurrency method. 
using System;

class DecimalToOACurrencyDemo
{
    const string dataFmt = "{0,31}{1,27}";

    // 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 decimal.ToOACurrency parameter and the result 
    // or exception.
    public static void ShowDecimalToOACurrency( decimal Argument )
    {
        // Catch the exception if ToOACurrency( ) throws one.
        try
        {
            long oaCurrency = decimal.ToOACurrency( Argument );
            Console.WriteLine( dataFmt, Argument, oaCurrency );
        }
        catch( Exception ex )
        {
            Console.WriteLine( dataFmt, Argument, 
                GetExceptionType( ex ) );
        }
    }

    public static void Main( )
    {
        Console.WriteLine( "This example of the " +
            "decimal.ToOACurrency( ) method generates \nthe " +
            "following output. It displays the argument as a " +
            "decimal \nand the OLE Automation Currency value " +
            "as a long.\n" );
        Console.WriteLine( dataFmt, "Argument", 
            "OA Currency or Exception" );
        Console.WriteLine( dataFmt, "--------", 
            "------------------------" );

        // Convert decimal values to OLE Automation Currency values.
        ShowDecimalToOACurrency( 0M );
        ShowDecimalToOACurrency( 1M );
        ShowDecimalToOACurrency( 1.0000000000000000000000000000M );
        ShowDecimalToOACurrency( 100000000000000M );
        ShowDecimalToOACurrency( 100000000000000.00000000000000M );
        ShowDecimalToOACurrency( 10000000000000000000000000000M );
        ShowDecimalToOACurrency( 0.000000000123456789M );
        ShowDecimalToOACurrency( 0.123456789M );
        ShowDecimalToOACurrency( 123456789M );
        ShowDecimalToOACurrency( 123456789000000000M );
        ShowDecimalToOACurrency( 4294967295M );
        ShowDecimalToOACurrency( 18446744073709551615M );
        ShowDecimalToOACurrency( -79.228162514264337593543950335M );
        ShowDecimalToOACurrency( -79228162514264.337593543950335M );
    }
}

/*
This example of the decimal.ToOACurrency( ) method generates
the following output. It displays the argument as a decimal
and the OLE Automation Currency value as a long.

                       Argument   OA Currency or Exception
                       --------   ------------------------
                              0                          0
                              1                      10000
 1.0000000000000000000000000000                      10000
                100000000000000        1000000000000000000
 100000000000000.00000000000000        1000000000000000000
  10000000000000000000000000000          OverflowException
           0.000000000123456789                          0
                    0.123456789                       1235
                      123456789              1234567890000
             123456789000000000          OverflowException
                     4294967295             42949672950000
           18446744073709551615          OverflowException
-79.228162514264337593543950335                    -792282
-79228162514264.337593543950335        -792281625142643376
*/

[C++] 
// Example of the Decimal::ToOACurrency method. 
#using <mscorlib.dll>
using namespace System;

const __wchar_t* dataFmt = L"{0,31}{1,27}";

// Get the exception type name; remove the namespace prefix.
String* GetExceptionType( Exception* ex )
{
    String* exceptionType = ex->GetType( )->ToString( );
    return exceptionType->Substring( 
        exceptionType->LastIndexOf( '.' ) + 1 );
}

// Display the Decimal::ToOACurrency parameter and the result 
// or exception.
void ShowDecimalToOACurrency( Decimal Argument )
{
    // Catch the exception if ToOACurrency( ) throws one.
    try
    {
        __int64 oaCurrency = Decimal::ToOACurrency( Argument );
        Console::WriteLine( dataFmt, __box( Argument ), 
            __box( oaCurrency ) );
    }
    catch( Exception* ex )
    {
        Console::WriteLine( dataFmt, __box( Argument ), 
            GetExceptionType( ex ) );
    }
}

void main( )
{
    Console::WriteLine( S"This example of the " 
        S"Decimal::ToOACurrency( ) method generates \nthe " 
        S"following output. It displays the argument as a " 
        S"Decimal \nand the OLE Automation Currency value " 
        S"as an __int64.\n" );
    Console::WriteLine( dataFmt, S"Argument", 
        S"OA Currency or Exception" );
    Console::WriteLine( dataFmt, S"--------", 
        S"------------------------" );

    // Convert Decimal values to OLE Automation Currency values.
    ShowDecimalToOACurrency( Decimal( 0 ) );
    ShowDecimalToOACurrency( Decimal( 1 ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"1.0000000000000000000000000000" ) );
    ShowDecimalToOACurrency( Decimal::Parse( S"100000000000000" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"100000000000000.00000000000000" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"10000000000000000000000000000" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"0.000000000123456789" ) );
    ShowDecimalToOACurrency( Decimal::Parse( S"0.123456789" ) );
    ShowDecimalToOACurrency( Decimal::Parse( S"123456789" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"123456789000000000" ) );
    ShowDecimalToOACurrency( Decimal::Parse( S"4294967295" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"18446744073709551615" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"-79.228162514264337593543950335" ) );
    ShowDecimalToOACurrency( 
        Decimal::Parse( S"-79228162514264.337593543950335" ) );
}

/*
This example of the Decimal::ToOACurrency( ) method generates
the following output. It displays the argument as a Decimal
and the OLE Automation Currency value as an __int64.

                       Argument   OA Currency or Exception
                       --------   ------------------------
                              0                          0
                              1                      10000
 1.0000000000000000000000000000                      10000
                100000000000000        1000000000000000000
 100000000000000.00000000000000        1000000000000000000
  10000000000000000000000000000          OverflowException
           0.000000000123456789                          0
                    0.123456789                       1235
                      123456789              1234567890000
             123456789000000000          OverflowException
                     4294967295             42949672950000
           18446744073709551615          OverflowException
-79.228162514264337593543950335                    -792282
-79228162514264.337593543950335        -792281625142643376
*/

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

See Also

Decimal Structure | Decimal Members | System Namespace | FromOACurrency

Show:
© 2014 Microsoft