Develop Reference

Custom function when using a class as a boolean?

Is there anyway to make is so that I can say something like
if(boolClass) {}
Where the boolClass is calling a contained function. Kinda like an overloaded bool operator or something.
Thanks for any help.

There is actually a 'true' operator you can use for this purpose, though it's a bit obscure. This is slightly more specific than a conversion to bool, as it is limited to use in expressions that check for true/false.
public class BoolClass
{
public static bool operator true(BoolClass instance)
{
return true; //Logic goes here
}
public static bool operator false(BoolClass instance)
{
return true; //Logic goes here
}
public void Test()
{
BoolClass boolClass = new BoolClass();
if (boolClass)
{
//Do something here
}
}
}
Note that MS actually recommends against using this operator,as it was originally intended to allow for a kind of nullable bool type (where a value could be neither true nor false). Since nullable bools are now natively supported, those are preferred. I'd recommend against using it in production code, mainly because most developers won't be familiar with the syntax, causing confusion.

My first point would be to caution you against this, usually you want to use the bool or bool? classes available directly or indirectly.
If you are certain that is what you need, then you will need an implicit conversion operator to bool
//In the definition of boolClass
public static implicit operator bool(boolClass obj)
{
//Return a bool in this method
}

You can use a implicit operator to convert your class to a Boolean.
This is a full and simple example :
Classe
using System;
namespace TestLogic
{
internal class FuzzyLogic
{
public FuzzyLogic(Double init)
{
this.value = init;
}
public Double value { get; private set; }
public static implicit operator Boolean(FuzzyLogic logic)
{
return logic.value < 0.1;
}
}
}
Using the convertion
using System;
namespace TestLogic
{
internal class Program
{
private static void Main(string[] args)
{
FuzzyLogic logic = new FuzzyLogic(0.2);
if (logic)
{
Console.WriteLine("It's true !");
}
else
{
Console.WriteLine("It's not true !");
}
Console.ReadLine();
}
}
}

Sounds like a property:
public bool boolClass
{
get { return false; } // or a calculated boolean value
}
You can invoke it exactly like you asked about from inside the same class:
if(boolClass) {}

Add a conversion operator to your class. Example (ideone):
using System;
public class A
{
private int i;
public int I { get { return i; } }
public A(int i) { this.i = i; }
public static implicit operator bool(A a) { return a.i != 0; }
}
public class Test
{
public static void Main()
{
A a1 = new A(0);
if (a1)
Console.WriteLine("a1 is true");
else
Console.WriteLine("a1 is false");
A a2 = new A(42);
if (a2)
Console.WriteLine("a2 is true");
else
Console.WriteLine("a2 is false");
}
}
Output:
a1 is false
a2 is true

how to create a custom cast explicit in c #?

