Export (0) Print
Expand All

Convert.ToInt64 Method

Converts a specified value to a 64-bit signed integer.

Overload List

Converts the value of the specified Boolean value to the equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Boolean) As Long
[C#] public static long ToInt64(bool);
[C++] public: static __int64 ToInt64(bool);
[JScript] public static function ToInt64(Boolean) : long;

Converts the value of the specified 8-bit unsigned integer to the equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Byte) As Long
[C#] public static long ToInt64(byte);
[C++] public: static __int64 ToInt64(unsigned char);
[JScript] public static function ToInt64(Byte) : long;

Converts the value of the specified Unicode character to the equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Char) As Long
[C#] public static long ToInt64(char);
[C++] public: static __int64 ToInt64(__wchar_t);
[JScript] public static function ToInt64(Char) : long;

Calling this method always throws InvalidCastException.

[Visual Basic] Overloads Public Shared Function ToInt64(DateTime) As Long
[C#] public static long ToInt64(DateTime);
[C++] public: static __int64 ToInt64(DateTime);
[JScript] public static function ToInt64(DateTime) : long;

Converts the value of the specified Decimal number to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

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

Converts the value of the specified double-precision floating point number to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Double) As Long
[C#] public static long ToInt64(double);
[C++] public: static __int64 ToInt64(double);
[JScript] public static function ToInt64(double) : long;

Converts the value of the specified 16-bit signed integer to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Short) As Long
[C#] public static long ToInt64(short);
[C++] public: static __int64 ToInt64(short);
[JScript] public static function ToInt64(Int16) : long;

Converts the value of the specified 32-bit signed integer to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Integer) As Long
[C#] public static long ToInt64(int);
[C++] public: static __int64 ToInt64(int);
[JScript] public static function ToInt64(int) : long;

Returns the specified 64-bit signed integer; no actual conversion is performed.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Long) As Long
[C#] public static long ToInt64(long);
[C++] public: static __int64 ToInt64(__int64);
[JScript] public static function ToInt64(long) : long;

Converts the value of the specified Object to a 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Object) As Long
[C#] public static long ToInt64(object);
[C++] public: static __int64 ToInt64(Object*);
[JScript] public static function ToInt64(Object) : long;

Converts the value of the specified 8-bit signed integer to the equivalent 64-bit signed integer. This method is not CLS-compliant.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(SByte) As Long
[C#] public static long ToInt64(sbyte);
[C++] public: static __int64 ToInt64(char);
[JScript] public static function ToInt64(SByte) : long;

Converts the value of the specified single-precision floating point number to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(Single) As Long
[C#] public static long ToInt64(float);
[C++] public: static __int64 ToInt64(float);
[JScript] public static function ToInt64(float) : long;

Converts the specified String representation of a number to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(String) As Long
[C#] public static long ToInt64(string);
[C++] public: static __int64 ToInt64(String*);
[JScript] public static function ToInt64(String) : long;

Converts the value of the specified 16-bit unsigned integer to the equivalent 64-bit signed integer. This method is not CLS-compliant.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(UInt16) As Long
[C#] public static long ToInt64(ushort);
[C++] public: static __int64 ToInt64(unsigned short);
[JScript] public static function ToInt64(UInt16) : long;

Converts the value of the specified 32-bit unsigned integer to an equivalent 64-bit signed integer. This method is not CLS-compliant.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(UInt32) As Long
[C#] public static long ToInt64(uint);
[C++] public: static __int64 ToInt64(unsigned int);
[JScript] public static function ToInt64(UInt32) : long;

Converts the value of the specified 64-bit unsigned integer to an equivalent 64-bit signed integer. This method is not CLS-compliant.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(UInt64) As Long
[C#] public static long ToInt64(ulong);
[C++] public: static __int64 ToInt64(unsigned __int64);
[JScript] public static function ToInt64(UInt64) : long;

Converts the value of the specified Object to a 64-bit signed integer using the specified culture-specific formatting information.

[Visual Basic] Overloads Public Shared Function ToInt64(Object, IFormatProvider) As Long
[C#] public static long ToInt64(object, IFormatProvider);
[C++] public: static __int64 ToInt64(Object*, IFormatProvider*);
[JScript] public static function ToInt64(Object, IFormatProvider) : long;

Converts the specified String representation of a number to an equivalent 64-bit signed integer using the specified culture-specific formatting information.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(String, IFormatProvider) As Long
[C#] public static long ToInt64(string, IFormatProvider);
[C++] public: static __int64 ToInt64(String*, IFormatProvider*);
[JScript] public static function ToInt64(String, IFormatProvider) : long;

Converts the String representation of a number in a specified base to an equivalent 64-bit signed integer.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Function ToInt64(String, Integer) As Long
[C#] public static long ToInt64(string, int);
[C++] public: static __int64 ToInt64(String*, int);
[JScript] public static function ToInt64(String, int) : long;

Example

[Visual Basic, C#, C++] The following code example converts String representations of Int64 (64-bit integers) with the ToInt64 method, using an IFormatProvider object.

[Visual Basic, C#, C++] Note   This example shows how to use one of the overloaded versions of ToInt64. For other examples that might be available, see the individual overload topics.
[Visual Basic] 
' Example of the Convert.ToInt64( String ) and 
' Convert.ToInt64( String, IFormatProvider ) methods.
Imports System
Imports System.Globalization
Imports Microsoft.VisualBasic

Module ToInt64ProviderDemo

    Dim format As String = "{0,-22}{1,-20}{2}"

    ' 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

    Sub ConvertToInt64( numericStr As String, _
        provider As IFormatProvider )

        Dim defaultValue    As Object
        Dim providerValue   As Object

        ' Convert numericStr to Int64 without a format provider.
        Try
            defaultValue = Convert.ToInt64( numericStr )
        Catch ex As Exception
            defaultValue = GetExceptionType( ex )
        End Try

        ' Convert numericStr to Int64 with a format provider.
        Try
            providerValue = Convert.ToInt64( numericStr, provider )
        Catch ex As Exception
            providerValue = GetExceptionType( ex )
        End Try

        Console.WriteLine( format, numericStr, _
            defaultValue, providerValue )
    End Sub

    Sub Main( )

        ' Create a NumberFormatInfo object and set several of its
        ' properties that apply to numbers.
        Dim provider  As NumberFormatInfo = new NumberFormatInfo( )

        ' These properties affect the conversion.
        provider.NegativeSign = "neg "
        provider.PositiveSign = "pos "

        ' These properties do not affect the conversion.
        ' The input string cannot have decimal and group separators.
        provider.NumberDecimalSeparator = "."
        provider.NumberGroupSeparator = ","
        provider.NumberGroupSizes = New Integer( ) { 3 }
        provider.NumberNegativePattern = 0

        Console.WriteLine( "This example of" & vbCrLf & _
            "  Convert.ToInt64( String ) and " & vbCrLf & _
            "  Convert.ToInt64( String, IFormatProvider ) " & _
            vbCrLf & "generates the following output. It " & _
            "converts several strings to " & vbCrLf & "Long " & _
            "values, using default formatting " & _
            "or a NumberFormatInfo object." & vbCrLf )
        Console.WriteLine( format, "String to convert", _
            "Default/exception", "Provider/exception" )
        Console.WriteLine( format, "-----------------", _
            "-----------------", "------------------" )

        ' Convert strings, with and without an IFormatProvider.
        ConvertToInt64( "123456789", provider )
        ConvertToInt64( "+123456789", provider )
        ConvertToInt64( "pos 123456789", provider )
        ConvertToInt64( "-123456789", provider )
        ConvertToInt64( "neg 123456789", provider )
        ConvertToInt64( "123456789.", provider )
        ConvertToInt64( "123,456,789", provider )
        ConvertToInt64( "(123456789)", provider )
        ConvertToInt64( "9223372036854775808", provider )
        ConvertToInt64( "-9223372036854775809", provider )
    End Sub 
End Module 

' This example of
'   Convert.ToInt64( String ) and
'   Convert.ToInt64( String, IFormatProvider )
' generates the following output. It converts several strings to
' Long values, using default formatting or a NumberFormatInfo object.
' 
' String to convert     Default/exception   Provider/exception
' -----------------     -----------------   ------------------
' 123456789             123456789           123456789
' +123456789            123456789           FormatException
' pos 123456789         FormatException     123456789
' -123456789            -123456789          FormatException
' neg 123456789         FormatException     -123456789
' 123456789.            FormatException     FormatException
' 123,456,789           FormatException     FormatException
' (123456789)           FormatException     FormatException
' 9223372036854775808   OverflowException   OverflowException
' -9223372036854775809  OverflowException   FormatException

[C#] 
// Example of the Convert.ToInt64( string ) and 
// Convert.ToInt64( string, IFormatProvider ) methods.
using System;
using System.Globalization;

class ToInt64ProviderDemo
{
    static string format = "{0,-22}{1,-20}{2}";

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

    static void ConvertToInt64( string numericStr, 
        IFormatProvider provider )
    {
        object defaultValue;
        object providerValue;

        // Convert numericStr to Int64 without a format provider.
        try
        {
            defaultValue = Convert.ToInt64( numericStr );
        }
        catch( Exception ex )
        {
            defaultValue = GetExceptionType( ex );
        }

        // Convert numericStr to Int64 with a format provider.
        try
        {
            providerValue = Convert.ToInt64( numericStr, provider );
        }
        catch( Exception ex )
        {
            providerValue = GetExceptionType( ex );
        }

        Console.WriteLine( format, numericStr, 
            defaultValue, providerValue );
    }

    public static void Main( )
    {
        // Create a NumberFormatInfo object and set several of its
        // properties that apply to numbers.
        NumberFormatInfo provider = new NumberFormatInfo();

        // These properties affect the conversion.
        provider.NegativeSign = "neg ";
        provider.PositiveSign = "pos ";

        // These properties do not affect the conversion.
        // The input string cannot have decimal and group separators.
        provider.NumberDecimalSeparator = ".";
        provider.NumberGroupSeparator = ",";
        provider.NumberGroupSizes = new int[ ] { 3 };
        provider.NumberNegativePattern = 0;

        Console.WriteLine("This example of\n" +
            "  Convert.ToInt64( string ) and \n" +
            "  Convert.ToInt64( string, IFormatProvider ) " +
            "\ngenerates the following output. It converts " +
            "several strings to \nlong values, using " +
            "default formatting or a NumberFormatInfo object.\n" );
        Console.WriteLine( format, "String to convert", 
            "Default/exception", "Provider/exception" );
        Console.WriteLine( format, "-----------------", 
            "-----------------", "------------------" );

        // Convert strings, with and without an IFormatProvider.
        ConvertToInt64( "123456789", provider );
        ConvertToInt64( "+123456789", provider );
        ConvertToInt64( "pos 123456789", provider );
        ConvertToInt64( "-123456789", provider );
        ConvertToInt64( "neg 123456789", provider );
        ConvertToInt64( "123456789.", provider );
        ConvertToInt64( "123,456,789", provider );
        ConvertToInt64( "(123456789)", provider );
        ConvertToInt64( "9223372036854775808", provider );
        ConvertToInt64( "-9223372036854775809", provider );
    }
}

/*
This example of
  Convert.ToInt64( string ) and
  Convert.ToInt64( string, IFormatProvider )
generates the following output. It converts several strings to
long values, using default formatting or a NumberFormatInfo object.

String to convert     Default/exception   Provider/exception
-----------------     -----------------   ------------------
123456789             123456789           123456789
+123456789            123456789           FormatException
pos 123456789         FormatException     123456789
-123456789            -123456789          FormatException
neg 123456789         FormatException     -123456789
123456789.            FormatException     FormatException
123,456,789           FormatException     FormatException
(123456789)           FormatException     FormatException
9223372036854775808   OverflowException   OverflowException
-9223372036854775809  OverflowException   FormatException
*/ 

[C++] 
// Example of the Convert::ToInt64( String* ) and 
// Convert::ToInt64( String*, IFormatProvider* ) methods.
#using <mscorlib.dll>
using namespace System;
using namespace System::Globalization;

const __wchar_t* protoFmt = L"{0,-22}{1,-20}{2}" ;

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

void ConvertToInt64( String* numericStr, IFormatProvider* provider )
{
    Object* defaultValue;
    Object* providerValue;

    // Convert numericStr to Int64 without a format provider.
    try
    {
        defaultValue = __box( Convert::ToInt64( numericStr ) );
    }
    catch( Exception* ex )
    {
        defaultValue = GetExceptionType( ex );
    }

    // Convert numericStr to Int64 with a format provider.
    try
    {
        providerValue = __box( Convert::ToInt64( 
            numericStr, provider ) );
    }
    catch( Exception* ex )
    {
        providerValue = GetExceptionType( ex );
    }

    Console::WriteLine( new String( protoFmt ), numericStr, 
        defaultValue, providerValue );
}

void main( )
{
    // Create a NumberFormatInfo object and set several of its
    // properties that apply to numbers.
    NumberFormatInfo* provider = new NumberFormatInfo( );

    // These properties affect the conversion.
    provider->NegativeSign = S"neg ";
    provider->PositiveSign = S"pos ";

    // These properties do not affect the conversion.
    // The input string cannot have decimal and group separators.
    provider->NumberDecimalSeparator = S".";
    provider->NumberGroupSeparator = S",";
    Int32 sizes __gc [ ] = { 3 };
    provider->NumberGroupSizes = sizes;
    provider->NumberNegativePattern = 0;

    Console::WriteLine(S"This example of\n" 
        S"  Convert::ToInt64( String* ) and \n" 
        S"  Convert::ToInt64( String*, IFormatProvider* ) " 
        S"\ngenerates the following output. It converts " 
        S"several strings to \n__int64 values, using " 
        S"default formatting or a NumberFormatInfo object.\n" );
    Console::WriteLine( new String( protoFmt ), S"String to convert", 
        S"Default/exception", S"Provider/exception" );
    Console::WriteLine( new String( protoFmt ), S"-----------------", 
        S"-----------------", S"------------------" );

    // Convert strings, with and without an IFormatProvider.
    ConvertToInt64( S"123456789", provider );
    ConvertToInt64( S"+123456789", provider );
    ConvertToInt64( S"pos 123456789", provider );
    ConvertToInt64( S"-123456789", provider );
    ConvertToInt64( S"neg 123456789", provider );
    ConvertToInt64( S"123456789.", provider );
    ConvertToInt64( S"123,456,789", provider );
    ConvertToInt64( S"(123456789)", provider );
    ConvertToInt64( S"9223372036854775808", provider );
    ConvertToInt64( S"-9223372036854775809", provider );
}

/*
This example of
  Convert::ToInt64( String* ) and
  Convert::ToInt64( String*, IFormatProvider* )
generates the following output. It converts several strings to
__int64 values, using default formatting or a NumberFormatInfo object.

String to convert     Default/exception   Provider/exception
-----------------     -----------------   ------------------
123456789             123456789           123456789
+123456789            123456789           FormatException
pos 123456789         FormatException     123456789
-123456789            -123456789          FormatException
neg 123456789         FormatException     -123456789
123456789.            FormatException     FormatException
123,456,789           FormatException     FormatException
(123456789)           FormatException     FormatException
9223372036854775808   OverflowException   OverflowException
-9223372036854775809  OverflowException   FormatException
*/ 

[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.

See Also

Convert Class | Convert Members | System Namespace

Show:
© 2014 Microsoft