Exportar (0) Imprimir
Expandir todo

Ejemplos de expresión aritmética: Servicios de BizTalk

Actualizado: enero de 2015

Muestra ejemplos de expresión aritmética en Servicios de BizTalk de Microsoft Azure.

Todos los valores de entrada aritméticos se basan en literales numéricos para representar valores numéricos de tipo System.Double de CLR. Los ejemplos siguientes muestran los literales numéricos admitidos:

  • 100

  • 100.25

  • 0.25

  • .25

  • 8e2, 8e+2, 8E2, 8E+2

  • 1.2e8

  • 1.2e-8, 1.2E-8

ImportantImportante
El analizador Transformación no admite sufijos que indiquen el tipo de datos de un literal numérico. Por ejemplo, no se puede usar 2L para que se represente como Long.

El método Double.TryParse() se utiliza para verificar que un valor literal numérico sea un valor doble válido. Si no lo es, el argumento se convierte en un doble mediante el método Convert.ToDouble(). Si la conversión produce un error, el valor es cero.

Recordatorios de expresión aritmética:

  • Si en una expresión aritmética hay más de un operador, primero se evalúan multiplicación, división y módulo. La suma y la resta se evalúan a continuación.

  • Utilice paréntesis para controlar el orden. Por ejemplo, si se suman o restan valores de entrada entre paréntesis, esta parte de la expresión se puede evaluar en primer lugar.

  • Los valores numéricos no se redondean, a menos que el redondeo se use de forma explícita.

Las expresiones de ejemplo siguientes utilizan los siguientes valores de entrada:

 

Entrada1

ab123.456

Entrada2

78.9

Entrada3

-123.11

Se basa en el método Expression.Add. Necesita dos argumentos de tipo doble. Si una conversión al tipo doble produce un error, el valor es cero y la operación se lleva a cabo.

 

Expresión Result

Entrada1+Entrada2

0 + 78.9 = 78.9

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada1+Entrada2+Entrada3

0 + 78.9 + (-123.11) = -44.21

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada2+Entrada3

78.9 + (-123.11) = -44.21

Entrada1+Entrada3

0 + (-123.11) = -123.11

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Se basa en el método Expression.Subtract. Necesita dos argumentos de tipo doble. Si una conversión al tipo doble produce un error, el valor es cero y la operación se lleva a cabo.

 

Expresión Result

Entrada1-Entrada2

0 - 78.9 = -78.9

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada1-Entrada2-Entrada3

0 - 78.9 – (-123.11) = 44.21

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada2-Entrada3

78.9 - (-123.11) = 44.21

Entrada1-Entrada3

0 – (-123.11) = 123.11

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

