Decimal.Explicit Operador

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Define una conversión explícita entre un objeto Decimal y otro tipo.

Sobrecargas

Explicit(Single to Decimal)	Define una conversión explícita de un número de punto flotante de precisión sencilla en un Decimal.
Explicit(Double to Decimal)	Define una conversión explícita de un número de punto flotante de precisión doble en un Decimal.
Explicit(Decimal to UInt64)	Define una conversión explícita de un Decimal en un entero de 64 bits sin signo. Esta API no es conforme a CLS.
Explicit(Decimal to UInt32)	Define una conversión explícita de un Decimal en un entero de 32 bits sin signo. Esta API no es conforme a CLS.
Explicit(Decimal to UInt16)	Define una conversión explícita de un Decimal en un entero de 16 bits sin signo. Esta API no es conforme a CLS.
Explicit(Decimal to SByte)	Define una conversión explícita de un objeto Decimal en un entero de 8 bits con signo. Esta API no es conforme a CLS.
Explicit(Decimal to Single)	Define una conversión explícita de un Decimal en un número de punto flotante de precisión sencillo.
Explicit(Decimal to Int32)	Define una conversión explícita de un Decimal en un entero de 32 bits con signo.
Explicit(Decimal to Int16)	Define una conversión explícita de un Decimal en un entero de 16 bits con signo.
Explicit(Decimal to Double)	Define una conversión explícita de un Decimal en un número de punto flotante de precisión doble.
Explicit(Decimal to Char)	Define una conversión explícita de un objeto Decimal en un carácter Unicode.
Explicit(Decimal to Byte)	Define una conversión explícita de un objeto Decimal en un entero de 8 bits sin signo.
Explicit(Decimal to Int64)	Define una conversión explícita de un Decimal en un entero de 64 bits con signo.

Explicit(Single to Decimal)

Source:

Decimal.cs

Define una conversión explícita de un número de punto flotante de precisión sencilla en un Decimal.

C#

public static explicit operator decimal (float value);

Parámetros

value

Single

Número de punto flotante de precisión sencilla que se va a convertir.

Devoluciones

Decimal

Número de punto flotante de precisión sencilla que se ha convertido.

Excepciones

OverflowException

value es mayor que Decimal.MaxValue o menor que Decimal.MinValue.

o bien

value es NaN, PositiveInfinity o NegativeInfinity.

Ejemplos

En el ejemplo siguiente se convierten Single los valores en Decimal números mediante el Single operador de conversión .Decimal Esta conversión requiere el operador op_Explicit en Visual Basic.

C#

// Example of the explicit conversion from float to decimal.
using System;

class DecimalFromSingleDemo
{
    const string formatter = "{0,16:E7}{1,33}";

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

    // Convert the float argument; catch exceptions that are thrown.
    public static void DecimalFromSingle( float argument )
    {
        object decValue;

        // Convert the float argument to a decimal value.
        try
        {
            decValue = (decimal)argument;
        }
        catch( Exception ex )
        {
            decValue = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument, decValue );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversion from float " +
            "to decimal \ngenerates the following output.\n" );
        Console.WriteLine( formatter, "float argument",
            "decimal value" );
        Console.WriteLine( formatter, "--------------",
            "-------------" );

        // Convert float values and display the results.
        DecimalFromSingle( 1.2345E-30F );
        DecimalFromSingle( 1.2345E-26F );
        DecimalFromSingle( 1.23456E-22F );
        DecimalFromSingle( 1.23456E-12F );
        DecimalFromSingle( 1.234567F );
        DecimalFromSingle( 1.234567E+12F );
        DecimalFromSingle( 1.2345678E+28F );
        DecimalFromSingle( 1.2345678E+30F );
    }
}

/*
This example of the explicit conversion from float to decimal
generates the following output.

  float argument                    decimal value
  --------------                    -------------
  1.2345000E-030                                0
  1.2345000E-026   0.0000000000000000000000000123
  1.2345600E-022    0.000000000000000000000123456
  1.2345600E-012              0.00000000000123456
  1.2345671E+000                         1.234567
  1.2345670E+012                    1234567000000
  1.2345678E+028    12345680000000000000000000000
  1.2345678E+030                OverflowException
*/

Consulte también

• Single

Explicit(Double to Decimal)

Source:

Decimal.cs

