false (Operador, Referencia de C#)

Actualización: Julio de 2008

Devuelve el valor booleanotrue para indicar que un operando es false; de lo contrario, devuelve false.

En las versiones anteriores a C# 2.0, los operadores true y false se utilizaban para crear tipos de valor que aceptan valores NULL definidos por el usuario compatibles con tipos como SqlBool. Sin embargo, ahora este lenguaje proporciona compatibilidad integrada con los tipos de valor que aceptan valores NULL; además, debe utilizarlos siempre que sea posible, en lugar de sobrecargar los operadores true y false. Para obtener más información, vea Tipos que aceptan valores NULL (Guía de programación de C#).

Con los tipos booleanos que aceptan valores NULL, la expresión a != b no es necesariamente igual a !(a == b), ya que uno o ambos valores pueden ser NULL. Debe sobrecargar ambos operadores, true y false, por separado para controlar correctamente los valores NULL en la expresión. En el ejemplo siguiente se muestra cómo sobrecargar y usar los operadores true y false.

// For example purposes only. Use the built-in nullable bool 
// type (bool?) whenever possible.
public struct DBBool
{
    // The three possible DBBool values.
    public static readonly DBBool Null = new DBBool(0);
    public static readonly DBBool False = new DBBool(-1);
    public static readonly DBBool True = new DBBool(1);
    // Private field that stores –1, 0, 1 for False, Null, True.
    sbyte value;
    // Private instance constructor. The value parameter must be –1, 0, or 1.
    DBBool(int value)
    {
        this.value = (sbyte)value;
    }
    // Properties to examine the value of a DBBool. Return true if this
    // DBBool has the given value, false otherwise.
    public bool IsNull { get { return value == 0; } }
    public bool IsFalse { get { return value < 0; } }
    public bool IsTrue { get { return value > 0; } }
    // Implicit conversion from bool to DBBool. Maps true to DBBool.True and
    // false to DBBool.False.
    public static implicit operator DBBool(bool x)
    {
        return x ? True : False;
    }
    // Explicit conversion from DBBool to bool. Throws an exception if the
    // given DBBool is Null; otherwise returns true or false.
    public static explicit operator bool(DBBool x)
    {
        if (x.value == 0) throw new InvalidOperationException();
        return x.value > 0;
    }
    // Equality operator. Returns Null if either operand is Null; otherwise
    // returns True or False.
    public static DBBool operator ==(DBBool x, DBBool y)
    {
        if (x.value == 0 || y.value == 0) return Null;
        return x.value == y.value ? True : False;
    }
    // Inequality operator. Returns Null if either operand is Null; otherwise
    // returns True or False.
    public static DBBool operator !=(DBBool x, DBBool y)
    {
        if (x.value == 0 || y.value == 0) return Null;
        return x.value != y.value ? True : False;
    }
    // Logical negation operator. Returns True if the operand is False, Null
    // if the operand is Null, or False if the operand is True.
    public static DBBool operator !(DBBool x)
    {
        return new DBBool(-x.value);
    }
    // Logical AND operator. Returns False if either operand is False,
    // Null if either operand is Null, otherwise True.
    public static DBBool operator &(DBBool x, DBBool y)
    {
        return new DBBool(x.value < y.value ? x.value : y.value);
    }
    // Logical OR operator. Returns True if either operand is True, 
    // Null if either operand is Null, otherwise False.
    public static DBBool operator |(DBBool x, DBBool y)
    {
        return new DBBool(x.value > y.value ? x.value : y.value);
    }
    // Definitely true operator. Returns true if the operand is True, false
    // otherwise.
    public static bool operator true(DBBool x)
    {
        return x.value > 0;
    }
    // Definitely false operator. Returns true if the operand is False, false
    // otherwise.
    public static bool operator false(DBBool x)
    {
        return x.value < 0;
    }
    public override bool Equals(object obj)
    {
        if (!(obj is DBBool)) return false;
        return value == ((DBBool)obj).value;
    }
    public override int GetHashCode()
    {
        return value;
    }
    public override string ToString()
    {
        if (value > 0) return "DBBool.True";
        if (value < 0) return "DBBool.False";
        return "DBBool.Null";
    }
}

Un tipo que sobrecarga los operadores true y false puede utilizarse para la expresión de control en las instrucciones if, do, while y for y en las expresiones condicionales.

Si un tipo define el operador false, también debe definir el operador true.

Un tipo no puede sobrecargar directamente los operadores lógicos condicionales && y ||, pero al sobrecargar los operadores lógicos regulares y los operadores true y false se puede lograr un efecto equivalente.

Especificación del lenguaje C#

Para obtener más información, vea las secciones siguientes de Especificación del lenguaje C#.

• 10.10.1 Operadores unarios

• 7.11.2 Operadores lógicos condicionales definidos por el usuario

• 7.19 Expresiones Boolean

Vea también

Conceptos

Guía de programación de C#

Referencia

Palabras clave de C#

Operadores de C#

true (Referencia de C#)

Otros recursos

Referencia de C#

Historial de cambios

Fecha	Historial	Motivo
Julio de 2008	Se ha agregado información sobre la sobrecarga de los operadores true y false.	Mejora de la información.