C#

using System.Text.RegularExpressions;
...
string expr = "(X, <OS:Size>, Z), (X, <OS:Type>, Y), (X, <OS:DateModified>, W), (X, <PDF:Title>, U)";
 
Regex re = new Regex("(\\([^,]*,\\s*<[^>]*>,[^)]*\\))");
 
MatchCollection matches = re.Matches(expr);
string[] str = new string[matches.Count];
for (int i=0; i < matches.Count; i++)
    str[i] = matches[i].Value;

• (...) - Capture the result of this expression as a match;
• \\(...\\) - The expression is contained within regular brackets. NB: The bracket must be escaped, since it has special meaning for regular expressions. Since this is a normal C# string, the escape character must also be escaped;
• [^,]*,... - Match anything except a comma zero or more times, followed by a comma;
• ...\\s*... - Match zero or more white-space characters;
• ...<[^>]*>,... - Match the < charcter, followed by zero or more characters which are not >, followed by >, followed by a comma;
• ...[^)]* - Match anything except a closing bracket.

Regex re = new Regex(@"(\([^,]*,\s*<[^>]*>,[^)]*\))");

int[] Converter(byte[] ba)
{
	int[] rtn = new int[ba.Length / 4];
	int idx = 0;

	foreach (int x in rtn)
	{
		for (int i = 0; i < 4; i++)
		{
			x *= 256;
			x += ba[idx++];
		}
	}

	return rtn;
}</code>

[StructLayout(LayoutKind.Explicit)]
public class Converter
{
[FieldOffset(0)] public byte[] byteArray;
[FieldOffset(0)] public int intConverted;
[FieldOffset(0)] public string stringConverted;
// etc
}

static Array ConvertByteArray(byte[] inArray, Type destType)
{
    if (!destType.IsValueType) 
        throw new Exception("destType must be a value type!");
 
    // Can't calculate size for enum types.
    if (destType.IsEnum) destType = Enum.GetUnderlyingType(destType);
 
    int iSize = System.Runtime.InteropServices.Marshal.SizeOf(destType);
 
    if (iSize > 8) 
        throw new Exception("destType is too large!");
 
    System.Diagnostics.Debug.Assert(
        inArray.Length % iSize == 0, 
        "Invalid array length!");
 
    Array outArray = Array.CreateInstance(
        destType, inArray.Length / iSize);
 
    for (int i=0, j=0; 
        i<inArray.Length && j<outArray.Length; 
        i += iSize, j++)
    {
        // The value will not be larger than a UInt64.
        // NB: Left-shift doesn't work on 64-bit numbers.
        ulong val = 0;
 
        // Bytes from source array
        for (int k=0; k<iSize && i+k < inArray.Length; k++)
            val = (val * 256) + inArray[i + k];
 
        // Shouldn't happen, but just in case
        for (int k=inArray.Length - i; k < iSize; k++)
            val *= 256;
 
        try 
        {
            outArray.SetValue(Convert.ChangeType(val, destType), j);
        }
        catch (OverflowException ex)
        {
            // If destType is signed, we may have a negative value
            ulong iMask = (ulong)Math.Pow(2, 8 * iSize - 1);
 
            if ((val & iMask) != 0)
            {
                // Try negative value.
                // NB: If destType is long, (long)iMask is negative
                // so just cast val to long.
                long val2;
                if ((long)iMask < 0) 
                    val2 = (long)val;
                else 
                    val2 = (long)(val & ~iMask) - (long)iMask;
 
                outArray.SetValue(Convert.ChangeType(val2, destType), j);
            }
            else
                // Not negative - just allow the 
                // exception to propogate
                throw ex;
        }
    }
 
    return outArray;
}

byte[] a = new byte[6] {12, 34, 56, 78, 91, 111};
short[] b = (short[])ConvertByteArray(a, typeof(short));

static void TestConvert(Type T)
{
    int tSize;
    if (T.IsEnum) 
        tSize = System.Runtime.InteropServices.Marshal.SizeOf(
            Enum.GetUnderlyingType(T));
    else 
        tSize = System.Runtime.InteropServices.Marshal.SizeOf(T);
 
    Random R = new Random();
 
    int iBytes = R.Next(1, 10) * tSize;
    Console.WriteLine("{0} bytes", iBytes);
 
    byte[] a = new byte[iBytes];
 
    for (int i=0; i<a.Length; i++)
    {
        a[i] = (byte)R.Next(255);
        Console.WriteLine("a[{0}] = {1}", i, a[i]);
    }
 
    Array b = ConvertByteArray(a, T);
 
    for (int i=0; i<b.Length; i++) 
        Console.WriteLine("b[{0}] = {1}", i, b.GetValue(i));
}
 
[Flags]
public enum TestEnum : byte
{
    Value0 = 1,
    Value1 = 2,
    Value2 = 4,
    Value3 = 8,
    Value4 = 16,
    Value5 = 32,
    Value6 = 64,
    Value7 = 128,
}
 
static void Main()
{
    TestConvert(typeof(byte));
    TestConvert(typeof(sbyte));
    TestConvert(typeof(short));
    TestConvert(typeof(ushort));
    TestConvert(typeof(int));
    TestConvert(typeof(uint));
    TestConvert(typeof(long));
    TestConvert(typeof(ulong));
 
    // NB: This will be the same as byte
    TestConvert(typeof(TestEnum));
 
    // Early-bound enum test
    Random R = new Random();
    byte[] a = new byte[4];
    for (int i=0; i<4; i++)
    {
        a[i] = (byte)R.Next(255);
        Console.WriteLine("a[{0}] = {1}", i, a[i]);
    }
 
    TestEnum[] b = (TestEnum[])ConvertByteArray(a, typeof(TestEnum));
    for (int i=0; i < b.Length; i++)
        Console.WriteLine("b[{0}] = {1}", i, b[i]);
}

---

"When the only tool you have is a hammer, a sore thumb you will have."