Define una conversión explícita de un número de punto flotante de precisión doble en un Decimal.

C#

public static explicit operator decimal (double value);

Parámetros

value

Double

Número de punto flotante de precisión doble que se va a convertir.

Devoluciones

Decimal

Número de punto flotante de precisión doble que se ha convertido.

Excepciones

OverflowException

value es mayor que Decimal.MaxValue o menor que Decimal.MinValue.

o bien

value es NaN, PositiveInfinity o NegativeInfinity.

Ejemplos

En el ejemplo siguiente se convierten Double los valores en Decimal números mediante el Double operador de conversión .Decimal Esta conversión requiere el operador op_Explicit en Visual Basic.

C#

// Example of the explicit conversion from double to decimal.
using System;

class DecimalFromDoubleDemo
{
    const string formatter = "{0,25:E16}{1,33}";

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

    // Convert the double argument; catch exceptions that are thrown.
    public static void DecimalFromDouble( double argument )
    {
        object decValue;

        // Convert the double argument to a decimal value.
        try
        {
            decValue = (decimal)argument;
        }
        catch( Exception ex )
        {
            decValue = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument, decValue );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversion from double " +
            "to decimal \ngenerates the following output.\n" );
        Console.WriteLine( formatter, "double argument",
            "decimal value" );
        Console.WriteLine( formatter, "---------------",
            "-------------" );

        // Convert double values and display the results.
        DecimalFromDouble( 1.234567890123E-30 );
        DecimalFromDouble( 1.2345678901234E-25 );
        DecimalFromDouble( 1.23456789012345E-20 );
        DecimalFromDouble( 1.234567890123456E-10 );
        DecimalFromDouble( 1.2345678901234567 );
        DecimalFromDouble( 1.23456789012345678E+12 );
        DecimalFromDouble( 1.234567890123456789E+28 );
        DecimalFromDouble( 1.234567890123456789E+30 );
    }
}

/*
This example of the explicit conversion from double to decimal
generates the following output.

          double argument                    decimal value
          ---------------                    -------------
  1.2345678901230000E-030                                0
  1.2345678901233999E-025   0.0000000000000000000000001235
  1.2345678901234499E-020   0.0000000000000000000123456789
  1.2345678901234560E-010       0.000000000123456789012346
  1.2345678901234567E+000                 1.23456789012346
  1.2345678901234568E+012                 1234567890123.46
  1.2345678901234568E+028    12345678901234600000000000000
  1.2345678901234569E+030                OverflowException
*/

Consulte también

• Double

Explicit(Decimal to UInt64)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

Define una conversión explícita de un Decimal en un entero de 64 bits sin signo.

Esta API no es conforme a CLS.

C#

[System.CLSCompliant(false)]
public static explicit operator ulong (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

UInt64

Entero de 64 bits sin signo que representa el Decimal convertido.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es negativo o mayor que UInt64.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en UInt64 valores mediante el operador explícito Decimal para la UInt64 conversión.

C#

// Example of the explicit conversions from decimal to long and
// decimal to ulong.
using System;

class DecimalToU_Int64Demo
{
    const string formatter = "{0,25}{1,22}{2,22}";

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

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToU_Int64( decimal argument )
    {
        object Int64Value;
        object UInt64Value;

        // Convert the argument to a long value.
        try
        {
            Int64Value = (long)argument;
        }
        catch( Exception ex )
        {
            Int64Value = GetExceptionType( ex );
        }

        // Convert the argument to a ulong value.
        try
        {
            UInt64Value = (ulong)argument;
        }
        catch( Exception ex )
        {
            UInt64Value = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument,
            Int64Value, UInt64Value );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversions from decimal " +
            "to long \nand decimal to ulong generates the following " +
            "output. It displays \nseveral converted decimal " +
            "values.\n" );
        Console.WriteLine( formatter, "decimal argument",
            "long/exception", "ulong/exception" );
        Console.WriteLine( formatter, "----------------",
            "--------------", "---------------" );

        // Convert decimal values and display the results.
        DecimalToU_Int64( 123M );
        DecimalToU_Int64( new decimal( 123000, 0, 0, false, 3 ) );
        DecimalToU_Int64( 123.999M );
        DecimalToU_Int64( 18446744073709551615.999M );
        DecimalToU_Int64( 18446744073709551616M );
        DecimalToU_Int64( 9223372036854775807.999M );
        DecimalToU_Int64( 9223372036854775808M );
        DecimalToU_Int64( - 0.999M );
        DecimalToU_Int64( - 1M );
        DecimalToU_Int64( - 9223372036854775808.999M );
        DecimalToU_Int64( - 9223372036854775809M );
    }
}

