I have often wanted an operator or something that will do something like run a method on an object if that object is not null (returning a default value if it is null). An example:
string s = SomeClass.SomeMember.ToString();
maybe for output or something. Now this works just fine, unless SomeMember happens to be null, when this code will throw an exception. So the code has to become:
string s = SomeClass.SomeMember != null ? SomeClass.SomeMember.ToString() : "";
or something like that. Upon finding the ?? ‘null coalescing operator’ I thought that would do the trick, but that will only munge the ToString (say) return value to "" if it was null, not let you call members on a null reference. You could do something with a chain of ?? operators, but that looks nasty and if anything in the chain is actually a method call rather than a property access then it may be called multiple times…
I think that I have come up with something neat and simple that works.
public static TResult Try<T, TResult>(this T left, Func<T, TResult> func) {
return Try(left, func, default(TResult));
}
public static TResult Try<T, TResult>(this T left, Func<T, TResult> func, TResult defaultValue) {
if(left != null) {
return func(left);
} else {
return defaultValue;
}
}
Which can be used like this:
string s = SomeClass.SomeMember.Try(m => m.ToString(), "");
I named it Try in reference to functions such as TryParse. Perhaps not the best choice of name, but I am pretty phenomenally bad a choosing names for things… If you use it on a null reference you will get back the default value you specify or if you don't specify one you get the default value of type of the lambda expression. This second case (not specifying the default explicitly) is more useful when the type is not nullable... It is useful for calling functions on members of a class that might be null. More than that of course though, as that is a lambda (well actually a Func<T, TResult> Generic Delegate which is most easily populated with a lambda) you can pretty much do whatever you like in there.
Now I understand that this is not for everybody and that it is not going to work in all situations. Sometimes a null return value will not always have the same meaning as the default value for that type, but if you keep this in mind to does clean up a lot of code.
Another example to illustrate:
public class DataObject {
public List<string> Strings;
}
DataObject myDataObject = new DataObject();
// int stringCount = myDataObject.Strings.Count; // *boom!*
int stringCount = myDataObject.Strings.Try(l => l.Count);
So this does not give you all of the same information that you get from receiving the null value, but it makes some common stuff painless, like telling the user how many strings there are. I find myself hiding the null value a lot of the time anyway, converting it to "" or 0 or whatever, so there you go.
Real world ‘improvement’. This:
object obj = ExecuteScript(script);
if(obj != null) {
return obj.ToString();
} else {
return "";
}
return ExecuteScript(script).Try(o => o.ToString(), "");
Incidentally, I really love how well the type inference works now. There is no need to specify the types when calling the function - like myDataObject.Strings.Try<string, int>(l => l.Count) - and the return type gets updated when you add or change the return type of the lambda expression. Very neat.
