Pass existing FileSystemObject or create multiple instances

Question

I have several procedures that use the FileSystemObject. I find it's quite convenient.

Question: Is it sensible to pass an existing instance of FileSystemObject from a "main" procedure to these other procedures as an argument, rather than having each procedure create its own instance of FileSystemObject?

Example: is it better in any way to do this:

Sub MainSub()
    Dim FSO : Set FSO = CreateObject("Scripting.FileSystemObject")
    Call OtherSub(FSO, myargs)
    ' call other subs and functions that use FileSystemObject
End Sub

Sub OtherSub(FSO, myargs)
    ' Do stuff with FSO
    ' call other subs and functions that use FileSystemObject
End Sub 

which I have seen at least one programmer do, rather than the following, which is what I usually do:

Sub MainSub()
    Dim FSO : Set FSO = CreateObject("Scripting.FileSystemObject")
    Call OtherSub(myargs)
    ' call other subs and functions that use FileSystemObject
End Sub

Sub OtherSub(myargs)
    Dim FSO : Set FSO = CreateObject("Scripting.FileSystemObject")
    Call OtherSub(myargs)
    ' Do stuff with FSO
    ' call other subs and functions that use FileSystemObject
End Sub 

I can see the idea of doing the former in that this potentially reduces the overhead associated with having multiple instances of FileSystemObject. But it seems terribly cumbersome to have to pass FSO as an argument each time. And seriously, is the overhead really that big?

Answer 1

I have done something like this recently, and I personally prefer to use a single file system object wherever possible. I think of it as passing file handles between functions, which in-turn write to the open file handle.

When defining your functions/subs, be sure to pass the file system object using the ByRef keyword.

The only time this would be unacceptable is if you are navigating through a file hierarchy, and you need the FSO to maintain the same directory. It should be noted, however, that the memory requirements of a single FSO are negligible in today's computers, and you will only notice a performance gain if you need to use a recursive function or repeatedly call a function which creates/destroys these objects.