/*
This example of the explicit conversions from decimal to long
and decimal to ulong generates the following output. It displays
several converted decimal values.

         decimal argument        long/exception       ulong/exception
         ----------------        --------------       ---------------
                      123                   123                   123
                  123.000                   123                   123
                  123.999                   123                   123
 18446744073709551615.999     OverflowException  18446744073709551615
     18446744073709551616     OverflowException     OverflowException
  9223372036854775807.999   9223372036854775807   9223372036854775807
      9223372036854775808     OverflowException   9223372036854775808
                   -0.999                     0                     0
                       -1                    -1     OverflowException
 -9223372036854775808.999  -9223372036854775808     OverflowException
     -9223372036854775809     OverflowException     OverflowException
*/

Comentarios

Este operador admite la conversión explícita de a Decimal .UInt64 La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un UInt64 valor mediante C# y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToUInt64(Decimal) método o Convert.ToUInt64(Decimal) .

Consulte también

• UInt64

Explicit(Decimal to UInt32)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS

System.Decimal.ToInt64(Decimal)

Define una conversión explícita de un Decimal en un entero de 32 bits sin signo.

Esta API no es conforme a CLS.

C#

[System.CLSCompliant(false)]
public static explicit operator uint (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

UInt32

Entero de 32 bits sin signo que representa el Decimal convertido.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que UInt32.MinValue o mayor que UInt32.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en UInt32 valores mediante el operador explícito Decimal para la UInt32 conversión.

C#

// Example of the explicit conversions from decimal to int and
// decimal to uint.
using System;

class DecimalToU_Int32Demo
{
    const string formatter = "{0,17}{1,19}{2,19}";

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

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToU_Int32( decimal argument )
    {
        object Int32Value;
        object UInt32Value;

        // Convert the argument to an int value.
        try
        {
            Int32Value = (int)argument;
        }
        catch( Exception ex )
        {
            Int32Value = GetExceptionType( ex );
        }

        // Convert the argument to a uint value.
        try
        {
            UInt32Value = (uint)argument;
        }
        catch( Exception ex )
        {
            UInt32Value = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument,
            Int32Value, UInt32Value );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversions from decimal " +
            "to int \nand decimal to uint generates the following " +
            "output. It displays \nseveral converted decimal " +
            "values.\n" );
        Console.WriteLine( formatter, "decimal argument",
            "int/exception", "uint/exception" );
        Console.WriteLine( formatter, "----------------",
            "-------------", "--------------" );

        // Convert decimal values and display the results.
        DecimalToU_Int32( 123M );
        DecimalToU_Int32( new decimal( 123000, 0, 0, false, 3 ) );
        DecimalToU_Int32( 123.999M );
        DecimalToU_Int32( 4294967295.999M );
        DecimalToU_Int32( 4294967296M );
        DecimalToU_Int32( 2147483647.999M );
        DecimalToU_Int32( 2147483648M );
        DecimalToU_Int32( - 0.999M );
        DecimalToU_Int32( - 1M );
        DecimalToU_Int32( - 2147483648.999M );
        DecimalToU_Int32( - 2147483649M );
    }
}

/*
This example of the explicit conversions from decimal to int
and decimal to uint generates the following output. It displays
several converted decimal values.

 decimal argument      int/exception     uint/exception
 ----------------      -------------     --------------
              123                123                123
          123.000                123                123
          123.999                123                123
   4294967295.999  OverflowException         4294967295
       4294967296  OverflowException  OverflowException
   2147483647.999         2147483647         2147483647
       2147483648  OverflowException         2147483648
           -0.999                  0                  0
               -1                 -1  OverflowException
  -2147483648.999        -2147483648  OverflowException
      -2147483649  OverflowException  OverflowException
*/

Comentarios

Este operador admite la conversión explícita de a Decimal .UInt32 La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un UInt32 valor mediante C# y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToUInt32(Decimal) método o Convert.ToUInt32(Decimal) .

Consulte también

