Accessing Compressed Blobs from outside NAV (NAV2013) (Revisited)

I already bloged about this some time ago: https://devch.wordpress.com/2013/01/17/accessing-compressed-blobs-from-outside-nav-nav2013/
But this was in the beta phase of NAV2013, and since then i did not use the code for any real project. Since there were a few comments about it not realy working i revisited the solution and encountered that it infact was not a completly working solution.

So here is the working solution for this, it enables you to read compressed & non-compressed BLOBs. I tested it with the Object & the Object Metadata Table.

class NAV2013BLOBReader
    {
        public static int GetDecompressedStream2013(SqlDataReader reader, bool decompress, ref MemoryStream ResultStream)
        {
            int fieldIndex = 0;
            int num2 = reader.IsDBNull(fieldIndex) ? 0 : ((int)reader.GetBytes(fieldIndex, 0L, null, 0, 0));
            if (num2 > 0)
            {
                using (Stream stream = new BlobReaderStream(reader, fieldIndex, num2))
                {
                    if (decompress)
                    {
                        byte[] array = new byte[4];
                        long num3 = (long)stream.Read(array, 0, 4);
                        if (num3 < 4L || !BlobMagicOk(array))
                        {
                            int result = 22926086;
                            return result;
                        }

                        using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
                        {
                            deflateStream.CopyTo(ResultStream);
                        }
                    }
                    else
                        stream.CopyTo(ResultStream);
                    return 1;
                }
            }

            return 0;
        }

        private static bool BlobMagicOk(byte[] checkMagic)
        {
            for (int i = 0; i < 4; i++)
            {
                if (checkMagic[i] != BlobMagic[i])
                {
                    return false;
                }
            }
            return true;
        }

        private static byte[] BlobMagic = new byte[]
        {
	        2,
	        69,
	        125,
	        91
        };
    }

    public class BlobReaderStream : System.IO.Stream
    {
        private System.Data.SqlClient.SqlDataReader reader;
        private int fieldIndex;
        private int length;
        private int position;
        public override bool CanRead
        {
            get
            {
                return true;
            }
        }
        public override bool CanSeek
        {
            get
            {
                return false;
            }
        }
        public override bool CanWrite
        {
            get
            {
                return false;
            }
        }
        public override long Length
        {
            get
            {
                return (long)this.length;
            }
        }
        public override long Position
        {
            get
            {
                return (long)this.position;
            }
            set
            {
                this.position = (int)value;
            }
        }
        public BlobReaderStream(System.Data.SqlClient.SqlDataReader reader, int fieldIndex, int length)
        {
            this.reader = reader;
            this.fieldIndex = fieldIndex;
            this.length = length;
        }
        public override void Flush()
        {
        }
        public override long Seek(long offset, System.IO.SeekOrigin origin)
        {
            throw new System.NotSupportedException();
        }
        public override void SetLength(long value)
        {
            throw new System.NotSupportedException();
        }
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (this.position < this.length)
            {
                int num = (int)this.reader.GetBytes(this.fieldIndex, (long)this.position, buffer, offset, count);
                this.position += num;
                return num;
            }
            return 0;
        }
        public override void Write(byte[] buffer, int offset, int count)
        {
            throw new System.NotSupportedException();
        }
    }

To call the method simply use something like this:

            string SQLServer = "<Your Instance>";
            string Database = "<Your Database>";
            using (SqlConnection connection = new SqlConnection(string.Format("server={0};Trusted_Connection=yes;database={1};connection timeout=5", SQLServer, Database)))
            {
                connection.Open();
                SqlCommand command = new SqlCommand(string.Format("select [Metadata] from [Object Metadata] where [Object Type] = 1 AND [Object ID] = {0}", ID), connection);

                SqlDataReader reader = command.ExecuteReader();

                if (reader.Read())
                {

                    var ms = new MemoryStream();
                    if (NAV2013_Compressed_Stream.GetDecompressedStream2013(reader, true, ref ms) == 1)
                    {
                        ms.Position = 0;
                        StreamReader Sreader = new StreamReader(ms);
                        string text = Sreader.ReadToEnd();
                        return text;
                    }
                }
            }