Have this code:
string abc = "123456";
To convert to int should I use convert:
int abcInt = Convert.ToInt32(abc);
The problem is that if not a number I have an exception see returning zero so my final code will look like:
try{ int abcInt = Convert.ToInt32(abc); }catch(Exception e){ int abcInt = 0; }
So you see that I decided to create a book that made ​​me an object returning zero numeric without exception if it failed, so could keep most flexible programming without much junk code:
int abcInt = Libs.str.safeInt(abc);
The code is:
public int safeInt(object ob)
{
if ((ob == null) || (String.IsNullOrEmpty(ob.ToString())))
return 0;
try
{
return Convert.ToInt32(
System.Text.RegularExpressions.Regex.Replace(ob.ToString(), #"#[^Ee0-9\.\,]+#i", "").
ToString(CultureInfo.InvariantCulture.NumberFormat)
);
}
catch (FormatException e)
{
return 0;
}
}
But I want to go one step further and do something like this:
int abcInt = (safeInt)abc;
how to do?
Can not convert type 'string' to 'Libs.safeInt.safeInt'

You should just use Int32.TryParse:
int abcInt;
if(!Int32.TryParse(abc, out abcInt)) {
abcInt = 0;
}
// abcInt has been parsed to an int, or defaulted to zero
Note that this can be shortened to
int abcInt;
Int32.TryParse(abc, out abcInt);
if all that you want is the default value to be zero because:
When this method returns, contains the 32-bit signed integer value equivalent to the number contained in s, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is null, is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.
I actually recommend against writing it this way because now you can't distinguish between abc = "0" and abc = "garbage"; both with exhibit exactly the same behavior with the above two lines of code. With the initial version above (i.e., the if, you can distinguish the two cases if you need to; silently ignoring errors is generally a bad idea).
That said, if you absolutely are dying to know how to implement an explicit cast operator, you proceed like this:
class SafeInt32 {
private readonly int value;
public int Value { get { return this.value; } }
private readonly string source;
public string Source { get { return this.source; } }
private readonly bool successful;
public bool Successful { get { return this.successful; } }
public SafeInt32(string source) {
this.source = source;
this.successful = Int32.TryParse(source, out this.value);
}
public static explicit operator SafeInt32(string source) {
return new SafeInt32(source);
}
public static implicit operator int(SafeInt32 safeInt32) {
return safeInt32.Value;
}
}
Usage:
int abcInt = (SafeInt32)"123456";
Note that we had to define an explicit cast operator to cast a string to a SafeInt32, and an implicit cast operator to cast a SafeInt32 to an int to achieve your desired syntax. The latter is necessary so that the compiler can silently convert the result of (SafeInt32)"123456" to an int.
Again, I recommend against this; use Int32.TryParse.

You can leverage implicit and explicit operators to do what you want, yes. You can also use int.TryParse to avoid using exceptions for control flow.
public struct SafeInt
{
public int Value { get; private set; }
public static implicit operator int(SafeInt safeInt)
{
return safeInt.Value;
}
public static explicit operator SafeInt(string obj)
{
return new SafeInt() { Value = SafeParse(obj) };
}
public static int SafeParse(object value)
{
int output;
int.TryParse((value ?? "0").ToString(), out output);
return output;
}
}

I mean, you should use int.TryParse, but if you're dead-set on the cast syntax:
public class SafeInt
{
private int _value;
private SafeInt() {}
public static explicit operator SafeInt(string str)
{
int x;
int.TryParse(str, out x);
SafeInt si = new SafeInt();
si._value = x;
return si;
}
public static implicit operator int(SafeInt x)
{
return x._value;
}
public override string ToString()
{
return _value.ToString();
}
}
You can then use it like this:
int x = (SafeInt)"234234";

First, let me just go on record saying that you may not want to do this.
Silently ignoring problems like this can cause other types of problems, such as a customer asking "Why is this total over here always wrong?".
Having said that, let's see how you can do what you want before I give you a better option:
void Main()
{
int a = (SafeInt)"123";
a.Dump();
int b = (SafeInt)"xyz";
b.Dump();
}
public struct SafeInt
{
private readonly int _Value;
public SafeInt(int value)
{
_Value = value;
}
public SafeInt(int? value)
{
_Value = value ?? 0;
}
public int Value
{
get
{
return _Value;
}
}
public static implicit operator int(SafeInt s)
{
return s.Value;
}
public static implicit operator SafeInt(string s)
{
try
{
return new SafeInt(Convert.ToInt32(s));
}
catch (FormatException)
{
return new SafeInt();
}
}
}
This will print out:
123
0
Now, my advice is to stay away from this. Instead, use this:
void Main()
{
TryParse("123").Dump();
TryParse("xyz").Dump();
}
public static int TryParse(string s, int errorValue = 0)
{
int result;
if (int.TryParse(s, out result))
return result;
return errorValue;
}
Note that if you always want 0 as the value to return upon an error, there's even a much simpler way built into the system, this:
int value;
int.TryParse("123", out value);
Here we disregard the Boolean result from TryParse, because if TryParse fails, it'll set the parameter to 0.

I'd recommend that you do not do this. I find explicit and implicit conversions to be hard to discover, read, and use, compared to simpler static methods and/or constructors. Also, are you aware of the int.TryParse method? That might be a better solution for you:
public static int SafeInt(object value)
{
int i;
int.TryParse(value.ToString(), out i);
return i;
}
Or, more directly to answer your question, you can use explicit and implicit conversions on a SafeInt class to do this:
public class SafeInt
{
public int Value { get; set; }
public static implicit operator int(SafeInt si)
{
return si.Value;
}
public static explicit operator SafeInt(String str)
{
return new SafeInt { Value = Libs.str.safeInt(str) };
}
}
Use like:
int i = (SafeInt)"123";

How can I implicitly convert another struct to my Type?

As it is MyClass x = 120;, is it possible to create such a custom class?
If so, how can I do that?

It's generally considered a bad idea to use implicit operators, as they are, after all, implicit and run behind your back. Debugging code littered with operator overloads is a nightmare. That said, with something like this:
public class Complex
{
public int Real { get; set; }
public int Imaginary { get; set; }
public static implicit operator Complex(int value)
{
Complex x = new Complex();
x.Real = value;
return x;
}
}
you could use:
Complex complex = 10;
or you could ever overload the + operator
public static Complex operator +(Complex cmp, int value)
{
Complex x = new Complex();
x.Real = cmp.Real + value;
x.Imaginary = cmp.Imaginary;
return x;
}
and use code like
complex +=5;

Not sure if this is what you want but you may get there by implementing the implicit operator:
http://msdn.microsoft.com/en-us/library/z5z9kes2(VS.71).aspx

Create an implicit operator:
http://msdn.microsoft.com/en-us/library/z5z9kes2.aspx
For example:
public struct MyStruct // I assume this is what you meant, since you mention struct in your title, but use MyClass in your example.
{
public MyClass(int i) { val = i; }
public int val;
// ...other members
// User-defined conversion from MyStruct to double
public static implicit operator int(MyStruct i)
{
return i.val;
}
// User-defined conversion from double to Digit
public static implicit operator MyStruct(int i)
{
return new MyStruct(i);
}
}
"Is this a good idea?" is debatable. Implicit conversions tend to break accepted standards for programmers; generally not a good idea. But if you're doing some large value library, for example, then it might be a good idea.

yes, here's a short example ...
public struct MyCustomInteger
{
private int val;
private bool isDef;
public bool HasValue { get { return isDef; } }
public int Value { return val; } }
private MyCustomInteger() { }
private MyCustomInteger(int intVal)
{ val = intVal; isDef = true; }
public static MyCustomInteger Make(int intVal)
{ return new MyCustomInteger(intVal); }
public static NullInt = new MyCustomInteger();
public static explicit operator int (MyCustomInteger val)
{ if (!HasValue) throw new ArgumentNullEception();
return Value; }
public static implicit operator MyCustomInteger (int val)
{ return new MyCustomInteger(val); }
}