• UInt32

Explicit(Decimal to UInt16)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

Define una conversión explícita de un Decimal en un entero de 16 bits sin signo.

Esta API no es conforme a CLS.

C#

[System.CLSCompliant(false)]
public static explicit operator ushort (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

UInt16

Entero de 16 bits sin signo que representa el Decimal convertido.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que UInt16.MinValue o mayor que UInt16.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en UInt16 valores mediante el operador explícito Decimal para la UInt16 conversión.

C#

// Example of the explicit conversions from decimal to short and
// decimal to ushort.
using System;

class DecimalToU_Int16Demo
{
    const string formatter = "{0,16}{1,19}{2,19}";

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

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToU_Int16( decimal argument )
    {
        object Int16Value;
        object UInt16Value;

        // Convert the argument to a short value.
        try
        {
            Int16Value = (short)argument;
        }
        catch( Exception ex )
        {
            Int16Value = GetExceptionType( ex );
        }

        // Convert the argument to a ushort value.
        try
        {
            UInt16Value = (ushort)argument;
        }
        catch( Exception ex )
        {
            UInt16Value = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument,
            Int16Value, UInt16Value );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversions from decimal " +
            "to short \nand decimal to ushort generates the " +
            "following output. It displays \nseveral converted " +
            "decimal values.\n" );
        Console.WriteLine( formatter, "decimal argument",
            "short/exception", "ushort/exception" );
        Console.WriteLine( formatter, "----------------",
            "---------------", "----------------" );

        // Convert decimal values and display the results.
        DecimalToU_Int16( 123M );
        DecimalToU_Int16( new decimal( 123000, 0, 0, false, 3 ) );
        DecimalToU_Int16( 123.999M );
        DecimalToU_Int16( 65535.999M );
        DecimalToU_Int16( 65536M );
        DecimalToU_Int16( 32767.999M );
        DecimalToU_Int16( 32768M );
        DecimalToU_Int16( - 0.999M );
        DecimalToU_Int16( - 1M );
        DecimalToU_Int16( - 32768.999M );
        DecimalToU_Int16( - 32769M );
    }
}

/*
This example of the explicit conversions from decimal to short
and decimal to ushort generates the following output. It displays
several converted decimal values.

decimal argument    short/exception   ushort/exception
----------------    ---------------   ----------------
             123                123                123
         123.000                123                123
         123.999                123                123
       65535.999  OverflowException              65535
           65536  OverflowException  OverflowException
       32767.999              32767              32767
           32768  OverflowException              32768
          -0.999                  0                  0
              -1                 -1  OverflowException
      -32768.999             -32768  OverflowException
          -32769  OverflowException  OverflowException
*/

Comentarios

Este operador admite la conversión explícita de a Decimal .UInt16 La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un UInt16 valor mediante C# y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToUInt16(Decimal) método o Convert.ToUInt16(Decimal) .

Consulte también

• UInt16

Explicit(Decimal to SByte)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS

System.Decimal.ToInt16(Decimal)

Define una conversión explícita de un objeto Decimal en un entero de 8 bits con signo.

Esta API no es conforme a CLS.

C#

[System.CLSCompliant(false)]
public static explicit operator sbyte (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

SByte

Entero de 8 bits con signo que representa el Decimal convertido.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que SByte.MinValue o mayor que SByte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en SByte valores mediante el operador explícito Decimal para la SByte conversión.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of decimal values.
       decimal[] values = { 78m, new Decimal(78000, 0, 0, false, 3),
                            78.999m, 255.999m, 256m, 127.999m,
                            128m, -0.999m, -1m, -128.999m, -129m };
       foreach (var value in values) {
          try {
              SByte byteValue = (SByte) value;
              Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                                value.GetType().Name, byteValue,
                                byteValue.GetType().Name);
           }
           catch (OverflowException) {
              Console.WriteLine("OverflowException: Cannot convert {0}",
                                value);
           }
       }
    }
}
// The example displays the following output:
//       78 (Decimal) --> 78 (SByte)
//       78.000 (Decimal) --> 78 (SByte)
//       78.999 (Decimal) --> 78 (SByte)
//       OverflowException: Cannot convert 255.999
//       OverflowException: Cannot convert 256
//       127.999 (Decimal) --> 127 (SByte)
//       OverflowException: Cannot convert 128
//       -0.999 (Decimal) --> 0 (SByte)
//       -1 (Decimal) --> -1 (SByte)
//       -128.999 (Decimal) --> -128 (SByte)
//       OverflowException: Cannot convert -129

