DynamicObject.TryBinaryOperation Methode

Referenz

Definition

Namespace:: System.Dynamic

Assembly:: System.Dynamic.Runtime.dll

Assembly:: System.Linq.Expressions.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Quelle:: DynamicObject.cs

Quelle:: DynamicObject.cs

Quelle:: DynamicObject.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt die Implementierung für binäre Operationen bereit. Von der DynamicObject-Klasse abgeleitete Klassen können diese Methode überschreiben, um dynamisches Verhalten für Operationen wie Addition oder Multiplikation anzugeben.

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

Parameter

binder: BinaryOperationBinder

Stellt Informationen zur binären Operation bereit. Die binder.Operation -Eigenschaft gibt ein ExpressionType -Objekt zurück. Für die -Anweisung, bei der sum = first + second und von der DynamicObject -Klasse abgeleitet sind, binder.Operation wird beispielsweise zurückgegebenExpressionType.Add.secondfirst

arg: Object

Der rechte Operand für die binäre Operation. Für die sum = first + second -Anweisung ist beispielsweise gleich, wobei first und second von der DynamicObject -Klasse abgeleitet werden, arg gleich second.

result: Object

Das Ergebnis der binären Operation.

Gibt zurück

Boolean

true, wenn der Vorgang erfolgreich ist, andernfalls false. Wenn die Methode false zurückgibt, wird das Verhalten vom Laufzeitbinder der Sprache bestimmt. (In den meisten Fällen wird eine sprachspezifische Laufzeitausnahme ausgelöst.)

Beispiele

Angenommen, Sie benötigen eine Datenstruktur, um textliche und numerische Darstellungen von Zahlen zu speichern, und Sie möchten grundlegende mathematische Vorgänge wie Addition und Subtraktion für solche Daten definieren.

Im folgenden Codebeispiel wird die DynamicNumber -Klasse veranschaulicht, die von der DynamicObject -Klasse abgeleitet ist. DynamicNumber Überschreibt die TryBinaryOperation Methode, um mathematische Vorgänge zu ermöglichen. Außerdem werden die TrySetMember Methoden und TryGetMember außer Kraft gesetzt, um den Zugriff auf die Elemente zu ermöglichen.

In diesem Beispiel werden nur Additions- und Subtraktionsvorgänge unterstützt. Wenn Sie versuchen, eine Anweisung wie resultNumber = firstNumber*secondNumberzu schreiben, wird eine Laufzeitausnahme ausgelöst.

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

Hinweise

Von der -Klasse abgeleitete DynamicObject Klassen können diese Methode überschreiben, um anzugeben, wie binäre Vorgänge für ein dynamisches Objekt ausgeführt werden sollen. Wenn die Methode nicht überschrieben wird, bestimmt der Laufzeitbinder der Sprache das Verhalten. (In den meisten Fällen wird eine sprachspezifische Laufzeitausnahme ausgelöst.)

Diese Methode wird aufgerufen, wenn Sie über binäre Vorgänge wie Addition oder Multiplikation verfügen. Wenn die TryBinaryOperation -Methode beispielsweise überschrieben wird, wird sie automatisch für Anweisungen wie sum = first + second oder multiply = first*secondaufgerufen, wobei first von der DynamicObject -Klasse abgeleitet wird.

Sie können Informationen zum Typ des binären Vorgangs abrufen, indem Sie die Operation -Eigenschaft des binder Parameters verwenden.

Wenn Ihr dynamisches Objekt nur in C# und Visual Basic verwendet wird, kann die binder.Operation -Eigenschaft einen der folgenden Werte aus der ExpressionType Enumeration aufweisen. In anderen Sprachen wie IronPython oder IronRuby können Sie jedoch andere Werte haben.

