Labview DLL and Defining Static Variables

Question

A Labview DLL that I am making currently consists of three parts:
1) Initialization protocols for a data recorder
2) Data retrieval from digital data recorder
3) Uninitialization of the data recorder
The DLL has one large sequence structure broken into three sections, and inside each segment there is a true/false case statement which allows the code to run or not.  Each case statement is run one-at-a-time by sending a "selection" value to the DLL which signifies which of the three case statements should execute.  There are hard coded wires running between each of the three in-line sequence structures enabling data to flow from left to right as the code in the DLL executes.
What happens to the state of the data in the hard coded wires when the DLL runs some code in one of the case statements and hands control back to VB?  In other words, in VB I can define variables which are static or self-destruct upon leaving a subroutine.  How is this controlled in Labview?
Also, in the "false" case statements, what is the effect of selecting "use default if unwired"?  I would like to explicitely define this connection properly but am not sure how to proceed.  I would the data held in this wire to be the same data that passed during the function call when the case was "true".
Thanks.

Answer 1

After our disussion above, I was "thinking outside the box" and decided to try a much simpler approach to creating a Labview DLL, which is called by VB.  Being primarily a text based programmer, I wanted to create a Labview DLL project that kept all the function calls in one VI and not have them spread across several VI's, as is the normal practice in Labview coding.  As in text based programming, where multiple function calls can be placed in one module and are easy to read and understand because of their close proximity in the editing compiler, I wanted the same thing from Labview.  This has been accomplished.
To do this I created the code shown in Simple-DLL.JPG.  All the code is in one VI and all parameters that are meant to stay static during calls to the DLL are maintained by local variables.  I'm sure shift registers could be made to work here, but code in this routine is only called once every five or ten seconds.  There are only three parameters that are passed during each call to the center routine to get data back from a digital data recorder.  Those parameters are 1) lSelector, 2) lArraySize, and 3) dArray[].  As mentioned earlier, the other parameters are held static by use of the local variables.
I like the simplicity of this approach, and maintenance of code is extremely easy.  Much easier that flipping between multiple function call VI's and the VI holding the global variables.  Reading and understanding the code is also easy to do in this approach.
Obviously, if one has a project where multiple functions are called with many variables being passed back and forth, then my example may have limitations.  But I wanted to document the above approach for text based programmers to reap the benefits of something easy to understand and implement, especially when their programming experience with Labview is limited, and their Labview project is relatively small.  Your comments are welcome!!
Attachments:
Simple-DLL.jpg ‏153 KB