Decimal.Implicit Operador

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Define una conversión implícita del valor de un tipo a un valor Decimal.

Sobrecargas

Implicit(UInt16 to Decimal)	Define una conversión implícita de un entero sin signo de 16 bits en Decimal. Esta API no es conforme a CLS.
Implicit(UInt64 to Decimal)	Define una conversión implícita de un entero sin signo de 64 bits en un Decimal. Esta API no es conforme a CLS.
Implicit(UInt32 to Decimal)	Define una conversión implícita de un entero sin signo de 32 bits en un Decimal. Esta API no es conforme a CLS.
Implicit(SByte to Decimal)	Define una conversión implícita de un entero de 8 bits con signo en un valor Decimal. Esta API no es conforme a CLS.
Implicit(Int64 to Decimal)	Define una conversión implícita de un entero de 64 bits con signo en un Decimal.
Implicit(Int32 to Decimal)	Define una conversión implícita de un entero de 32 bits con signo en un Decimal.
Implicit(Int16 to Decimal)	Define una conversión implícita de un entero de 16 bits con signo en un Decimal.
Implicit(Char to Decimal)	Define una conversión implícita de un carácter Unicode en un Decimal.
Implicit(Byte to Decimal)	Define una conversión implícita de un entero de 8 bits sin signo en un valor Decimal.

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Implicit(UInt16 to Decimal)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

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

Esta API no es conforme a CLS.

C#

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

Parámetros

value

UInt16

Entero de 16 bits sin signo que se va a convertir.

Devoluciones

Decimal

