DBreeze.Storage.MemoryStorage.Read C# (CSharp) Method

        public byte[] Read(int offset, int length)
        {
            if(offset >= _capacity)
                return null;

            if(offset<0 || length<0)
                return null;

            if(length == 0)
                return new byte[0];

            byte[] ret = null;

            lock (_lock)
            {

                int q2r = length;

                if (offset + length > _capacity)
                    q2r = _capacity - offset;

                ret = new byte[q2r];

                Buffer.BlockCopy(_f, offset, ret, 0, q2r);
            }

            return ret;
        }

        /// <summary>
        /// Standard and transactional rollback
        /// </summary>
        public void Rollback()
        {
            try
            {
                lock (lock_fs)
                {
                    //Clearing random buffer
                    if (_randBuf.Count() != 0)
                    {
                        usedBufferSize = 0;
                        _randBuf.Clear();
                    }

                    //Restoring Rollback records
                    byte[] btWork = null;

                    if (_rollbackCache.Count() > 0)
                    {
                        foreach (var rb in _rollbackCache)
                        {
                            btWork = new byte[rb.Value.l];

                            btWork = _fsRollback.Read((int)rb.Value.o, btWork.Length);

                            //_fsRollback.Position = rb.Value.o;
                            //_fsRollback.Read(btWork, 0, btWork.Length);

                            _fsData.Write_ByOffset((int)rb.Key, btWork);
                            //_fsData.Position = rb.Key;
                            //_fsData.Write(btWork, 0, btWork.Length);
                        }

                        //NET_Flush(_fsData);

                        //Restoring rhp
                        eofRollback = 0;
                        btWork      = eofRollback.To_8_bytes_array_BigEndian();
                        _fsRollbackHelper.Write_ByOffset(0, btWork);
                        //_fsRollbackHelper.Position = 0;
                        //_fsRollbackHelper.Write(eofRollback.To_8_bytes_array_BigEndian(), 0, 8);

                        //NET_Flush(_fsRollbackHelper);

                        //Clearing rollbackCache
                        _rollbackCache.Clear();
                    }

                    //we dont move eofData, space can be re-used up to next restart (may be root can have this info in next protocols)
                    //eofData = this._fsData.Length;
                }
            }
            catch (Exception ex)
            {
                IsOperable = false;
                throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.RESTORE_ROLLBACK_DATA_FAILED, this._fileName, ex);
            }
        }