Comentarios

Este operador admite la conversión explícita de a Decimal .SByte La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en Byte y un SByte valor mediante C# y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToSByte(Decimal) método o al Convert.ToSByte(Decimal) método .

Consulte también

• SByte

Explicit(Decimal to Single)

Source:

Decimal.cs

Define una conversión explícita de un Decimal en un número de punto flotante de precisión sencillo.

C#

public static explicit operator float (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Single

Número de punto flotante de precisión sencilla que representa el Decimal convertido.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Single valores mediante el operador explícito Decimal para la Single conversión.

C#

using System;

class Example
{
    public static void Main( )
    {
        // Define an array of decimal values.
        decimal[] values = { 0.0000000000000000000000000001M,
                             0.0000000000123456789123456789M,
                             123M, new decimal(123000000, 0, 0, false, 6),
                             123456789.123456789M,
                             123456789123456789123456789M,
                             decimal.MinValue, decimal.MaxValue };
        // Convert each value to a double.
        foreach (var value in values) {
            float dblValue = (float) value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                              value.GetType().Name, dblValue,
                              dblValue.GetType().Name);
       }
    }
}
// The example displays the following output:
//    0.0000000000000000000000000001 (Decimal) --> 1E-28 (Single)
//    0.0000000000123456789123456789 (Decimal) --> 1.234568E-11 (Single)
//    123 (Decimal) --> 123 (Single)
//    123.000000 (Decimal) --> 123 (Single)
//    123456789.123456789 (Decimal) --> 1.234568E+08 (Single)
//    123456789123456789123456789 (Decimal) --> 1.234568E+26 (Single)
//    -79228162514264337593543950335 (Decimal) --> -7.922816E+28 (Single)
//    79228162514264337593543950335 (Decimal) --> 7.922816E+28 (Single)

Comentarios

Esta operación puede producir una pérdida de precisión, ya que un número de punto flotante de precisión única tiene menos dígitos significativos que .Decimal

Este operador admite la conversión explícita de a Decimal .Single La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un Single valor mediante C# y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToSingle(Decimal) método o Convert.ToSingle(Decimal) .

Consulte también

• Single

Explicit(Decimal to Int32)

Source:

Decimal.cs

Define una conversión explícita de un Decimal en un entero de 32 bits con signo.

C#

public static explicit operator int (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Int32

Entero de 32 bits con signo que representa el Decimal convertido.

Excepciones

OverflowException

value es menor que Int32.MinValue o mayor que Int32.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Int32 valores mediante el operador explícito Decimal para la Int32 conversión.

C#

// Example of the explicit conversions from decimal to int and
// decimal to uint.
using System;

class DecimalToU_Int32Demo
{
    const string formatter = "{0,17}{1,19}{2,19}";

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

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToU_Int32( decimal argument )
    {
        object Int32Value;
        object UInt32Value;

        // Convert the argument to an int value.
        try
        {
            Int32Value = (int)argument;
        }
        catch( Exception ex )
        {
            Int32Value = GetExceptionType( ex );
        }

        // Convert the argument to a uint value.
        try
        {
            UInt32Value = (uint)argument;
        }
        catch( Exception ex )
        {
            UInt32Value = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument,
            Int32Value, UInt32Value );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversions from decimal " +
            "to int \nand decimal to uint generates the following " +
            "output. It displays \nseveral converted decimal " +
            "values.\n" );
        Console.WriteLine( formatter, "decimal argument",
            "int/exception", "uint/exception" );
        Console.WriteLine( formatter, "----------------",
            "-------------", "--------------" );

        // Convert decimal values and display the results.
        DecimalToU_Int32( 123M );
        DecimalToU_Int32( new decimal( 123000, 0, 0, false, 3 ) );
        DecimalToU_Int32( 123.999M );
        DecimalToU_Int32( 4294967295.999M );
        DecimalToU_Int32( 4294967296M );
        DecimalToU_Int32( 2147483647.999M );
        DecimalToU_Int32( 2147483648M );
        DecimalToU_Int32( - 0.999M );
        DecimalToU_Int32( - 1M );
        DecimalToU_Int32( - 2147483648.999M );
        DecimalToU_Int32( - 2147483649M );
    }
}

