Return code or out parameter?

Question

I'm making a method to fetch a list of filenames from a server but I have come to a problem that I cannot answer.

The method returns two things:

• an SftpResult which is an enum with a variety of return codes.
• the list of filenames.

Of these three signatures:

public static ArrayList GetFileList(string directory, out SftpResult result)

public static SftpResult GetFileList(string directory, out ArrayList fileNames)

public static SftpFileListResult GetFileList(string directory)

(where SftpFileListResult is a composite object of an SftpResult and an ArrayList)

which is preferred and why?

Answer 1

I prefer the final option. Out parameters are rarely used and can be surprising / confusing to some. Creating a composite result object is a clean solution. The only drawback is that you must create a class solely for this purpose.

Answer 2

Personally I prefer the last option (although using a List<T> or ReadOnlyCollection<T> instead of ArrayList). out parameters are basically a way of returning multiple values, and it's generally nicer to encapsulate those.

Another option in .NET 4 would be

Tuple<SftpResult, ArrayList> GetFileList(string directory)

That explicitly says, "this method returns two things... I've packed them together for you for this particular case, but it's not worth further encapsulating them: they're not worth composing in a separate type".

(If you're not using .NET 4 you could always write your own Tuple type.)

Answer 3

I would prefer to wrap it up in a return object:

class FileResult
{
    public FileResult(SftpResult resultCode, IEnumerable<string> files)
    {
         ResultCode = resultCode;
         FileList = new List<string>(files);
    }
    public SftpResult ResultCode { get; private set; }
    public IEnumerable<string> FileList { get; private set; }
}

It feels a lot cleaner not to use out.

Answer 4

I would say the third, since it encapsulates the logic that you need in one location. I can only assume that SftpResult and ArrayList return methods should be private and then make up the internal logic of the composite return object.

Answer 5

I would make it:

public static bool GetFileList(string directory, out SftpResult result, out ArrayList fileNames)

So there is no confusion about what the function does, and also i would return a bool, if the GetFileList can fail.

Answer 6

Why not provide all three? I prefer not having out parameters in my function calls but I can appreciate that in many times they're needed. If you don't know which signature to support then support all three. Ultimately, the choice is on the side of the caller and the best thing you can do is offer this choice.

Answer 7

If you like designs where one function does two things then I would use a tuple a la Jon or a return object a la Fredrik.

If you wanted to be all OOPy about it you could let the type system do the work:

abstract class FtpResult { ... }
sealed class FileList : FtpResult { ... }
sealed class Error : FtpResult { ... }
...
sealed class FtpService
{
    ...
    public FtpResult GetFileList(string directory) { ... }
    ...
}
...
var result = service.GetFileList(dir);
var error = result as Error;
var list = result as FileList;
if (error != null) { ... }
else if (list != null)
{
    foreach(var name in list.Files) { ... }
}
...