Code:
```// Overload true.
public static bool operator true(ThreeD op) {
if((op.x != 0) || (op.y != 0) || (op.z != 0))
return true; // at least one coordinate is non-zero
else
return false;
}

public static bool operator false(ThreeD op) {
if((op.x == 0) && (op.y == 0) && (op.z == 0))
return true; // all coordinates are zero
else
return false;
}

public class TrueFalseDemo {
public static void Main() {
ThreeD a = new ThreeD(5, 6, 7);
ThreeD b = new ThreeD(10, 10, 10);
ThreeD c = new ThreeD(0, 0, 0);

Console.Write("Here is a: ");
a.show();
Console.Write("Here is b: ");
b.show();
Console.Write("Here is c: ");
c.show();
Console.WriteLine();

if(a) Console.WriteLine("a is true.");
else Console.WriteLine("a is false.");

if(b) Console.WriteLine("b is true.");
else Console.WriteLine("b is false.");

if(c) Console.WriteLine("c is true.");
else Console.WriteLine("c is false.");```
So as you knows, in any C based language, when you overload the true and false operators, you have to overload both of them. But the question is what invokes the false overload operator method? When the program reaches the if(a) Console.WriteLine("a is true."); This will invokes the true overload operator method and within the operator method, we already have the result of true and false. If the expression within the true overload operator method is true, then returns true, and if it is false, returns false.

Because within the if statement in main, the a, which is the object, is always assumed to be true. There is no way to invoke the false overload operator method. Just why we need it and what codes to write within the method?

2. Originally Posted by kenryuakuma
So as you knows, in any C based language, when you overload the true and false operators, you have to overload both of them.
There is no such thing as a true or false operator in ANY C-like language except C#.

3. SO would you please tell me why and explain it to me if possible. I would really appreciate it because this has been bugging me for a while.

4. Kind of bored to test it myself, except if you paste the whole code
But what I would do if I wasn't bored is sth like this
Code:
```  public static bool operator true(ThreeD op) {
Console.WriteLine("Yoohoo I am in trueee");
if((op.x != 0) || (op.y != 0) || (op.z != 0))
return true; // at least one coordinate is non-zero
else
return false;
}

public static bool operator false(ThreeD op) {
Console.WriteLine("Yoohoo I am in faaallseee");
if((op.x == 0) && (op.y == 0) && (op.z == 0))
return true; // all coordinates are zero
else
return false;
}```
To see when it actually goes in false. Maybe when
Code:
`if(!a) ...`
then the false operator is invoked rather than the true

5. So is it certain that by doing if(!a), the false operator will be invoked?

Besides this, Is it really ok to directly display the object value by doing something like this?

Code:
```myclass ob = new myclass(6, 8);

Console.Write("Object value:  {0}", (int) ob);```
THIS IS THE WHOLE CODE

Code:
```using System;

// A three-dimensional coordinate class.
class ThreeD {
int x, y, z; // 3-D coordinates

public ThreeD() { x = y = z = 0; }
public ThreeD(int i, int j, int k) { x = i; y = j; z = k; }

public static ThreeD operator +(ThreeD op1, ThreeD op2)
{
ThreeD result = new ThreeD();

/* This adds together the coordinates of the two points
and returns the result. */
result.x = op1.x + op2.x; // These are integer additions
result.y = op1.y + op2.y; // and the + retains its original
result.z = op1.z + op2.z; // meaning relative to them.

return result;
}

public static ThreeD operator -(ThreeD op1, ThreeD op2)
{
ThreeD result = new ThreeD();

/* Notice the order of the operands. op1 is the left
operand and op2 is the right. */
result.x = op1.x - op2.x; // these are integer subtractions
result.y = op1.y - op2.y;
result.z = op1.z - op2.z;

return result;
}

// Show X, Y, Z coordinates.
public void show()
{
Console.WriteLine(x + ", " + y + ", " + z);
}
}

public class ThreeDDemo {
public static void Main() {
ThreeD a = new ThreeD(1, 2, 3);
ThreeD b = new ThreeD(10, 10, 10);
ThreeD c = new ThreeD();

Console.WriteLine("Here is a: (int) a");
Console.WriteLine("Here is b: (int) b");

c = a + b; // add a and b together
Console.Write("Result of a + b: (int) c ");

Console.WriteLine();

c = a + b + c; // add a, b and c together
Console.Write("Result of a + b + c: ");
c.show();
Console.WriteLine();

c = c - a; // subtract a
Console.Write("Result of c - a: ");
c.show();
Console.WriteLine();

c = c - b; // subtract b
Console.Write("Result of c - b: ");
c.show();
Console.WriteLine();
}
}```
The code the author wrote is just switching around by applying the void method and the object containing the values in the Console.WriteLine();

6. No !a won't work. You need to overload the ! operator, which won't work either. Was just a wild guess, had to try it to be sure.

Reading from msdn, the false operator was useful for nullable types, that existed prior C# 2.0. Well, didn't read further.

Found this which explains a way to overload && and || using the false operator.

7. Text from MSDN link - User-defined conditional logical operators.

SUMMARY:

The operation x && y is evaluated as T.false(x) ? x : T.&(x, y), where T.false(x) is an invocation of the operator false declared in T, and T.&(x, y) is an invocation of the selected operator &. In other words, x is first evaluated and operator false is invoked on the result to determine if x is definitely false.