/*
This example of the explicit conversions from decimal to int
and decimal to uint generates the following output. It displays
several converted decimal values.

 decimal argument      int/exception     uint/exception
 ----------------      -------------     --------------
              123                123                123
          123.000                123                123
          123.999                123                123
   4294967295.999  OverflowException         4294967295
       4294967296  OverflowException  OverflowException
   2147483647.999         2147483647         2147483647
       2147483648  OverflowException         2147483648
           -0.999                  0                  0
               -1                 -1  OverflowException
  -2147483648.999        -2147483648  OverflowException
      -2147483649  OverflowException  OverflowException
*/

Comentarios

Este operador admite la conversión explícita de a Decimal a .Int32 La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un Int32 valor mediante C#, C++y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToInt32(Decimal) método o Convert.ToInt32(Decimal) .

Consulte también

• Int32

Explicit(Decimal to Int16)

Source:

Decimal.cs

Define una conversión explícita de un Decimal en un entero de 16 bits con signo.

C#

public static explicit operator short (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Int16

Entero de 16 bits con signo que representa el Decimal convertido.

Excepciones

OverflowException

value es menor que Int16.MinValue o mayor que Int16.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Int16 valores mediante el operador explícito Decimal para la Int16 conversión.

C#

// Example of the explicit conversions from decimal to short and
// decimal to ushort.
using System;

class DecimalToU_Int16Demo
{
    const string formatter = "{0,16}{1,19}{2,19}";

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

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToU_Int16( decimal argument )
    {
        object Int16Value;
        object UInt16Value;

        // Convert the argument to a short value.
        try
        {
            Int16Value = (short)argument;
        }
        catch( Exception ex )
        {
            Int16Value = GetExceptionType( ex );
        }

        // Convert the argument to a ushort value.
        try
        {
            UInt16Value = (ushort)argument;
        }
        catch( Exception ex )
        {
            UInt16Value = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument,
            Int16Value, UInt16Value );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversions from decimal " +
            "to short \nand decimal to ushort generates the " +
            "following output. It displays \nseveral converted " +
            "decimal values.\n" );
        Console.WriteLine( formatter, "decimal argument",
            "short/exception", "ushort/exception" );
        Console.WriteLine( formatter, "----------------",
            "---------------", "----------------" );

        // Convert decimal values and display the results.
        DecimalToU_Int16( 123M );
        DecimalToU_Int16( new decimal( 123000, 0, 0, false, 3 ) );
        DecimalToU_Int16( 123.999M );
        DecimalToU_Int16( 65535.999M );
        DecimalToU_Int16( 65536M );
        DecimalToU_Int16( 32767.999M );
        DecimalToU_Int16( 32768M );
        DecimalToU_Int16( - 0.999M );
        DecimalToU_Int16( - 1M );
        DecimalToU_Int16( - 32768.999M );
        DecimalToU_Int16( - 32769M );
    }
}

/*
This example of the explicit conversions from decimal to short
and decimal to ushort generates the following output. It displays
several converted decimal values.

decimal argument    short/exception   ushort/exception
----------------    ---------------   ----------------
             123                123                123
         123.000                123                123
         123.999                123                123
       65535.999  OverflowException              65535
           65536  OverflowException  OverflowException
       32767.999              32767              32767
           32768  OverflowException              32768
          -0.999                  0                  0
              -1                 -1  OverflowException
      -32768.999             -32768  OverflowException
          -32769  OverflowException  OverflowException
*/

Comentarios

Este operador admite la conversión explícita de a Decimal a .Int16 La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un Int16 valor mediante C#, Visual Basic y C++. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToInt16(Decimal) método o Convert.ToInt16(Decimal) .

Consulte también

• Int16

Explicit(Decimal to Double)

Source:

Decimal.cs

Define una conversión explícita de un Decimal en un número de punto flotante de precisión doble.

C#