C#, Copy one bool to another (by ref, not val)

I am at a brick wall here. Is it possible to copy one bool to the ref of another. Consider this code . . .
bool a = false;
bool b = a;
b is now a totally separate bool with a value of false. If I subsequently change a, it will have no effect on b. Is it possible to make a = b by ref? How would I do that?
Many thanks

No. Since bool is a value type, it will always be copied by value.
The best option is to wrap your bool within a class - this will give it reference type semantics:
public class BoolWrapper
{
public bool Value { get; set; }
public BoolWrapper (bool value) { this.Value = value; }
}
BoolWrapper a = new BoolWrapper(false);
BoolWrapper b = a;
b.Value = true;
// a.Value == true

Thanks to #Reed for his answer (+1)! He encouraged me to a more "generic" solution! :)
public class ValueWrapper<T> where T : struct
{
public T Value { get; set; }
public ValueWrapper(T value) { this.Value = value; }
}

Small extension to Andrey's answer... this allows you to assign it to whatever type you want in the end directly. So:
ValueWrapper<bool> wrappedBool = new ValueWrapper<bool>(true);
bool unwrapped = wrappedBool; // you can assign it direclty:
if (wrappedBool) { // or use it how you'd use a bool directly
// ...
}
public class ValueWrapper<T>
{
public T Value { get; set; }
public ValueWrapper() { }
public ValueWrapper(T value) {
this.Value = value;
}
public static implicit operator T(ValueWrapper<T> wrapper)
{
if (wrapper == null) {
return default(T);
}
return wrapper.Value;
}
}

this may not be what you want, but if your scenario were such that you wanted a function that you called to modify your local boolean, you can use the ref or out keyworkd.
bool a = false;
F(ref a);
// a now equals true
...
void F(ref bool x)
{
x = true;
}

So I'm guessing you are needing to pass a reference a bool, that you cannot wrap with a 'BoolWrapper' class, because the bool lives some place that you cannot or do not wish to modify.
It can be done!
First declare what any bool reference will look like
/// <summary> A reference to a bool.</summary>
/// <param name="value">new value</param>
/// <returns>Value of boolean</returns>
public delegate bool BoolRef(bool? value = null);
Now you can make a reference to myBool like this
bool myBool; // A given bool that you cannot wrap or change
private bool myBoolRef(bool? value) {
if (value != null) {
myBool = (bool)value;
}
return myBool;
}
And use it like this:
void myTestCaller() {
foo(myBoolRef);
}
void foo(BoolRef b) {
bool c = b(); // get myBool
b(true); // set myBool to true
}
The same trick works for other value types such as int

A bool is a value type and cannot be copied by reference.

