I am currently writing a C# app replacing an old app written in VB6.  Part of
the app save it's structure contents to a binary file.  The old VB6 app dumps
the structure into the file via:

    Put #Fnumb, , MyVB6Structure

It is critial for my app that I write to this binary file in the same format
as the old VB6 app did because another VB6 will be reading the file generated
by my new app.

Inside my C# app, I have the old VB6 structure defined as follows:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class MyVB6StructureInCSharp
    {
        public float myfloat1;
        public int myInt1;
       
        [MarshalAs(UnmanagedType.SafeArray)]
        public bool[,] TwoDimArrayOfBool;

        [MarshalAs(UnmanagedType.BStr, SizeConst = 255)]
        public string myString;

    }//end of class TimingType1

During my save function, I am able to create an instance of this class and
populate it with the appropiate data.  I then want to take this class and
then write it to a binary file (in the same format that VB6 does it).  The
approach I am using is that I want to take the class and convert it into an
unmanaged array of bytes, and write this byte array to the binary file.  I
convert the class into an an array of bytes as follows:

private byte[] StructureToBytes(MyVB6StructureInCSharp myStruct)
        {
            int size;
            IntPtr p;
            byte[] ret;

            //The line below generates an exception:
                                              //can not be marshaled as an
unmanaged
                                              //structure; no meaningful
size or offset can be
                                              //computed.
                                              size =
Marshal.SizeOf(myStruct.GetType());
            p = Marshal.AllocCoTaskMem(size);

            try
            {
                Marshal.StructureToPtr(timingStruct, p, false);

                //Copy the unmanaged structure pointer into an array of bytes.
                ret = new byte[size];
                Marshal.Copy(p, ret, 0, size);
            }
            finally
            {
                //clean up our little mess.
                Marshal.FreeCoTaskMem(p);
            }

            //return the bytes
            return ret;

        }

When I perform the "size = Marshal.SizeOf(myStruct.GetType());" command I
get an exception that tells me that it can not marshal the structure as an
unmanaged structure becasue no size or offset can be determined.  I have
narrowed down the problem to be the 2 dimensional array of booleans that is
defined in my class.  It appears that the problem is that.

So my question is how can I properly marshal a two dimensional array of
booleans, to that I can convert the class into an array of bytes to write to
a binary file.  Any help would be appreciated.

Thanks!