public static explicit operator double (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Double

Número de punto flotante de precisión doble que representa el Decimal convertido.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Double valores mediante el operador explícito Decimal para la Double conversión.

C#

using System;

class Example
{
    public static void Main( )
    {
        // Define an array of decimal values.
        decimal[] values = { 0.0000000000000000000000000001M,
                             0.0000000000123456789123456789M,
                             123M, new decimal(123000000, 0, 0, false, 6),
                             123456789.123456789M,
                             123456789123456789123456789M,
                             decimal.MinValue, decimal.MaxValue };
        // Convert each value to a double.
        foreach (var value in values) {
            double dblValue = (double) value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                              value.GetType().Name, dblValue,
                              dblValue.GetType().Name);
       }
    }
}
// The example displays the following output:
//    0.0000000000000000000000000001 (Decimal) --> 1E-28 (Double)
//    0.0000000000123456789123456789 (Decimal) --> 1.23456789123457E-11 (Double)
//    123 (Decimal) --> 123 (Double)
//    123.000000 (Decimal) --> 123 (Double)
//    123456789.123456789 (Decimal) --> 123456789.123457 (Double)
//    123456789123456789123456789 (Decimal) --> 1.23456789123457E+26 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.92281625142643E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.92281625142643E+28 (Double)

Comentarios

Esta operación puede producir una pérdida de precisión, ya que un número de punto flotante de doble precisión tiene menos dígitos significativos que un Decimal.

Este operador admite la conversión explícita de a Decimal .Double La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un Double valor mediante C#, C++y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToDouble(Decimal) método o Convert.ToDouble(Decimal) .

Consulte también

• Double

Explicit(Decimal to Char)

Source:

Decimal.cs

Define una conversión explícita de un objeto Decimal en un carácter Unicode.

C#

public static explicit operator char (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Char

Carácter Unicode que representa el Decimal convertido.

Excepciones

OverflowException

value es menor que Char.MinValue o mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Char valores (caracteres Unicode) mediante el operador explícito Decimal para la Char conversión.

C#

using System;

class Example
{
   public static void Main( )
   {
      // Define an array of decimal values.
      decimal[] values = { 3.33m, 55.5m, 77.7m, 123m, 123.999m, 170m,
                           188.88m, 222m, 244m, 8217m, 8250m, 65536m,
                           -1m };
      // Convert each value to a Char.
      foreach (decimal value in values) {
         try {
            char charValue = (char) value;
            Console.WriteLine("{0} --> {1} ({2:X4})", value,
                              charValue, (ushort) charValue);
         }
         catch (OverflowException) {
            Console.WriteLine("OverflowException: Cannot convert {0}",
                              value);
         }
      }
   }
}
// The example displays the following output:
//       3.33 --> ? (0003)
//       55.5 --> 7 (0037)
//       77.7 --> M (004D)
//       123 --> { (007B)
//       123.999 --> { (007B)
//       170 --> ª (00AA)
//       188.88 --> ¼ (00BC)
//       222 --> _ (00DE)
//       244 --> ô (00F4)
//       8217 --> ' (2019)
//       8250 --> > (203A)
//       OverflowException: Cannot convert 65536
//       OverflowException: Cannot convert -1

Comentarios

Este operador admite la conversión explícita de a Decimal .Char La sintaxis de estas conversiones explícitas depende del lenguaje, y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes, o es posible que no admitan la conversión en absoluto. Por ejemplo, los compiladores de Visual Basic y C++ no admiten una conversión explícitaDecimal.Char

Consulte también

• Char

Explicit(Decimal to Byte)

Source:

Decimal.cs

Define una conversión explícita de un objeto Decimal en un entero de 8 bits sin signo.

C#

public static explicit operator byte (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Byte

Entero de 8 bits sin signo que representa el Decimal convertido.

Excepciones

OverflowException

value es menor que Byte.MinValue o mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Byte valores mediante el operador explícito Decimal para la Byte conversión.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of decimal values.
       decimal[] values = { 78m, new Decimal(78000, 0, 0, false, 3),
                            78.999m, 255.999m, 256m, 127.999m,
                            128m, -0.999m, -1m, -128.999m, -129m };
       foreach (var value in values) {
          try {
              Byte byteValue = (Byte) value;
              Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                                value.GetType().Name, byteValue,
                                byteValue.GetType().Name);
           }
           catch (OverflowException) {
              Console.WriteLine("OverflowException: Cannot convert {0}",
                                value);
           }
       }
    }
}
// The example displays the following output:
//       78 (Decimal) --> 78 (Byte)
//       78.000 (Decimal) --> 78 (Byte)
//       78.999 (Decimal) --> 78 (Byte)
//       255.999 (Decimal) --> 255 (Byte)
//       OverflowException: Cannot convert 256
//       127.999 (Decimal) --> 127 (Byte)
//       128 (Decimal) --> 128 (Byte)
//       -0.999 (Decimal) --> 0 (Byte)
//       OverflowException: Cannot convert -1
//       OverflowException: Cannot convert -128.999
//       OverflowException: Cannot convert -129

