Opinions on null return vs ​argumentexc​eption

Just looking for some opinions here... which do you like better and why?  Thanks in advance!

        public struct Foo
        {
            public readonly int Number;
            public Foo(int number)
            {
                Number = number;
            }
        }

        public struct Bar
        {
            public static readonly Foo[] AllFoos;
            static Bar()
            {
                List<Foo> list = new List<Foo>();
                for(int i=0; i< 20; i++)
                {
                    list.Add(new Foo(i));
                }
                AllFoos = list.ToArray();
            }
            public static Foo FindFoo(int number)
            {
                foreach(Foo foo in AllFoos)
                {
                    if(foo.Number == number)
                    {
                        return foo;
                    }
                }
                throw new ArgumentException(String.Format("Foo with an number of {0} not found", number), "number");
            }
        }

OR

        public class Foo
        {
            public readonly int Number;
            public Foo(int number)
            {
                Number = number;
            }
        }

        public struct Bar
        {
            public static readonly Foo[] AllFoos;
            static Bar()
            {
                List<Foo> list = new List<Foo>();
                for(int i=0; i< 20; i++)
                {
                    list.Add(new Foo(i));
                }
                AllFoos = list.ToArray();
            }
            public static Foo FindFoo(int number)
            {
                foreach(Foo foo in AllFoos)
                {
                    if(foo.Number == number)
                    {
                        return foo;
                    }
                }
                return null;
            }
        }

As the previous poster mentioned, exceptions should be used for exceptional conditions. Not finding an element is not exceptional IMO.

Also the use of Structs vs. Classes depends on the situation and in this example, I would use a Class.

http://www.jaggersoft.com/pubs/StructsVsClasses.htm

I'm with them - null is better in this case.

Null is better for the reasons that others have pointed out. I'd also make sure that you add an XML comment to document the return value when the item isn't found.

Again, I would support null in this instance, your method is about attempting to find something, just because it isn't found doesn't mean the feedback should be an error, it should simply say- no, it wasn't found.

Throwing the exception rather than returning NULL might be better if your collection holds valid keys attached to NULL values.  If I have strList = new List<string> where I set strList[23] = NULL, I might need to disambiguate the case where strList[23] == NULL from where there is no 24th element in the list.  This is probably why Dictionary<k,v> throws exceptions when you try and use a key that doesn't exist. 

But there are lots of examples that go the other way.  If you pass a string that's not found into String.IndexOf(), you don't get an exception -- you get a (-1).  If an XPath statement matches 0 nodes in an XmlElement, you get a zero-length array back - not an exception.

But having said all that, I tend to return NULL in most of my own code.

Also I would not base whether you use a class or struct on whether you return null or an exception. The reason you can't set it to null is int does not support null. You can easily allow for nullability:

readonly int? mymember;

Class or struct decision is made on how you want assignment to happen.

//With Struct:
MyType Instance2 = Instance1;
Instance1.intmember = 1;
Instance2.intmember = 2;
Console.WriteLine(Instance1.intmember);
Console.WriteLine(Instance2.intmember);

Would output:
1
2

//With Class:
MyType Instance2 = Instance1;
Instance1.intmember = 1;
Instance2.intmember = 2;
Console.WriteLine(Instance1.intmember);
Console.WriteLine(Instance2.intmember);

Would output
2
2

Because Instance2 is just a pointer reference to Instance1. Changing Instance 1 or Instance2 is a equivalent action.

I would always default to class. Unless you specifically have a reason to use a struct.

erik wrote:



Throwing the exception rather than returning NULL might be better if your collection holds valid keys attached to NULL values.  If I have strList = new List<string> where I set strList[23] = NULL, I might need to disambiguate the case where strList[23] == NULL from where there is no 24th element in the list.  This is probably why Dictionary<k,v> throws exceptions when you try and use a key that doesn't exist. 

I prefer "return null" but your situation might require the struct.  In this case, i think you can have your cake and eat it, too.

            public static Nullable<Foo> FindFoo(int number)
            {
                foreach(Foo foo in AllFoos)
                {
                    if(foo.Number == number)
                    {
                        return foo;
                    }
                }
                return null;
            }

Thanks for your opinions!  I normally use the null return approach, but noticed as some of you have that the dictionary and other framework classes use exceptions, so I figured I'd question my methods.

One argument against the null approach is that if you return null, your function is returning two different types of values. It can return a Foo, or a value for error checking (null). That's confusing and can increase complexity. Especially because the function name implies that it only returns a Foo.

This keeps biting me over and over again. I don't want to over-use exceptions and only use them for cases that are truly exceptional, but at the same time, I want my function to only return one type of value. I see simply no optimal solution for this.

Don't know if I agree with the 'handling two types' thing, null (nothing) is surely designed for this sort of comparison, if he attempts to pull some methods or properties out (after the find) that he belives are there (because its refence is foo), then he will get runtime exceptions explaining that null doesn't have that member.