Operator || (C#-Referenz)|| Operator (C# Reference)

Der bedingte Operator OR (||) führt ein logisches „Oder“ seiner bool-Operanden aus.The conditional-OR operator (||) performs a logical-OR of its bool operands. Wenn der erste Operand als true ausgewertet wird, wird der zweite Operand nicht ausgewertet.If the first operand evaluates to true, the second operand isn't evaluated. Wenn der erste Operand als false ausgewertet wird, wird durch den zweiten Operanden bestimmt, ob der ODER-Ausdruck als Ganzes als true oder false ausgewertet wird.If the first operand evaluates to false, the second operator determines whether the OR expression as a whole evaluates to true or false.

HinweiseRemarks

Der VorgangThe operation

x || y  

entspricht dem Vorgangcorresponds to the operation

x | y  

mit folgender Ausnahme: Wenn x true ist, wird y nicht ausgewertet, da der ODER-Vorgang unabhängig des Werts von y true ist.except that if x is true, y is not evaluated because the OR operation is true regardless of the value of y. Dieses Konzept wird als „Kurzschlussauswertung“ bezeichnet.This concept is known as "short-circuit" evaluation.

Der bedingte ODER-Operator kann nicht überladen werden, aber Überladungen der regulären logischen Operatoren und der Operatoren TRUE und FALSE gelten mit gewissen Einschränkungen auch als Überladungen der bedingten logischen Operatoren.The conditional-OR operator cannot be overloaded, but overloads of the regular logical operators and the true and false operators are, with certain restrictions, also considered to be overloads of the conditional logical operators.

BeispielExample

In den folgenden Beispielen wertet der Ausdruck, der || verwendet, nur den ersten Operanden aus.In the following examples, the expression that uses || evaluates only the first operand. Der Ausdruck, der | verwendet, wertet beide Operanden aus.The expression that uses | evaluates both operands. Im zweiten Beispiel tritt eine Laufzeitausnahme auf, wenn beide Operanden ausgewertet werden.In the second example, a run-time exception occurs if both operands are evaluated.

class ConditionalOr
{
    // Method1 returns true.
    static bool Method1()
    {
        Console.WriteLine("Method1 called.");
        return true;
    }

    // Method2 returns false.
    static bool Method2()
    {
        Console.WriteLine("Method2 called.");
        return false;
    }


    static bool Divisible(int number, int divisor)
    {
        // If the OR expression uses ||, the division is not attempted
        // when the divisor equals 0.
        return !(divisor == 0 || number % divisor != 0);

        // If the OR expression uses |, the division is attempted when
        // the divisor equals 0, and causes a divide-by-zero exception.
        // Replace the return statement with the following line to
        // see the exception.
        //return !(divisor == 0 | number % divisor != 0);
    }

    static void Main()
    {
        // Example #1 uses Method1 and Method2 to demonstrate 
        // short-circuit evaluation.

        Console.WriteLine("Regular OR:");
        // The | operator evaluates both operands, even though after 
        // Method1 returns true, you know that the OR expression is
        // true.
        Console.WriteLine("Result is {0}.\n", Method1() | Method2());

        Console.WriteLine("Short-circuit OR:");
        // Method2 is not called, because Method1 returns true.
        Console.WriteLine("Result is {0}.\n", Method1() || Method2());


        // In Example #2, method Divisible returns True if the
        // first argument is evenly divisible by the second, and False
        // otherwise. Using the | operator instead of the || operator
        // causes a divide-by-zero exception.

        // The following line displays True, because 42 is evenly 
        // divisible by 7.
        Console.WriteLine("Divisible returns {0}.", Divisible(42, 7));

        // The following line displays False, because 42 is not evenly
        // divisible by 5.
        Console.WriteLine("Divisible returns {0}.", Divisible(42, 5));

        // The following line displays False when method Divisible 
        // uses ||, because you cannot divide by 0.
        // If method Divisible uses | instead of ||, this line
        // causes an exception.
        Console.WriteLine("Divisible returns {0}.", Divisible(42, 0));
    }
}
/*
Output:
Regular OR:
Method1 called.
Method2 called.
Result is True.

Short-circuit OR:
Method1 called.
Result is True.

Divisible returns True.
Divisible returns False.
Divisible returns False.
*/

Siehe auchSee Also

C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
C#-OperatorenC# Operators