Comentarios

Este operador admite la conversión explícita de a Decimal .Byte La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un Byte valor mediante C#, C++y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToByte(Decimal) método o Convert.ToByte(Decimal) .

Consulte también

• Byte

Explicit(Decimal to Int64)

Source:

Decimal.cs

Define una conversión explícita de un Decimal en un entero de 64 bits con signo.

C#

public static explicit operator long (decimal value);

Parámetros

value

Decimal

Valor que se va a convertir.

Devoluciones

Int64

Entero de 64 bits con signo que representa el Decimal convertido.

Excepciones

OverflowException

value es menor que Int64.MinValue o mayor que Int64.MaxValue.

Ejemplos

En el ejemplo siguiente se convierten Decimal números en Int64 valores mediante el operador explícito Decimal para la Int64 conversión.

C#

// Example of the explicit conversions from decimal to long and
// decimal to ulong.
using System;

class DecimalToU_Int64Demo
{
    const string formatter = "{0,25}{1,22}{2,22}";

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

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToU_Int64( decimal argument )
    {
        object Int64Value;
        object UInt64Value;

        // Convert the argument to a long value.
        try
        {
            Int64Value = (long)argument;
        }
        catch( Exception ex )
        {
            Int64Value = GetExceptionType( ex );
        }

        // Convert the argument to a ulong value.
        try
        {
            UInt64Value = (ulong)argument;
        }
        catch( Exception ex )
        {
            UInt64Value = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument,
            Int64Value, UInt64Value );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the explicit conversions from decimal " +
            "to long \nand decimal to ulong generates the following " +
            "output. It displays \nseveral converted decimal " +
            "values.\n" );
        Console.WriteLine( formatter, "decimal argument",
            "long/exception", "ulong/exception" );
        Console.WriteLine( formatter, "----------------",
            "--------------", "---------------" );

        // Convert decimal values and display the results.
        DecimalToU_Int64( 123M );
        DecimalToU_Int64( new decimal( 123000, 0, 0, false, 3 ) );
        DecimalToU_Int64( 123.999M );
        DecimalToU_Int64( 18446744073709551615.999M );
        DecimalToU_Int64( 18446744073709551616M );
        DecimalToU_Int64( 9223372036854775807.999M );
        DecimalToU_Int64( 9223372036854775808M );
        DecimalToU_Int64( - 0.999M );
        DecimalToU_Int64( - 1M );
        DecimalToU_Int64( - 9223372036854775808.999M );
        DecimalToU_Int64( - 9223372036854775809M );
    }
}

/*
This example of the explicit conversions from decimal to long
and decimal to ulong generates the following output. It displays
several converted decimal values.

         decimal argument        long/exception       ulong/exception
         ----------------        --------------       ---------------
                      123                   123                   123
                  123.000                   123                   123
                  123.999                   123                   123
 18446744073709551615.999     OverflowException  18446744073709551615
     18446744073709551616     OverflowException     OverflowException
  9223372036854775807.999   9223372036854775807   9223372036854775807
      9223372036854775808     OverflowException   9223372036854775808
                   -0.999                     0                     0
                       -1                    -1     OverflowException
 -9223372036854775808.999  -9223372036854775808     OverflowException
     -9223372036854775809     OverflowException     OverflowException
*/

Comentarios

Este operador admite la conversión explícita de a Decimal a .Int64 La sintaxis de estas conversiones explícitas depende del lenguaje y los compiladores de lenguaje individuales pueden proporcionar diferentes implementaciones y devolver resultados diferentes. En el ejemplo se muestran los distintos valores devueltos cuando se convierte explícitamente un Decimal valor en un Int64 valor mediante C# y Visual Basic. Para realizar una conversión independiente del lenguaje, puede llamar al Decimal.ToInt64(Decimal) método o Convert.ToInt64(Decimal) .

Consulte también

• Int64