GCHandle handle = GCHandle.Alloc(ob, GCHandleType.Pinned);
....//working


handle.Free(ob);

GZ>GCHandle handle = GCHandle.Alloc(ob, GCHandleType.Pinned);
GZ>....//working

GZ>handle.Free(ob);
GZ>

int[] result = _input.DungerousReadStructs<Int32>(entry.Length / 4);



public static T[] DungerousReadStructs<T>(this Stream input, int count) where T : struct
{
    if (count < 1)
        return new T[0];

    Array result = new T[count];
    Int32 entrySize = UnsafeTypeCache<T>.UnsafeSize;
    using (UnsafeTypeCache<byte>.ChangeArrayType(result, entrySize))
        input.EnsureRead((byte[])result, 0, result.Length);

    return (T[])result;
}



public static class TypeCache<T>
{
    public static readonly Type Type = typeof(T);
}

public static class UnsafeTypeCache<T>
{
    public static readonly Int32 UnsafeSize = GetSize();
    public static readonly UIntPtr ArrayTypePointer = GetArrayTypePointer();

    private static Int32 GetSize()
    {
        DynamicMethod dynamicMethod = new DynamicMethod("SizeOf", typeof(Int32), Type.EmptyTypes);
        ILGenerator generator = dynamicMethod.GetILGenerator();

        generator.Emit(OpCodes.Sizeof, TypeCache<T>.Type);
        generator.Emit(OpCodes.Ret);

        return ((Func<int>)dynamicMethod.CreateDelegate(typeof(Func<Int32>)))();
    }

    private static unsafe UIntPtr GetArrayTypePointer()
    {
        T[] result = new T[1];
        using (SafeGCHandle handle = new SafeGCHandle(result, GCHandleType.Pinned))
            return *(((UIntPtr*)handle.AddrOfPinnedObject().ToPointer()) - 2);
    }

    public static IDisposable ChangeArrayType(Array array, Int32 oldElementSize)
    {
        if (array.Length < 1)
            throw new NotSupportedException();

        SafeGCHandle handle = new SafeGCHandle(array, GCHandleType.Pinned);
        try
        {
            unsafe
            {
                UIntPtr* arrayPointer = (UIntPtr*)handle.AddrOfPinnedObject().ToPointer();
                UIntPtr arrayLength = *(arrayPointer - 1);
                UIntPtr arrayType = *(arrayPointer - 2);
                UInt64 arraySize = ((UInt64)arrayLength * (UInt64)oldElementSize);

                if (arraySize % (UInt64)UnsafeSize != 0)
                    throw new InvalidCastException();

                GC.Collect(2, GCCollectionMode.Forced, true);
                GC.WaitForFullGCComplete();

                try
                {
                    *(arrayPointer - 1) = new UIntPtr(arraySize / (UInt64)UnsafeSize);
                    *(arrayPointer - 2) = ArrayTypePointer;

                    GC.Collect(2, GCCollectionMode.Forced, true);
                    GC.WaitForFullGCComplete();

                    return new DisposableAction(() =>
                    {
                        *(arrayPointer - 1) = arrayLength;
                        *(arrayPointer - 2) = arrayType;
                        handle.Dispose();

                        GC.Collect(2, GCCollectionMode.Forced, true);
                        GC.WaitForFullGCComplete();
                    });
                }
                catch
                {
                    *(arrayPointer - 1) = arrayLength;
                    *(arrayPointer - 2) = arrayType;
                    throw;
                }
            }
        }
        catch
        {
            handle.SafeDispose();
            throw;
        }
    }
}

memMappedFile.CreateViewAccessor().ReadArray<SomeStruct>()