C#

// This index will point to the current line and will start with
//   the first line.
Int32 index = 0;

// We want to loop while there are valid blocks. This means that
//   if our index is pointing to the first line, then there must
//   be atleast 6 lines left (one for each item in the block).
while (lines.Length >= index + 6) {
    // At this point we know that index should point to the start
    //   of a block. We also know that there are atleast 5 more
    //   lines beyond the current line (e.g. the one pointed to
    //   by index).
    //

    // Make sure that the block starts with a #, if not then we
    //   will skip this line and contine the loop. This means
    //   that if there is some extras lines after a block (either
    //   blank or just junk), then we will skip them.
    if ("#" != lines[index].Trim()) {
        // It's not a #, so it's a bad line we will skip it by
        //   incrementing the index, then start the loop again
        //   and hopefully this time we will be at the start of
        //   a valid block.
        index++;
        continue;
    }

    // The current line is a valid block indicator and we know
    //   that the 5 other pieces of information are available
    //   in the lines variable. So pull them out.
    String name1 = lines[index + 1];
    String path1 = lines[index + 2];
    String path2 = lines[index + 3];
    String price = lines[index + 4];
    String name2 = lines[index + 5];

    // Now we can skip over the lines we just read, which should
    //   move us to the next block.
    index += 6;

    // TODO: Do something with this information.
}

public class GlobalVars {
    public static Int32 MyInt = 0;
}

GlobalVars.MyInt = 1;
// ...
Int32 i = GlobalVars.MyInt;

public static GlobalishVariabelHolder
{
   private static int globalishIntegerVariabel = 0;
   public static int GlobalishIntegerVariabel
   {
      get { return globalishIntegerVariabel;}
      set { globalishIntegerVariabel = value;}
   }
}

//accessing the static variable from other classes is done by:
private void someMethod()
{
    int value = GlobalishVariabelHolder.GlobalishIntegerVariabel;
    //do something with the value.
}

int bitsInCell = Marshal.SizeOf(data[0]) * 8;

// Create buffer
Int32[] buffer = new Int32[10];
buffer[5] = 1;

// Allocate and copy to unmanaged memory
IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Int32)) * 10);
Marshal.Copy(buffer, 0, ptr, 10);

// Change buffer, so we can see that the ptr has restores the
//   old value
buffer[5] = 2;

// Copy from unmanged memory back to array
Marshal.Copy(ptr, buffer, 0, 10);

// Free memory, or else we will leak it
Marshal.FreeHGlobal(ptr);

<br />
// Create buffer<br />
Int32[] buffer = new Int32[10];<br />
buffer[5] = 1;<br />
<br />
// Allocate and copy to unmanaged memory<br />
IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Int32)) * 10);<br />
Marshal.Copy(buffer, 0, ptr, 10);<br />
<br />
// **** Need to add this, otherwise c# complains about not being able to convert IntPtr to int<br />
int bptr = (int)ptr;<br />
ocx.PutData(ref bptr, Marshal.SizeOf(typeof(Int32)) * 10);<br />
<br />
// Change buffer, so we can see that the ptr has restored the<br />
//   old value<br />
buffer[5] = 2;<br />
<br />
// **** Allocate another are to retrieve data<br />
IntPtr ptr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Int32)) * 10);<br />
int bptr2 = (int)ptr2;<br />
<br />
ocx.GetData(ref bptr2);<br />
// **** Here there is the problem: when GetData() returns, <br />
// the bptr2 variable has been changed and its value is = bptr = (int ptr) <br />
<br />
// Copy from unmanged memory back to array<br />
Marshal.Copy(ptr2, buffer, 0, 10);<br />
<br />
// Free memory, or else we will leak it<br />
Marshal.FreeHGlobal(ptr);<br />
Marshal.FreeHGlobal(ptr2);<br />

// Create buffer
Int32[] buffer = new Int32[10];
buffer[5] = 1;

// Allocate and copy to unmanaged memory
IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Int32)) * 10);
Marshal.Copy(buffer, 0, ptr, 10);

// **** Need to add this, otherwise c# complains about not being able to convert IntPtr to int
int bptr = (int)ptr;
ocx.PutData(ref bptr, Marshal.SizeOf(typeof(Int32)) * 10);

// Change buffer, so we can see that the ptr has restored the
// old value
buffer[5] = 2;

// Free memory, or else we will leak it
Marshal.FreeHGlobal(ptr);

// ... Somewhere else in code


// **** Allocate another are to retrieve data
IntPtr ptr2 = IntPtr.Zero;
int bptr2 = (int)ptr2;

ocx.GetData(ref bptr2);

// Copy from unmanged memory back to array
Marshal.Copy(ptr2, buffer, 0, 10);