Imports System
Imports System.Runtime.InteropServices



Public Structure Point
    Public x As Integer
    Public y As Integer
End Structure


Module Example


    Sub Main()

        ' Create a point struct.
        Dim p As Point
        p.x = 1
        p.y = 1

        Console.WriteLine("The value of first point is " + p.x.ToString + " and " + p.y.ToString + ".")

        ' Initialize unmanged memory to hold the struct.
        Dim pnt As IntPtr = Marshal.AllocHGlobal(Marshal.SizeOf(p))

        Try

            ' Copy the struct to unmanaged memory.
            Marshal.StructureToPtr(p, pnt, False)

            ' Create another point.
            Dim anotherP As Point

            ' Set this Point to the value of the 
            ' Point in unmanaged memory. 
            anotherP = CType(Marshal.PtrToStructure(pnt, GetType(Point)), Point)

            Console.WriteLine("The value of new point is " + anotherP.x.ToString + " and " + anotherP.y.ToString + ".")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

using System;
using System.Runtime.InteropServices;

public struct Point
{
    public int x;
    public int y;
}

class Example
{

    static void Main()
    {

        // Create a point struct.
        Point p;
        p.x = 1;
        p.y = 1;

        Console.WriteLine("The value of first point is " + p.x + " and " + p.y + ".");

        // Initialize unmanged memory to hold the struct.
        IntPtr pnt = Marshal.AllocHGlobal(Marshal.SizeOf(p));

        try
        {

            // Copy the struct to unmanaged memory.
            Marshal.StructureToPtr(p, pnt, false);

            // Create another point.
            Point anotherP;

            // Set this Point to the value of the 
            // Point in unmanaged memory. 
            anotherP = (Point)Marshal.PtrToStructure(pnt, typeof(Point));

            Console.WriteLine("The value of new point is " + anotherP.x + " and " + anotherP.y + ".");

        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
        


    }

}

        [StructLayout(LayoutKind.Sequential)]

        public class  INNER

        {

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst =  10)]

            public string field1 = "Test";

     

        }    

        [StructLayout(LayoutKind.Sequential)]

        public struct OUTER

        {

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst =  10)]

            public string field1;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst =  100)]

            public byte[] inner;

        }





        [DllImport(@"SomeTestDLL.dll")]

        public static extern void CallTest( ref OUTER po);



        static void Main(string[] args)

        {

            OUTER ed = new OUTER();

            INNER[] inn=new INNER[10];

            INNER test = new INNER();

            int iStructSize = Marshal.SizeOf(test);



            int sz =inn.Length * iStructSize;

            ed.inner = new byte[sz];



            try

            {

                CallTest( ref ed);

            }

            catch(Exception e)

            {

                Console.WriteLine(e.Message);

            }

            IntPtr buffer = Marshal.AllocCoTaskMem(iStructSize*10);

            Marshal.Copy(ed.inner,0,buffer,iStructSize*10);

            

            int iCurOffset = 0;

            for(int i=0;i<10;i++)

            {

                

                inn[i] = (INNER)Marshal.PtrToStructure(new
IntPtr(buffer.ToInt32()+iCurOffset),typeof(INNER) );

                iCurOffset += iStructSize;

            }

            Console.WriteLine(ed.field1);

            Marshal.FreeCoTaskMem(buffer);

        }

[StructLayout(LayoutKind::Sequential)]
ref class INNER
{
public:
    [MarshalAs(UnmanagedType::ByValTStr,SizeConst=10)]
    String^ field;

    INNER()
    {
        field = "Test";
    }
};

[StructLayout(LayoutKind::Sequential)]
value struct OUTER
{
public:
    [MarshalAs(UnmanagedType::ByValTStr,SizeConst=10)]
    String^ field;

    [MarshalAs(UnmanagedType::ByValArray,SizeConst=100)]
    array<Byte>^ inner;
};

[DllImport("SomeTestDLL.dll")]
static void CallTest(OUTER^ outerStructurePointer);

void static Work()
{
    OUTER outerStructure;
    array<INNER^>^ innerArray = gcnew array<INNER^>(10);
    INNER^ innerStructure = gcnew INNER;
    int structSize = Marshal::SizeOf(innerStructure);
    int size = innerArray->Length * structSize;
    outerStructure.inner = gcnew array<Byte>(size);

    try
    {
        CallTest(outerStructure);
    }
    catch (SystemException^ ex) 
    {
        Console::WriteLine(ex->Message);
    }

    IntPtr buffer = Marshal::AllocCoTaskMem(structSize * 10);
    Marshal::Copy(outerStructure.inner, 0, buffer, structSize * 10);
    int currentOffset = 0;
    for (int i = 0; i < 10; i++)
    {
        innerArray[i] = safe_cast<INNER^>(Marshal::PtrToStructure(
            IntPtr(buffer.ToInt32() + currentOffset),
            INNER::typeid));
        currentOffset += structSize;
    }
    Console::WriteLine(outerStructure.field);
    Marshal::FreeCoTaskMem(buffer);
}

/** @attribute StructLayout(LayoutKind.Sequential)
 */
public static class Inner
{
    /** @attribute MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)
     */
    public String field1 = "Test";
} //Inner

/** @attribute StructLayout(LayoutKind.Sequential)
 */
public static class Outer
{
    /** @attribute MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)
     */
    public String field1;

    /** @attribute MarshalAs(UnmanagedType.ByValArray, SizeConst = 100)
     */
    public ubyte inner[];
} //Outer

/** @attribute DllImport("SomeTestDLL.dll")
 */
public static native void CallTest(Outer po);

private static void main(String[] args)
{
    Outer ed = new Outer();
    Inner inn[] = new Inner[10];
    Inner test = new Inner();
    int iStructSize = Marshal.SizeOf(test);
    int sz = inn.get_Length() * iStructSize;
    ed.inner = new ubyte[sz];
    try {
        CallTest(ed);
    }
    catch (System.Exception e) {
        Console.WriteLine(e.get_Message());
    }
    IntPtr buffer = Marshal.AllocCoTaskMem(iStructSize * 10);
    Marshal.Copy(ed.inner, 0, buffer, iStructSize * 10);
    int iCurOffset = 0;
    for (int i = 0; i < 10; i++) {
        inn.set_Item(i, (Inner)(Marshal.PtrToStructure(new IntPtr(
            buffer.ToInt32() + iCurOffset), Inner.class.ToType())));
        iCurOffset += iStructSize;
    }
    Console.WriteLine(ed.field1);
    Marshal.FreeCoTaskMem(buffer);
} //main