DynamicObject.TryBinaryOperation Metodo

Definizione

Spazio dei nomi:

System.Dynamic

Assembly:

System.Linq.Expressions.dll

Origine:

DynamicObject.cs

Fornisce l'implementazione per le operazioni binarie. Le classi derivate dalla classe DynamicObject possono eseguire l'override di questo metodo per specificare il comportamento dinamico per operazioni quali l'aggiunta e la moltiplicazione.

public:
 virtual bool TryBinaryOperation(System::Dynamic::BinaryOperationBinder ^ binder, System::Object ^ arg, [Runtime::InteropServices::Out] System::Object ^ % result);

public virtual bool TryBinaryOperation (System.Dynamic.BinaryOperationBinder binder, object arg, out object? result);

abstract member TryBinaryOperation : System.Dynamic.BinaryOperationBinder * obj * obj -> bool
override this.TryBinaryOperation : System.Dynamic.BinaryOperationBinder * obj * obj -> bool

Public Overridable Function TryBinaryOperation (binder As BinaryOperationBinder, arg As Object, ByRef result As Object) As Boolean

Parametri

binder

BinaryOperationBinder

Fornisce informazioni sull'operazione binaria. La binder.Operation proprietà restituisce un ExpressionType oggetto . Ad esempio, per l'istruzione sum = first + second , dove first e second sono derivati dalla DynamicObject classe , binder.Operation restituisce ExpressionType.Add.

arg

Object

Operando destro per l'operazione binaria. Ad esempio, per l'istruzione sum = first + second , dove first e second sono derivati dalla DynamicObject classe , arg è uguale a second.

result

Object

Risultato dell'operazione binaria.

Restituisce

Boolean

true se l'operazione riesce; in caso contrario, false. Se questo metodo restituisce false, il comportamento viene determinato dal gestore di associazione di runtime del linguaggio. Nella maggior parte dei casi viene generata un'eccezione di runtime specifica del linguaggio.

Esempio

Si supponga di avere bisogno di una struttura di dati per archiviare rappresentazioni testuali e numeriche di numeri e si desidera definire operazioni matematiche di base, ad esempio addizione e sottrazione per tali dati.

Nell'esempio di codice seguente viene illustrata la DynamicNumber classe derivata dalla DynamicObject classe . DynamicNumber esegue l'override del TryBinaryOperation metodo per abilitare le operazioni matematiche. Esegue anche l'override dei TrySetMember metodi e TryGetMember per abilitare l'accesso agli elementi.

In questo esempio sono supportate solo le operazioni di addizione e sottrazione. Se si tenta di scrivere un'istruzione come resultNumber = firstNumber*secondNumber, viene generata un'eccezione di runtime.

// Add using System.Linq.Expressions;
// to the beginning of the file.

// The class derived from DynamicObject.
public class DynamicNumber : DynamicObject
{
    // The inner dictionary to store field names and values.
    Dictionary<string, object> dictionary
        = new Dictionary<string, object>();

    // Get the property value.
    public override bool TryGetMember(
        GetMemberBinder binder, out object result)
    {
        return dictionary.TryGetValue(binder.Name, out result);
    }

    // Set the property value.
    public override bool TrySetMember(
        SetMemberBinder binder, object value)
    {
        dictionary[binder.Name] = value;
        return true;
    }

    // Perform the binary operation.
    public override bool TryBinaryOperation(
        BinaryOperationBinder binder, object arg, out object result)
    {
        // The Textual property contains the textual representaion
        // of two numbers, in addition to the name
        // of the binary operation.
        string resultTextual =
            dictionary["Textual"].ToString() + " "
            + binder.Operation + " " +
            ((DynamicNumber)arg).dictionary["Textual"].ToString();

        int resultNumeric;

        // Checking what type of operation is being performed.
        switch (binder.Operation)
        {
            // Proccessing mathematical addition (a + b).
            case ExpressionType.Add:
                resultNumeric =
                    (int)dictionary["Numeric"] +
                    (int)((DynamicNumber)arg).dictionary["Numeric"];
                break;

            // Processing mathematical substraction (a - b).
            case ExpressionType.Subtract:
                resultNumeric =
                    (int)dictionary["Numeric"] -
                    (int)((DynamicNumber)arg).dictionary["Numeric"];
                break;

            // In case of any other binary operation,
            // print out the type of operation and return false,
            // which means that the language should determine
            // what to do.
            // (Usually the language just throws an exception.)
            default:
                Console.WriteLine(
                    binder.Operation +
                    ": This binary operation is not implemented");
                result = null;
                return false;
        }

        dynamic finalResult = new DynamicNumber();
        finalResult.Textual = resultTextual;
        finalResult.Numeric = resultNumeric;
        result = finalResult;
        return true;
    }
}