Wert	BESCHREIBUNG	C#	Visual Basic
`Add`	Ein Additionsvorgang ohne Überlaufprüfung für numerische Operanden.	`a + b`	`a + b`
`AddAssign`	Ein Additionsverbundzuweisungsvorgang ohne Überlaufprüfung für numerische Operanden.	`a += b`	Wird nicht unterstützt.
`And`	Ein bitweiser `AND` Vorgang.	`a & b`	`a And b`
`AndAssign`	Ein bitweiser `AND` zusammengesetzter Zuweisungsvorgang.	`a &= b`	Wird nicht unterstützt.
`Divide`	Ein Arithmetikteilungsvorgang.	`a / b`	`a / b`
`DivideAssign`	Ein zusammengesetzter Zuweisungsvorgang für arithmetische Divisionen.	`a /= b`	Wird nicht unterstützt.
`ExclusiveOr`	Ein bitweiser `XOR` Vorgang.	`a ^ b`	`a Xor b`
`ExclusiveOrAssign`	Ein bitweiser `XOR` zusammengesetzter Zuweisungsvorgang.	`a ^= b`	Wird nicht unterstützt.
`GreaterThan`	Ein "größer als"-Vergleich.	`a > b`	`a > b`
`GreaterThanOrEqual`	Ein Vergleich mit "größer als oder gleich".	`a >= b`	Wird nicht unterstützt.
`LeftShift`	Ein bitweiser Linksverschiebungsvorgang.	`a << b`	`a << b`
`LeftShiftAssign`	Ein bitweiser Verbundzuweisungsvorgang mit linker Verschiebung.	`a <<= b`	Wird nicht unterstützt.
`LessThan`	Ein "kleiner als"-Vergleich.	`a < b`	`a < b`
`LessThanOrEqual`	Ein Vergleich mit "kleiner oder gleich".	`a <= b`	Wird nicht unterstützt.
`Modulo`	Ein arithmetischer Restvorgang.	`a % b`	`a Mod b`
`ModuloAssign`	Ein arithmetischer Restzuordnungsvorgang.	`a %= b`	Wird nicht unterstützt.
`Multiply`	Ein Multiplikationsvorgang ohne Überlaufprüfung für numerische Operanden.	`a * b`	`a * b`
`MultiplyAssign`	Ein Multiplikationsverbundzuweisungsvorgang ohne Überlaufprüfung für numerische Operanden.	`a *= b`	Wird nicht unterstützt.
`NotEqual`	Ein Ungleichheitsvergleich.	`a != b`	`a <> b`
`Or`	Ein bitweiser oder logischer `OR` Vorgang.	`a \| b`	`a Or b`
`OrAssign`	Eine bitweise oder logische `OR` Verbundzuweisung.	`a \|= b`	Wird nicht unterstützt.
`Power`	Ein mathematischer Vorgang der Erhöhung einer Zahl zu einer Macht.	Wird nicht unterstützt.	`a ^ b`
`RightShift`	Ein bitweiser Rechtsverschiebungsvorgang.	`a >> b`	`a >> b`
`RightShiftAssign`	Ein bitweiser Verbundzuweisungsvorgang mit der rechten Verschiebung.	`a >>= b`	Wird nicht unterstützt.
`Subtract`	Ein Subtraktionsvorgang ohne Überlaufprüfung für numerische Operanden.	`a - b`	`a - b`
`SubtractAssign`	Ein Zusammengesetzter Subtraktionszuweisungsvorgang ohne Überlaufprüfung für numerische Operanden.	`a -= b`	Wird nicht unterstützt.

Hinweis

Um Vorgänge (a || b) und AndAlso (a && b) für dynamische Objekte in C# zu implementieren OrElse , sollten Sie sowohl die TryUnaryOperation -Methode als auch die TryBinaryOperation -Methode implementieren.

Der OrElse Vorgang besteht aus dem unären IsTrue Vorgang und dem binären Or Vorgang. Der Or Vorgang wird nur ausgeführt, wenn das Ergebnis des IsTrue Vorgangs ist false.

Der AndAlso Vorgang besteht aus dem unären IsFalse Vorgang und dem binären And Vorgang. Der And Vorgang wird nur ausgeführt, wenn das Ergebnis des IsFalse Vorgangs ist false.

Gilt für:

Teilen über