Entero de 16 bits sin signo que se ha convertido.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierten valores UInt16 en Decimal números.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 16-bit unsigned integer values.
        ushort[] values = { ushort.MinValue, ushort.MaxValue,
                            0xFFF, 12345, 40000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (UInt16) --> 0 (Decimal)
//       65535 (UInt16) --> 65535 (Decimal)
//       4095 (UInt16) --> 4095 (Decimal)
//       12345 (UInt16) --> 12345 (Decimal)
//       40000 (UInt16) --> 40000 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• UInt16

Implicit(UInt64 to Decimal)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

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

Esta API no es conforme a CLS.

C#

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

Parámetros

value

UInt64

Entero de 64 bits sin signo que se va a convertir.

Devoluciones

Decimal

Entero de 64 bits sin signo que se ha convertido.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierten valores UInt64 en Decimal números mediante el operador de UInt64 conversión .Decimal

C#

using System;

public class Example
{
    public static void Main()
    {
        // Define an array of 64-bit unsigned integer values.
        ulong[] values = { ulong.MinValue, ulong.MaxValue,
                           0xFFFFFFFFFFFF, 123456789123456789,
                           1000000000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    0 (UInt64) --> 0 (Decimal)
//    18446744073709551615 (UInt64) --> 18446744073709551615 (Decimal)
//    281474976710655 (UInt64) --> 281474976710655 (Decimal)
//    123456789123456789 (UInt64) --> 123456789123456789 (Decimal)
//    1000000000000000 (UInt64) --> 1000000000000000 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• UInt64

Implicit(UInt32 to Decimal)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

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

Esta API no es conforme a CLS.

C#

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

Parámetros

value

UInt32

Entero de 32 bits sin signo que se va a convertir.

Devoluciones

Decimal

Entero de 32 bits sin signo que se ha convertido.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierten valores UInt32 en Decimal números.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 32-bit unsigned integer values.
        uint[] values = { uint.MinValue, uint.MaxValue, 0xFFFFFF,
                          123456789, 4000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (UInt32) --> 0 (Decimal)
//       4294967295 (UInt32) --> 4294967295 (Decimal)
//       16777215 (UInt32) --> 16777215 (Decimal)
//       123456789 (UInt32) --> 123456789 (Decimal)
//       4000000000 (UInt32) --> 4000000000 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• UInt32

Implicit(SByte to Decimal)

Source:

Decimal.cs

Importante

Esta API no es conforme a CLS.

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

Esta API no es conforme a CLS.

C#

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

Parámetros

value

SByte

Entero de 8 bits con signo que se va a convertir.

Devoluciones

Decimal

Entero de 8 bits con signo convertido.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierten valores SByte en Decimal números.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 8-bit signed integer values.
        sbyte[] values = { sbyte.MinValue, sbyte.MaxValue,
                           0x3F, 123, -100 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    -128 (SByte) --> -128 (Decimal)
//    127 (SByte) --> 127 (Decimal)
//    63 (SByte) --> 63 (Decimal)
//    123 (SByte) --> 123 (Decimal)
//    -100 (SByte) --> -100 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• SByte

Implicit(Int64 to Decimal)

Source:

Decimal.cs

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

C#

public static implicit operator decimal(long value);

Parámetros

value

Int64

Entero de 64 bits con signo que se va a convertir.

Devoluciones

Decimal

Entero de 64 bits con signo convertido.

Ejemplos

En el ejemplo siguiente se convierten valores Int64 en Decimal números.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 64-bit integer values.
        long[] values = { long.MinValue, long.MaxValue,
                          0xFFFFFFFFFFFF, 123456789123456789,
                          -1000000000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    -9223372036854775808 (Int64) --> -9223372036854775808 (Decimal)
//    9223372036854775807 (Int64) --> 9223372036854775807 (Decimal)
//    281474976710655 (Int64) --> 281474976710655 (Decimal)
//    123456789123456789 (Int64) --> 123456789123456789 (Decimal)
//    -1000000000000000 (Int64) --> -1000000000000000 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• Int64

Implicit(Int32 to Decimal)

Source:

Decimal.cs

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

C#

public static implicit operator decimal(int value);

Parámetros

value

Int32

Entero de 32 bits con signo que se va a convertir.

Devoluciones

Decimal

Entero de 32 bits con signo convertido.

Ejemplos

En el ejemplo siguiente se convierten valores Int32 en Decimal números.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 32-bit integer values.
        int[] values = { int.MinValue, int.MaxValue, 0xFFFFFF,
                         123456789, -1000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    -2147483648 (Int32) --> -2147483648 (Decimal)
//    2147483647 (Int32) --> 2147483647 (Decimal)
//    16777215 (Int32) --> 16777215 (Decimal)
//    123456789 (Int32) --> 123456789 (Decimal)
//    -1000000000 (Int32) --> -1000000000 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• Int32

Implicit(Int16 to Decimal)

Source:

Decimal.cs

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

C#

public static implicit operator decimal(short value);

Parámetros

value

Int16

Entero de 16 bits con signo que se va a convertir.

Devoluciones

Decimal

Entero de 16 bits con signo convertido.

Ejemplos

En el ejemplo siguiente se convierten valores Int16 en Decimal números. Esta conversión requiere el operador op_Implicit en Visual Basic, pero no en C# y C++.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 16-bit integer values.
        short[] values = { short.MinValue, short.MaxValue,
                           0xFFF, 12345, -10000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       -32768 (Int16) --> -32768 (Decimal)
//       32767 (Int16) --> 32767 (Decimal)
//       4095 (Int16) --> 4095 (Decimal)
//       12345 (Int16) --> 12345 (Decimal)
//       -10000 (Int16) --> -10000 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• Int16

Implicit(Char to Decimal)

Source:

Decimal.cs

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

C#

public static implicit operator decimal(char value);

Parámetros

value

Char

Carácter Unicode que se va a convertir.

Devoluciones

Decimal

Carácter Unicode convertido.

Ejemplos

En el ejemplo siguiente se convierten valores Char (caracteres Unicode) en Decimal números. Esta conversión requiere el operador op_Implicit en Visual Basic, pero no en C# y C++.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of Char values.
        Char[] values = { '\0', ' ', '*', 'A', 'a', '{', 'Æ' };

        // Convert each Char value to a Decimal.
        foreach (var value in values) {
           decimal decValue = value;
           Console.WriteLine("'{0}' ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       ' ' (Char) --> 0 (Decimal)
//       ' ' (Char) --> 32 (Decimal)
//       '*' (Char) --> 42 (Decimal)
//       'A' (Char) --> 65 (Decimal)
//       'a' (Char) --> 97 (Decimal)
//       '{' (Char) --> 123 (Decimal)
//       'Æ' (Char) --> 198 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• Char

Implicit(Byte to Decimal)

Source:

Decimal.cs

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

C#

public static implicit operator decimal(byte value);

Parámetros

value

Byte

Entero de 8 bits sin signo que se va a convertir.

Devoluciones

Decimal

Entero de 8 bits sin signo que se ha convertido.

Ejemplos

En el ejemplo siguiente se convierten valores Byte en Decimal números.

C#

using System;

class Example
{
    public static void Main()
    {
        // Define an array of byte values.
        byte[] values = { byte.MinValue, byte.MaxValue,
                          0x3F, 123, 200 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Decimal)
//       255 (Byte) --> 255 (Decimal)
//       63 (Byte) --> 63 (Decimal)
//       123 (Byte) --> 123 (Decimal)
//       200 (Byte) --> 200 (Decimal)

Comentarios

Las sobrecargas del Implicit método definen los tipos desde los que el compilador puede convertir automáticamente un Decimal valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowException excepción.

Consulte también

• Byte