class Program
{
    static void Test(string[] args)
    {
        // Creating the first dynamic number.
        dynamic firstNumber = new DynamicNumber();

        // Creating properties and setting their values
        // for the first dynamic number.
        // The TrySetMember method is called.
        firstNumber.Textual = "One";
        firstNumber.Numeric = 1;

        // Printing out properties. The TryGetMember method is called.
        Console.WriteLine(
            firstNumber.Textual + " " + firstNumber.Numeric);

        // Creating the second dynamic number.
        dynamic secondNumber = new DynamicNumber();
        secondNumber.Textual = "Two";
        secondNumber.Numeric = 2;
        Console.WriteLine(
            secondNumber.Textual + " " + secondNumber.Numeric);

        dynamic resultNumber = new DynamicNumber();

        // Adding two numbers. The TryBinaryOperation is called.
        resultNumber = firstNumber + secondNumber;

        Console.WriteLine(
            resultNumber.Textual + " " + resultNumber.Numeric);

        // Subtracting two numbers. TryBinaryOperation is called.
        resultNumber = firstNumber - secondNumber;

        Console.WriteLine(
            resultNumber.Textual + " " + resultNumber.Numeric);

        // The following statement produces a run-time exception
        // because the multiplication operation is not implemented.
        // resultNumber = firstNumber * secondNumber;
    }
}

// This code example produces the following output:

// One 1
// Two 2
// One Add Two 3
// One Subtract Two -1

' Add Imports System.Linq.Expressions
' to the beginning of the file.
' The class derived from DynamicObject.
Public Class DynamicNumber
    Inherits DynamicObject

    ' The inner dictionary to store field names and values.
    Dim dictionary As New Dictionary(Of String, Object)

    ' Get the property value.
    Public Overrides Function TryGetMember(
        ByVal binder As System.Dynamic.GetMemberBinder,
        ByRef result As Object) As Boolean

        Return dictionary.TryGetValue(binder.Name, result)

    End Function

    ' Set the property value.
    Public Overrides Function TrySetMember(
        ByVal binder As System.Dynamic.SetMemberBinder,
        ByVal value As Object) As Boolean

        dictionary(binder.Name) = value
        Return True

    End Function

    ' Perform the binary operation. 
    Public Overrides Function TryBinaryOperation(
        ByVal binder As System.Dynamic.BinaryOperationBinder,
        ByVal arg As Object, ByRef result As Object) As Boolean

        ' The Textual property contains the textual representaion 
        ' of two numbers, in addition to the name of the binary operation.
        Dim resultTextual As String =
            dictionary("Textual") & " " &
            binder.Operation.ToString() & " " &
        CType(arg, DynamicNumber).dictionary("Textual")

        Dim resultNumeric As Integer

        ' Checking what type of operation is being performed.
        Select Case binder.Operation
            ' Proccessing mathematical addition (a + b).
            Case ExpressionType.Add
                resultNumeric =
                CInt(dictionary("Numeric")) +
                CInt((CType(arg, DynamicNumber)).dictionary("Numeric"))

                ' Processing mathematical substraction (a - b).
            Case ExpressionType.Subtract
                resultNumeric =
                CInt(dictionary("Numeric")) -
                CInt((CType(arg, DynamicNumber)).dictionary("Numeric"))

            Case Else
                ' In case of any other binary operation,
                ' print out the type of operation and return false,
                ' which means that the language should determine 
                ' what to do.
                ' (Usually the language just throws an exception.)
                Console.WriteLine(
                    binder.Operation.ToString() &
                    ": This binary operation is not implemented")
                result = Nothing
                Return False
        End Select

        Dim finalResult As Object = New DynamicNumber()
        finalResult.Textual = resultTextual
        finalResult.Numeric = resultNumeric
        result = finalResult
        Return True
    End Function
End Class

Sub Test()
    ' Creating the first dynamic number.
    Dim firstNumber As Object = New DynamicNumber()

    ' Creating properties and setting their values
    ' for the first dynamic number. 
    ' The TrySetMember method is called.
    firstNumber.Textual = "One"
    firstNumber.Numeric = 1

    ' Printing out properties. The TryGetMember method is called.
    Console.WriteLine(
        firstNumber.Textual & " " & firstNumber.Numeric)

    ' Creating the second dynamic number.
    Dim secondNumber As Object = New DynamicNumber()
    secondNumber.Textual = "Two"
    secondNumber.Numeric = 2
    Console.WriteLine(
        secondNumber.Textual & " " & secondNumber.Numeric)

    Dim resultNumber As Object = New DynamicNumber()

    ' Adding two numbers. TryBinaryOperation is called.
    resultNumber = firstNumber + secondNumber
    Console.WriteLine(
        resultNumber.Textual & " " & resultNumber.Numeric)

    ' Subtracting two numbers. TryBinaryOperation is called.
    resultNumber = firstNumber - secondNumber
    Console.WriteLine(
        resultNumber.Textual & " " & resultNumber.Numeric)

    ' The following statement produces a run-time exception
    ' because the multiplication operation is not implemented.
    ' resultNumber = firstNumber * secondNumber
