DynamicObject.TryBinaryOperation Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Dynamic

Zestaw:: System.Dynamic.Runtime.dll

Zestaw:: System.Linq.Expressions.dll

Zestaw:: System.Core.dll

Zestaw:: netstandard.dll

Źródło:: DynamicObject.cs

Źródło:: DynamicObject.cs

Źródło:: DynamicObject.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Zapewnia implementację operacji binarnych. Klasy pochodzące z DynamicObject klasy mogą zastąpić tę metodę w celu określenia dynamicznego zachowania operacji, takich jak dodawanie i mnożenie.

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

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

Parametry

binder: BinaryOperationBinder

Zawiera informacje o operacji binarnej. Właściwość binder.Operation zwraca ExpressionType obiekt. Na przykład w przypadku instrukcji sum = first + second , gdzie first i second pochodzą z DynamicObject klasy, binder.Operation zwraca wartość ExpressionType.Add.

arg: Object

Prawy operand operacji binarnej. Na przykład dla instrukcji sum = first + second , gdzie first i second są pochodzące z DynamicObject klasy, arg jest równe second.

result: Object

Wynik operacji binarnej.

Zwraca

Boolean

true jeśli operacja zakończy się pomyślnie; w przeciwnym razie , false. Jeśli ta metoda zwróci falsewartość , powiązanie czasu wykonywania języka określa zachowanie. (W większości przypadków zgłaszany jest wyjątek czasu wykonywania specyficzny dla języka).

Przykłady

Załóżmy, że potrzebujesz struktury danych do przechowywania tekstowych i liczbowych reprezentacji liczb i chcesz zdefiniować podstawowe operacje matematyczne, takie jak dodawanie i odejmowanie takich danych.

Poniższy przykład kodu przedstawia klasę DynamicNumber , która pochodzi z DynamicObject klasy. DynamicNumber zastępuje metodę w celu włączenia TryBinaryOperation operacji matematycznych. Zastępuje również TrySetMember metody i TryGetMember , aby umożliwić dostęp do elementów.

W tym przykładzie obsługiwane są tylko operacje dodawania i odejmowania. Jeśli spróbujesz napisać instrukcję podobną resultNumber = firstNumber*secondNumberdo , zostanie zgłoszony wyjątek czasu wykonywania.

// 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

Uwagi

Klasy pochodzące z DynamicObject klasy mogą zastąpić tę metodę, aby określić sposób wykonywania operacji binarnych dla obiektu dynamicznego. Gdy metoda nie jest zastępowana, powiązanie czasu wykonywania języka określa zachowanie. (W większości przypadków zgłaszany jest wyjątek czasu wykonywania specyficzny dla języka).

Ta metoda jest wywoływana, gdy masz operacje binarne, takie jak dodawanie lub mnożenie. Jeśli na przykład TryBinaryOperation metoda jest zastępowana, jest ona automatycznie wywoływana dla instrukcji takich jak sum = first + second lub multiply = first*second, gdzie first pochodzi z DynamicObject klasy .

Informacje o typie operacji binarnej można uzyskać przy użyciu Operation właściwości parametru binder .

Jeśli obiekt dynamiczny jest używany tylko w języku C# i Visual Basic, binder.Operation właściwość może mieć jedną z następujących wartości z wyliczenia ExpressionType . Jednak w innych językach, takich jak IronPython lub IronRuby, można mieć inne wartości.

Wartość	Opis	C#	Visual Basic
`Add`	Operacja dodawania bez sprawdzania przepełnienia dla operandów liczbowych.	`a + b`	`a + b`
`AddAssign`	Dodawanie operacji przypisania złożonego bez sprawdzania przepełnienia dla operandów liczbowych.	`a += b`	Nieobsługiwane.
`And`	Bitowa `AND` operacja.	`a & b`	`a And b`
`AndAssign`	Bitowa `AND` operacja przypisania złożonego.	`a &= b`	Nieobsługiwane.
`Divide`	Operacja dzielenia arytmetycznego.	`a / b`	`a / b`
`DivideAssign`	Operacja przypisania złożonego dzielenia arytmetycznego.	`a /= b`	Nieobsługiwane.
`ExclusiveOr`	Bitowa `XOR` operacja.	`a ^ b`	`a Xor b`
`ExclusiveOrAssign`	Bitowa `XOR` operacja przypisania złożonego.	`a ^= b`	Nieobsługiwane.
`GreaterThan`	Porównanie "większe niż".	`a > b`	`a > b`
`GreaterThanOrEqual`	Porównanie "większe niż lub równe".	`a >= b`	Nieobsługiwane.
`LeftShift`	Bitowa operacja przesunięcia w lewo.	`a << b`	`a << b`
`LeftShiftAssign`	Bitowa operacja przypisania złożonego przesunięcia w lewo.	`a <<= b`	Nieobsługiwane.
`LessThan`	Porównanie "mniejsze niż".	`a < b`	`a < b`
`LessThanOrEqual`	Porównanie "mniejsze niż lub równe".	`a <= b`	Nieobsługiwane.
`Modulo`	Operacja arytmetyczna.	`a % b`	`a Mod b`
`ModuloAssign`	Arytmetyczna operacja przypisania złożonego pozostałego.	`a %= b`	Nieobsługiwane.
`Multiply`	Operacja mnożenia bez sprawdzania przepełnienia dla operandów liczbowych.	`a * b`	`a * b`
`MultiplyAssign`	Operacja przypisania złożonego mnożenia bez sprawdzania przepełnienia dla operandów liczbowych.	`a *= b`	Nieobsługiwane.
`NotEqual`	Porównanie nierówności.	`a != b`	`a <> b`
`Or`	Bitowa lub logiczna `OR` operacja.	`a \| b`	`a Or b`
`OrAssign`	Bitowe lub logiczne `OR` przypisanie złożone.	`a \|= b`	Nieobsługiwane.
`Power`	Matematyczna operacja podnoszenia liczby do potęgi.	Nieobsługiwane.	`a ^ b`
`RightShift`	Bitowa operacja przesunięcia prawego.	`a >> b`	`a >> b`
`RightShiftAssign`	Bitowa operacja przypisania złożonego przesunięcia prawego.	`a >>= b`	Nieobsługiwane.
`Subtract`	Operacja odejmowania bez sprawdzania przepełnienia dla operandów liczbowych.	`a - b`	`a - b`
`SubtractAssign`	Operacja przypisania złożonego odejmowania bez sprawdzania przepełnienia dla operandów liczbowych.	`a -= b`	Nieobsługiwane.

Uwaga

Aby zaimplementować OrElse operacje () i AndAlso (a || ba && b) dla obiektów dynamicznych w języku C#, warto zaimplementować zarówno metodęTryUnaryOperation, jak i metodęTryBinaryOperation.

Operacja OrElse składa się z operacji jednoargumentowej IsTrue i operacji binarnej Or . Operacja jest wykonywana Or tylko wtedy, gdy wynikiem IsTrue operacji jest false.

Operacja AndAlso składa się z operacji jednoargumentowej IsFalse i operacji binarnej And . Operacja jest wykonywana And tylko wtedy, gdy wynikiem IsFalse operacji jest false.

Dotyczy

Share via