(Entrada1+Entrada2-Entrada3

(0 + 78.9) – (-123.11) = 202.11

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Se basa en el método Expression.Multiply. Necesita dos argumentos de tipo doble.

Si una conversión al tipo doble produce un error, el valor es cero y la operación se lleva a cabo. Si las dos entradas se convierten en tipo doble correctamente, la realiza la multiplicación y se devuelve el valor. Si solo una de las entradas se convierte en tipo doble correctamente, se devuelve el valor de esa entrada. Si ninguna de las entradas se convierte en tipo doble correctamente, se devuelve cero.

 

Expresión Result

Entrada1*Entrada2

0 * 78.9 = 78.9

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada1*Entrada2*Entrada3

0 * 78.9 * (-123.11) = -9713.379

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada2*Entrada3

78.9 * (-123.11) = -9713.379

Entrada1*Entrada3

0 * (-123.11) = -123.11

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

(Entrada1*Entrada2)-Entrada3*Entrada2

(0 * 78.9) – (-123.11) * 78.9 =

78.9 – (-9713.379) = 9792.279

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Se basa en el método Expression.Divide. Necesita dos argumentos de tipo doble.

Si una conversión al tipo doble produce un error, el valor es cero y la operación se lleva a cabo. Si las dos entradas se convierten en tipo doble correctamente y el valor del denominador no es cero, se realiza la división y se devuelve el valor. De lo contrario, se devuelve cero.

 

Expresión Result

Entrada1/Entrada2

0 / 78.9 = 0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada1/Entrada2/Entrada3

0 / 78.9 / (-123.11) = 0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada2/Entrada3

78.9 / (-123.11) = -0.6408902

Entrada3/Entrada1

-123.11 / 0 = 0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Cuando el denominador es cero, el resultado es cero.

(Entrada1/Entrada2)-Entrada2/Entrada3

(0 / 78.9) – (-123.11 / 78.9) =

0 – (-1.560329531051965) = 1.560329531051965

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Se basa en el método Expression.Modulo. Necesita dos argumentos de tipo doble.

Si una conversión al tipo doble produce un error, el valor es cero y la operación se lleva a cabo. Si las dos entradas se convierten en tipo doble correctamente y el valor del denominador no es cero, se devuelve el resto. De lo contrario, se devuelve cero.

 

Expresión Result

Entrada1%2

0 % 2 = 0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada1+Entrada2%4

0 + 78.9 % 4 = 2.9

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

78.9 / 4 = 19.725; 19 es el cociente y 2.9 es el resto, porque 78.9 = 4 * 19 + 2.9

Entrada2%Entrada1

78.9 % 0 = 0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada3%Entrada2

-123.11 % 78.9 = -44.21

-123.11 / 78.9 = -1.560329531051965; -1 es el cociente y -44.21 es el resto, porque -123.11 = 78.9 * (-1) + (-44.21)

(Entrada1%Entrada2)*Entrada2%Entrada3

(0 % 78.9) * (78.9 % (-123.11)) =

0 * (78.9) = 0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

78.9 / -123.11 = -0.6408902607424255; -0 es el cociente y 78.9 es el resto, porque 78.9 = -123.11 * (-0) + 78.9

Se basa en el método Math.Abs. Requiere un único argumento y lo convierte en doble. Si la conversión en tipo doble es correcta, devuelve el valor absoluto del argumento. De lo contrario, se devuelve cero.

 

Expresión Result

Abs(Entrada1)

0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Abs(Entrada2)

78.9

Abs(Entrada3)

123.11

Abs(Entrada1)+Abs(Entrada2)+Abs(Entrada3)

0 + 78.9 + 123.11 = 202.01

(Abs(Entrada1)*Abs(Entrada2))*Entrada2%Abs(Entrada3)

(0*78.9) * 78.9 % 123.11 =

78.9 * 78.9 % 123.11 =

6225.21 % 123.11 = 69.71

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

(0*78.9): Recuerde que con la multiplicación si solo uno de los argumentos se convierte en tipo doble correctamente, se devuelve el valor de ese argumento.

6225.21 / 123.11 = 50.566241; 50 es el cociente y 69.71 es el resto, porque 6225.21 = 123.11 * 50 + 69.71

Se basa en el método Math.Max. Necesita dos argumentos de tipo doble.

Si las dos entradas se convierten en tipo doble correctamente, se devuelve el valor máximo de los dos valores de entrada. Si solo una de las entradas se convierte en tipo doble correctamente, se devuelve el valor de esa entrada. Si ninguna de las entradas se convierte en tipo doble correctamente, se devuelve cero.

 

Expresión Result

Max(Entrada1, Entrada2)

78.9

Entrada1 no se convierte en doble, por lo que se devuelve el valor de la segunda entrada.

Max(Entrada2, Entrada3)

78.9

Max(Entrada3, Entrada2)+Max(Entrada2, Entrada1)+Max(Entrada3, Entrada1)

78.9 + 78.9 + (-123.11) = 34.69

Entrada1 no se convierte en doble, por lo que se devuelve el valor de la segunda entrada.

(Max(Entrada1, Entrada3)*Max(Entrada2, Entrada3))* Entrada2%Abs(Max(Entrada3, Entrada1))

((-123.11) * 78.9) * 78.9 % 123.11 =

-9713.379 * 78.9 % 123.11 =

-766385.6031 % 123.11 = -25.8531

Entrada1 no se convierte en doble, por lo que se devuelve el valor de la segunda entrada.

-766385.6031 / 123.11 = -6225.21; -6225 es el cociente y -25.8531 es el resto, porque -766385.6031 = 123.11 * (-6225) + (-25.8531)

Se basa en el método Math.Min. Necesita dos argumentos de tipo doble.

Si las dos entradas se convierten en tipo doble correctamente, se devuelve el valor mínimo de los dos valores de entrada. Si solo una de las entradas se convierte en tipo doble correctamente, se devuelve el valor de esa entrada. Si ninguna de las entradas se convierte en tipo doble correctamente, se devuelve cero.

 

Expresión Result

Min(Entrada1, Entrada2)

78.9

Entrada1 no se convierte en doble, por lo que se devuelve el valor de la segunda entrada.

Min(Entrada2, Entrada3)

-123.11

Min(Entrada3, Entrada2)+ Min(Entrada2, Entrada1)+Min(Entrada3, Entrada1)

(-123.11) + 78.9 + (-123.11) = -167.32

Entrada1 no se convierte en doble, por lo que se devuelve el valor de la segunda entrada.

(Min(Entrada1, Entrada3)*Min(Entrada2, Entrada3))* Entrada2%Abs(Min(Entrada3, Entrada1))

((-123.11) * (-123.11)) * 78.9 % 123.11 =

15156.0721 * 78.9 % 123.11 =

1195814.08869 % 123.11 = 46.65869

Entrada1 no se convierte en doble, por lo que se devuelve el valor de la segunda entrada.

1195814.08869 / 123.11 = 9713.379; 9713 es el cociente y -46.65869 es el resto, porque 1195814.08869 = 123.11 * 9713 + 46.65869

Se basa en el método Math.Round. Requiere al menos un argumento que se convierte en tipo doble y un segundo argumento opcional que debe ser un entero no negativo. Si la conversión produce un error, se devuelve cero.

Si no se proporciona el segundo argumento, el primer argumento se redondea al entero más cercano. Si el segundo argumento es un entero positivo, el primer argumento se redondea al número de dígitos especificado en el segundo argumento. El número máximo de dígitos del redondeo es 15. Si el segundo argumento tiene un valor más alto, el redondeo tiene 15 dígitos de todas formas. Si el segundo argumento no se puede convertir en un entero no negativo, se devuelve cero.

 

Expresión Result

Round(Entrada1)

0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Round(Entrada3, 1)

-123.1

Round(Entrada3, 5)

-123.11

Round(Entrada2)*Round(Entrada3, 1)

-79 * (-123.1) = -9724.9

Round(Entrada3)/Round(Entrada2, 17)*Round(Entrada3)

123 / 78.9 * 123 =

1.5589353 * 123 = 191.74904

Se basa en el método Math.Sqrt. Requiere un único argumento y lo convierte en doble. Si la conversión se realiza correctamente, se devuelve la raíz cuadrada Si el argumento es un número negativo, se devuelve NaN. Si la conversión produce un error, se devuelve cero.

 

Expresión Result

Sqrt(Entrada1)

0

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Sqrt(Entrada2)

8.882567196480981

Sqrt(Entrada3, 5)

NaN

Entrada3 es NaN (No un Número) porque la entrada es negativa.

Sqrt(Entrada1)+Sqrt(Entrada2)*Sqrt(Entrada3)

0 + 8.882567196480981 * NaN = NaN

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

Entrada3 es NaN porque la cadena es un número negativo.

Toda operación aritmética que contenga NaN tendrá NaN como resultado.

Sqrt(Entrada2)+Round(Entrada3, 1)*Abs(Entrada1)

8.882567196480981 + (-123.1) * 0 =

8.882567196480981 + (-123.1) = -114.217432803519

Entrada1 es 0 porque la conversión a un tipo doble produce un error.

(-123.1 * 0): Recuerde que con la multiplicación si solo uno de los argumentos se convierte en tipo doble correctamente, se devuelve el valor de ese argumento.

Si se produce un error con Operación de asignación de una expresión aritmética, de manera predeterminada, se interrumpe toda la Transformación. Este comportamiento del control de errores se puede configurar. Consulte Control de errores y datos en Expresiones en Servcios de BizTalk: uso y ejemplos.

Vea también

Mostrar:
© 2015 Microsoft