End Sub

' This code example produces the following output:

' One 1
' Two 2
' One Add Two 3
' One Subtract Two -1

Commenti

Le classi derivate dalla classe possono eseguire l'override DynamicObject di questo metodo per specificare la modalità di esecuzione delle operazioni binarie per un oggetto dinamico. Quando il metodo non viene sottoposto a override, il binder di runtime del linguaggio determina il comportamento. Nella maggior parte dei casi viene generata un'eccezione di runtime specifica del linguaggio.

Questo metodo viene chiamato quando si dispone di operazioni binarie, ad esempio l'aggiunta o la moltiplicazione. Ad esempio, se il TryBinaryOperation metodo viene sottoposto a override, viene richiamato automaticamente per le istruzioni come sum = first + second o multiply = first*second, dove first è derivato dalla DynamicObject classe .

È possibile ottenere informazioni sul tipo di operazione binaria usando la Operation proprietà del binder parametro .

Se l'oggetto dinamico viene usato solo in C# e Visual Basic, la binder.Operation proprietà può avere uno dei valori seguenti dell'enumerazione ExpressionType . Tuttavia, in altri linguaggi, ad esempio IronPython o IronRuby, è possibile avere altri valori.

Valore	Descrizione	C#	Visual Basic
Add	Operazione di addizione senza controllo dell'overflow per gli operandi numerici.	a + b	a + b
AddAssign	Operazione di assegnazione composta di addizione senza controllo dell'overflow per gli operandi numerici.	a += b	Non supportata.
And	Operazione bit per AND bit.	a & b	a And b
AndAssign	Operazione di assegnazione composta bit per AND bit.	a &= b	Non supportata.
Divide	Operazione di divisione aritmetica.	a / b	a / b
DivideAssign	Operazione di assegnazione composta di divisione aritmetica.	a /= b	Non supportata.
ExclusiveOr	Operazione bit per XOR bit.	a ^ b	a Xor b
ExclusiveOrAssign	Operazione di assegnazione composta bit per XOR bit.	a ^= b	Non supportata.
GreaterThan	Confronto "maggiore di".	a > b	a > b
GreaterThanOrEqual	Confronto "maggiore o uguale a".	a >= b	Non supportata.
LeftShift	Operazione di spostamento a sinistra bit per bit.	a << b	a << b
LeftShiftAssign	Operazione di assegnazione composta bit per bit a sinistra.	a <<= b	Non supportata.
LessThan	Confronto "minore di".	a < b	a < b
LessThanOrEqual	Confronto "minore o uguale a".	a <= b	Non supportata.
Modulo	Operazione di resto aritmetica.	a % b	a Mod b
ModuloAssign	Operazione di assegnazione composta di resto aritmetica.	a %= b	Non supportata.
Multiply	Operazione di moltiplicazione senza controllo dell'overflow per gli operandi numerici.	a * b	a * b
MultiplyAssign	Operazione di assegnazione composta di moltiplicazione senza controllo dell'overflow per gli operandi numerici.	a *= b	Non supportata.
NotEqual	Confronto tra disuguaglianze.	a != b	a <> b
Or	Operazione bit per bit o logica OR .	a &#124; b	a Or b
OrAssign	Assegnazione composta bit per bit o logica OR .	a &#124;= b	Non supportata.
Power	Un'operazione matematica di elevare un numero a una potenza.	Non supportata.	a ^ b
RightShift	Operazione di spostamento a destra bit per bit.	a >> b	a >> b
RightShiftAssign	Operazione di assegnazione composta bit per bit a destra.	a >>= b	Non supportata.
Subtract	Operazione di sottrazione senza controllo dell'overflow per gli operandi numerici.	a - b	a - b
SubtractAssign	Operazione di assegnazione composta di sottrazione senza controllo dell'overflow per gli operandi numerici.	a -= b	Non supportata.

Nota

Per implementare OrElse operazioni (a || b) e AndAlso (a && b) per gli oggetti dinamici in C#, è possibile implementare sia il TryUnaryOperation metodo che il TryBinaryOperation metodo .

L'operazione OrElse è costituita dall'operazione unaria IsTrue e dall'operazione binaria Or . L'operazione Or viene eseguita solo se il risultato dell'operazione IsTrue è false.

L'operazione AndAlso è costituita dall'operazione unaria IsFalse e dall'operazione binaria And . L'operazione And viene eseguita solo se il risultato dell'operazione IsFalse è false.