I had a case where I wanted one class to change another class' bool - please note that there are better ways to handle this situation but this is a proof of concept using Actions.
public class Class1
{
bool myBool { get; set; }
void changeBoolFunc(bool val) { myBool = val; }
public Class1()
{
Action<bool> changeBoolAction = changeBoolFunc;
myBool = true;
Console.WriteLine(myBool); // outputs "True"
Class2 c2 = new Class2(changeBoolAction);
Console.WriteLine(myBool); // outputs "False"
}
}
public class Class2
{
public Class2(Action<bool> boolChanger) { boolChanger(false); }
}
void Main()
{
Class1 c1 = new Class1();
}

Just use the flags as Nullable<bool> or bool? and set those in the struct that's passed to the generic method. The ValueWrapper<T> class above is essentially exactly what Nullable<T> does.

Handling comparisons with a custom boolean type?

I have a custom object that maps a boolean value from a legacy database to a C# bool (and back again).
My custom bool object looks like this:
public class S2kBool : IUserDefinedType {
public bool Value { get; set; }
public Type SupportedType { get { return typeof(string); } }
// These are the values used to represent booleans in the database
public const string TrueValue = "Y";
public const string FalseValue = "N";
public static S2kBool True {
get { return new S2kBool(true); }
}
public static S2kBool False {
get { return new S2kBool(false); }
}
public S2kBool() : this(false) { }
public S2kBool(bool value) {
this.Value = value;
}
// Called when a property of this type is populated from the database
public void FromSimpleDataType(object value) {
this.Value = value.ToString() == TrueValue;
}
// Called when a property of this type is inserted into the database
public object ToSimpleDataType() {
return this.Value ? TrueValue : FalseValue;
}
}
I would like to be able to do something like this:
public class TestObject {
public S2kBool IsActive = S2kBool.True;
}
TestObject tObj = new TestObject();
if (tObj.IsActive == S2kBool.True) {
// the above would evaluate to true
}
I've seen a few different methods for doing comparisons between objects, but I'm not sure of which one to use.
EDIT: Better yet, would it be possible to do something like the following and have C# treat the S2kBool object as an actual Boolean during comparison? It should also allow comparisons with other S2kBool objects, as well.
if (tObj.IsActive == true) { ... }

There are 2 things to look at; an implicit conversion operator (in S2kBool) to bool, or the true/false operators themselves...
true/false operators (note I prefer the implicit bool conversion myself):
public static bool operator true(S2kBool x) {
return x.Value;
}
public static bool operator false(S2kBool x) {
return !x.Value;
}
then you can use if(tObj.IsActive)
conversion operator:
public static implicit operator bool(S2kBool x) {
return x.Value;
}
works likewise
You might also add a conversion in the other direction:
public static implicit operator S2kBool(bool x)
{
return new S2kBool(x);
}
Then you can assign IsActive = false; etc
Finally, I wonder if this should be an immutable struct? It might be confusing if you expect this to behave like a value. For example, look at the last line here:
TestObject obj1 = new TestObject(),
obj2 = new TestObject();
obj1.IsActive = obj2.IsActive = S2kBool.True;
Console.WriteLine(obj1.IsActive);
Console.WriteLine(obj2.IsActive);
obj1.IsActive.Value = false;
Console.WriteLine(obj1.IsActive);
Console.WriteLine(obj2.IsActive); // what does this print?
This prints false, because both IsActive fields point to the same instance of S2kBool. If that was the intent, then fine. But if it was me, I'd make it immutable (whether class or struct). But since it doesn't really have any state other than a bool, I'd argue that this fits well as a struct.
To be honest, I'm not entirely sure why it is needed at all, when all the functionality could be done via static methods / etc.

Yes, you can do that. You would need to define equality operators and override the Equals method.
Here is an article about operator overloading:
http://www.csharphelp.com/archives/archive135.html
Here is an example of a type with overridden equality operators. You can do the same with assignment and conversion operators, making your type work seamlessly with the built-in bool type. (I took your example, shortened it a bit to keep the example short, and added the equality operators).
public struct S2kBool : IEquatable<bool>
{
public bool Value { get; set; }
public bool Equals(bool other)
{
return Value == other;
}
public override int GetHashCode()
{
return Value.GetHashCode();
}
public static bool operator ==(bool left, S2kBool right)
{
return right.Equals(left);
}
public static bool operator !=(bool left, S2kBool right)
{
return !(left == right);
}
public static bool operator ==(S2kBool left, bool right)
{
return left.Equals(right);
}
public static bool operator !=(S2kBool left, bool right)
{
return !(left == right);
}
}